FFmpeg
utils.c
Go to the documentation of this file.
1 /*
2  * various utility functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdint.h>
23 #include <time.h>
24 
25 #include "config.h"
26 
27 #include "libavutil/avstring.h"
28 #include "libavutil/bprint.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/internal.h"
31 #include "libavutil/mem.h"
32 #include "libavutil/time.h"
34 
35 #include "libavcodec/internal.h"
36 
37 #include "avformat.h"
38 #include "avio_internal.h"
39 #include "internal.h"
40 #if CONFIG_NETWORK
41 #include "network.h"
42 #endif
43 #include "os_support.h"
44 
45 /**
46  * @file
47  * various utility functions for use within FFmpeg
48  */
49 
50 /* an arbitrarily chosen "sane" max packet size -- 50M */
51 #define SANE_CHUNK_SIZE (50000000)
52 
53 /* Read the data in sane-sized chunks and append to pkt.
54  * Return the number of bytes read or an error. */
56 {
57  int orig_size = pkt->size;
58  int ret;
59 
60  do {
61  int prev_size = pkt->size;
62  int read_size;
63 
64  /* When the caller requests a lot of data, limit it to the amount
65  * left in file or SANE_CHUNK_SIZE when it is not known. */
66  read_size = size;
67  if (read_size > SANE_CHUNK_SIZE/10) {
68  read_size = ffio_limit(s, read_size);
69  // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
70  if (ffiocontext(s)->maxsize < 0)
71  read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
72  }
73 
74  ret = av_grow_packet(pkt, read_size);
75  if (ret < 0)
76  break;
77 
78  ret = avio_read(s, pkt->data + prev_size, read_size);
79  if (ret != read_size) {
80  av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
81  break;
82  }
83 
84  size -= read_size;
85  } while (size > 0);
86  if (size > 0)
88 
89  if (!pkt->size)
91  return pkt->size > orig_size ? pkt->size - orig_size : ret;
92 }
93 
95 {
96 #if FF_API_INIT_PACKET
98  av_init_packet(pkt);
99  pkt->data = NULL;
100  pkt->size = 0;
102 #else
104 #endif
105  pkt->pos = avio_tell(s);
106 
107  return append_packet_chunked(s, pkt, size);
108 }
109 
111 {
112  if (!pkt->size)
113  return av_get_packet(s, pkt, size);
114  return append_packet_chunked(s, pkt, size);
115 }
116 
117 int av_filename_number_test(const char *filename)
118 {
119  char buf[1024];
120  return filename &&
121  (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
122 }
123 
124 /**********************************************************/
125 
126 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
127 {
128  while (tags->id != AV_CODEC_ID_NONE) {
129  if (tags->id == id)
130  return tags->tag;
131  tags++;
132  }
133  return 0;
134 }
135 
136 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
137 {
138  for (int i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
139  if (tag == tags[i].tag)
140  return tags[i].id;
141  for (int i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
142  if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
143  return tags[i].id;
144  return AV_CODEC_ID_NONE;
145 }
146 
147 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
148 {
149  if (bps <= 0 || bps > 64)
150  return AV_CODEC_ID_NONE;
151 
152  if (flt) {
153  switch (bps) {
154  case 32:
156  case 64:
158  default:
159  return AV_CODEC_ID_NONE;
160  }
161  } else {
162  bps += 7;
163  bps >>= 3;
164  if (sflags & (1 << (bps - 1))) {
165  switch (bps) {
166  case 1:
167  return AV_CODEC_ID_PCM_S8;
168  case 2:
170  case 3:
172  case 4:
174  case 8:
176  default:
177  return AV_CODEC_ID_NONE;
178  }
179  } else {
180  switch (bps) {
181  case 1:
182  return AV_CODEC_ID_PCM_U8;
183  case 2:
185  case 3:
187  case 4:
189  default:
190  return AV_CODEC_ID_NONE;
191  }
192  }
193  }
194 }
195 
196 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
197 {
198  unsigned int tag;
199  if (!av_codec_get_tag2(tags, id, &tag))
200  return 0;
201  return tag;
202 }
203 
204 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
205  unsigned int *tag)
206 {
207  for (int i = 0; tags && tags[i]; i++) {
208  const AVCodecTag *codec_tags = tags[i];
209  while (codec_tags->id != AV_CODEC_ID_NONE) {
210  if (codec_tags->id == id) {
211  *tag = codec_tags->tag;
212  return 1;
213  }
214  codec_tags++;
215  }
216  }
217  return 0;
218 }
219 
220 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
221 {
222  for (int i = 0; tags && tags[i]; i++) {
223  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
224  if (id != AV_CODEC_ID_NONE)
225  return id;
226  }
227  return AV_CODEC_ID_NONE;
228 }
229 
231 {
232  av_freep(&par->extradata);
233  par->extradata_size = 0;
234 
235  if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
236  return AVERROR(EINVAL);
237 
239  if (!par->extradata)
240  return AVERROR(ENOMEM);
241 
242  memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
243  par->extradata_size = size;
244 
245  return 0;
246 }
247 
248 /*******************************************************/
249 
250 uint64_t ff_ntp_time(void)
251 {
252  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
253 }
254 
255 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
256 {
257  uint64_t ntp_ts, frac_part, sec;
258  uint32_t usec;
259 
260  //current ntp time in seconds and micro seconds
261  sec = ntp_time_us / 1000000;
262  usec = ntp_time_us % 1000000;
263 
264  //encoding in ntp timestamp format
265  frac_part = usec * 0xFFFFFFFFULL;
266  frac_part /= 1000000;
267 
268  if (sec > 0xFFFFFFFFULL)
269  av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
270 
271  ntp_ts = sec << 32;
272  ntp_ts |= frac_part;
273 
274  return ntp_ts;
275 }
276 
277 uint64_t ff_parse_ntp_time(uint64_t ntp_ts)
278 {
279  uint64_t sec = ntp_ts >> 32;
280  uint64_t frac_part = ntp_ts & 0xFFFFFFFFULL;
281  uint64_t usec = (frac_part * 1000000) / 0xFFFFFFFFULL;
282 
283  return (sec * 1000000) + usec;
284 }
285 
286 int ff_get_frame_filename(char *buf, int buf_size, const char *path, int64_t number, int flags)
287 {
288  const char *p;
289  char *q, buf1[20], c;
290  int nd, len, percentd_found;
291 
292  q = buf;
293  p = path;
294  percentd_found = 0;
295  for (;;) {
296  c = *p++;
297  if (c == '\0')
298  break;
299  if (c == '%') {
300  do {
301  nd = 0;
302  while (av_isdigit(*p)) {
303  if (nd >= INT_MAX / 10 - 255)
304  goto fail;
305  nd = nd * 10 + *p++ - '0';
306  }
307  c = *p++;
308  } while (av_isdigit(c));
309 
310  switch (c) {
311  case '%':
312  goto addchar;
313  case 'd':
314  if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
315  goto fail;
316  percentd_found = 1;
317  if (number < 0)
318  nd += 1;
319  snprintf(buf1, sizeof(buf1), "%0*" PRId64, nd, number);
320  len = strlen(buf1);
321  if ((q - buf + len) > buf_size - 1)
322  goto fail;
323  memcpy(q, buf1, len);
324  q += len;
325  break;
326  default:
327  goto fail;
328  }
329  } else {
330 addchar:
331  if ((q - buf) < buf_size - 1)
332  *q++ = c;
333  }
334  }
335  if (!percentd_found)
336  goto fail;
337  *q = '\0';
338  return 0;
339 fail:
340  *q = '\0';
341  return -1;
342 }
343 
344 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
345 {
346  return ff_get_frame_filename(buf, buf_size, path, number, flags);
347 }
348 
349 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
350 {
351  return ff_get_frame_filename(buf, buf_size, path, number, 0);
352 }
353 
354 void av_url_split(char *proto, int proto_size,
355  char *authorization, int authorization_size,
356  char *hostname, int hostname_size,
357  int *port_ptr, char *path, int path_size, const char *url)
358 {
359  const char *p, *ls, *at, *at2, *col, *brk;
360 
361  if (port_ptr)
362  *port_ptr = -1;
363  if (proto_size > 0)
364  proto[0] = 0;
365  if (authorization_size > 0)
366  authorization[0] = 0;
367  if (hostname_size > 0)
368  hostname[0] = 0;
369  if (path_size > 0)
370  path[0] = 0;
371 
372  /* parse protocol */
373  if ((p = strchr(url, ':'))) {
374  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
375  p++; /* skip ':' */
376  if (*p == '/')
377  p++;
378  if (*p == '/')
379  p++;
380  } else {
381  /* no protocol means plain filename */
382  av_strlcpy(path, url, path_size);
383  return;
384  }
385 
386  /* separate path from hostname */
387  ls = p + strcspn(p, "/?#");
388  av_strlcpy(path, ls, path_size);
389 
390  /* the rest is hostname, use that to parse auth/port */
391  if (ls != p) {
392  /* authorization (user[:pass]@hostname) */
393  at2 = p;
394  while ((at = strchr(p, '@')) && at < ls) {
395  av_strlcpy(authorization, at2,
396  FFMIN(authorization_size, at + 1 - at2));
397  p = at + 1; /* skip '@' */
398  }
399 
400  if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
401  /* [host]:port */
402  av_strlcpy(hostname, p + 1,
403  FFMIN(hostname_size, brk - p));
404  if (brk[1] == ':' && port_ptr)
405  *port_ptr = atoi(brk + 2);
406  } else if ((col = strchr(p, ':')) && col < ls) {
407  av_strlcpy(hostname, p,
408  FFMIN(col + 1 - p, hostname_size));
409  if (port_ptr)
410  *port_ptr = atoi(col + 1);
411  } else
412  av_strlcpy(hostname, p,
413  FFMIN(ls + 1 - p, hostname_size));
414  }
415 }
416 
417 int ff_mkdir_p(const char *path)
418 {
419  int ret = 0;
420  char *temp = av_strdup(path);
421  char *pos = temp;
422  char tmp_ch = '\0';
423 
424  if (!path || !temp) {
425  return -1;
426  }
427 
428  if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
429  pos++;
430  } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
431  pos += 2;
432  }
433 
434  for ( ; *pos != '\0'; ++pos) {
435  if (*pos == '/' || *pos == '\\') {
436  tmp_ch = *pos;
437  *pos = '\0';
438  ret = mkdir(temp, 0755);
439  *pos = tmp_ch;
440  }
441  }
442 
443  if ((*(pos - 1) != '/') && (*(pos - 1) != '\\')) {
444  ret = mkdir(temp, 0755);
445  }
446 
447  av_free(temp);
448  return ret;
449 }
450 
451 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
452 {
453  static const char hex_table_uc[16] = { '0', '1', '2', '3',
454  '4', '5', '6', '7',
455  '8', '9', 'A', 'B',
456  'C', 'D', 'E', 'F' };
457  static const char hex_table_lc[16] = { '0', '1', '2', '3',
458  '4', '5', '6', '7',
459  '8', '9', 'a', 'b',
460  'c', 'd', 'e', 'f' };
461  const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
462 
463  for (int i = 0; i < s; i++) {
464  buff[i * 2] = hex_table[src[i] >> 4];
465  buff[i * 2 + 1] = hex_table[src[i] & 0xF];
466  }
467  buff[2 * s] = '\0';
468 
469  return buff;
470 }
471 
472 int ff_hex_to_data(uint8_t *data, const char *p)
473 {
474  int c, len, v;
475 
476  len = 0;
477  v = 1;
478  for (;;) {
479  p += strspn(p, SPACE_CHARS);
480  if (*p == '\0')
481  break;
482  c = av_toupper((unsigned char) *p++);
483  if (c >= '0' && c <= '9')
484  c = c - '0';
485  else if (c >= 'A' && c <= 'F')
486  c = c - 'A' + 10;
487  else
488  break;
489  v = (v << 4) | c;
490  if (v & 0x100) {
491  if (data)
492  data[len] = v;
493  len++;
494  v = 1;
495  }
496  }
497  return len;
498 }
499 
500 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
501  void *context)
502 {
503  const char *ptr = str;
504 
505  /* Parse key=value pairs. */
506  for (;;) {
507  const char *key;
508  char *dest = NULL, *dest_end;
509  int key_len, dest_len = 0;
510 
511  /* Skip whitespace and potential commas. */
512  while (*ptr && (av_isspace(*ptr) || *ptr == ','))
513  ptr++;
514  if (!*ptr)
515  break;
516 
517  key = ptr;
518 
519  if (!(ptr = strchr(key, '=')))
520  break;
521  ptr++;
522  key_len = ptr - key;
523 
524  callback_get_buf(context, key, key_len, &dest, &dest_len);
525  dest_end = dest ? dest + dest_len - 1 : NULL;
526 
527  if (*ptr == '\"') {
528  ptr++;
529  while (*ptr && *ptr != '\"') {
530  if (*ptr == '\\') {
531  if (!ptr[1])
532  break;
533  if (dest && dest < dest_end)
534  *dest++ = ptr[1];
535  ptr += 2;
536  } else {
537  if (dest && dest < dest_end)
538  *dest++ = *ptr;
539  ptr++;
540  }
541  }
542  if (*ptr == '\"')
543  ptr++;
544  } else {
545  for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
546  if (dest && dest < dest_end)
547  *dest++ = *ptr;
548  }
549  if (dest)
550  *dest = 0;
551  }
552 }
553 
555 {
556 #if CONFIG_NETWORK
557  int ret;
558  if ((ret = ff_network_init()) < 0)
559  return ret;
560  if ((ret = ff_tls_init()) < 0)
561  return ret;
562 #endif
563  return 0;
564 }
565 
567 {
568 #if CONFIG_NETWORK
570  ff_tls_deinit();
571 #endif
572  return 0;
573 }
574 
575 int ff_is_http_proto(const char *filename) {
576  const char *proto = avio_find_protocol_name(filename);
577  return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
578 }
579 
580 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
581 {
582  int ret;
583  char *str;
584 
585  ret = av_bprint_finalize(buf, &str);
586  if (ret < 0)
587  return ret;
588  if (!av_bprint_is_complete(buf)) {
589  av_free(str);
590  return AVERROR(ENOMEM);
591  }
592 
593  par->extradata = str;
594  /* Note: the string is NUL terminated (so extradata can be read as a
595  * string), but the ending character is not accounted in the size (in
596  * binary formats you are likely not supposed to mux that character). When
597  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
598  * zeros. */
599  par->extradata_size = buf->len;
600  return 0;
601 }
602 
603 int ff_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)
604 {
605  time_t seconds = timestamp / 1000000;
606  struct tm *ptm, tmbuf;
607  ptm = gmtime_r(&seconds, &tmbuf);
608  if (ptm) {
609  char buf[32];
610  if (!strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S", ptm))
611  return AVERROR_EXTERNAL;
612  av_strlcatf(buf, sizeof(buf), ".%06dZ", (int)(timestamp % 1000000));
613  return av_dict_set(dict, key, buf, 0);
614  } else {
615  return AVERROR_EXTERNAL;
616  }
617 }
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:335
flags
const SwsFlags flags[]
Definition: swscale.c:61
ff_dict_set_timestamp
int ff_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)
Set a dictionary value to an ISO-8601 compliant timestamp string.
Definition: utils.c:603
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:430
be
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:136
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AV_CODEC_ID_PCM_F32BE
@ AV_CODEC_ID_PCM_F32BE
Definition: codec_id.h:355
ff_data_to_hex
char * ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
Write hexadecimal string corresponding to given binary data.
Definition: utils.c:451
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:218
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
av_codec_get_tag2
int av_codec_get_tag2(const AVCodecTag *const *tags, enum AVCodecID id, unsigned int *tag)
Definition: utils.c:204
ff_mkdir_p
int ff_mkdir_p(const char *path)
Automatically create sub-directories.
Definition: utils.c:417
ff_ntp_time
uint64_t ff_ntp_time(void)
Get the current time since NTP epoch in microseconds.
Definition: utils.c:250
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
ffiocontext
static av_always_inline FFIOContext * ffiocontext(AVIOContext *ctx)
Definition: avio_internal.h:81
AVCodecTag::id
enum AVCodecID id
Definition: internal.h:43
int64_t
long long int64_t
Definition: coverity.c:34
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: packet.c:122
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
av_isspace
static av_const int av_isspace(int c)
Locale-independent conversion of ASCII isspace.
Definition: avstring.h:218
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:535
av_get_frame_filename2
int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
Return in 'buf' the path with 'd' replaced by a number.
Definition: utils.c:344
data
const char data[16]
Definition: mxf.c:149
AV_CODEC_ID_PCM_U24LE
@ AV_CODEC_ID_PCM_U24LE
Definition: codec_id.h:349
ff_toupper4
unsigned int ff_toupper4(unsigned int x)
Definition: to_upper4.h:29
AVDictionary
Definition: dict.c:32
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ff_network_close
void ff_network_close(void)
Definition: network.c:121
av_get_frame_filename
int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
Definition: utils.c:349
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:103
os_support.h
ff_network_init
int ff_network_init(void)
Definition: network.c:63
ff_tls_init
int ff_tls_init(void)
Definition: network.c:36
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
av_filename_number_test
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:117
AV_CODEC_ID_PCM_S64LE
@ AV_CODEC_ID_PCM_S64LE
Definition: codec_id.h:366
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:336
fail
#define fail()
Definition: checkasm.h:194
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: packet.c:114
gmtime_r
#define gmtime_r
Definition: time_internal.h:34
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
avformat_network_init
int avformat_network_init(void)
Do global initialization of network libraries.
Definition: utils.c:554
SPACE_CHARS
#define SPACE_CHARS
Definition: dnn_backend_tf.c:356
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:339
av_codec_get_tag
unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
Definition: utils.c:196
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:591
AVCodecTag
Definition: internal.h:42
ff_get_frame_filename
int ff_get_frame_filename(char *buf, int buf_size, const char *path, int64_t number, int flags)
Return in 'buf' the path with 'd' replaced by a number.
Definition: utils.c:286
s
#define s(width, name)
Definition: cbs_vp9.c:198
av_append_packet
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
Read data and append it to the current content of the AVPacket.
Definition: utils.c:110
AV_CODEC_ID_PCM_U16BE
@ AV_CODEC_ID_PCM_U16BE
Definition: codec_id.h:338
key
const char * key
Definition: hwcontext_opencl.c:189
ff_hex_to_data
int ff_hex_to_data(uint8_t *data, const char *p)
Parse a string of hexadecimal strings.
Definition: utils.c:472
time_internal.h
context
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
NULL
#define NULL
Definition: coverity.c:32
AV_CODEC_ID_PCM_U24BE
@ AV_CODEC_ID_PCM_U24BE
Definition: codec_id.h:350
AV_CODEC_ID_PCM_U32BE
@ AV_CODEC_ID_PCM_U32BE
Definition: codec_id.h:346
AV_CODEC_ID_PCM_S64BE
@ AV_CODEC_ID_PCM_S64BE
Definition: codec_id.h:367
ff_parse_key_value
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf, void *context)
Parse a string with comma-separated key=value pairs.
Definition: utils.c:500
time.h
ff_get_formatted_ntp_time
uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
Get the NTP time stamp formatted as per the RFC-5905.
Definition: utils.c:255
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
av_strncasecmp
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
Definition: avstring.c:217
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:347
AVPacket::size
int size
Definition: packet.h:536
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
bps
unsigned bps
Definition: movenc.c:1912
ff_get_pcm_codec_id
enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
Select a PCM codec based on the given parameters.
Definition: utils.c:147
size
int size
Definition: twinvq_data.h:10344
NTP_OFFSET_US
#define NTP_OFFSET_US
Definition: internal.h:404
av_isdigit
static av_const int av_isdigit(int c)
Locale-independent conversion of ASCII isdigit.
Definition: avstring.h:202
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:541
AV_FRAME_FILENAME_FLAGS_MULTIPLE
#define AV_FRAME_FILENAME_FLAGS_MULTIPLE
Allow multiple d.
Definition: avformat.h:2825
SANE_CHUNK_SIZE
#define SANE_CHUNK_SIZE
Definition: utils.c:51
ffio_limit
int ffio_limit(AVIOContext *s, int size)
Definition: aviobuf.c:1061
bprint.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
avio_internal.h
internal.h
AV_CODEC_ID_PCM_F64BE
@ AV_CODEC_ID_PCM_F64BE
Definition: codec_id.h:357
av_toupper
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:227
av_url_split
void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)
Split a URL string into components.
Definition: utils.c:354
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:344
len
int len
Definition: vorbis_enc_data.h:426
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:94
ff_tls_deinit
void ff_tls_deinit(void)
Definition: network.c:51
tag
uint32_t tag
Definition: movenc.c:1911
ret
ret
Definition: filter_design.txt:187
ff_is_http_proto
int ff_is_http_proto(const char *filename)
Utility function to check if the file uses http or https protocol.
Definition: utils.c:575
ff_bprint_to_codecpar_extradata
int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
Finalize buf into extradata and set its size appropriately.
Definition: utils.c:580
lowercase
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in lowercase
Definition: writing_filters.txt:89
pos
unsigned int pos
Definition: spdifenc.c:414
avformat.h
dict.h
network.h
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
id
enum AVCodecID id
Definition: dts2pts.c:367
avformat_network_deinit
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:566
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:612
ff_parse_key_val_cb
void(* ff_parse_key_val_cb)(void *context, const char *key, int key_len, char **dest, int *dest_len)
Callback function type for ff_parse_key_value.
Definition: internal.h:483
AV_CODEC_ID_PCM_U32LE
@ AV_CODEC_ID_PCM_U32LE
Definition: codec_id.h:345
temp
else temp
Definition: vf_mcdeint.c:263
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AV_CODEC_ID_PCM_S32LE
@ AV_CODEC_ID_PCM_S32LE
Definition: codec_id.h:343
mem.h
ff_codec_get_tag
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:126
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:340
AV_CODEC_ID_PCM_F64LE
@ AV_CODEC_ID_PCM_F64LE
Definition: codec_id.h:358
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVPacket
This structure stores compressed data.
Definition: packet.h:512
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:86
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:555
avio_find_protocol_name
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
Definition: avio.c:657
ff_parse_ntp_time
uint64_t ff_parse_ntp_time(uint64_t ntp_ts)
Parse the NTP time in micro seconds (since NTP epoch).
Definition: utils.c:277
AV_CODEC_ID_PCM_U16LE
@ AV_CODEC_ID_PCM_U16LE
Definition: codec_id.h:337
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
AV_CODEC_ID_PCM_F32LE
@ AV_CODEC_ID_PCM_F32LE
Definition: codec_id.h:356
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
avstring.h
av_codec_get_id
enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
Definition: utils.c:220
AVCodecTag::tag
unsigned int tag
Definition: internal.h:44
snprintf
#define snprintf
Definition: snprintf.h:34
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:230
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:348
src
#define src
Definition: vp8dsp.c:248
append_packet_chunked
static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
Definition: utils.c:55