FFmpeg
mp3dec.c
Go to the documentation of this file.
1 /*
2  * MP3 demuxer
3  * Copyright (c) 2003 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 "libavutil/opt.h"
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/dict.h"
25 #include "libavutil/mathematics.h"
26 #include "avformat.h"
27 #include "internal.h"
28 #include "avio_internal.h"
29 #include "demux.h"
30 #include "id3v2.h"
31 #include "id3v1.h"
32 #include "replaygain.h"
33 
34 #include "libavcodec/codec_id.h"
35 #include "libavcodec/mpegaudiodecheader.h"
36 
37 #define XING_FLAG_FRAMES 0x01
38 #define XING_FLAG_SIZE 0x02
39 #define XING_FLAG_TOC 0x04
40 #define XING_FLAC_QSCALE 0x08
41 
42 #define XING_TOC_COUNT 100
43 
44 
45 typedef struct {
46  AVClass *class;
47  int64_t filesize;
48  int xing_toc;
49  int start_pad;
50  int end_pad;
51  int usetoc;
52  unsigned frames; /* Total number of frames in file */
53  unsigned header_filesize; /* Total number of bytes in the stream */
54  int is_cbr;
55 } MP3DecContext;
56 
57 enum CheckRet {
58  CHECK_WRONG_HEADER = -1,
59  CHECK_SEEK_FAILED = -2,
60 };
61 
62 static int check(AVIOContext *pb, int64_t pos, uint32_t *header);
63 
64 /* mp3 read */
65 
66 static int mp3_read_probe(const AVProbeData *p)
67 {
68  int max_frames, first_frames = 0;
69  int whole_used = 0;
70  int frames, ret;
71  int framesizes, max_framesizes;
72  uint32_t header;
73  const uint8_t *buf, *buf0, *buf2, *buf3, *end;
74 
75  buf0 = p->buf;
76  end = p->buf + p->buf_size - sizeof(uint32_t);
77  while (buf0 < end && !*buf0)
78  buf0++;
79 
80  max_frames = 0;
81  max_framesizes = 0;
82  buf = buf0;
83 
84  for (; buf < end; buf = buf2+1) {
85  buf2 = buf;
86  for (framesizes = frames = 0; buf2 < end; frames++) {
87  MPADecodeHeader h;
88  int header_emu = 0;
89  int available;
90 
91  header = AV_RB32(buf2);
92  ret = avpriv_mpegaudio_decode_header(&h, header);
93  if (ret != 0)
94  break;
95 
96  available = FFMIN(h.frame_size, end - buf2);
97  for (buf3 = buf2 + 4; buf3 < buf2 + available; buf3++) {
98  uint32_t next_sync = AV_RB32(buf3);
99  header_emu += (next_sync & MP3_MASK) == (header & MP3_MASK);
100  }
101  if (header_emu > 2)
102  break;
103  framesizes += h.frame_size;
104  if (available < h.frame_size) {
105  frames++;
106  break;
107  }
108  buf2 += h.frame_size;
109  }
110  max_frames = FFMAX(max_frames, frames);
111  max_framesizes = FFMAX(max_framesizes, framesizes);
112  if (buf == buf0) {
113  first_frames= frames;
114  if (buf2 == end + sizeof(uint32_t))
115  whole_used = 1;
116  }
117  }
118  // keep this in sync with ac3 probe, both need to avoid
119  // issues with MPEG-files!
120  if (first_frames>=7) return AVPROBE_SCORE_EXTENSION + 1;
121  else if (max_frames>200 && p->buf_size < 2*max_framesizes)return AVPROBE_SCORE_EXTENSION;
122  else if (max_frames>=4 && p->buf_size < 2*max_framesizes) return AVPROBE_SCORE_EXTENSION / 2;
123  else if (ff_id3v2_match(buf0, ID3v2_DEFAULT_MAGIC) && 2*ff_id3v2_tag_len(buf0) >= p->buf_size)
124  return p->buf_size < PROBE_BUF_MAX ? AVPROBE_SCORE_EXTENSION / 4 : AVPROBE_SCORE_EXTENSION - 2;
125  else if (first_frames > 1 && whole_used) return 5;
126  else if (max_frames>=1 && p->buf_size < 10*max_framesizes) return 1;
127  else return 0;
128  //mpegps_mp3_unrecognized_format.mpg has max_frames=3
129 }
130 
131 static void read_xing_toc(AVFormatContext *s, int64_t filesize, int64_t duration)
132 {
133  int i;
134  MP3DecContext *mp3 = s->priv_data;
135  int fast_seek = s->flags & AVFMT_FLAG_FAST_SEEK;
136  int fill_index = (mp3->usetoc || fast_seek) && duration > 0;
137 
138  if (!filesize &&
139  !(filesize = avio_size(s->pb))) {
140  av_log(s, AV_LOG_WARNING, "Cannot determine file size, skipping TOC table.\n");
141  fill_index = 0;
142  }
143 
144  for (i = 0; i < XING_TOC_COUNT; i++) {
145  uint8_t b = avio_r8(s->pb);
146  if (fill_index)
147  av_add_index_entry(s->streams[0],
148  av_rescale(b, filesize, 256),
149  av_rescale(i, duration, XING_TOC_COUNT),
150  0, 0, AVINDEX_KEYFRAME);
151  }
152  if (fill_index)
153  mp3->xing_toc = 1;
154 }
155 
156 static void mp3_parse_info_tag(AVFormatContext *s, AVStream *st,
157  MPADecodeHeader *c, uint32_t spf)
158 {
159 #define LAST_BITS(k, n) ((k) & ((1 << (n)) - 1))
160 #define MIDDLE_BITS(k, m, n) LAST_BITS((k) >> (m), ((n) - (m) + 1))
161 
162  FFStream *const sti = ffstream(st);
163  uint16_t crc;
164  uint32_t v;
165 
166  char version[10];
167 
168  uint32_t peak = 0;
169  int32_t r_gain = INT32_MIN, a_gain = INT32_MIN;
170 
171  MP3DecContext *mp3 = s->priv_data;
172  static const int64_t xing_offtbl[2][2] = {{32, 17}, {17,9}};
173  uint64_t fsize = avio_size(s->pb);
174  int64_t pos = avio_tell(s->pb);
175  fsize = fsize >= pos ? fsize - pos : 0;
176 
177  /* Check for Xing / Info tag */
178  avio_skip(s->pb, xing_offtbl[c->lsf == 1][c->nb_channels == 1]);
179  v = avio_rb32(s->pb);
180  mp3->is_cbr = v == MKBETAG('I', 'n', 'f', 'o');
181  if (v != MKBETAG('X', 'i', 'n', 'g') && !mp3->is_cbr)
182  return;
183 
184  v = avio_rb32(s->pb);
185  if (v & XING_FLAG_FRAMES)
186  mp3->frames = avio_rb32(s->pb);
187  if (v & XING_FLAG_SIZE)
188  mp3->header_filesize = avio_rb32(s->pb);
189  if (fsize && mp3->header_filesize) {
190  uint64_t min, delta;
191  min = FFMIN(fsize, mp3->header_filesize);
192  delta = FFMAX(fsize, mp3->header_filesize) - min;
193  if (fsize > mp3->header_filesize && delta > min >> 4) {
194  mp3->frames = 0;
195  av_log(s, AV_LOG_WARNING,
196  "invalid concatenated file detected - using bitrate for duration\n");
197  } else if (delta > min >> 4) {
198  av_log(s, AV_LOG_WARNING,
199  "filesize and duration do not match (growing file?)\n");
200  }
201  }
202  if (v & XING_FLAG_TOC)
203  read_xing_toc(s, mp3->header_filesize, av_rescale_q(mp3->frames,
204  (AVRational){spf, c->sample_rate},
205  st->time_base));
206  /* VBR quality */
207  if (v & XING_FLAC_QSCALE)
208  avio_rb32(s->pb);
209 
210  /* Encoder short version string */
211  memset(version, 0, sizeof(version));
212  avio_read(s->pb, version, 9);
213 
214  /* Info Tag revision + VBR method */
215  avio_r8(s->pb);
216 
217  /* Lowpass filter value */
218  avio_r8(s->pb);
219 
220  /* ReplayGain peak */
221  v = avio_rb32(s->pb);
222  peak = av_rescale(v, 100000, 1 << 23);
223 
224  /* Radio ReplayGain */
225  v = avio_rb16(s->pb);
226 
227  if (MIDDLE_BITS(v, 13, 15) == 1) {
228  r_gain = MIDDLE_BITS(v, 0, 8) * 10000;
229 
230  if (v & (1 << 9))
231  r_gain *= -1;
232  }
233 
234  /* Audiophile ReplayGain */
235  v = avio_rb16(s->pb);
236 
237  if (MIDDLE_BITS(v, 13, 15) == 2) {
238  a_gain = MIDDLE_BITS(v, 0, 8) * 10000;
239 
240  if (v & (1 << 9))
241  a_gain *= -1;
242  }
243 
244  /* Encoding flags + ATH Type */
245  avio_r8(s->pb);
246 
247  /* if ABR {specified bitrate} else {minimal bitrate} */
248  avio_r8(s->pb);
249 
250  /* Encoder delays */
251  v = avio_rb24(s->pb);
252  if (AV_RB32(version) == MKBETAG('L', 'A', 'M', 'E')
253  || AV_RB32(version) == MKBETAG('L', 'a', 'v', 'f')
254  || AV_RB32(version) == MKBETAG('L', 'a', 'v', 'c')
255  ) {
256 
257  mp3->start_pad = v>>12;
258  mp3-> end_pad = v&4095;
259  sti->start_skip_samples = mp3->start_pad + 528 + 1;
260  if (mp3->frames) {
261  sti->first_discard_sample = -mp3->end_pad + 528 + 1 + mp3->frames * (int64_t)spf;
262  sti->last_discard_sample = mp3->frames * (int64_t)spf;
263  }
264  if (!st->start_time)
265  st->start_time = av_rescale_q(sti->start_skip_samples,
266  (AVRational){1, c->sample_rate},
267  st->time_base);
268  av_log(s, AV_LOG_DEBUG, "pad %d %d\n", mp3->start_pad, mp3-> end_pad);
269  }
270 
271  /* Misc */
272  avio_r8(s->pb);
273 
274  /* MP3 gain */
275  avio_r8(s->pb);
276 
277  /* Preset and surround info */
278  avio_rb16(s->pb);
279 
280  /* Music length */
281  avio_rb32(s->pb);
282 
283  /* Music CRC */
284  avio_rb16(s->pb);
285 
286  /* Info Tag CRC */
287  crc = ffio_get_checksum(s->pb);
288  v = avio_rb16(s->pb);
289 
290  if (v == crc) {
291  ff_replaygain_export_raw(st, r_gain, peak, a_gain, 0);
292  av_dict_set(&st->metadata, "encoder", version, 0);
293  }
294 }
295 
296 static void mp3_parse_vbri_tag(AVFormatContext *s, AVStream *st, int64_t base)
297 {
298  uint32_t v;
299  MP3DecContext *mp3 = s->priv_data;
300 
301  /* Check for VBRI tag (always 32 bytes after end of mpegaudio header) */
302  avio_seek(s->pb, base + 4 + 32, SEEK_SET);
303  v = avio_rb32(s->pb);
304  if (v == MKBETAG('V', 'B', 'R', 'I')) {
305  /* Check tag version */
306  if (avio_rb16(s->pb) == 1) {
307  /* skip delay and quality */
308  avio_skip(s->pb, 4);
309  mp3->header_filesize = avio_rb32(s->pb);
310  mp3->frames = avio_rb32(s->pb);
311  }
312  }
313 }
314 
315 /**
316  * Try to find Xing/Info/VBRI tags and compute duration from info therein
317  */
318 static int mp3_parse_vbr_tags(AVFormatContext *s, AVStream *st, int64_t base)
319 {
320  uint32_t v, spf;
321  MPADecodeHeader c;
322  int vbrtag_size = 0;
323  MP3DecContext *mp3 = s->priv_data;
324  int ret;
325 
326  ffio_init_checksum(s->pb, ff_crcA001_update, 0);
327 
328  v = avio_rb32(s->pb);
329 
330  ret = avpriv_mpegaudio_decode_header(&c, v);
331  if (ret < 0)
332  return ret;
333  else if (ret == 0)
334  vbrtag_size = c.frame_size;
335  if (c.layer != 3)
336  return -1;
337 
338  spf = c.lsf ? 576 : 1152; /* Samples per frame, layer 3 */
339 
340  mp3->frames = 0;
341  mp3->header_filesize = 0;
342 
343  mp3_parse_info_tag(s, st, &c, spf);
344  mp3_parse_vbri_tag(s, st, base);
345 
346  if (!mp3->frames && !mp3->header_filesize)
347  return -1;
348 
349  /* Skip the vbr tag frame */
350  avio_seek(s->pb, base + vbrtag_size, SEEK_SET);
351 
352  if (mp3->frames)
353  st->duration = av_rescale_q(mp3->frames, (AVRational){spf, c.sample_rate},
354  st->time_base);
355  if (mp3->header_filesize && mp3->frames && !mp3->is_cbr)
356  st->codecpar->bit_rate = av_rescale(mp3->header_filesize, 8 * c.sample_rate, mp3->frames * (int64_t)spf);
357 
358  return 0;
359 }
360 
361 static int mp3_read_header(AVFormatContext *s)
362 {
363  FFFormatContext *const si = ffformatcontext(s);
364  MP3DecContext *mp3 = s->priv_data;
365  AVStream *st;
366  FFStream *sti;
367  int64_t off;
368  int ret;
369  int i;
370 
371  s->metadata = si->id3v2_meta;
372  si->id3v2_meta = NULL;
373 
374  st = avformat_new_stream(s, NULL);
375  if (!st)
376  return AVERROR(ENOMEM);
377  sti = ffstream(st);
378 
379  st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
380  st->codecpar->codec_id = AV_CODEC_ID_MP3;
381  sti->need_parsing = AVSTREAM_PARSE_FULL_RAW;
382  st->start_time = 0;
383 
384  // lcm of all mp3 sample rates
385  avpriv_set_pts_info(st, 64, 1, 14112000);
386 
387  ffiocontext(s->pb)->maxsize = -1;
388  off = avio_tell(s->pb);
389 
390  if (!av_dict_count(s->metadata))
391  ff_id3v1_read(s);
392 
393  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
394  mp3->filesize = avio_size(s->pb);
395 
396  if (mp3_parse_vbr_tags(s, st, off) < 0)
397  avio_seek(s->pb, off, SEEK_SET);
398 
399  ret = ff_replaygain_export(st, s->metadata);
400  if (ret < 0)
401  return ret;
402 
403  off = avio_tell(s->pb);
404  for (i = 0; i < 64 * 1024; i++) {
405  uint32_t header, header2;
406  int frame_size;
407  if (!(i&1023))
408  ffio_ensure_seekback(s->pb, i + 1024 + 4);
409  frame_size = check(s->pb, off + i, &header);
410  if (frame_size > 0) {
411  ret = avio_seek(s->pb, off, SEEK_SET);
412  if (ret < 0)
413  return ret;
414  ffio_ensure_seekback(s->pb, i + 1024 + frame_size + 4);
415  ret = check(s->pb, off + i + frame_size, &header2);
416  if (ret >= 0 &&
417  (header & MP3_MASK) == (header2 & MP3_MASK))
418  {
419  av_log(s, i > 0 ? AV_LOG_INFO : AV_LOG_VERBOSE, "Skipping %d bytes of junk at %"PRId64".\n", i, off);
420  ret = avio_seek(s->pb, off + i, SEEK_SET);
421  if (ret < 0)
422  return ret;
423  break;
424  } else if (ret == CHECK_SEEK_FAILED) {
425  av_log(s, AV_LOG_ERROR, "Invalid frame size (%d): Could not seek to %"PRId64".\n", frame_size, off + i + frame_size);
426  return AVERROR(EINVAL);
427  }
428  } else if (frame_size == CHECK_SEEK_FAILED) {
429  av_log(s, AV_LOG_ERROR, "Failed to read frame size: Could not seek to %"PRId64".\n", (int64_t) (i + 1024 + frame_size + 4));
430  return AVERROR(EINVAL);
431  }
432  ret = avio_seek(s->pb, off, SEEK_SET);
433  if (ret < 0)
434  return ret;
435  }
436 
437  off = avio_tell(s->pb);
438  // the seek index is relative to the end of the xing vbr headers
439  for (int i = 0; i < sti->nb_index_entries; i++)
440  sti->index_entries[i].pos += off;
441 
442  /* the parameters will be extracted from the compressed bitstream */
443  return 0;
444 }
445 
446 #define MP3_PACKET_SIZE 1024
447 
448 static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)
449 {
450  MP3DecContext *mp3 = s->priv_data;
451  int ret, size;
452  int64_t pos;
453 
454  size = MP3_PACKET_SIZE;
455  pos = avio_tell(s->pb);
456  if (mp3->filesize > ID3v1_TAG_SIZE && pos < mp3->filesize)
457  size= FFMIN(size, mp3->filesize - pos);
458 
459  ret = av_get_packet(s->pb, pkt, size);
460  if (ret <= 0) {
461  if(ret<0)
462  return ret;
463  return AVERROR_EOF;
464  }
465 
466  pkt->flags &= ~AV_PKT_FLAG_CORRUPT;
467  pkt->stream_index = 0;
468 
469  return ret;
470 }
471 
472 #define SEEK_WINDOW 4096
473 
474 static int check(AVIOContext *pb, int64_t pos, uint32_t *ret_header)
475 {
476  int64_t ret = avio_seek(pb, pos, SEEK_SET);
477  uint8_t header_buf[4];
478  unsigned header;
479  MPADecodeHeader sd;
480  if (ret < 0)
481  return CHECK_SEEK_FAILED;
482 
483  ret = avio_read(pb, &header_buf[0], 4);
484  /* We should always find four bytes for a valid mpa header. */
485  if (ret < 4)
486  return CHECK_SEEK_FAILED;
487 
488  header = AV_RB32(&header_buf[0]);
489  if (ff_mpa_check_header(header) < 0)
490  return CHECK_WRONG_HEADER;
491  if (avpriv_mpegaudio_decode_header(&sd, header) == 1)
492  return CHECK_WRONG_HEADER;
493 
494  if (ret_header)
495  *ret_header = header;
496  return sd.frame_size;
497 }
498 
499 static int64_t mp3_sync(AVFormatContext *s, int64_t target_pos, int flags)
500 {
501  int dir = (flags&AVSEEK_FLAG_BACKWARD) ? -1 : 1;
502  int64_t best_pos;
503  int best_score, i, j;
504  int64_t ret;
505 
506  avio_seek(s->pb, FFMAX(target_pos - SEEK_WINDOW, 0), SEEK_SET);
507  ret = avio_seek(s->pb, target_pos, SEEK_SET);
508  if (ret < 0)
509  return ret;
510 
511 #define MIN_VALID 3
512  best_pos = target_pos;
513  best_score = 999;
514  for (i = 0; i < SEEK_WINDOW; i++) {
515  int64_t pos = target_pos + (dir > 0 ? i - SEEK_WINDOW/4 : -i);
516  int64_t candidate = -1;
517  int score = 999;
518 
519  if (pos < 0)
520  continue;
521 
522  for (j = 0; j < MIN_VALID; j++) {
523  ret = check(s->pb, pos, NULL);
524  if (ret < 0) {
525  if (ret == CHECK_WRONG_HEADER) {
526  break;
527  } else if (ret == CHECK_SEEK_FAILED) {
528  av_log(s, AV_LOG_ERROR, "Could not seek to %"PRId64".\n", pos);
529  return AVERROR(EINVAL);
530  }
531  }
532  if ((target_pos - pos)*dir <= 0 && FFABS(MIN_VALID/2-j) < score) {
533  candidate = pos;
534  score = FFABS(MIN_VALID/2-j);
535  }
536  pos += ret;
537  }
538  if (best_score > score && j == MIN_VALID) {
539  best_pos = candidate;
540  best_score = score;
541  if(score == 0)
542  break;
543  }
544  }
545 
546  return avio_seek(s->pb, best_pos, SEEK_SET);
547 }
548 
549 static int mp3_seek(AVFormatContext *s, int stream_index, int64_t timestamp,
550  int flags)
551 {
552  FFFormatContext *const si = ffformatcontext(s);
553  MP3DecContext *mp3 = s->priv_data;
554  AVIndexEntry *ie, ie1;
555  AVStream *st = s->streams[0];
556  FFStream *const sti = ffstream(st);
557  int64_t best_pos;
558  int fast_seek = s->flags & AVFMT_FLAG_FAST_SEEK;
559  int64_t filesize = mp3->header_filesize;
560 
561  if (filesize <= 0) {
562  int64_t size = avio_size(s->pb);
563  if (size > 0 && size > si->data_offset)
564  filesize = size - si->data_offset;
565  }
566 
567  if (mp3->xing_toc && (mp3->usetoc || (fast_seek && !mp3->is_cbr))) {
568  int64_t ret = av_index_search_timestamp(st, timestamp, flags);
569 
570  // NOTE: The MP3 TOC is not a precise lookup table. Accuracy is worse
571  // for bigger files.
572  av_log(s, AV_LOG_WARNING, "Using MP3 TOC to seek; may be imprecise.\n");
573 
574  if (ret < 0)
575  return ret;
576 
577  ie = &sti->index_entries[ret];
578  } else if (fast_seek && st->duration > 0 && filesize > 0) {
579  if (!mp3->is_cbr)
580  av_log(s, AV_LOG_WARNING, "Using scaling to seek VBR MP3; may be imprecise.\n");
581 
582  ie = &ie1;
583  timestamp = av_clip64(timestamp, 0, st->duration);
584  ie->timestamp = timestamp;
585  ie->pos = av_rescale(timestamp, filesize, st->duration) + si->data_offset;
586  } else {
587  return -1; // generic index code
588  }
589 
590  best_pos = mp3_sync(s, ie->pos, flags);
591  if (best_pos < 0)
592  return best_pos;
593 
594  if (mp3->is_cbr && ie == &ie1 && mp3->frames) {
595  int frame_duration = av_rescale(st->duration, 1, mp3->frames);
596  ie1.timestamp = frame_duration * av_rescale(best_pos - si->data_offset, mp3->frames, mp3->header_filesize);
597  }
598 
599  avpriv_update_cur_dts(s, st, ie->timestamp);
600  return 0;
601 }
602 
603 static const AVOption options[] = {
604  { "usetoc", "use table of contents", offsetof(MP3DecContext, usetoc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM},
605  { NULL },
606 };
607 
608 static const AVClass demuxer_class = {
609  .class_name = "mp3",
610  .item_name = av_default_item_name,
611  .option = options,
612  .version = LIBAVUTIL_VERSION_INT,
613  .category = AV_CLASS_CATEGORY_DEMUXER,
614 };
615 
616 const AVInputFormat ff_mp3_demuxer = {
617  .name = "mp3",
618  .long_name = NULL_IF_CONFIG_SMALL("MP2/3 (MPEG audio layer 2/3)"),
619  .read_probe = mp3_read_probe,
620  .read_header = mp3_read_header,
621  .read_packet = mp3_read_packet,
622  .read_seek = mp3_seek,
623  .priv_data_size = sizeof(MP3DecContext),
624  .flags = AVFMT_GENERIC_INDEX,
625  .extensions = "mp2,mp3,m2a,mpa", /* XXX: use probe */
626  .priv_class = &demuxer_class,
627 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ID3v1_TAG_SIZE
#define ID3v1_TAG_SIZE
Definition: id3v1.h:27
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
opt.h
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: options.c:237
xing_offtbl
static const uint8_t xing_offtbl[2][2]
Definition: mp3enc.c:138
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
XING_FLAC_QSCALE
#define XING_FLAC_QSCALE
Definition: mp3dec.c:40
ffiocontext
static av_always_inline FFIOContext * ffiocontext(AVIOContext *ctx)
Definition: avio_internal.h:82
demuxer_class
static const AVClass demuxer_class
Definition: mp3dec.c:608
mp3_read_packet
static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mp3dec.c:448
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:192
ff_replaygain_export
int ff_replaygain_export(AVStream *st, AVDictionary *metadata)
Parse replaygain tags and export them as per-stream side data.
Definition: replaygain.c:90
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
av_dict_count
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:35
MP3DecContext
Definition: mp3dec.c:45
id3v2.h
FFStream::first_discard_sample
int64_t first_discard_sample
If not 0, the first audio sample that should be discarded from the stream.
Definition: internal.h:293
ff_replaygain_export_raw
int ff_replaygain_export_raw(AVStream *st, int32_t tg, uint32_t tp, int32_t ag, uint32_t ap)
Export already decoded replaygain values as per-stream side data.
Definition: replaygain.c:69
mpegaudiodecheader.h
ff_id3v1_read
void ff_id3v1_read(AVFormatContext *s)
Read an ID3v1 tag.
Definition: id3v1.c:278
AVOption
AVOption.
Definition: opt.h:251
b
#define b
Definition: input.c:34
MPADecodeHeader
Definition: mpegaudiodecheader.h:47
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
base
uint8_t base
Definition: vp3data.h:141
mathematics.h
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:456
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
MP3_MASK
#define MP3_MASK
Definition: mpegaudiodecheader.h:33
id3v1.h
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:352
avpriv_update_cur_dts
void avpriv_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
Update cur_dts of all streams based on the given timestamp and AVStream.
Definition: seek.c:33
ffio_get_checksum
unsigned long ffio_get_checksum(AVIOContext *s)
Definition: aviobuf.c:612
AVIndexEntry
Definition: avformat.h:807
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:815
MIDDLE_BITS
#define MIDDLE_BITS(k, m, n)
XING_FLAG_FRAMES
#define XING_FLAG_FRAMES
Definition: mp3dec.c:37
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:697
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:407
av_add_index_entry
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: seek.c:118
frames
if it could not because there are no more frames
Definition: filter_design.txt:266
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:505
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:482
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:428
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:998
read_xing_toc
static void read_xing_toc(AVFormatContext *s, int64_t filesize, int64_t duration)
Definition: mp3dec.c:131
av_clip64
#define av_clip64
Definition: common.h:98
MP3DecContext::filesize
int64_t filesize
Definition: mp3dec.c:47
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:790
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
avpriv_mpegaudio_decode_header
int avpriv_mpegaudio_decode_header(MPADecodeHeader *s, uint32_t header)
Definition: mpegaudiodecheader.c:34
AVInputFormat
Definition: avformat.h:656
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:430
SEEK_WINDOW
#define SEEK_WINDOW
Definition: mp3dec.c:472
codec_id.h
duration
int64_t duration
Definition: movenc.c:64
MP3_PACKET_SIZE
#define MP3_PACKET_SIZE
Definition: mp3dec.c:446
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:661
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:455
frame_size
int frame_size
Definition: mxfenc.c:2201
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVIndexEntry::timestamp
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:809
MP3DecContext::end_pad
int end_pad
Definition: mp3dec.c:50
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
FFFormatContext::data_offset
int64_t data_offset
offset of the first packet
Definition: internal.h:109
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
MP3DecContext::xing_toc
int xing_toc
Definition: mp3dec.c:48
XING_FLAG_TOC
#define XING_FLAG_TOC
Definition: mp3dec.c:39
fsize
static int64_t fsize(FILE *f)
Definition: audiomatch.c:29
AV_CLASS_CATEGORY_DEMUXER
@ AV_CLASS_CATEGORY_DEMUXER
Definition: log.h:33
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
FFFormatContext
Definition: internal.h:72
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:380
AVFormatContext
Format I/O context.
Definition: avformat.h:1213
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2289
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:978
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
FFStream::nb_index_entries
int nb_index_entries
Definition: internal.h:254
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:453
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:1019
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
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:463
FFIOContext::maxsize
int64_t maxsize
max filesize, used to limit allocations
Definition: avio_internal.h:47
FFFormatContext::id3v2_meta
AVDictionary * id3v2_meta
ID3v2 tag useful for MP3 demuxing.
Definition: internal.h:174
MP3DecContext::start_pad
int start_pad
Definition: mp3dec.c:49
mp3_parse_vbr_tags
static int mp3_parse_vbr_tags(AVFormatContext *s, AVStream *st, int64_t base)
Try to find Xing/Info/VBRI tags and compute duration from info therein.
Definition: mp3dec.c:318
AVIOContext
Bytestream IO Context.
Definition: avio.h:162
avio_rb24
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:783
ff_mpa_check_header
static int ff_mpa_check_header(uint32_t header)
Definition: mpegaudiodecheader.h:62
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
ff_mp3_demuxer
const AVInputFormat ff_mp3_demuxer
Definition: mp3dec.c:616
FFStream
Definition: internal.h:197
FFStream::last_discard_sample
int64_t last_discard_sample
The sample after last sample that is intended to be discarded after first_discard_sample.
Definition: internal.h:300
mp3_read_header
static int mp3_read_header(AVFormatContext *s)
Definition: mp3dec.c:361
MP3DecContext::frames
unsigned frames
Definition: mp3dec.c:52
size
int size
Definition: twinvq_data.h:10344
CHECK_SEEK_FAILED
@ CHECK_SEEK_FAILED
Definition: mp3dec.c:59
ID3v2_DEFAULT_MAGIC
#define ID3v2_DEFAULT_MAGIC
Default magic bytes for ID3v2 header: "ID3".
Definition: id3v2.h:35
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
XING_FLAG_SIZE
#define XING_FLAG_SIZE
Definition: mp3dec.c:38
ffio_init_checksum
void ffio_init_checksum(AVIOContext *s, unsigned long(*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum)
Definition: aviobuf.c:620
header
static const uint8_t header[24]
Definition: sdr2.c:67
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:632
ffio_ensure_seekback
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:1055
XING_TOC_COUNT
#define XING_TOC_COUNT
Definition: mp3dec.c:42
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
FFStream::start_skip_samples
int64_t start_skip_samples
If not 0, the number of samples that should be skipped from the start of the stream (the samples are ...
Definition: internal.h:285
version
version
Definition: libkvazaar.c:313
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
MP3DecContext::is_cbr
int is_cbr
Definition: mp3dec.c:54
PROBE_BUF_MAX
#define PROBE_BUF_MAX
Definition: internal.h:36
AVFMT_FLAG_FAST_SEEK
#define AVFMT_FLAG_FAST_SEEK
Enable fast, but inaccurate seeks for some formats.
Definition: avformat.h:1353
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
avio_internal.h
available
if no frame is available
Definition: filter_design.txt:166
mp3_parse_info_tag
static void mp3_parse_info_tag(AVFormatContext *s, AVStream *st, MPADecodeHeader *c, uint32_t spf)
Definition: mp3dec.c:156
mp3_seek
static int mp3_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: mp3dec.c:549
delta
float delta
Definition: vorbis_enc_data.h:430
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:282
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
mp3_sync
static int64_t mp3_sync(AVFormatContext *s, int64_t target_pos, int flags)
Definition: mp3dec.c:499
mp3_read_probe
static int mp3_read_probe(const AVProbeData *p)
Definition: mp3dec.c:66
demux.h
ff_crcA001_update
unsigned long ff_crcA001_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
Definition: aviobuf.c:606
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
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:102
ff_id3v2_tag_len
int ff_id3v2_tag_len(const uint8_t *buf)
Get the length of an ID3v2 tag.
Definition: id3v2.c:157
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:948
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:775
CheckRet
CheckRet
Definition: mp3dec.c:57
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
dict.h
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:641
mp3_parse_vbri_tag
static void mp3_parse_vbri_tag(AVFormatContext *s, AVStream *st, int64_t base)
Definition: mp3dec.c:296
MP3DecContext::header_filesize
unsigned header_filesize
Definition: mp3dec.c:53
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:808
AVSTREAM_PARSE_FULL_RAW
@ AVSTREAM_PARSE_FULL_RAW
full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...
Definition: avformat.h:802
AVPacket::stream_index
int stream_index
Definition: packet.h:376
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:347
MP3DecContext::usetoc
int usetoc
Definition: mp3dec.c:51
options
static const AVOption options[]
Definition: mp3dec.c:603
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:252
check
static int check(AVIOContext *pb, int64_t pos, uint32_t *header)
Definition: mp3dec.c:474
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:61
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
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:70
int32_t
int32_t
Definition: audioconvert.c:56
replaygain.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:90
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2038
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:988
MIN_VALID
#define MIN_VALID
ff_id3v2_match
int ff_id3v2_match(const uint8_t *buf, const char *magic)
Detect ID3v2 Header.
Definition: id3v2.c:144
av_index_search_timestamp
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: seek.c:238
CHECK_WRONG_HEADER
@ CHECK_WRONG_HEADER
Definition: mp3dec.c:58
min
float min
Definition: vorbis_enc_data.h:429
Generated on Wed Aug 24 2022 21:42:17 for FFmpeg by   doxygen 1.8.17