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 
80  sys++;
81  else if (code == PACK_START_CODE && pack)
82  pspack++;
83  else if ((code & 0xf0) == VIDEO_ID && pes) {
84  endpes = i + len;
85  vid++;
86  }
87  // skip pes payload to avoid start code emulation for private
88  // and audio streams
89  else if ((code & 0xe0) == AUDIO_ID && pes) {audio++; i+=len;}
90  else if (code == PRIVATE_STREAM_1 && pes) {priv1++; i+=len;}
91  else if (code == 0x1fd && pes) vid++; //VC1
92 
93  else if ((code & 0xf0) == VIDEO_ID && !pes) invalid++;
94  else if ((code & 0xe0) == AUDIO_ID && !pes) invalid++;
95  else if (code == PRIVATE_STREAM_1 && !pes) invalid++;
96  }
97  }
98 
99  if (vid + audio > invalid + 1) /* invalid VDR files nd short PES streams */
100  score = AVPROBE_SCORE_EXTENSION / 2;
101 
102 // av_log(NULL, AV_LOG_ERROR, "vid:%d aud:%d sys:%d pspack:%d invalid:%d size:%d \n",
103 // vid, audio, sys, pspack, invalid, p->buf_size);
104 
105  if (sys > invalid && sys * 9 <= pspack * 10)
106  return (audio > 12 || vid > 3 || pspack > 2) ? AVPROBE_SCORE_EXTENSION + 2
107  : AVPROBE_SCORE_EXTENSION / 2 + (audio + vid + pspack > 1); // 1 more than mp3
108  if (pspack > invalid && (priv1 + vid + audio) * 10 >= pspack * 9)
109  return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2
110  : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg
111  if ((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys &&
112  !pspack && p->buf_size > 2048 && vid + audio > invalid) /* PES stream */
113  return (audio > 12 || vid > 6 + 2 * invalid) ? AVPROBE_SCORE_EXTENSION + 2
115 
116  // 02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
117  // mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6
118  // Have\ Yourself\ a\ Merry\ Little\ Christmas.mp3 0 0 0 5 0 1 len:21618
119  return score;
120 }
121 
122 typedef struct MpegDemuxContext {
124  unsigned char psm_es_type[256];
125  int sofdec;
126  int dvd;
128  int raw_ac3;
130 
132 {
133  MpegDemuxContext *m = s->priv_data;
134  char buffer[7] = { 0 };
135  int64_t last_pos = avio_tell(s->pb);
136 
137  m->header_state = 0xff;
138  s->ctx_flags |= AVFMTCTX_NOHEADER;
139 
140  avio_get_str(s->pb, 6, buffer, sizeof(buffer));
141  if (!memcmp("IMKH", buffer, 4)) {
142  m->imkh_cctv = 1;
143  } else if (!memcmp("Sofdec", buffer, 6)) {
144  m->sofdec = 1;
145  } else
146  avio_seek(s->pb, last_pos, SEEK_SET);
147 
148  /* no need to do more */
149  return 0;
150 }
151 
152 static int64_t get_pts(AVIOContext *pb, int c)
153 {
154  uint8_t buf[5];
155  int ret;
156 
157  buf[0] = c < 0 ? avio_r8(pb) : c;
158  ret = avio_read(pb, buf + 1, 4);
159  if (ret < 4)
160  return AV_NOPTS_VALUE;
161 
162  return ff_parse_pes_pts(buf);
163 }
164 
165 static int find_next_start_code(AVIOContext *pb, int *size_ptr,
166  int32_t *header_state)
167 {
168  unsigned int state, v;
169  int val, n;
170 
171  state = *header_state;
172  n = *size_ptr;
173  while (n > 0) {
174  if (avio_feof(pb))
175  break;
176  v = avio_r8(pb);
177  n--;
178  if (state == 0x000001) {
179  state = ((state << 8) | v) & 0xffffff;
180  val = state;
181  goto found;
182  }
183  state = ((state << 8) | v) & 0xffffff;
184  }
185  val = -1;
186 
187 found:
188  *header_state = state;
189  *size_ptr = n;
190  return val;
191 }
192 
193 /**
194  * Extract stream types from a program stream map
195  * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
196  *
197  * @return number of bytes occupied by PSM in the bitstream
198  */
200 {
201  int psm_length, ps_info_length, es_map_length;
202 
203  psm_length = avio_rb16(pb);
204  avio_r8(pb);
205  avio_r8(pb);
206  ps_info_length = avio_rb16(pb);
207 
208  /* skip program_stream_info */
209  avio_skip(pb, ps_info_length);
210  /*es_map_length = */avio_rb16(pb);
211  /* Ignore es_map_length, trust psm_length */
212  es_map_length = psm_length - ps_info_length - 10;
213 
214  /* at least one es available? */
215  while (es_map_length >= 4) {
216  unsigned char type = avio_r8(pb);
217  unsigned char es_id = avio_r8(pb);
218  uint16_t es_info_length = avio_rb16(pb);
219 
220  /* remember mapping from stream id to stream type */
221  m->psm_es_type[es_id] = type;
222  /* skip program_stream_info */
223  avio_skip(pb, es_info_length);
224  es_map_length -= 4 + es_info_length;
225  }
226  avio_rb32(pb); /* crc32 */
227  return 2 + psm_length;
228 }
229 
230 /* read the next PES header. Return its position in ppos
231  * (if not NULL), and its start code, pts and dts.
232  */
234  int64_t *ppos, int *pstart_code,
235  int64_t *ppts, int64_t *pdts)
236 {
237  MpegDemuxContext *m = s->priv_data;
238  int len, size, startcode, c, flags, header_len;
239  int pes_ext, ext2_len, id_ext, skip;
240  int64_t pts, dts;
241  int64_t last_sync = avio_tell(s->pb);
242 
243 error_redo:
244  avio_seek(s->pb, last_sync, SEEK_SET);
245 redo:
246  /* next start code (should be immediately after) */
247  m->header_state = 0xff;
249  startcode = find_next_start_code(s->pb, &size, &m->header_state);
250  last_sync = avio_tell(s->pb);
251  if (startcode < 0) {
252  if (avio_feof(s->pb))
253  return AVERROR_EOF;
254  // FIXME we should remember header_state
255  return FFERROR_REDO;
256  }
257 
258  if (startcode == PACK_START_CODE)
259  goto redo;
260  if (startcode == SYSTEM_HEADER_START_CODE)
261  goto redo;
262  if (startcode == PADDING_STREAM) {
263  avio_skip(s->pb, avio_rb16(s->pb));
264  goto redo;
265  }
266  if (startcode == PRIVATE_STREAM_2) {
267  if (!m->sofdec) {
268  /* Need to detect whether this from a DVD or a 'Sofdec' stream */
269  int len = avio_rb16(s->pb);
270  int bytesread = 0;
271  uint8_t *ps2buf = av_malloc(len);
272 
273  if (ps2buf) {
274  bytesread = avio_read(s->pb, ps2buf, len);
275 
276  if (bytesread != len) {
277  avio_skip(s->pb, len - bytesread);
278  } else {
279  uint8_t *p = 0;
280  if (len >= 6)
281  p = memchr(ps2buf, 'S', len - 5);
282 
283  if (p)
284  m->sofdec = !memcmp(p+1, "ofdec", 5);
285 
286  m->sofdec -= !m->sofdec;
287 
288  if (m->sofdec < 0) {
289  if (len == 980 && ps2buf[0] == 0) {
290  /* PCI structure? */
291  uint32_t startpts = AV_RB32(ps2buf + 0x0d);
292  uint32_t endpts = AV_RB32(ps2buf + 0x11);
293  uint8_t hours = ((ps2buf[0x19] >> 4) * 10) + (ps2buf[0x19] & 0x0f);
294  uint8_t mins = ((ps2buf[0x1a] >> 4) * 10) + (ps2buf[0x1a] & 0x0f);
295  uint8_t secs = ((ps2buf[0x1b] >> 4) * 10) + (ps2buf[0x1b] & 0x0f);
296 
297  m->dvd = (hours <= 23 &&
298  mins <= 59 &&
299  secs <= 59 &&
300  (ps2buf[0x19] & 0x0f) < 10 &&
301  (ps2buf[0x1a] & 0x0f) < 10 &&
302  (ps2buf[0x1b] & 0x0f) < 10 &&
303  endpts >= startpts);
304  } else if (len == 1018 && ps2buf[0] == 1) {
305  /* DSI structure? */
306  uint8_t hours = ((ps2buf[0x1d] >> 4) * 10) + (ps2buf[0x1d] & 0x0f);
307  uint8_t mins = ((ps2buf[0x1e] >> 4) * 10) + (ps2buf[0x1e] & 0x0f);
308  uint8_t secs = ((ps2buf[0x1f] >> 4) * 10) + (ps2buf[0x1f] & 0x0f);
309 
310  m->dvd = (hours <= 23 &&
311  mins <= 59 &&
312  secs <= 59 &&
313  (ps2buf[0x1d] & 0x0f) < 10 &&
314  (ps2buf[0x1e] & 0x0f) < 10 &&
315  (ps2buf[0x1f] & 0x0f) < 10);
316  }
317  }
318  }
319 
320  av_free(ps2buf);
321 
322  /* If this isn't a DVD packet or no memory
323  * could be allocated, just ignore it.
324  * If we did, move back to the start of the
325  * packet (plus 'length' field) */
326  if (!m->dvd || avio_skip(s->pb, -(len + 2)) < 0) {
327  /* Skip back failed.
328  * This packet will be lost but that can't be helped
329  * if we can't skip back
330  */
331  goto redo;
332  }
333  } else {
334  /* No memory */
335  avio_skip(s->pb, len);
336  goto redo;
337  }
338  } else if (!m->dvd) {
339  int len = avio_rb16(s->pb);
340  avio_skip(s->pb, len);
341  goto redo;
342  }
343  }
344  if (startcode == PROGRAM_STREAM_MAP) {
345  mpegps_psm_parse(m, s->pb);
346  goto redo;
347  }
348 
349  /* find matching stream */
350  if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
351  (startcode >= 0x1e0 && startcode <= 0x1ef) ||
352  (startcode == 0x1bd) ||
353  (startcode == PRIVATE_STREAM_2) ||
354  (startcode == 0x1fd)))
355  goto redo;
356  if (ppos) {
357  *ppos = avio_tell(s->pb) - 4;
358  }
359  len = avio_rb16(s->pb);
360  pts =
361  dts = AV_NOPTS_VALUE;
362  if (startcode != PRIVATE_STREAM_2)
363  {
364  /* stuffing */
365  for (;;) {
366  if (len < 1)
367  goto error_redo;
368  c = avio_r8(s->pb);
369  len--;
370  /* XXX: for MPEG-1, should test only bit 7 */
371  if (c != 0xff)
372  break;
373  }
374  if ((c & 0xc0) == 0x40) {
375  /* buffer scale & size */
376  avio_r8(s->pb);
377  c = avio_r8(s->pb);
378  len -= 2;
379  }
380  if ((c & 0xe0) == 0x20) {
381  dts =
382  pts = get_pts(s->pb, c);
383  len -= 4;
384  if (c & 0x10) {
385  dts = get_pts(s->pb, -1);
386  len -= 5;
387  }
388  } else if ((c & 0xc0) == 0x80) {
389  /* mpeg 2 PES */
390  flags = avio_r8(s->pb);
391  header_len = avio_r8(s->pb);
392  len -= 2;
393  if (header_len > len)
394  goto error_redo;
395  len -= header_len;
396  if (flags & 0x80) {
397  dts = pts = get_pts(s->pb, -1);
398  header_len -= 5;
399  if (flags & 0x40) {
400  dts = get_pts(s->pb, -1);
401  header_len -= 5;
402  }
403  }
404  if (flags & 0x3f && header_len == 0) {
405  flags &= 0xC0;
406  av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");
407  }
408  if (flags & 0x01) { /* PES extension */
409  pes_ext = avio_r8(s->pb);
410  header_len--;
411  /* Skip PES private data, program packet sequence counter
412  * and P-STD buffer */
413  skip = (pes_ext >> 4) & 0xb;
414  skip += skip & 0x9;
415  if (pes_ext & 0x40 || skip > header_len) {
416  av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext);
417  pes_ext = skip = 0;
418  }
419  avio_skip(s->pb, skip);
420  header_len -= skip;
421 
422  if (pes_ext & 0x01) { /* PES extension 2 */
423  ext2_len = avio_r8(s->pb);
424  header_len--;
425  if ((ext2_len & 0x7f) > 0) {
426  id_ext = avio_r8(s->pb);
427  if ((id_ext & 0x80) == 0)
428  startcode = ((startcode & 0xff) << 8) | id_ext;
429  header_len--;
430  }
431  }
432  }
433  if (header_len < 0)
434  goto error_redo;
435  avio_skip(s->pb, header_len);
436  } else if (c != 0xf)
437  goto redo;
438  }
439 
440  if (startcode == PRIVATE_STREAM_1) {
441  int ret = ffio_ensure_seekback(s->pb, 2);
442 
443  if (ret < 0)
444  return ret;
445 
446  startcode = avio_r8(s->pb);
447  m->raw_ac3 = 0;
448  if (startcode == 0x0b) {
449  if (avio_r8(s->pb) == 0x77) {
450  startcode = 0x80;
451  m->raw_ac3 = 1;
452  avio_skip(s->pb, -2);
453  } else {
454  avio_skip(s->pb, -1);
455  }
456  } else {
457  len--;
458  }
459  }
460  if (len < 0)
461  goto error_redo;
462  if (dts != AV_NOPTS_VALUE && ppos) {
463  int i;
464  for (i = 0; i < s->nb_streams; i++) {
465  if (startcode == s->streams[i]->id &&
466  (s->pb->seekable & AVIO_SEEKABLE_NORMAL) /* index useless on streams anyway */) {
467  ff_reduce_index(s, i);
468  av_add_index_entry(s->streams[i], *ppos, dts, 0, 0,
469  AVINDEX_KEYFRAME /* FIXME keyframe? */);
470  }
471  }
472  }
473 
474  *pstart_code = startcode;
475  *ppts = pts;
476  *pdts = dts;
477  return len;
478 }
479 
481  AVPacket *pkt)
482 {
483  MpegDemuxContext *m = s->priv_data;
484  AVStream *st;
485  FFStream *sti;
486  int len, startcode, i, es_type, ret;
487  int pcm_dvd = 0;
488  int request_probe= 0;
490  enum AVMediaType type;
491  int64_t pts, dts, dummy_pos; // dummy_pos is needed for the index building to work
492 
493 redo:
494  len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
495  if (len < 0)
496  return len;
497 
498  if (startcode >= 0x80 && startcode <= 0xcf) {
499  if (len < 4)
500  goto skip;
501 
502  if (!m->raw_ac3) {
503  /* audio: skip header */
504  avio_skip(s->pb, 3);
505  len -= 3;
506  if (startcode >= 0xb0 && startcode <= 0xbf) {
507  /* MLP/TrueHD audio has a 4-byte header */
508  avio_r8(s->pb);
509  len--;
510  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
511  ret = ffio_ensure_seekback(s->pb, 3);
512  if (ret < 0)
513  return ret;
514  pcm_dvd = (avio_rb24(s->pb) & 0xFF) == 0x80;
515  avio_skip(s->pb, -3);
516  }
517  }
518  }
519 
520  /* now find stream */
521  for (i = 0; i < s->nb_streams; i++) {
522  st = s->streams[i];
523  if (st->id == startcode)
524  goto found;
525  }
526 
527  es_type = m->psm_es_type[startcode & 0xff];
528  if (es_type == STREAM_TYPE_VIDEO_MPEG1) {
531  } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {
534  } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||
535  es_type == STREAM_TYPE_AUDIO_MPEG2) {
538  } else if (es_type == STREAM_TYPE_AUDIO_AAC) {
541  } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {
544  } else if (es_type == STREAM_TYPE_VIDEO_H264) {
547  } else if (es_type == STREAM_TYPE_VIDEO_HEVC) {
550  } else if (es_type == STREAM_TYPE_VIDEO_VVC) {
553  } else if (es_type == STREAM_TYPE_AUDIO_AC3) {
556  } else if (es_type == 0x90) {
559  } else if (m->imkh_cctv && es_type == 0x91) {
562  } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
563  static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
564  unsigned char buf[8];
565 
566  avio_read(s->pb, buf, 8);
567  avio_seek(s->pb, -8, SEEK_CUR);
568  if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
570  else
571  request_probe= 1;
573  } else if (startcode == PRIVATE_STREAM_2) {
576  } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
578  if (m->sofdec > 0) {
580  // Auto-detect AC-3
581  request_probe = 50;
582  } else if (m->imkh_cctv && startcode == 0x1c0 && len > 80) {
584  request_probe = 50;
585  } else {
587  if (m->imkh_cctv)
588  request_probe = 25;
589  }
590  } else if (startcode >= 0x80 && startcode <= 0x87) {
593  } else if ((startcode >= 0x88 && startcode <= 0x8f) ||
594  (startcode >= 0x98 && startcode <= 0x9f)) {
595  /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
598  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
600  if (!pcm_dvd) {
602  } else {
604  }
605  } else if (startcode >= 0xb0 && startcode <= 0xbf) {
608  } else if (startcode >= 0xc0 && startcode <= 0xcf) {
609  /* Used for both AC-3 and E-AC-3 in EVOB files */
612  } else if (startcode >= 0x20 && startcode <= 0x3f) {
615  } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
618  } else {
619 skip:
620  /* skip packet */
621  avio_skip(s->pb, len);
622  goto redo;
623  }
624  /* no stream found: add a new stream */
625  st = avformat_new_stream(s, NULL);
626  if (!st)
627  goto skip;
628  sti = ffstream(st);
629  st->id = startcode;
630  st->codecpar->codec_type = type;
631  st->codecpar->codec_id = codec_id;
635  st->codecpar->sample_rate = 8000;
636  }
637  sti->request_probe = request_probe;
639 
640 found:
641  if (st->discard >= AVDISCARD_ALL)
642  goto skip;
643  if (startcode >= 0xa0 && startcode <= 0xaf) {
644  if (st->codecpar->codec_id == AV_CODEC_ID_MLP) {
645  if (len < 6)
646  goto skip;
647  avio_skip(s->pb, 6);
648  len -=6;
649  }
650  }
651  ret = av_get_packet(s->pb, pkt, len);
652 
653  pkt->pts = pts;
654  pkt->dts = dts;
655  pkt->pos = dummy_pos;
656  pkt->stream_index = st->index;
657 
658  if (s->debug & FF_FDEBUG_TS)
659  av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
660  pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
661  pkt->size);
662 
663  return (ret < 0) ? ret : 0;
664 }
665 
666 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
667  int64_t *ppos, int64_t pos_limit)
668 {
669  int len, startcode;
670  int64_t pos, pts, dts;
671 
672  pos = *ppos;
673  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
674  return AV_NOPTS_VALUE;
675 
676  for (;;) {
677  len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
678  if (len < 0) {
679  if (s->debug & FF_FDEBUG_TS)
680  av_log(s, AV_LOG_DEBUG, "none (ret=%d)\n", len);
681  return AV_NOPTS_VALUE;
682  }
683  if (startcode == s->streams[stream_index]->id &&
684  dts != AV_NOPTS_VALUE) {
685  break;
686  }
687  avio_skip(s->pb, len);
688  }
689  if (s->debug & FF_FDEBUG_TS)
690  av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
691  pos, dts, dts / 90000.0);
692  *ppos = pos;
693  return dts;
694 }
695 
697  .p.name = "mpeg",
698  .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),
699  .p.flags = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,
700  .priv_data_size = sizeof(MpegDemuxContext),
705 };
706 
707 #if CONFIG_VOBSUB_DEMUXER
708 
709 #include "subtitles.h"
710 #include "libavutil/avassert.h"
711 #include "libavutil/bprint.h"
712 #include "libavutil/opt.h"
713 
714 #define REF_STRING "# VobSub index file,"
715 #define MAX_LINE_SIZE 2048
716 
717 typedef struct VobSubDemuxContext {
718  const AVClass *class;
719  AVFormatContext *sub_ctx;
720  FFDemuxSubtitlesQueue q[32];
721  char *sub_name;
722 } VobSubDemuxContext;
723 
724 static int vobsub_probe(const AVProbeData *p)
725 {
726  if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))
727  return AVPROBE_SCORE_MAX;
728  return 0;
729 }
730 
731 static int vobsub_read_close(AVFormatContext *s)
732 {
733  VobSubDemuxContext *vobsub = s->priv_data;
734  int i;
735 
736  for (i = 0; i < s->nb_streams; i++)
737  ff_subtitles_queue_clean(&vobsub->q[i]);
738  avformat_close_input(&vobsub->sub_ctx);
739  return 0;
740 }
741 
742 static int vobsub_read_header(AVFormatContext *s)
743 {
744  int i, ret = 0, header_parsed = 0, langidx = 0;
745  VobSubDemuxContext *vobsub = s->priv_data;
746  const AVInputFormat *iformat;
747  size_t fname_len;
748  AVBPrint header;
749  int64_t delay = 0;
750  AVStream *st = NULL;
751  int stream_id = -1;
752  char id[64] = {0};
753  char alt[MAX_LINE_SIZE] = {0};
754 
755  if (!vobsub->sub_name) {
756  char *ext;
757  vobsub->sub_name = av_strdup(s->url);
758  if (!vobsub->sub_name) {
759  return AVERROR(ENOMEM);
760  }
761 
762  fname_len = strlen(vobsub->sub_name);
763  ext = vobsub->sub_name - 3 + fname_len;
764  if (fname_len < 4 || *(ext - 1) != '.') {
765  av_log(s, AV_LOG_ERROR, "The input index filename is too short "
766  "to guess the associated .SUB file\n");
767  return AVERROR_INVALIDDATA;
768  }
769  memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3);
770  av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->url, vobsub->sub_name);
771  }
772 
773  if (!(iformat = av_find_input_format("mpeg"))) {
775  }
776 
777  vobsub->sub_ctx = avformat_alloc_context();
778  if (!vobsub->sub_ctx) {
779  return AVERROR(ENOMEM);
780  }
781 
782  if ((ret = ff_copy_whiteblacklists(vobsub->sub_ctx, s)) < 0)
783  return ret;
784 
785  ret = avformat_open_input(&vobsub->sub_ctx, vobsub->sub_name, iformat, NULL);
786  if (ret < 0) {
787  av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", vobsub->sub_name);
788  return ret;
789  }
790 
792 
793  while (!avio_feof(s->pb)) {
794  char line[MAX_LINE_SIZE];
795  int len = ff_get_line(s->pb, line, sizeof(line));
796 
797  if (!len)
798  break;
799 
800  line[strcspn(line, "\r\n")] = 0;
801 
802  if (!strncmp(line, "id:", 3)) {
803  if (sscanf(line, "id: %63[^,], index: %u", id, &stream_id) != 2) {
804  av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', "
805  "assuming 'id: und, index: 0'\n", line);
806  strcpy(id, "und");
807  stream_id = 0;
808  }
809 
810  if (stream_id >= FF_ARRAY_ELEMS(vobsub->q)) {
811  av_log(s, AV_LOG_ERROR, "Maximum number of subtitles streams reached\n");
812  ret = AVERROR(EINVAL);
813  goto end;
814  }
815 
816  header_parsed = 1;
817  alt[0] = '\0';
818  /* We do not create the stream immediately to avoid adding empty
819  * streams. See the following timestamp entry. */
820 
821  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);
822 
823  } else if (!strncmp(line, "timestamp:", 10)) {
824  AVPacket *sub;
825  int hh, mm, ss, ms;
826  int64_t pos, timestamp;
827  const char *p = line + 10;
828 
829  if (stream_id == -1) {
830  av_log(s, AV_LOG_ERROR, "Timestamp declared before any stream\n");
832  goto end;
833  }
834 
835  if (!st || st->id != stream_id) {
836  st = avformat_new_stream(s, NULL);
837  if (!st) {
838  ret = AVERROR(ENOMEM);
839  goto end;
840  }
841  st->id = stream_id;
844  avpriv_set_pts_info(st, 64, 1, 1000);
845  av_dict_set(&st->metadata, "language", id, 0);
846  if (alt[0])
847  av_dict_set(&st->metadata, "title", alt, 0);
848  }
849 
850  if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"SCNx64,
851  &hh, &mm, &ss, &ms, &pos) != 5) {
852  av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "
853  "abort parsing\n", line);
855  goto end;
856  }
857  timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay;
858  timestamp = av_rescale_q(timestamp, av_make_q(1, 1000), st->time_base);
859 
860  sub = ff_subtitles_queue_insert(&vobsub->q[s->nb_streams - 1], "", 0, 0);
861  if (!sub) {
862  ret = AVERROR(ENOMEM);
863  goto end;
864  }
865  sub->pos = pos;
866  sub->pts = timestamp;
867  sub->stream_index = s->nb_streams - 1;
868 
869  } else if (!strncmp(line, "alt:", 4)) {
870  const char *p = line + 4;
871 
872  while (*p == ' ')
873  p++;
874  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", stream_id, p);
875  av_strlcpy(alt, p, sizeof(alt));
876  header_parsed = 1;
877 
878  } else if (!strncmp(line, "delay:", 6)) {
879  int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0;
880  const char *p = line + 6;
881 
882  while (*p == ' ')
883  p++;
884  if (*p == '-' || *p == '+') {
885  sign = *p == '-' ? -1 : 1;
886  p++;
887  }
888  sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms);
889  delay = ((hh*3600LL + mm*60LL + ss) * 1000LL + ms) * sign;
890 
891  } else if (!strncmp(line, "langidx:", 8)) {
892  const char *p = line + 8;
893 
894  if (sscanf(p, "%d", &langidx) != 1)
895  av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n");
896 
897  } else if (!header_parsed) {
898  if (line[0] && line[0] != '#')
899  av_bprintf(&header, "%s\n", line);
900  }
901  }
902 
903  if (langidx < s->nb_streams)
904  s->streams[langidx]->disposition |= AV_DISPOSITION_DEFAULT;
905 
906  for (i = 0; i < s->nb_streams; i++) {
907  vobsub->q[i].sort = SUB_SORT_POS_TS;
908  vobsub->q[i].keep_duplicates = 1;
909  ff_subtitles_queue_finalize(s, &vobsub->q[i]);
910  }
911 
912  if (!av_bprint_is_complete(&header)) {
913  ret = AVERROR(ENOMEM);
914  goto end;
915  }
916  for (i = 0; i < s->nb_streams; i++) {
917  AVCodecParameters *par = s->streams[i]->codecpar;
918  ret = ff_alloc_extradata(par, header.len);
919  if (ret < 0) {
920  goto end;
921  }
922  memcpy(par->extradata, header.str, header.len);
923  }
924 end:
926  return ret;
927 }
928 
929 static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt)
930 {
931  VobSubDemuxContext *vobsub = s->priv_data;
933  AVIOContext *pb = vobsub->sub_ctx->pb;
934  int ret, psize, total_read = 0, i;
935 
936  int64_t min_ts = INT64_MAX;
937  int sid = 0;
938  for (i = 0; i < s->nb_streams; i++) {
939  FFDemuxSubtitlesQueue *tmpq = &vobsub->q[i];
940  int64_t ts;
941  av_assert0(tmpq->nb_subs);
942 
943  if (tmpq->current_sub_idx >= tmpq->nb_subs)
944  continue;
945 
946  ts = tmpq->subs[tmpq->current_sub_idx]->pts;
947  if (ts < min_ts) {
948  min_ts = ts;
949  sid = i;
950  }
951  }
952  q = &vobsub->q[sid];
953  /* The returned packet will have size zero,
954  * so that it can be directly used with av_grow_packet. */
956  if (ret < 0)
957  return ret;
958 
959  /* compute maximum packet size using the next packet position. This is
960  * useful when the len in the header is non-sense */
961  if (q->current_sub_idx < q->nb_subs) {
962  psize = q->subs[q->current_sub_idx]->pos - pkt->pos;
963  } else {
964  int64_t fsize = avio_size(pb);
965  psize = fsize < 0 ? 0xffff : fsize - pkt->pos;
966  }
967 
968  avio_seek(pb, pkt->pos, SEEK_SET);
969 
970  do {
971  int n, to_read, startcode;
972  int64_t pts, dts;
973  int64_t old_pos = avio_tell(pb), new_pos;
974  int pkt_size;
975 
976  ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);
977  if (ret < 0) {
978  if (pkt->size) // raise packet even if incomplete
979  break;
980  return ret;
981  }
982  to_read = ret & 0xffff;
983  new_pos = avio_tell(pb);
984  pkt_size = ret + (new_pos - old_pos);
985 
986  /* this prevents reads above the current packet */
987  if (total_read + pkt_size > psize)
988  break;
989  total_read += pkt_size;
990 
991  /* the current chunk doesn't match the stream index (unlikely) */
992  if ((startcode & 0x1f) != s->streams[pkt->stream_index]->id)
993  break;
994 
995  ret = av_grow_packet(pkt, to_read);
996  if (ret < 0)
997  return ret;
998 
999  n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);
1000  if (n < to_read)
1001  pkt->size -= to_read - n;
1002  } while (total_read < psize);
1003 
1004  return 0;
1005 }
1006 
1007 static int vobsub_read_seek(AVFormatContext *s, int stream_index,
1008  int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1009 {
1010  VobSubDemuxContext *vobsub = s->priv_data;
1011 
1012  /* Rescale requested timestamps based on the first stream (timebase is the
1013  * same for all subtitles stream within a .idx/.sub). Rescaling is done just
1014  * like in avformat_seek_file(). */
1015  if (stream_index == -1 && s->nb_streams != 1) {
1016  int i, ret = 0;
1017  AVRational time_base = s->streams[0]->time_base;
1018  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
1019  min_ts = av_rescale_rnd(min_ts, time_base.den,
1020  time_base.num * (int64_t)AV_TIME_BASE,
1022  max_ts = av_rescale_rnd(max_ts, time_base.den,
1023  time_base.num * (int64_t)AV_TIME_BASE,
1025  for (i = 0; i < s->nb_streams; i++) {
1026  int r = ff_subtitles_queue_seek(&vobsub->q[i], s, stream_index,
1027  min_ts, ts, max_ts, flags);
1028  if (r < 0)
1029  ret = r;
1030  }
1031  return ret;
1032  }
1033 
1034  if (stream_index == -1) // only 1 stream
1035  stream_index = 0;
1036  return ff_subtitles_queue_seek(&vobsub->q[stream_index], s, stream_index,
1037  min_ts, ts, max_ts, flags);
1038 }
1039 
1040 static const AVOption options[] = {
1041  { "sub_name", "URI for .sub file", offsetof(VobSubDemuxContext, sub_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_DECODING_PARAM },
1042  { NULL }
1043 };
1044 
1045 static const AVClass vobsub_demuxer_class = {
1046  .class_name = "vobsub",
1047  .item_name = av_default_item_name,
1048  .option = options,
1049  .version = LIBAVUTIL_VERSION_INT,
1050 };
1051 
1053  .p.name = "vobsub",
1054  .p.long_name = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),
1055  .p.flags = AVFMT_SHOW_IDS,
1056  .p.extensions = "idx",
1057  .p.priv_class = &vobsub_demuxer_class,
1058  .priv_data_size = sizeof(VobSubDemuxContext),
1059  .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,
1060  .read_probe = vobsub_probe,
1061  .read_header = vobsub_read_header,
1062  .read_packet = vobsub_read_packet,
1063  .read_seek2 = vobsub_read_seek,
1064  .read_close = vobsub_read_close,
1065 };
1066 #endif
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:186
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:443
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:480
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:1534
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:814
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
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: packet.c:121
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:524
AVOption
AVOption.
Definition: opt.h:357
find_next_start_code
static int find_next_start_code(AVIOContext *pb, int *size_ptr, int32_t *header_state)
Definition: mpeg.c:165
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
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:484
MpegDemuxContext::dvd
int dvd
Definition: mpeg.c:126
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:363
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:853
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:417
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:121
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:78
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_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:134
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:441
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:180
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:215
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:440
get_pts
static int64_t get_pts(AVIOContext *pb, int c)
Definition: mpeg.c:152
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:201
nb_streams
static int nb_streams
Definition: ffprobe.c:384
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:334
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:392
AV_CODEC_ID_PCM_DVD
@ AV_CODEC_ID_PCM_DVD
Definition: codec_id.h:347
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_CODEC_ID_DVD_NAV
@ AV_CODEC_ID_DVD_NAV
Definition: codec_id.h:588
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:386
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:335
internal.h
mpegps_read_header
static int mpegps_read_header(AVFormatContext *s)
Definition: mpeg.c:131
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
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:782
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:1206
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:898
AV_CODEC_ID_DVD_SUBTITLE
@ AV_CODEC_ID_DVD_SUBTITLE
Definition: codec_id.h:550
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
ff_mpegps_demuxer
const FFInputFormat ff_mpegps_demuxer
Definition: mpeg.c:696
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:823
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:125
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:442
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:124
AVMediaType
AVMediaType
Definition: avutil.h:199
AV_CODEC_ID_ADPCM_ADX
@ AV_CODEC_ID_ADPCM_ADX
Definition: codec_id.h:376
AVPacket::size
int size
Definition: packet.h:525
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:161
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:303
FFStream
Definition: internal.h:193
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:444
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:123
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:41
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:523
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:250
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:127
MpegDemuxContext::raw_ac3
int raw_ac3
Definition: mpeg.c:128
FFERROR_REDO
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data).
Definition: demux.h:171
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:360
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:517
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_ROUND_DOWN
@ AV_ROUND_DOWN
Round toward -infinity.
Definition: mathematics.h:133
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:590
state
static struct @416 state
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:755
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
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:71
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:199
VIDEO_ID
#define VIDEO_ID
Definition: mpeg.h:42
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
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:526
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:284
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:378
FFStream::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: internal.h:263
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
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
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:501
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:233
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:544
mpegps_probe
static int mpegps_probe(const AVProbeData *p)
Definition: mpeg.c:64
FFInputFormat
Definition: demux.h:37
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:474
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_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:666
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:280
MAX_SYNC_SIZE
#define MAX_SYNC_SIZE
Definition: mpeg.c:35
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:249
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:49
MpegDemuxContext
Definition: mpeg.c:122
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_MLP
@ AV_CODEC_ID_MLP
Definition: codec_id.h:469
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