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  ffio_ensure_seekback(s->pb, i + 1024 + frame_size + 4);
412  ret = check(s->pb, off + i + frame_size, &header2);
413  if (ret >= 0 &&
414  (header & MP3_MASK) == (header2 & MP3_MASK))
415  {
416  break;
417  } else if (ret == CHECK_SEEK_FAILED) {
418  av_log(s, AV_LOG_ERROR, "Invalid frame size (%d): Could not seek to %"PRId64".\n", frame_size, off + i + frame_size);
419  return AVERROR(EINVAL);
420  }
421  } else if (frame_size == CHECK_SEEK_FAILED) {
422  av_log(s, AV_LOG_ERROR, "Failed to read frame size: Could not seek to %"PRId64".\n", (int64_t) (i + 1024 + frame_size + 4));
423  return AVERROR(EINVAL);
424  }
425  }
426  if (i == 64 * 1024) {
427  off = avio_seek(s->pb, off, SEEK_SET);
428  } else {
429  av_log(s, i > 0 ? AV_LOG_INFO : AV_LOG_VERBOSE, "Skipping %d bytes of junk at %"PRId64".\n", i, off);
430  off = avio_seek(s->pb, off + i, SEEK_SET);
431  }
432  if (off < 0)
433  return off;
434 
435  // the seek index is relative to the end of the xing vbr headers
436  for (int i = 0; i < sti->nb_index_entries; i++)
437  sti->index_entries[i].pos += off;
438 
439  /* the parameters will be extracted from the compressed bitstream */
440  return 0;
441 }
442 
443 #define MP3_PACKET_SIZE 1024
444 
445 static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)
446 {
447  MP3DecContext *mp3 = s->priv_data;
448  int ret, size;
449  int64_t pos;
450 
451  size = MP3_PACKET_SIZE;
452  pos = avio_tell(s->pb);
453  if (mp3->filesize > ID3v1_TAG_SIZE && pos < mp3->filesize)
454  size= FFMIN(size, mp3->filesize - pos);
455 
456  ret = av_get_packet(s->pb, pkt, size);
457  if (ret <= 0) {
458  if(ret<0)
459  return ret;
460  return AVERROR_EOF;
461  }
462 
463  pkt->flags &= ~AV_PKT_FLAG_CORRUPT;
464  pkt->stream_index = 0;
465 
466  return ret;
467 }
468 
469 #define SEEK_WINDOW 4096
470 
471 static int check(AVIOContext *pb, int64_t pos, uint32_t *ret_header)
472 {
473  int64_t ret = avio_seek(pb, pos, SEEK_SET);
474  uint8_t header_buf[4];
475  unsigned header;
476  MPADecodeHeader sd;
477  if (ret < 0)
478  return CHECK_SEEK_FAILED;
479 
480  ret = avio_read(pb, &header_buf[0], 4);
481  /* We should always find four bytes for a valid mpa header. */
482  if (ret < 4)
483  return CHECK_SEEK_FAILED;
484 
485  header = AV_RB32(&header_buf[0]);
486  if (ff_mpa_check_header(header) < 0)
487  return CHECK_WRONG_HEADER;
488  if (avpriv_mpegaudio_decode_header(&sd, header) == 1)
489  return CHECK_WRONG_HEADER;
490 
491  if (ret_header)
492  *ret_header = header;
493  return sd.frame_size;
494 }
495 
496 static int64_t mp3_sync(AVFormatContext *s, int64_t target_pos, int flags)
497 {
498  int dir = (flags&AVSEEK_FLAG_BACKWARD) ? -1 : 1;
499  int64_t best_pos;
500  int best_score, i, j;
501  int64_t ret;
502 
503  avio_seek(s->pb, FFMAX(target_pos - SEEK_WINDOW, 0), SEEK_SET);
504  ret = avio_seek(s->pb, target_pos, SEEK_SET);
505  if (ret < 0)
506  return ret;
507 
508 #define MIN_VALID 3
509  best_pos = target_pos;
510  best_score = 999;
511  for (i = 0; i < SEEK_WINDOW; i++) {
512  int64_t pos = target_pos + (dir > 0 ? i - SEEK_WINDOW/4 : -i);
513  int64_t candidate = -1;
514  int score = 999;
515 
516  if (pos < 0)
517  continue;
518 
519  for (j = 0; j < MIN_VALID; j++) {
520  ret = check(s->pb, pos, NULL);
521  if (ret < 0) {
522  if (ret == CHECK_WRONG_HEADER) {
523  break;
524  } else if (ret == CHECK_SEEK_FAILED) {
525  av_log(s, AV_LOG_ERROR, "Could not seek to %"PRId64".\n", pos);
526  return AVERROR(EINVAL);
527  }
528  }
529  if ((target_pos - pos)*dir <= 0 && FFABS(MIN_VALID/2-j) < score) {
530  candidate = pos;
531  score = FFABS(MIN_VALID/2-j);
532  }
533  pos += ret;
534  }
535  if (best_score > score && j == MIN_VALID) {
536  best_pos = candidate;
537  best_score = score;
538  if(score == 0)
539  break;
540  }
541  }
542 
543  return avio_seek(s->pb, best_pos, SEEK_SET);
544 }
545 
546 static int mp3_seek(AVFormatContext *s, int stream_index, int64_t timestamp,
547  int flags)
548 {
549  FFFormatContext *const si = ffformatcontext(s);
550  MP3DecContext *mp3 = s->priv_data;
551  AVIndexEntry *ie, ie1;
552  AVStream *st = s->streams[0];
553  FFStream *const sti = ffstream(st);
554  int64_t best_pos;
555  int fast_seek = s->flags & AVFMT_FLAG_FAST_SEEK;
556  int64_t filesize = mp3->header_filesize;
557 
558  if (filesize <= 0) {
559  int64_t size = avio_size(s->pb);
560  if (size > 0 && size > si->data_offset)
561  filesize = size - si->data_offset;
562  }
563 
564  if (mp3->xing_toc && (mp3->usetoc || (fast_seek && !mp3->is_cbr))) {
565  int64_t ret = av_index_search_timestamp(st, timestamp, flags);
566 
567  // NOTE: The MP3 TOC is not a precise lookup table. Accuracy is worse
568  // for bigger files.
569  av_log(s, AV_LOG_WARNING, "Using MP3 TOC to seek; may be imprecise.\n");
570 
571  if (ret < 0)
572  return ret;
573 
574  ie = &sti->index_entries[ret];
575  } else if (fast_seek && st->duration > 0 && filesize > 0) {
576  if (!mp3->is_cbr)
577  av_log(s, AV_LOG_WARNING, "Using scaling to seek VBR MP3; may be imprecise.\n");
578 
579  ie = &ie1;
580  timestamp = av_clip64(timestamp, 0, st->duration);
581  ie->timestamp = timestamp;
582  ie->pos = av_rescale(timestamp, filesize, st->duration) + si->data_offset;
583  } else {
584  return -1; // generic index code
585  }
586 
587  best_pos = mp3_sync(s, ie->pos, flags);
588  if (best_pos < 0)
589  return best_pos;
590 
591  if (mp3->is_cbr && ie == &ie1 && mp3->frames) {
592  int frame_duration = av_rescale(st->duration, 1, mp3->frames);
593  ie1.timestamp = frame_duration * av_rescale(best_pos - si->data_offset, mp3->frames, mp3->header_filesize);
594  }
595 
596  avpriv_update_cur_dts(s, st, ie->timestamp);
597  return 0;
598 }
599 
600 static const AVOption options[] = {
601  { "usetoc", "use table of contents", offsetof(MP3DecContext, usetoc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM},
602  { NULL },
603 };
604 
605 static const AVClass demuxer_class = {
606  .class_name = "mp3",
607  .item_name = av_default_item_name,
608  .option = options,
609  .version = LIBAVUTIL_VERSION_INT,
610  .category = AV_CLASS_CATEGORY_DEMUXER,
611 };
612 
613 const AVInputFormat ff_mp3_demuxer = {
614  .name = "mp3",
615  .long_name = NULL_IF_CONFIG_SMALL("MP2/3 (MPEG audio layer 2/3)"),
616  .read_probe = mp3_read_probe,
617  .read_header = mp3_read_header,
618  .read_packet = mp3_read_packet,
619  .read_seek = mp3_seek,
620  .priv_data_size = sizeof(MP3DecContext),
621  .flags = AVFMT_GENERIC_INDEX,
622  .extensions = "mp2,mp3,m2a,mpa", /* XXX: use probe */
623  .priv_class = &demuxer_class,
624 };
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
xing_offtbl
static const uint8_t xing_offtbl[2][2]
Definition: mp3enc.c:139
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
XING_FLAC_QSCALE
#define XING_FLAC_QSCALE
Definition: mp3dec.c:40
ffiocontext
static av_always_inline FFIOContext * ffiocontext(AVIOContext *ctx)
Definition: avio_internal.h:81
demuxer_class
static const AVClass demuxer_class
Definition: mp3dec.c:605
mp3_read_packet
static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mp3dec.c:445
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:194
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
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:94
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:39
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:295
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:41
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:128
mathematics.h
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:455
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:370
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:35
ffio_get_checksum
unsigned long ffio_get_checksum(AVIOContext *s)
Definition: aviobuf.c:630
AVIndexEntry
Definition: avformat.h:700
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:708
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:761
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:420
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:120
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:513
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:481
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:443
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:900
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:99
MP3DecContext::filesize
int64_t filesize
Definition: mp3dec.c:47
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:808
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:549
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:547
SEEK_WINDOW
#define SEEK_WINDOW
Definition: mp3dec.c:469
codec_id.h
duration
int64_t duration
Definition: movenc.c:64
MP3_PACKET_SIZE
#define MP3_PACKET_SIZE
Definition: mp3dec.c:443
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:554
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:454
frame_size
int frame_size
Definition: mxfenc.c:2311
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:702
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:107
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:65
FFFormatContext
Definition: internal.h:70
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:391
AVFormatContext
Format I/O context.
Definition: avformat.h:1115
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:864
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVSEEK_FLAG_BACKWARD
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2224
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:880
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:256
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:452
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:921
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:462
FFIOContext::maxsize
int64_t maxsize
max filesize, used to limit allocations
Definition: avio_internal.h:46
FFFormatContext::id3v2_meta
AVDictionary * id3v2_meta
ID3v2 tag useful for MP3 demuxing.
Definition: internal.h:176
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:166
avio_rb24
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:801
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:106
ff_mp3_demuxer
const AVInputFormat ff_mp3_demuxer
Definition: mp3dec.c:613
FFStream
Definition: internal.h:199
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:302
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:638
header
static const uint8_t header[24]
Definition: sdr2.c:67
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:650
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:1071
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:497
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:287
version
version
Definition: libkvazaar.c:321
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
MP3DecContext::is_cbr
int is_cbr
Definition: mp3dec.c:54
filesize
static int64_t filesize(AVIOContext *pb)
Definition: ffmpeg_mux.c:48
PROBE_BUF_MAX
#define PROBE_BUF_MAX
Definition: internal.h:34
AVFMT_FLAG_FAST_SEEK
#define AVFMT_FLAG_FAST_SEEK
Enable fast, but inaccurate seeks for some formats.
Definition: avformat.h:1252
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
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:546
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:496
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:624
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:103
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:841
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:278
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:793
CheckRet
CheckRet
Definition: mp3dec.c:57
pos
unsigned int pos
Definition: spdifenc.c:413
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:659
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:701
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:695
AVPacket::stream_index
int stream_index
Definition: packet.h:493
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:365
MP3DecContext::usetoc
int usetoc
Definition: mp3dec.c:51
options
static const AVOption options[]
Definition: mp3dec.c:600
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:254
check
static int check(AVIOContext *pb, int64_t pos, uint32_t *header)
Definition: mp3dec.c:471
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:468
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:88
int32_t
int32_t
Definition: audioconvert.c:56
replaygain.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:84
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:890
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:243
CHECK_WRONG_HEADER
@ CHECK_WRONG_HEADER
Definition: mp3dec.c:58
min
float min
Definition: vorbis_enc_data.h:429
Generated on Thu Apr 18 2024 22:42:37 for FFmpeg by   doxygen 1.8.17