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 
24 #include "config.h"
25 
26 #include "libavutil/avstring.h"
27 #include "libavutil/bprint.h"
28 #include "libavutil/internal.h"
29 #include "libavutil/mem.h"
30 #include "libavutil/time.h"
31 
32 #include "libavcodec/internal.h"
33 
34 #include "avformat.h"
35 #include "avio_internal.h"
36 #include "internal.h"
37 #if CONFIG_NETWORK
38 #include "network.h"
39 #endif
40 #include "os_support.h"
41 
42 /**
43  * @file
44  * various utility functions for use within FFmpeg
45  */
46 
47 /* an arbitrarily chosen "sane" max packet size -- 50M */
48 #define SANE_CHUNK_SIZE (50000000)
49 
50 /* Read the data in sane-sized chunks and append to pkt.
51  * Return the number of bytes read or an error. */
53 {
54  int orig_size = pkt->size;
55  int ret;
56 
57  do {
58  int prev_size = pkt->size;
59  int read_size;
60 
61  /* When the caller requests a lot of data, limit it to the amount
62  * left in file or SANE_CHUNK_SIZE when it is not known. */
63  read_size = size;
64  if (read_size > SANE_CHUNK_SIZE/10) {
65  read_size = ffio_limit(s, read_size);
66  // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
67  if (ffiocontext(s)->maxsize < 0)
68  read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
69  }
70 
71  ret = av_grow_packet(pkt, read_size);
72  if (ret < 0)
73  break;
74 
75  ret = avio_read(s, pkt->data + prev_size, read_size);
76  if (ret != read_size) {
77  av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
78  break;
79  }
80 
81  size -= read_size;
82  } while (size > 0);
83  if (size > 0)
85 
86  if (!pkt->size)
88  return pkt->size > orig_size ? pkt->size - orig_size : ret;
89 }
90 
92 {
93 #if FF_API_INIT_PACKET
95  av_init_packet(pkt);
96  pkt->data = NULL;
97  pkt->size = 0;
99 #else
101 #endif
102  pkt->pos = avio_tell(s);
103 
104  return append_packet_chunked(s, pkt, size);
105 }
106 
108 {
109  if (!pkt->size)
110  return av_get_packet(s, pkt, size);
111  return append_packet_chunked(s, pkt, size);
112 }
113 
114 int av_filename_number_test(const char *filename)
115 {
116  char buf[1024];
117  return filename &&
118  (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
119 }
120 
121 /**********************************************************/
122 
123 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
124 {
125  while (tags->id != AV_CODEC_ID_NONE) {
126  if (tags->id == id)
127  return tags->tag;
128  tags++;
129  }
130  return 0;
131 }
132 
133 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
134 {
135  for (int i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
136  if (tag == tags[i].tag)
137  return tags[i].id;
138  for (int i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
139  if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
140  return tags[i].id;
141  return AV_CODEC_ID_NONE;
142 }
143 
144 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
145 {
146  if (bps <= 0 || bps > 64)
147  return AV_CODEC_ID_NONE;
148 
149  if (flt) {
150  switch (bps) {
151  case 32:
153  case 64:
155  default:
156  return AV_CODEC_ID_NONE;
157  }
158  } else {
159  bps += 7;
160  bps >>= 3;
161  if (sflags & (1 << (bps - 1))) {
162  switch (bps) {
163  case 1:
164  return AV_CODEC_ID_PCM_S8;
165  case 2:
167  case 3:
169  case 4:
171  case 8:
173  default:
174  return AV_CODEC_ID_NONE;
175  }
176  } else {
177  switch (bps) {
178  case 1:
179  return AV_CODEC_ID_PCM_U8;
180  case 2:
182  case 3:
184  case 4:
186  default:
187  return AV_CODEC_ID_NONE;
188  }
189  }
190  }
191 }
192 
193 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
194 {
195  unsigned int tag;
196  if (!av_codec_get_tag2(tags, id, &tag))
197  return 0;
198  return tag;
199 }
200 
201 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
202  unsigned int *tag)
203 {
204  for (int i = 0; tags && tags[i]; i++) {
205  const AVCodecTag *codec_tags = tags[i];
206  while (codec_tags->id != AV_CODEC_ID_NONE) {
207  if (codec_tags->id == id) {
208  *tag = codec_tags->tag;
209  return 1;
210  }
211  codec_tags++;
212  }
213  }
214  return 0;
215 }
216 
217 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
218 {
219  for (int i = 0; tags && tags[i]; i++) {
220  enum AVCodecID id = ff_codec_get_id(tags[i], tag);
221  if (id != AV_CODEC_ID_NONE)
222  return id;
223  }
224  return AV_CODEC_ID_NONE;
225 }
226 
228 {
229  av_freep(&par->extradata);
230  par->extradata_size = 0;
231 
232  if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
233  return AVERROR(EINVAL);
234 
236  if (!par->extradata)
237  return AVERROR(ENOMEM);
238 
239  memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
240  par->extradata_size = size;
241 
242  return 0;
243 }
244 
245 /*******************************************************/
246 
247 uint64_t ff_ntp_time(void)
248 {
249  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
250 }
251 
252 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
253 {
254  uint64_t ntp_ts, frac_part, sec;
255  uint32_t usec;
256 
257  //current ntp time in seconds and micro seconds
258  sec = ntp_time_us / 1000000;
259  usec = ntp_time_us % 1000000;
260 
261  //encoding in ntp timestamp format
262  frac_part = usec * 0xFFFFFFFFULL;
263  frac_part /= 1000000;
264 
265  if (sec > 0xFFFFFFFFULL)
266  av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
267 
268  ntp_ts = sec << 32;
269  ntp_ts |= frac_part;
270 
271  return ntp_ts;
272 }
273 
274 uint64_t ff_parse_ntp_time(uint64_t ntp_ts)
275 {
276  uint64_t sec = ntp_ts >> 32;
277  uint64_t frac_part = ntp_ts & 0xFFFFFFFFULL;
278  uint64_t usec = (frac_part * 1000000) / 0xFFFFFFFFULL;
279 
280  return (sec * 1000000) + usec;
281 }
282 
283 int ff_get_frame_filename(char *buf, int buf_size, const char *path, int64_t number, int flags)
284 {
285  const char *p;
286  char *q, buf1[20], c;
287  int nd, len, percentd_found;
288 
289  q = buf;
290  p = path;
291  percentd_found = 0;
292  for (;;) {
293  c = *p++;
294  if (c == '\0')
295  break;
296  if (c == '%') {
297  do {
298  nd = 0;
299  while (av_isdigit(*p)) {
300  if (nd >= INT_MAX / 10 - 255)
301  goto fail;
302  nd = nd * 10 + *p++ - '0';
303  }
304  c = *p++;
305  } while (av_isdigit(c));
306 
307  switch (c) {
308  case '%':
309  goto addchar;
310  case 'd':
311  if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
312  goto fail;
313  percentd_found = 1;
314  if (number < 0)
315  nd += 1;
316  snprintf(buf1, sizeof(buf1), "%0*" PRId64, nd, number);
317  len = strlen(buf1);
318  if ((q - buf + len) > buf_size - 1)
319  goto fail;
320  memcpy(q, buf1, len);
321  q += len;
322  break;
323  default:
324  goto fail;
325  }
326  } else {
327 addchar:
328  if ((q - buf) < buf_size - 1)
329  *q++ = c;
330  }
331  }
332  if (!percentd_found)
333  goto fail;
334  *q = '\0';
335  return 0;
336 fail:
337  *q = '\0';
338  return -1;
339 }
340 
341 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
342 {
343  return ff_get_frame_filename(buf, buf_size, path, number, flags);
344 }
345 
346 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
347 {
348  return ff_get_frame_filename(buf, buf_size, path, number, 0);
349 }
350 
351 void av_url_split(char *proto, int proto_size,
352  char *authorization, int authorization_size,
353  char *hostname, int hostname_size,
354  int *port_ptr, char *path, int path_size, const char *url)
355 {
356  const char *p, *ls, *at, *at2, *col, *brk;
357 
358  if (port_ptr)
359  *port_ptr = -1;
360  if (proto_size > 0)
361  proto[0] = 0;
362  if (authorization_size > 0)
363  authorization[0] = 0;
364  if (hostname_size > 0)
365  hostname[0] = 0;
366  if (path_size > 0)
367  path[0] = 0;
368 
369  /* parse protocol */
370  if ((p = strchr(url, ':'))) {
371  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
372  p++; /* skip ':' */
373  if (*p == '/')
374  p++;
375  if (*p == '/')
376  p++;
377  } else {
378  /* no protocol means plain filename */
379  av_strlcpy(path, url, path_size);
380  return;
381  }
382 
383  /* separate path from hostname */
384  ls = p + strcspn(p, "/?#");
385  av_strlcpy(path, ls, path_size);
386 
387  /* the rest is hostname, use that to parse auth/port */
388  if (ls != p) {
389  /* authorization (user[:pass]@hostname) */
390  at2 = p;
391  while ((at = strchr(p, '@')) && at < ls) {
392  av_strlcpy(authorization, at2,
393  FFMIN(authorization_size, at + 1 - at2));
394  p = at + 1; /* skip '@' */
395  }
396 
397  if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
398  /* [host]:port */
399  av_strlcpy(hostname, p + 1,
400  FFMIN(hostname_size, brk - p));
401  if (brk[1] == ':' && port_ptr)
402  *port_ptr = atoi(brk + 2);
403  } else if ((col = strchr(p, ':')) && col < ls) {
404  av_strlcpy(hostname, p,
405  FFMIN(col + 1 - p, hostname_size));
406  if (port_ptr)
407  *port_ptr = atoi(col + 1);
408  } else
409  av_strlcpy(hostname, p,
410  FFMIN(ls + 1 - p, hostname_size));
411  }
412 }
413 
414 int ff_mkdir_p(const char *path)
415 {
416  int ret = 0;
417  char *temp = av_strdup(path);
418  char *pos = temp;
419  char tmp_ch = '\0';
420 
421  if (!path || !temp) {
422  return -1;
423  }
424 
425  if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
426  pos++;
427  } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
428  pos += 2;
429  }
430 
431  for ( ; *pos != '\0'; ++pos) {
432  if (*pos == '/' || *pos == '\\') {
433  tmp_ch = *pos;
434  *pos = '\0';
435  ret = mkdir(temp, 0755);
436  *pos = tmp_ch;
437  }
438  }
439 
440  if ((*(pos - 1) != '/') && (*(pos - 1) != '\\')) {
441  ret = mkdir(temp, 0755);
442  }
443 
444  av_free(temp);
445  return ret;
446 }
447 
448 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
449 {
450  static const char hex_table_uc[16] = { '0', '1', '2', '3',
451  '4', '5', '6', '7',
452  '8', '9', 'A', 'B',
453  'C', 'D', 'E', 'F' };
454  static const char hex_table_lc[16] = { '0', '1', '2', '3',
455  '4', '5', '6', '7',
456  '8', '9', 'a', 'b',
457  'c', 'd', 'e', 'f' };
458  const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
459 
460  for (int i = 0; i < s; i++) {
461  buff[i * 2] = hex_table[src[i] >> 4];
462  buff[i * 2 + 1] = hex_table[src[i] & 0xF];
463  }
464  buff[2 * s] = '\0';
465 
466  return buff;
467 }
468 
469 int ff_hex_to_data(uint8_t *data, const char *p)
470 {
471  int c, len, v;
472 
473  len = 0;
474  v = 1;
475  for (;;) {
476  p += strspn(p, SPACE_CHARS);
477  if (*p == '\0')
478  break;
479  c = av_toupper((unsigned char) *p++);
480  if (c >= '0' && c <= '9')
481  c = c - '0';
482  else if (c >= 'A' && c <= 'F')
483  c = c - 'A' + 10;
484  else
485  break;
486  v = (v << 4) | c;
487  if (v & 0x100) {
488  if (data)
489  data[len] = v;
490  len++;
491  v = 1;
492  }
493  }
494  return len;
495 }
496 
497 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
498  void *context)
499 {
500  const char *ptr = str;
501 
502  /* Parse key=value pairs. */
503  for (;;) {
504  const char *key;
505  char *dest = NULL, *dest_end;
506  int key_len, dest_len = 0;
507 
508  /* Skip whitespace and potential commas. */
509  while (*ptr && (av_isspace(*ptr) || *ptr == ','))
510  ptr++;
511  if (!*ptr)
512  break;
513 
514  key = ptr;
515 
516  if (!(ptr = strchr(key, '=')))
517  break;
518  ptr++;
519  key_len = ptr - key;
520 
521  callback_get_buf(context, key, key_len, &dest, &dest_len);
522  dest_end = dest ? dest + dest_len - 1 : NULL;
523 
524  if (*ptr == '\"') {
525  ptr++;
526  while (*ptr && *ptr != '\"') {
527  if (*ptr == '\\') {
528  if (!ptr[1])
529  break;
530  if (dest && dest < dest_end)
531  *dest++ = ptr[1];
532  ptr += 2;
533  } else {
534  if (dest && dest < dest_end)
535  *dest++ = *ptr;
536  ptr++;
537  }
538  }
539  if (*ptr == '\"')
540  ptr++;
541  } else {
542  for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
543  if (dest && dest < dest_end)
544  *dest++ = *ptr;
545  }
546  if (dest)
547  *dest = 0;
548  }
549 }
550 
552 {
553 #if CONFIG_NETWORK
554  int ret;
555  if ((ret = ff_network_init()) < 0)
556  return ret;
557  if ((ret = ff_tls_init()) < 0)
558  return ret;
559 #endif
560  return 0;
561 }
562 
564 {
565 #if CONFIG_NETWORK
567  ff_tls_deinit();
568 #endif
569  return 0;
570 }
571 
572 int ff_is_http_proto(const char *filename) {
573  const char *proto = avio_find_protocol_name(filename);
574  return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
575 }
576 
577 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
578 {
579  int ret;
580  char *str;
581 
582  ret = av_bprint_finalize(buf, &str);
583  if (ret < 0)
584  return ret;
585  if (!av_bprint_is_complete(buf)) {
586  av_free(str);
587  return AVERROR(ENOMEM);
588  }
589 
590  par->extradata = str;
591  /* Note: the string is NUL terminated (so extradata can be read as a
592  * string), but the ending character is not accounted in the size (in
593  * binary formats you are likely not supposed to mux that character). When
594  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
595  * zeros. */
596  par->extradata_size = buf->len;
597  return 0;
598 }
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:334
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
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:133
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:354
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:448
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:201
ff_mkdir_p
int ff_mkdir_p(const char *path)
Automatically create sub-directories.
Definition: utils.c:414
ff_ntp_time
uint64_t ff_ntp_time(void)
Get the current time since NTP epoch in microseconds.
Definition: utils.c:247
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:121
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:539
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:341
data
const char data[16]
Definition: mxf.c:149
AV_CODEC_ID_PCM_U24LE
@ AV_CODEC_ID_PCM_U24LE
Definition: codec_id.h:348
ff_toupper4
unsigned int ff_toupper4(unsigned int x)
Definition: to_upper4.h:29
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:346
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:30
av_filename_number_test
int av_filename_number_test(const char *filename)
Check whether filename actually is a numbered sequence generator.
Definition: utils.c:114
AV_CODEC_ID_PCM_S64LE
@ AV_CODEC_ID_PCM_S64LE
Definition: codec_id.h:365
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:335
fail
#define fail()
Definition: checkasm.h:193
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: packet.c:113
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:551
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:338
av_codec_get_tag
unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
Definition: utils.c:193
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:595
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:283
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:107
AV_CODEC_ID_PCM_U16BE
@ AV_CODEC_ID_PCM_U16BE
Definition: codec_id.h:337
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:469
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:349
AV_CODEC_ID_PCM_U32BE
@ AV_CODEC_ID_PCM_U32BE
Definition: codec_id.h:345
AV_CODEC_ID_PCM_S64BE
@ AV_CODEC_ID_PCM_S64BE
Definition: codec_id.h:366
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:497
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:252
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:346
AVPacket::size
int size
Definition: packet.h:540
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:1880
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:144
size
int size
Definition: twinvq_data.h:10344
NTP_OFFSET_US
#define NTP_OFFSET_US
Definition: internal.h:415
av_isdigit
static av_const int av_isdigit(int c)
Locale-independent conversion of ASCII isdigit.
Definition: avstring.h:202
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
AV_FRAME_FILENAME_FLAGS_MULTIPLE
#define AV_FRAME_FILENAME_FLAGS_MULTIPLE
Allow multiple d.
Definition: avformat.h:2944
SANE_CHUNK_SIZE
#define SANE_CHUNK_SIZE
Definition: utils.c:48
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:356
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:351
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:343
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:91
ff_tls_deinit
void ff_tls_deinit(void)
Definition: network.c:51
tag
uint32_t tag
Definition: movenc.c:1879
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:572
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:577
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
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:563
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:494
AV_CODEC_ID_PCM_U32LE
@ AV_CODEC_ID_PCM_U32LE
Definition: codec_id.h:344
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:342
mem.h
ff_codec_get_tag
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:123
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:339
AV_CODEC_ID_PCM_F64LE
@ AV_CODEC_ID_PCM_F64LE
Definition: codec_id.h:357
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVPacket
This structure stores compressed data.
Definition: packet.h:516
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
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:274
AV_CODEC_ID_PCM_U16LE
@ AV_CODEC_ID_PCM_U16LE
Definition: codec_id.h:336
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
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:355
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:217
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:227
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:347
src
#define src
Definition: vp8dsp.c:248
append_packet_chunked
static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
Definition: utils.c:52