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 av_get_frame_filename2(char *buf, int buf_size, const char *path, int 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*d", 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_filename(char *buf, int buf_size, const char *path, int number)
342 {
343  return av_get_frame_filename2(buf, buf_size, path, number, 0);
344 }
345 
346 void av_url_split(char *proto, int proto_size,
347  char *authorization, int authorization_size,
348  char *hostname, int hostname_size,
349  int *port_ptr, char *path, int path_size, const char *url)
350 {
351  const char *p, *ls, *at, *at2, *col, *brk;
352 
353  if (port_ptr)
354  *port_ptr = -1;
355  if (proto_size > 0)
356  proto[0] = 0;
357  if (authorization_size > 0)
358  authorization[0] = 0;
359  if (hostname_size > 0)
360  hostname[0] = 0;
361  if (path_size > 0)
362  path[0] = 0;
363 
364  /* parse protocol */
365  if ((p = strchr(url, ':'))) {
366  av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
367  p++; /* skip ':' */
368  if (*p == '/')
369  p++;
370  if (*p == '/')
371  p++;
372  } else {
373  /* no protocol means plain filename */
374  av_strlcpy(path, url, path_size);
375  return;
376  }
377 
378  /* separate path from hostname */
379  ls = p + strcspn(p, "/?#");
380  av_strlcpy(path, ls, path_size);
381 
382  /* the rest is hostname, use that to parse auth/port */
383  if (ls != p) {
384  /* authorization (user[:pass]@hostname) */
385  at2 = p;
386  while ((at = strchr(p, '@')) && at < ls) {
387  av_strlcpy(authorization, at2,
388  FFMIN(authorization_size, at + 1 - at2));
389  p = at + 1; /* skip '@' */
390  }
391 
392  if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
393  /* [host]:port */
394  av_strlcpy(hostname, p + 1,
395  FFMIN(hostname_size, brk - p));
396  if (brk[1] == ':' && port_ptr)
397  *port_ptr = atoi(brk + 2);
398  } else if ((col = strchr(p, ':')) && col < ls) {
399  av_strlcpy(hostname, p,
400  FFMIN(col + 1 - p, hostname_size));
401  if (port_ptr)
402  *port_ptr = atoi(col + 1);
403  } else
404  av_strlcpy(hostname, p,
405  FFMIN(ls + 1 - p, hostname_size));
406  }
407 }
408 
409 int ff_mkdir_p(const char *path)
410 {
411  int ret = 0;
412  char *temp = av_strdup(path);
413  char *pos = temp;
414  char tmp_ch = '\0';
415 
416  if (!path || !temp) {
417  return -1;
418  }
419 
420  if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
421  pos++;
422  } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
423  pos += 2;
424  }
425 
426  for ( ; *pos != '\0'; ++pos) {
427  if (*pos == '/' || *pos == '\\') {
428  tmp_ch = *pos;
429  *pos = '\0';
430  ret = mkdir(temp, 0755);
431  *pos = tmp_ch;
432  }
433  }
434 
435  if ((*(pos - 1) != '/') && (*(pos - 1) != '\\')) {
436  ret = mkdir(temp, 0755);
437  }
438 
439  av_free(temp);
440  return ret;
441 }
442 
443 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
444 {
445  static const char hex_table_uc[16] = { '0', '1', '2', '3',
446  '4', '5', '6', '7',
447  '8', '9', 'A', 'B',
448  'C', 'D', 'E', 'F' };
449  static const char hex_table_lc[16] = { '0', '1', '2', '3',
450  '4', '5', '6', '7',
451  '8', '9', 'a', 'b',
452  'c', 'd', 'e', 'f' };
453  const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
454 
455  for (int i = 0; i < s; i++) {
456  buff[i * 2] = hex_table[src[i] >> 4];
457  buff[i * 2 + 1] = hex_table[src[i] & 0xF];
458  }
459  buff[2 * s] = '\0';
460 
461  return buff;
462 }
463 
464 int ff_hex_to_data(uint8_t *data, const char *p)
465 {
466  int c, len, v;
467 
468  len = 0;
469  v = 1;
470  for (;;) {
471  p += strspn(p, SPACE_CHARS);
472  if (*p == '\0')
473  break;
474  c = av_toupper((unsigned char) *p++);
475  if (c >= '0' && c <= '9')
476  c = c - '0';
477  else if (c >= 'A' && c <= 'F')
478  c = c - 'A' + 10;
479  else
480  break;
481  v = (v << 4) | c;
482  if (v & 0x100) {
483  if (data)
484  data[len] = v;
485  len++;
486  v = 1;
487  }
488  }
489  return len;
490 }
491 
492 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
493  void *context)
494 {
495  const char *ptr = str;
496 
497  /* Parse key=value pairs. */
498  for (;;) {
499  const char *key;
500  char *dest = NULL, *dest_end;
501  int key_len, dest_len = 0;
502 
503  /* Skip whitespace and potential commas. */
504  while (*ptr && (av_isspace(*ptr) || *ptr == ','))
505  ptr++;
506  if (!*ptr)
507  break;
508 
509  key = ptr;
510 
511  if (!(ptr = strchr(key, '=')))
512  break;
513  ptr++;
514  key_len = ptr - key;
515 
516  callback_get_buf(context, key, key_len, &dest, &dest_len);
517  dest_end = dest ? dest + dest_len - 1 : NULL;
518 
519  if (*ptr == '\"') {
520  ptr++;
521  while (*ptr && *ptr != '\"') {
522  if (*ptr == '\\') {
523  if (!ptr[1])
524  break;
525  if (dest && dest < dest_end)
526  *dest++ = ptr[1];
527  ptr += 2;
528  } else {
529  if (dest && dest < dest_end)
530  *dest++ = *ptr;
531  ptr++;
532  }
533  }
534  if (*ptr == '\"')
535  ptr++;
536  } else {
537  for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
538  if (dest && dest < dest_end)
539  *dest++ = *ptr;
540  }
541  if (dest)
542  *dest = 0;
543  }
544 }
545 
547 {
548 #if CONFIG_NETWORK
549  int ret;
550  if ((ret = ff_network_init()) < 0)
551  return ret;
552  if ((ret = ff_tls_init()) < 0)
553  return ret;
554 #endif
555  return 0;
556 }
557 
559 {
560 #if CONFIG_NETWORK
562  ff_tls_deinit();
563 #endif
564  return 0;
565 }
566 
567 int ff_is_http_proto(const char *filename) {
568  const char *proto = avio_find_protocol_name(filename);
569  return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
570 }
571 
572 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
573 {
574  int ret;
575  char *str;
576 
577  ret = av_bprint_finalize(buf, &str);
578  if (ret < 0)
579  return ret;
580  if (!av_bprint_is_complete(buf)) {
581  av_free(str);
582  return AVERROR(ENOMEM);
583  }
584 
585  par->extradata = str;
586  /* Note: the string is NUL terminated (so extradata can be read as a
587  * string), but the ending character is not accounted in the size (in
588  * binary formats you are likely not supposed to mux that character). When
589  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
590  * zeros. */
591  par->extradata_size = buf->len;
592  return 0;
593 }
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:328
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:427
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:186
AV_CODEC_ID_PCM_F32BE
@ AV_CODEC_ID_PCM_F32BE
Definition: codec_id.h:348
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:443
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:409
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
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:524
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:283
data
const char data[16]
Definition: mxf.c:148
AV_CODEC_ID_PCM_U24LE
@ AV_CODEC_ID_PCM_U24LE
Definition: codec_id.h:342
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:341
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:359
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:329
fail
#define fail()
Definition: checkasm.h:182
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:546
SPACE_CHARS
#define SPACE_CHARS
Definition: dnn_backend_tf.c:357
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:332
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:580
AVCodecTag
Definition: internal.h:42
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:331
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:464
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:343
AV_CODEC_ID_PCM_U32BE
@ AV_CODEC_ID_PCM_U32BE
Definition: codec_id.h:339
AV_CODEC_ID_PCM_S64BE
@ AV_CODEC_ID_PCM_S64BE
Definition: codec_id.h:360
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:492
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:340
AVPacket::size
int size
Definition: packet.h:525
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:1789
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:497
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:530
AV_FRAME_FILENAME_FLAGS_MULTIPLE
#define AV_FRAME_FILENAME_FLAGS_MULTIPLE
Allow multiple d.
Definition: avformat.h:2891
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:350
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:346
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:337
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:1788
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:567
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:572
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:365
avformat_network_deinit
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:558
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:576
AV_CODEC_ID_PCM_U32LE
@ AV_CODEC_ID_PCM_U32LE
Definition: codec_id.h:338
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:336
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:333
AV_CODEC_ID_PCM_F64LE
@ AV_CODEC_ID_PCM_F64LE
Definition: codec_id.h:351
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVPacket
This structure stores compressed data.
Definition: packet.h:501
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:544
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:330
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
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:349
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:341
append_packet_chunked
static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
Definition: utils.c:52