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