FFmpeg
mpeg.c
Go to the documentation of this file.
1 /*
2  * MPEG-1/2 demuxer
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 "config_components.h"
23 
25 #include "libavutil/mem.h"
26 #include "avformat.h"
27 #include "avio_internal.h"
28 #include "demux.h"
29 #include "internal.h"
30 #include "mpeg.h"
31 
32 /*********************************************/
33 /* demux code */
34 
35 #define MAX_SYNC_SIZE 100000
36 
37 static int check_pes(const uint8_t *p, const uint8_t *end)
38 {
39  int pes1;
40  int pes2 = (p[3] & 0xC0) == 0x80 &&
41  (p[4] & 0xC0) != 0x40 &&
42  ((p[4] & 0xC0) == 0x00 ||
43  (p[4] & 0xC0) >> 2 == (p[6] & 0xF0));
44 
45  for (p += 3; p < end && *p == 0xFF; p++) ;
46  if ((*p & 0xC0) == 0x40)
47  p += 2;
48 
49  if ((*p & 0xF0) == 0x20)
50  pes1 = p[0] & p[2] & p[4] & 1;
51  else if ((*p & 0xF0) == 0x30)
52  pes1 = p[0] & p[2] & p[4] & p[5] & p[7] & p[9] & 1;
53  else
54  pes1 = *p == 0x0F;
55 
56  return pes1 || pes2;
57 }
58 
59 static int check_pack_header(const uint8_t *buf)
60 {
61  return (buf[1] & 0xC0) == 0x40 || (buf[1] & 0xF0) == 0x20;
62 }
63 
64 static int mpegps_probe(const AVProbeData *p)
65 {
66  uint32_t code = -1;
67  int i;
68  int sys = 0, pspack = 0, priv1 = 0, vid = 0;
69  int audio = 0, invalid = 0, score = 0;
70  int endpes = 0;
71 
72  for (i = 0; i < p->buf_size; i++) {
73  code = (code << 8) + p->buf[i];
74  if ((code & 0xffffff00) == 0x100) {
75  int len = p->buf[i + 1] << 8 | p->buf[i + 2];
76  int pes = endpes <= i && check_pes(p->buf + i, p->buf + p->buf_size);
77  int pack = check_pack_header(p->buf + i);
78 
79  if (len > INT_MAX - i)
80  break;
81 
83  sys++;
84  else if (code == PACK_START_CODE && pack)
85  pspack++;
86  else if ((code & 0xf0) == VIDEO_ID && pes) {
87  endpes = i + len;
88  vid++;
89  }
90  // skip pes payload to avoid start code emulation for private
91  // and audio streams
92  else if ((code & 0xe0) == AUDIO_ID && pes) {audio++; i+=len;}
93  else if (code == PRIVATE_STREAM_1 && pes) {priv1++; i+=len;}
94  else if (code == 0x1fd && pes) vid++; //VC1
95 
96  else if ((code & 0xf0) == VIDEO_ID && !pes) invalid++;
97  else if ((code & 0xe0) == AUDIO_ID && !pes) invalid++;
98  else if (code == PRIVATE_STREAM_1 && !pes) invalid++;
99  }
100  }
101 
102  if (vid + audio > invalid + 1) /* invalid VDR files nd short PES streams */
103  score = AVPROBE_SCORE_EXTENSION / 2;
104 
105 // av_log(NULL, AV_LOG_ERROR, "vid:%d aud:%d sys:%d pspack:%d invalid:%d size:%d \n",
106 // vid, audio, sys, pspack, invalid, p->buf_size);
107 
108  if (sys > invalid && sys * 9 <= pspack * 10)
109  return (audio > 12 || vid > 3 || pspack > 2) ? AVPROBE_SCORE_EXTENSION + 2
110  : AVPROBE_SCORE_EXTENSION / 2 + (audio + vid + pspack > 1); // 1 more than mp3
111  if (pspack > invalid && (priv1 + vid + audio) * 10 >= pspack * 9)
112  return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2
113  : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg
114  if ((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys &&
115  !pspack && p->buf_size > 2048 && vid + audio > invalid) /* PES stream */
116  return (audio > 12 || vid > 6 + 2 * invalid) ? AVPROBE_SCORE_EXTENSION + 2
118 
119  // 02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
120  // mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6
121  // Have\ Yourself\ a\ Merry\ Little\ Christmas.mp3 0 0 0 5 0 1 len:21618
122  return score;
123 }
124 
125 typedef struct MpegDemuxContext {
127  unsigned char psm_es_type[256];
128  int sofdec;
129  int dvd;
131  int raw_ac3;
133 
135 {
136  MpegDemuxContext *m = s->priv_data;
137  char buffer[7] = { 0 };
138  int64_t last_pos = avio_tell(s->pb);
139 
140  m->header_state = 0xff;
141  s->ctx_flags |= AVFMTCTX_NOHEADER;
142 
143  avio_get_str(s->pb, 6, buffer, sizeof(buffer));
144  if (!memcmp("IMKH", buffer, 4)) {
145  m->imkh_cctv = 1;
146  } else if (!memcmp("Sofdec", buffer, 6)) {
147  m->sofdec = 1;
148  } else
149  avio_seek(s->pb, last_pos, SEEK_SET);
150 
151  /* no need to do more */
152  return 0;
153 }
154 
155 static int64_t get_pts(AVIOContext *pb, int c)
156 {
157  uint8_t buf[5];
158  int ret;
159 
160  buf[0] = c < 0 ? avio_r8(pb) : c;
161  ret = avio_read(pb, buf + 1, 4);
162  if (ret < 4)
163  return AV_NOPTS_VALUE;
164 
165  return ff_parse_pes_pts(buf);
166 }
167 
168 static int find_next_start_code(AVIOContext *pb, int *size_ptr,
169  int32_t *header_state)
170 {
171  unsigned int state, v;
172  int val, n;
173 
174  state = *header_state;
175  n = *size_ptr;
176  while (n > 0) {
177  if (avio_feof(pb))
178  break;
179  v = avio_r8(pb);
180  n--;
181  if (state == 0x000001) {
182  state = ((state << 8) | v) & 0xffffff;
183  val = state;
184  goto found;
185  }
186  state = ((state << 8) | v) & 0xffffff;
187  }
188  val = -1;
189 
190 found:
191  *header_state = state;
192  *size_ptr = n;
193  return val;
194 }
195 
196 /**
197  * Extract stream types from a program stream map
198  * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
199  *
200  * @return number of bytes occupied by PSM in the bitstream
201  */
203 {
204  int psm_length, ps_info_length, es_map_length;
205 
206  psm_length = avio_rb16(pb);
207  avio_r8(pb);
208  avio_r8(pb);
209  ps_info_length = avio_rb16(pb);
210 
211  /* skip program_stream_info */
212  avio_skip(pb, ps_info_length);
213  /*es_map_length = */avio_rb16(pb);
214  /* Ignore es_map_length, trust psm_length */
215  es_map_length = psm_length - ps_info_length - 10;
216 
217  /* at least one es available? */
218  while (es_map_length >= 4) {
219  unsigned char type = avio_r8(pb);
220  unsigned char es_id = avio_r8(pb);
221  uint16_t es_info_length = avio_rb16(pb);
222 
223  /* remember mapping from stream id to stream type */
224  m->psm_es_type[es_id] = type;
225  /* skip program_stream_info */
226  avio_skip(pb, es_info_length);
227  es_map_length -= 4 + es_info_length;
228  }
229  avio_rb32(pb); /* crc32 */
230  return 2 + psm_length;
231 }
232 
233 /* read the next PES header. Return its position in ppos
234  * (if not NULL), and its start code, pts and dts.
235  */
237  int64_t *ppos, int *pstart_code,
238  int64_t *ppts, int64_t *pdts)
239 {
240  MpegDemuxContext *m = s->priv_data;
241  int len, size, startcode, c, flags, header_len;
242  int pes_ext, ext2_len, id_ext, skip;
243  int64_t pts, dts;
244  int64_t last_sync = avio_tell(s->pb);
245 
246 error_redo:
247  avio_seek(s->pb, last_sync, SEEK_SET);
248 redo:
249  /* next start code (should be immediately after) */
250  m->header_state = 0xff;
252  startcode = find_next_start_code(s->pb, &size, &m->header_state);
253  last_sync = avio_tell(s->pb);
254  if (startcode < 0) {
255  if (avio_feof(s->pb))
256  return AVERROR_EOF;
257  // FIXME we should remember header_state
258  return FFERROR_REDO;
259  }
260 
261  if (startcode == PACK_START_CODE)
262  goto redo;
263  if (startcode == SYSTEM_HEADER_START_CODE)
264  goto redo;
265  if (startcode == PADDING_STREAM) {
266  avio_skip(s->pb, avio_rb16(s->pb));
267  goto redo;
268  }
269  if (startcode == PRIVATE_STREAM_2) {
270  if (!m->sofdec) {
271  /* Need to detect whether this from a DVD or a 'Sofdec' stream */
272  int len = avio_rb16(s->pb);
273  int bytesread = 0;
274  uint8_t *ps2buf = av_malloc(len);
275 
276  if (ps2buf) {
277  bytesread = avio_read(s->pb, ps2buf, len);
278 
279  if (bytesread != len) {
280  avio_skip(s->pb, len - bytesread);
281  } else {
282  uint8_t *p = 0;
283  if (len >= 6)
284  p = memchr(ps2buf, 'S', len - 5);
285 
286  if (p)
287  m->sofdec = !memcmp(p+1, "ofdec", 5);
288 
289  m->sofdec -= !m->sofdec;
290 
291  if (m->sofdec < 0) {
292  if (len == 980 && ps2buf[0] == 0) {
293  /* PCI structure? */
294  uint32_t startpts = AV_RB32(ps2buf + 0x0d);
295  uint32_t endpts = AV_RB32(ps2buf + 0x11);
296  uint8_t hours = ((ps2buf[0x19] >> 4) * 10) + (ps2buf[0x19] & 0x0f);
297  uint8_t mins = ((ps2buf[0x1a] >> 4) * 10) + (ps2buf[0x1a] & 0x0f);
298  uint8_t secs = ((ps2buf[0x1b] >> 4) * 10) + (ps2buf[0x1b] & 0x0f);
299 
300  m->dvd = (hours <= 23 &&
301  mins <= 59 &&
302  secs <= 59 &&
303  (ps2buf[0x19] & 0x0f) < 10 &&
304  (ps2buf[0x1a] & 0x0f) < 10 &&
305  (ps2buf[0x1b] & 0x0f) < 10 &&
306  endpts >= startpts);
307  } else if (len == 1018 && ps2buf[0] == 1) {
308  /* DSI structure? */
309  uint8_t hours = ((ps2buf[0x1d] >> 4) * 10) + (ps2buf[0x1d] & 0x0f);
310  uint8_t mins = ((ps2buf[0x1e] >> 4) * 10) + (ps2buf[0x1e] & 0x0f);
311  uint8_t secs = ((ps2buf[0x1f] >> 4) * 10) + (ps2buf[0x1f] & 0x0f);
312 
313  m->dvd = (hours <= 23 &&
314  mins <= 59 &&
315  secs <= 59 &&
316  (ps2buf[0x1d] & 0x0f) < 10 &&
317  (ps2buf[0x1e] & 0x0f) < 10 &&
318  (ps2buf[0x1f] & 0x0f) < 10);
319  }
320  }
321  }
322 
323  av_free(ps2buf);
324 
325  /* If this isn't a DVD packet or no memory
326  * could be allocated, just ignore it.
327  * If we did, move back to the start of the
328  * packet (plus 'length' field) */
329  if (!m->dvd || avio_skip(s->pb, -(len + 2)) < 0) {
330  /* Skip back failed.
331  * This packet will be lost but that can't be helped
332  * if we can't skip back
333  */
334  goto redo;
335  }
336  } else {
337  /* No memory */
338  avio_skip(s->pb, len);
339  goto redo;
340  }
341  } else if (!m->dvd) {
342  int len = avio_rb16(s->pb);
343  avio_skip(s->pb, len);
344  goto redo;
345  }
346  }
347  if (startcode == PROGRAM_STREAM_MAP) {
348  mpegps_psm_parse(m, s->pb);
349  goto redo;
350  }
351 
352  /* find matching stream */
353  if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
354  (startcode >= 0x1e0 && startcode <= 0x1ef) ||
355  (startcode == 0x1bd) ||
356  (startcode == PRIVATE_STREAM_2) ||
357  (startcode == 0x1fd)))
358  goto redo;
359  if (ppos) {
360  *ppos = avio_tell(s->pb) - 4;
361  }
362  len = avio_rb16(s->pb);
363  pts =
364  dts = AV_NOPTS_VALUE;
365  if (startcode != PRIVATE_STREAM_2)
366  {
367  /* stuffing */
368  for (;;) {
369  if (len < 1)
370  goto error_redo;
371  c = avio_r8(s->pb);
372  len--;
373  /* XXX: for MPEG-1, should test only bit 7 */
374  if (c != 0xff)
375  break;
376  }
377  if ((c & 0xc0) == 0x40) {
378  /* buffer scale & size */
379  avio_r8(s->pb);
380  c = avio_r8(s->pb);
381  len -= 2;
382  }
383  if ((c & 0xe0) == 0x20) {
384  dts =
385  pts = get_pts(s->pb, c);
386  len -= 4;
387  if (c & 0x10) {
388  dts = get_pts(s->pb, -1);
389  len -= 5;
390  }
391  } else if ((c & 0xc0) == 0x80) {
392  /* mpeg 2 PES */
393  flags = avio_r8(s->pb);
394  header_len = avio_r8(s->pb);
395  len -= 2;
396  if (header_len > len)
397  goto error_redo;
398  len -= header_len;
399  if (flags & 0x80) {
400  dts = pts = get_pts(s->pb, -1);
401  header_len -= 5;
402  if (flags & 0x40) {
403  dts = get_pts(s->pb, -1);
404  header_len -= 5;
405  }
406  }
407  if (flags & 0x3f && header_len == 0) {
408  flags &= 0xC0;
409  av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");
410  }
411  if (flags & 0x01) { /* PES extension */
412  pes_ext = avio_r8(s->pb);
413  header_len--;
414  /* Skip PES private data, program packet sequence counter
415  * and P-STD buffer */
416  skip = (pes_ext >> 4) & 0xb;
417  skip += skip & 0x9;
418  if (pes_ext & 0x40 || skip > header_len) {
419  av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext);
420  pes_ext = skip = 0;
421  }
422  avio_skip(s->pb, skip);
423  header_len -= skip;
424 
425  if (pes_ext & 0x01) { /* PES extension 2 */
426  ext2_len = avio_r8(s->pb);
427  header_len--;
428  if ((ext2_len & 0x7f) > 0) {
429  id_ext = avio_r8(s->pb);
430  if ((id_ext & 0x80) == 0)
431  startcode = ((startcode & 0xff) << 8) | id_ext;
432  header_len--;
433  }
434  }
435  }
436  if (header_len < 0)
437  goto error_redo;
438  avio_skip(s->pb, header_len);
439  } else if (c != 0xf)
440  goto redo;
441  }
442 
443  if (startcode == PRIVATE_STREAM_1) {
444  int ret = ffio_ensure_seekback(s->pb, 2);
445 
446  if (ret < 0)
447  return ret;
448 
449  startcode = avio_r8(s->pb);
450  m->raw_ac3 = 0;
451  if (startcode == 0x0b) {
452  if (avio_r8(s->pb) == 0x77) {
453  startcode = 0x80;
454  m->raw_ac3 = 1;
455  avio_skip(s->pb, -2);
456  } else {
457  avio_skip(s->pb, -1);
458  }
459  } else {
460  len--;
461  }
462  }
463  if (len < 0)
464  goto error_redo;
465  if (dts != AV_NOPTS_VALUE && ppos) {
466  int i;
467  for (i = 0; i < s->nb_streams; i++) {
468  if (startcode == s->streams[i]->id &&
469  (s->pb->seekable & AVIO_SEEKABLE_NORMAL) /* index useless on streams anyway */) {
470  ff_reduce_index(s, i);
471  av_add_index_entry(s->streams[i], *ppos, dts, 0, 0,
472  AVINDEX_KEYFRAME /* FIXME keyframe? */);
473  }
474  }
475  }
476 
477  *pstart_code = startcode;
478  *ppts = pts;
479  *pdts = dts;
480  return len;
481 }
482 
484  AVPacket *pkt)
485 {
486  MpegDemuxContext *m = s->priv_data;
487  AVStream *st;
488  FFStream *sti;
489  int len, startcode, i, es_type, ret;
490  int pcm_dvd = 0;
491  int request_probe= 0;
493  enum AVMediaType type;
494  int64_t pts, dts, dummy_pos; // dummy_pos is needed for the index building to work
495 
496 redo:
497  len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
498  if (len < 0)
499  return len;
500 
501  if (startcode >= 0x80 && startcode <= 0xcf) {
502  if (len < 4)
503  goto skip;
504 
505  if (!m->raw_ac3) {
506  /* audio: skip header */
507  avio_skip(s->pb, 3);
508  len -= 3;
509  if (startcode >= 0xb0 && startcode <= 0xbf) {
510  /* MLP/TrueHD audio has a 4-byte header */
511  avio_r8(s->pb);
512  len--;
513  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
514  ret = ffio_ensure_seekback(s->pb, 3);
515  if (ret < 0)
516  return ret;
517  pcm_dvd = (avio_rb24(s->pb) & 0xFF) == 0x80;
518  avio_skip(s->pb, -3);
519  }
520  }
521  }
522 
523  /* now find stream */
524  for (i = 0; i < s->nb_streams; i++) {
525  st = s->streams[i];
526  if (st->id == startcode)
527  goto found;
528  }
529 
530  es_type = m->psm_es_type[startcode & 0xff];
531  if (es_type == STREAM_TYPE_VIDEO_MPEG1) {
534  } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {
537  } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||
538  es_type == STREAM_TYPE_AUDIO_MPEG2) {
541  } else if (es_type == STREAM_TYPE_AUDIO_AAC) {
544  } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {
547  } else if (es_type == STREAM_TYPE_VIDEO_H264) {
550  } else if (es_type == STREAM_TYPE_VIDEO_HEVC) {
553  } else if (es_type == STREAM_TYPE_VIDEO_VVC) {
556  } else if (es_type == STREAM_TYPE_AUDIO_AC3) {
559  } else if (es_type == 0x90) {
562  } else if (m->imkh_cctv && es_type == 0x91) {
565  } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
566  static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
567  unsigned char buf[8];
568 
569  ret = avio_read(s->pb, buf, 8);
570  if (ret != 8)
571  return AVERROR_INVALIDDATA;
572  avio_seek(s->pb, -8, SEEK_CUR);
573  if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
575  else
576  request_probe= 1;
578  } else if (startcode == PRIVATE_STREAM_2) {
581  } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
583  if (m->sofdec > 0) {
585  // Auto-detect AC-3
586  request_probe = 50;
587  } else if (m->imkh_cctv && startcode == 0x1c0 && len > 80) {
589  request_probe = 50;
590  } else {
592  if (m->imkh_cctv)
593  request_probe = 25;
594  }
595  } else if (startcode >= 0x80 && startcode <= 0x87) {
598  } else if ((startcode >= 0x88 && startcode <= 0x8f) ||
599  (startcode >= 0x98 && startcode <= 0x9f)) {
600  /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
603  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
605  if (!pcm_dvd) {
607  } else {
609  }
610  } else if (startcode >= 0xb0 && startcode <= 0xbf) {
613  } else if (startcode >= 0xc0 && startcode <= 0xcf) {
614  /* Used for both AC-3 and E-AC-3 in EVOB files */
617  } else if (startcode >= 0x20 && startcode <= 0x3f) {
620  } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
623  } else if (startcode == 0x69 || startcode == 0x49) {
626  } else {
627 skip:
628  /* skip packet */
629  avio_skip(s->pb, len);
630  goto redo;
631  }
632  /* no stream found: add a new stream */
633  st = avformat_new_stream(s, NULL);
634  if (!st)
635  goto skip;
636  sti = ffstream(st);
637  st->id = startcode;
638  st->codecpar->codec_type = type;
639  st->codecpar->codec_id = codec_id;
643  st->codecpar->sample_rate = 8000;
644  }
645  sti->request_probe = request_probe;
647 
648 found:
649  if (st->discard >= AVDISCARD_ALL)
650  goto skip;
651  if (startcode >= 0xa0 && startcode <= 0xaf) {
652  if (st->codecpar->codec_id == AV_CODEC_ID_MLP) {
653  if (len < 6)
654  goto skip;
655  avio_skip(s->pb, 6);
656  len -=6;
657  }
658  }
659  ret = av_get_packet(s->pb, pkt, len);
660 
661  pkt->pts = pts;
662  pkt->dts = dts;
663  pkt->pos = dummy_pos;
664  pkt->stream_index = st->index;
665 
666  if (s->debug & FF_FDEBUG_TS)
667  av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
668  pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
669  pkt->size);
670 
671  return (ret < 0) ? ret : 0;
672 }
673 
674 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
675  int64_t *ppos, int64_t pos_limit)
676 {
677  int len, startcode;
678  int64_t pos, pts, dts;
679 
680  pos = *ppos;
681  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
682  return AV_NOPTS_VALUE;
683 
684  for (;;) {
685  len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
686  if (len < 0) {
687  if (s->debug & FF_FDEBUG_TS)
688  av_log(s, AV_LOG_DEBUG, "none (ret=%d)\n", len);
689  return AV_NOPTS_VALUE;
690  }
691  if (startcode == s->streams[stream_index]->id &&
692  dts != AV_NOPTS_VALUE) {
693  break;
694  }
695  avio_skip(s->pb, len);
696  }
697  if (s->debug & FF_FDEBUG_TS)
698  av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
699  pos, dts, dts / 90000.0);
700  *ppos = pos;
701  return dts;
702 }
703 
705  .p.name = "mpeg",
706  .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),
707  .p.flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,
708  .priv_data_size = sizeof(MpegDemuxContext),
713 };
714 
715 #if CONFIG_VOBSUB_DEMUXER
716 
717 #include "subtitles.h"
718 #include "libavutil/avassert.h"
719 #include "libavutil/bprint.h"
720 #include "libavutil/opt.h"
721 
722 #define REF_STRING "# VobSub index file,"
723 #define MAX_LINE_SIZE 2048
724 
725 typedef struct VobSubDemuxContext {
726  const AVClass *class;
727  AVFormatContext *sub_ctx;
728  FFDemuxSubtitlesQueue q[32];
729  char *sub_name;
730 } VobSubDemuxContext;
731 
732 static int vobsub_probe(const AVProbeData *p)
733 {
734  if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))
735  return AVPROBE_SCORE_MAX;
736  return 0;
737 }
738 
739 static int vobsub_read_close(AVFormatContext *s)
740 {
741  VobSubDemuxContext *vobsub = s->priv_data;
742  int i;
743 
744  for (i = 0; i < s->nb_streams; i++)
745  ff_subtitles_queue_clean(&vobsub->q[i]);
746  avformat_close_input(&vobsub->sub_ctx);
747  return 0;
748 }
749 
750 static int vobsub_read_header(AVFormatContext *s)
751 {
752  int i, ret = 0, header_parsed = 0, langidx = 0;
753  VobSubDemuxContext *vobsub = s->priv_data;
754  const AVInputFormat *iformat;
755  size_t fname_len;
756  AVBPrint header;
757  int64_t delay = 0;
758  AVStream *st = NULL;
759  int stream_id = -1;
760  char id[64] = {0};
761  char alt[MAX_LINE_SIZE] = {0};
762 
763  if (!vobsub->sub_name) {
764  char *ext;
765  vobsub->sub_name = av_strdup(s->url);
766  if (!vobsub->sub_name) {
767  return AVERROR(ENOMEM);
768  }
769 
770  fname_len = strlen(vobsub->sub_name);
771  ext = vobsub->sub_name - 3 + fname_len;
772  if (fname_len < 4 || *(ext - 1) != '.') {
773  av_log(s, AV_LOG_ERROR, "The input index filename is too short "
774  "to guess the associated .SUB file\n");
775  return AVERROR_INVALIDDATA;
776  }
777  memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3);
778  av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->url, vobsub->sub_name);
779  }
780 
781  if (!(iformat = av_find_input_format("mpeg"))) {
783  }
784 
785  vobsub->sub_ctx = avformat_alloc_context();
786  if (!vobsub->sub_ctx) {
787  return AVERROR(ENOMEM);
788  }
789 
790  if ((ret = ff_copy_whiteblacklists(vobsub->sub_ctx, s)) < 0)
791  return ret;
792 
793  ret = avformat_open_input(&vobsub->sub_ctx, vobsub->sub_name, iformat, NULL);
794  if (ret < 0) {
795  av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", vobsub->sub_name);
796  return ret;
797  }
798 
800 
801  while (!avio_feof(s->pb)) {
802  char line[MAX_LINE_SIZE];
803  int len = ff_get_line(s->pb, line, sizeof(line));
804 
805  if (!len)
806  break;
807 
808  line[strcspn(line, "\r\n")] = 0;
809 
810  if (!strncmp(line, "id:", 3)) {
811  if (sscanf(line, "id: %63[^,], index: %u", id, &stream_id) != 2) {
812  av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', "
813  "assuming 'id: und, index: 0'\n", line);
814  strcpy(id, "und");
815  stream_id = 0;
816  }
817 
818  if (stream_id >= FF_ARRAY_ELEMS(vobsub->q)) {
819  av_log(s, AV_LOG_ERROR, "Maximum number of subtitles streams reached\n");
820  ret = AVERROR(EINVAL);
821  goto end;
822  }
823 
824  header_parsed = 1;
825  alt[0] = '\0';
826  /* We do not create the stream immediately to avoid adding empty
827  * streams. See the following timestamp entry. */
828 
829  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);
830 
831  } else if (!strncmp(line, "timestamp:", 10)) {
832  AVPacket *sub;
833  int hh, mm, ss, ms;
834  int64_t pos, timestamp;
835  const char *p = line + 10;
836 
837  if (stream_id == -1) {
838  av_log(s, AV_LOG_ERROR, "Timestamp declared before any stream\n");
840  goto end;
841  }
842 
843  if (!st || st->id != stream_id) {
844  st = avformat_new_stream(s, NULL);
845  if (!st) {
846  ret = AVERROR(ENOMEM);
847  goto end;
848  }
849  st->id = stream_id;
852  avpriv_set_pts_info(st, 64, 1, 1000);
853  av_dict_set(&st->metadata, "language", id, 0);
854  if (alt[0])
855  av_dict_set(&st->metadata, "title", alt, 0);
856  }
857 
858  if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"SCNx64,
859  &hh, &mm, &ss, &ms, &pos) != 5) {
860  av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "
861  "abort parsing\n", line);
863  goto end;
864  }
865  timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay;
866  timestamp = av_rescale_q(timestamp, av_make_q(1, 1000), st->time_base);
867 
868  sub = ff_subtitles_queue_insert(&vobsub->q[s->nb_streams - 1], "", 0, 0);
869  if (!sub) {
870  ret = AVERROR(ENOMEM);
871  goto end;
872  }
873  sub->pos = pos;
874  sub->pts = timestamp;
875  sub->stream_index = s->nb_streams - 1;
876 
877  } else if (!strncmp(line, "alt:", 4)) {
878  const char *p = line + 4;
879 
880  while (*p == ' ')
881  p++;
882  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", stream_id, p);
883  av_strlcpy(alt, p, sizeof(alt));
884  header_parsed = 1;
885 
886  } else if (!strncmp(line, "delay:", 6)) {
887  int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0;
888  const char *p = line + 6;
889 
890  while (*p == ' ')
891  p++;
892  if (*p == '-' || *p == '+') {
893  sign = *p == '-' ? -1 : 1;
894  p++;
895  }
896  sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms);
897  delay = ((hh*3600LL + mm*60LL + ss) * 1000LL + ms) * sign;
898 
899  } else if (!strncmp(line, "langidx:", 8)) {
900  const char *p = line + 8;
901 
902  if (sscanf(p, "%d", &langidx) != 1)
903  av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n");
904 
905  } else if (!header_parsed) {
906  if (line[0] && line[0] != '#')
907  av_bprintf(&header, "%s\n", line);
908  }
909  }
910 
911  if (langidx < s->nb_streams)
912  s->streams[langidx]->disposition |= AV_DISPOSITION_DEFAULT;
913 
914  for (i = 0; i < s->nb_streams; i++) {
915  vobsub->q[i].sort = SUB_SORT_POS_TS;
916  vobsub->q[i].keep_duplicates = 1;
917  ff_subtitles_queue_finalize(s, &vobsub->q[i]);
918  }
919 
920  if (!av_bprint_is_complete(&header)) {
921  ret = AVERROR(ENOMEM);
922  goto end;
923  }
924  for (i = 0; i < s->nb_streams; i++) {
925  AVCodecParameters *par = s->streams[i]->codecpar;
926  ret = ff_alloc_extradata(par, header.len);
927  if (ret < 0) {
928  goto end;
929  }
930  memcpy(par->extradata, header.str, header.len);
931  }
932 end:
934  return ret;
935 }
936 
937 static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt)
938 {
939  VobSubDemuxContext *vobsub = s->priv_data;
941  AVIOContext *pb = vobsub->sub_ctx->pb;
942  int ret, psize, total_read = 0, i;
943 
944  int64_t min_ts = INT64_MAX;
945  int sid = 0;
946  for (i = 0; i < s->nb_streams; i++) {
947  FFDemuxSubtitlesQueue *tmpq = &vobsub->q[i];
948  int64_t ts;
949  av_assert0(tmpq->nb_subs);
950 
951  if (tmpq->current_sub_idx >= tmpq->nb_subs)
952  continue;
953 
954  ts = tmpq->subs[tmpq->current_sub_idx]->pts;
955  if (ts < min_ts) {
956  min_ts = ts;
957  sid = i;
958  }
959  }
960  q = &vobsub->q[sid];
961  /* The returned packet will have size zero,
962  * so that it can be directly used with av_grow_packet. */
964  if (ret < 0)
965  return ret;
966 
967  /* compute maximum packet size using the next packet position. This is
968  * useful when the len in the header is non-sense */
969  if (q->current_sub_idx < q->nb_subs) {
970  psize = q->subs[q->current_sub_idx]->pos - pkt->pos;
971  } else {
972  int64_t fsize = avio_size(pb);
973  psize = fsize < 0 ? 0xffff : fsize - pkt->pos;
974  }
975 
976  avio_seek(pb, pkt->pos, SEEK_SET);
977 
978  do {
979  int n, to_read, startcode;
980  int64_t pts, dts;
981  int64_t old_pos = avio_tell(pb), new_pos;
982  int pkt_size;
983 
984  ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);
985  if (ret < 0) {
986  if (pkt->size) // raise packet even if incomplete
987  break;
988  return ret;
989  }
990  to_read = ret & 0xffff;
991  new_pos = avio_tell(pb);
992  pkt_size = ret + (new_pos - old_pos);
993 
994  /* this prevents reads above the current packet */
995  if (total_read + pkt_size > psize)
996  break;
997  total_read += pkt_size;
998 
999  /* the current chunk doesn't match the stream index (unlikely) */
1000  if ((startcode & 0x1f) != s->streams[pkt->stream_index]->id)
1001  break;
1002 
1003  ret = av_grow_packet(pkt, to_read);
1004  if (ret < 0)
1005  return ret;
1006 
1007  n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);
1008  if (n < to_read)
1009  pkt->size -= to_read - n;
1010  } while (total_read < psize);
1011 
1012  return 0;
1013 }
1014 
1015 static int vobsub_read_seek(AVFormatContext *s, int stream_index,
1016  int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1017 {
1018  VobSubDemuxContext *vobsub = s->priv_data;
1019 
1020  /* Rescale requested timestamps based on the first stream (timebase is the
1021  * same for all subtitles stream within a .idx/.sub). Rescaling is done just
1022  * like in avformat_seek_file(). */
1023  if (stream_index == -1 && s->nb_streams != 1) {
1024  int i, ret = 0;
1025  AVRational time_base = s->streams[0]->time_base;
1026  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
1027  min_ts = av_rescale_rnd(min_ts, time_base.den,
1028  time_base.num * (int64_t)AV_TIME_BASE,
1030  max_ts = av_rescale_rnd(max_ts, time_base.den,
1031  time_base.num * (int64_t)AV_TIME_BASE,
1033  for (i = 0; i < s->nb_streams; i++) {
1034  int r = ff_subtitles_queue_seek(&vobsub->q[i], s, stream_index,
1035  min_ts, ts, max_ts, flags);
1036  if (r < 0)
1037  ret = r;
1038  }
1039  return ret;
1040  }
1041 
1042  if (stream_index == -1) // only 1 stream
1043  stream_index = 0;
1044  return ff_subtitles_queue_seek(&vobsub->q[stream_index], s, stream_index,
1045  min_ts, ts, max_ts, flags);
1046 }
1047 
1048 static const AVOption options[] = {
1049  { "sub_name", "URI for .sub file", offsetof(VobSubDemuxContext, sub_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_DECODING_PARAM },
1050  { NULL }
1051 };
1052 
1053 static const AVClass vobsub_demuxer_class = {
1054  .class_name = "vobsub",
1055  .item_name = av_default_item_name,
1056  .option = options,
1057  .version = LIBAVUTIL_VERSION_INT,
1058 };
1059 
1061  .p.name = "vobsub",
1062  .p.long_name = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),
1063  .p.flags = AVFMT_SHOW_IDS,
1064  .p.extensions = "idx",
1065  .p.priv_class = &vobsub_demuxer_class,
1066  .priv_data_size = sizeof(VobSubDemuxContext),
1067  .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,
1068  .read_probe = vobsub_probe,
1069  .read_header = vobsub_read_header,
1070  .read_packet = vobsub_read_packet,
1071  .read_seek2 = vobsub_read_seek,
1072  .read_close = vobsub_read_close,
1073 };
1074 #endif
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:134
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
MAX_LINE_SIZE
#define MAX_LINE_SIZE
Definition: vf_lut3d.c:547
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:451
SYSTEM_HEADER_START_CODE
#define SYSTEM_HEADER_START_CODE
Definition: mpeg.h:29
mpegps_read_packet
static int mpegps_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpeg.c:483
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
r
const char * r
Definition: vf_curves.c:127
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
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:477
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1579
STREAM_TYPE_AUDIO_AAC
#define STREAM_TYPE_AUDIO_AAC
Definition: mpeg.h:55
ff_parse_pes_pts
static int64_t ff_parse_pes_pts(const uint8_t *buf)
Parse MPEG-PES five-byte timestamp.
Definition: mpeg.h:69
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:819
FFDemuxSubtitlesQueue::nb_subs
int nb_subs
number of subtitles packets
Definition: subtitles.h:105
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
int64_t
long long int64_t
Definition: coverity.c:34
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: packet.c:122
AV_DISPOSITION_DEFAULT
#define AV_DISPOSITION_DEFAULT
The stream should be chosen by default among other streams of the same type, unless the user has expl...
Definition: avformat.h:621
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
STREAM_TYPE_AUDIO_MPEG1
#define STREAM_TYPE_AUDIO_MPEG1
Definition: mpeg.h:51
ff_vobsub_demuxer
const FFInputFormat ff_vobsub_demuxer
STREAM_TYPE_VIDEO_VVC
#define STREAM_TYPE_VIDEO_VVC
Definition: mpeg.h:59
AVPacket::data
uint8_t * data
Definition: packet.h:539
AVOption
AVOption.
Definition: opt.h:429
find_next_start_code
static int find_next_start_code(AVIOContext *pb, int *size_ptr, int32_t *header_state)
Definition: mpeg.c:168
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
AUDIO_ID
#define AUDIO_ID
Definition: mpeg.h:41
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:323
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:492
MpegDemuxContext::dvd
int dvd
Definition: mpeg.c:129
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
STREAM_TYPE_AUDIO_MPEG2
#define STREAM_TYPE_AUDIO_MPEG2
Definition: mpeg.h:52
FFDemuxSubtitlesQueue::current_sub_idx
int current_sub_idx
current position for the read packet callback
Definition: subtitles.h:107
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:366
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:868
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:358
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:122
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
val
static double val(void *priv, double ch)
Definition: aeval.c:77
type
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 type
Definition: writing_filters.txt:86
pts
static int64_t pts
Definition: transcode_aac.c:644
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:449
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:202
AVRational::num
int num
Numerator.
Definition: rational.h:59
ff_subtitles_queue_seek
int ff_subtitles_queue_seek(FFDemuxSubtitlesQueue *q, AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Update current_sub_idx to emulate a seek.
Definition: subtitles.c:269
avassert.h
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:761
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
PROGRAM_STREAM_MAP
#define PROGRAM_STREAM_MAP
Definition: mpeg.h:36
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVInputFormat
Definition: avformat.h:548
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: demux.c:216
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
STREAM_TYPE_AUDIO_AC3
#define STREAM_TYPE_AUDIO_AC3
Definition: mpeg.h:62
STREAM_TYPE_VIDEO_MPEG4
#define STREAM_TYPE_VIDEO_MPEG4
Definition: mpeg.h:56
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:553
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:448
get_pts
static int64_t get_pts(AVIOContext *pb, int c)
Definition: mpeg.c:155
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
nb_streams
static int nb_streams
Definition: ffprobe.c:385
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
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:341
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:410
AV_CODEC_ID_PCM_DVD
@ AV_CODEC_ID_PCM_DVD
Definition: codec_id.h:354
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
STREAM_TYPE_VIDEO_MPEG1
#define STREAM_TYPE_VIDEO_MPEG1
Definition: mpeg.h:49
fsize
static int64_t fsize(FILE *f)
Definition: audiomatch.c:29
ff_subtitles_queue_read_packet
int ff_subtitles_queue_read_packet(FFDemuxSubtitlesQueue *q, AVPacket *pkt)
Generic read_packet() callback for subtitles demuxers using this queue system.
Definition: subtitles.c:230
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
AV_ROUND_PASS_MINMAX
@ AV_ROUND_PASS_MINMAX
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
Definition: mathematics.h:159
AV_CODEC_ID_DVD_NAV
@ AV_CODEC_ID_DVD_NAV
Definition: codec_id.h:597
if
if(ret)
Definition: filter_design.txt:179
AVERROR_DEMUXER_NOT_FOUND
#define AVERROR_DEMUXER_NOT_FOUND
Demuxer not found.
Definition: error.h:55
FF_INFMT_FLAG_INIT_CLEANUP
#define FF_INFMT_FLAG_INIT_CLEANUP
For an FFInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: demux.h:35
SUB_SORT_POS_TS
@ SUB_SORT_POS_TS
sort by position, then timestamps
Definition: subtitles.h:32
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:325
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:221
AVFormatContext
Format I/O context.
Definition: avformat.h:1300
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:342
internal.h
mpegps_read_header
static int mpegps_read_header(AVFormatContext *s)
Definition: mpeg.c:134
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
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:787
NULL
#define NULL
Definition: coverity.c:32
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1251
check_pes
static int check_pes(const uint8_t *p, const uint8_t *end)
Definition: mpeg.c:37
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: avformat.c:913
AV_CODEC_ID_DVD_SUBTITLE
@ AV_CODEC_ID_DVD_SUBTITLE
Definition: codec_id.h:558
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
options
Definition: swscale.c:42
ff_mpegps_demuxer
const FFInputFormat ff_mpegps_demuxer
Definition: mpeg.c:704
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:828
PACK_START_CODE
#define PACK_START_CODE
Definition: mpeg.h:28
ff_subtitles_queue_insert
AVPacket * ff_subtitles_queue_insert(FFDemuxSubtitlesQueue *q, const uint8_t *event, size_t len, int merge)
Insert a new subtitle event.
Definition: subtitles.c:111
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
MpegDemuxContext::sofdec
int sofdec
Definition: mpeg.c:128
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:461
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:450
AV_ROUND_DOWN
@ AV_ROUND_DOWN
Round toward -infinity.
Definition: mathematics.h:133
av_rescale_rnd
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
options
const OptionDef options[]
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
avio_rb24
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:754
MpegDemuxContext::psm_es_type
unsigned char psm_es_type[256]
Definition: mpeg.c:127
AVMediaType
AVMediaType
Definition: avutil.h:199
AV_CODEC_ID_ADPCM_ADX
@ AV_CODEC_ID_ADPCM_ADX
Definition: codec_id.h:383
AVPacket::size
int size
Definition: packet.h:540
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:94
PRIVATE_STREAM_1
#define PRIVATE_STREAM_1
Definition: mpeg.h:37
check_pack_header
static int check_pack_header(const uint8_t *buf)
Definition: mpeg.c:59
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:162
state
static struct @474 state
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
STREAM_TYPE_VIDEO_HEVC
#define STREAM_TYPE_VIDEO_HEVC
Definition: mpeg.h:58
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:319
FFStream
Definition: internal.h:132
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:452
avio_get_str
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition: aviobuf.c:866
size
int size
Definition: twinvq_data.h:10344
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
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
MpegDemuxContext::header_state
int32_t header_state
Definition: mpeg.c:126
ff_subtitles_queue_finalize
void ff_subtitles_queue_finalize(void *log_ctx, FFDemuxSubtitlesQueue *q)
Set missing durations, sort subtitles by PTS (and then byte position), and drop duplicated events.
Definition: subtitles.c:212
FFDemuxSubtitlesQueue
Definition: subtitles.h:103
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:46
header
static const uint8_t header[24]
Definition: sdr2.c:68
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
STREAM_TYPE_VIDEO_MPEG2
#define STREAM_TYPE_VIDEO_MPEG2
Definition: mpeg.h:50
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:1023
AV_CODEC_ID_VVC
@ AV_CODEC_ID_VVC
Definition: codec_id.h:252
ff_subtitles_queue_clean
void ff_subtitles_queue_clean(FFDemuxSubtitlesQueue *q)
Remove and destroy all the subtitles packets.
Definition: subtitles.c:321
mpeg.h
line
Definition: graph2dot.c:48
MpegDemuxContext::imkh_cctv
int imkh_cctv
Definition: mpeg.c:130
read_header
static int read_header(FFV1Context *f, RangeCoder *c)
Definition: ffv1dec.c:348
MpegDemuxContext::raw_ac3
int raw_ac3
Definition: mpeg.c:131
FFERROR_REDO
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data).
Definition: demux.h:176
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:361
PRIVATE_STREAM_2
#define PRIVATE_STREAM_2
Definition: mpeg.h:39
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
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
FFDemuxSubtitlesQueue::subs
AVPacket ** subs
array of subtitles packets
Definition: subtitles.h:104
avio_internal.h
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
AV_CODEC_ID_CAVS
@ AV_CODEC_ID_CAVS
Definition: codec_id.h:139
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:228
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:598
ff_get_line
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
Definition: aviobuf.c:769
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:122
demux.h
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
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:760
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
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:80
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:746
pos
unsigned int pos
Definition: spdifenc.c:414
avformat.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
mpegps_psm_parse
static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb)
Extract stream types from a program stream map According to ISO/IEC 13818-1 ('MPEG-2 Systems') table ...
Definition: mpeg.c:202
VIDEO_ID
#define VIDEO_ID
Definition: mpeg.h:42
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
STREAM_TYPE_VIDEO_H264
#define STREAM_TYPE_VIDEO_H264
Definition: mpeg.h:57
subtitles.h
channel_layout.h
PADDING_STREAM
#define PADDING_STREAM
Definition: mpeg.h:38
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
AVRational::den
int den
Denominator.
Definition: rational.h:60
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:612
av_find_input_format
const AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:144
AVPacket::stream_index
int stream_index
Definition: packet.h:541
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
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:356
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:481
mem.h
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:394
FFStream::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: internal.h:202
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
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:516
mpegps_read_pes_header
static int mpegps_read_pes_header(AVFormatContext *s, int64_t *ppos, int *pstart_code, int64_t *ppts, int64_t *pdts)
Definition: mpeg.c:236
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
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
mpegps_probe
static int mpegps_probe(const AVProbeData *p)
Definition: mpeg.c:64
FFInputFormat
Definition: demux.h:42
int32_t
int32_t
Definition: audioconvert.c:56
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:593
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
mpegps_read_dts
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
Definition: mpeg.c:674
read_timestamp
static int64_t read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Definition: seek.c:281
MAX_SYNC_SIZE
#define MAX_SYNC_SIZE
Definition: mpeg.c:35
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
ff_reduce_index
void ff_reduce_index(AVFormatContext *s, int stream_index)
Ensure the index uses less memory than the maximum specified in AVFormatContext.max_index_size by dis...
Definition: seek.c:50
MpegDemuxContext
Definition: mpeg.c:125
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
AV_CODEC_ID_IVTV_VBI
@ AV_CODEC_ID_IVTV_VBI
Definition: codec_id.h:584
AV_CODEC_ID_MLP
@ AV_CODEC_ID_MLP
Definition: codec_id.h:477
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
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346