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  int len, startcode, i, es_type, ret;
482  int pcm_dvd = 0;
483  int request_probe= 0;
485  enum AVMediaType type;
486  int64_t pts, dts, dummy_pos; // dummy_pos is needed for the index building to work
487 
488 redo:
489  len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
490  if (len < 0)
491  return len;
492 
493  if (startcode >= 0x80 && startcode <= 0xcf) {
494  if (len < 4)
495  goto skip;
496 
497  if (!m->raw_ac3) {
498  /* audio: skip header */
499  avio_skip(s->pb, 3);
500  len -= 3;
501  if (startcode >= 0xb0 && startcode <= 0xbf) {
502  /* MLP/TrueHD audio has a 4-byte header */
503  avio_r8(s->pb);
504  len--;
505  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
506  ret = ffio_ensure_seekback(s->pb, 3);
507  if (ret < 0)
508  return ret;
509  pcm_dvd = (avio_rb24(s->pb) & 0xFF) == 0x80;
510  avio_skip(s->pb, -3);
511  }
512  }
513  }
514 
515  /* now find stream */
516  for (i = 0; i < s->nb_streams; i++) {
517  st = s->streams[i];
518  if (st->id == startcode)
519  goto found;
520  }
521 
522  es_type = m->psm_es_type[startcode & 0xff];
523  if (es_type == STREAM_TYPE_VIDEO_MPEG1) {
526  } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {
529  } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||
530  es_type == STREAM_TYPE_AUDIO_MPEG2) {
533  } else if (es_type == STREAM_TYPE_AUDIO_AAC) {
536  } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {
539  } else if (es_type == STREAM_TYPE_VIDEO_H264) {
542  } else if (es_type == STREAM_TYPE_VIDEO_HEVC) {
545  } else if (es_type == STREAM_TYPE_AUDIO_AC3) {
548  } else if (m->imkh_cctv && es_type == 0x91) {
551  } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
552  static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
553  unsigned char buf[8];
554 
555  avio_read(s->pb, buf, 8);
556  avio_seek(s->pb, -8, SEEK_CUR);
557  if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
559  else
560  request_probe= 1;
562  } else if (startcode == PRIVATE_STREAM_2) {
565  } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
567  if (m->sofdec > 0) {
569  // Auto-detect AC-3
570  request_probe = 50;
571  } else if (m->imkh_cctv && startcode == 0x1c0 && len > 80) {
573  request_probe = 50;
574  } else {
576  if (m->imkh_cctv)
577  request_probe = 25;
578  }
579  } else if (startcode >= 0x80 && startcode <= 0x87) {
582  } else if ((startcode >= 0x88 && startcode <= 0x8f) ||
583  (startcode >= 0x98 && startcode <= 0x9f)) {
584  /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
587  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
589  if (!pcm_dvd) {
591  } else {
593  }
594  } else if (startcode >= 0xb0 && startcode <= 0xbf) {
597  } else if (startcode >= 0xc0 && startcode <= 0xcf) {
598  /* Used for both AC-3 and E-AC-3 in EVOB files */
601  } else if (startcode >= 0x20 && startcode <= 0x3f) {
604  } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
607  } else {
608 skip:
609  /* skip packet */
610  avio_skip(s->pb, len);
611  goto redo;
612  }
613  /* no stream found: add a new stream */
614  st = avformat_new_stream(s, NULL);
615  if (!st)
616  goto skip;
617  st->id = startcode;
618  st->codecpar->codec_type = type;
619  st->codecpar->codec_id = codec_id;
622  st->codecpar->channels = 1;
624  st->codecpar->sample_rate = 8000;
625  }
626  st->internal->request_probe = request_probe;
628 
629 found:
630  if (st->discard >= AVDISCARD_ALL)
631  goto skip;
632  if (startcode >= 0xa0 && startcode <= 0xaf) {
633  if (st->codecpar->codec_id == AV_CODEC_ID_MLP) {
634  if (len < 6)
635  goto skip;
636  avio_skip(s->pb, 6);
637  len -=6;
638  }
639  }
640  ret = av_get_packet(s->pb, pkt, len);
641 
642  pkt->pts = pts;
643  pkt->dts = dts;
644  pkt->pos = dummy_pos;
645  pkt->stream_index = st->index;
646 
647  if (s->debug & FF_FDEBUG_TS)
648  av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
649  pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
650  pkt->size);
651 
652  return (ret < 0) ? ret : 0;
653 }
654 
655 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
656  int64_t *ppos, int64_t pos_limit)
657 {
658  int len, startcode;
659  int64_t pos, pts, dts;
660 
661  pos = *ppos;
662  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
663  return AV_NOPTS_VALUE;
664 
665  for (;;) {
666  len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
667  if (len < 0) {
668  if (s->debug & FF_FDEBUG_TS)
669  av_log(s, AV_LOG_DEBUG, "none (ret=%d)\n", len);
670  return AV_NOPTS_VALUE;
671  }
672  if (startcode == s->streams[stream_index]->id &&
673  dts != AV_NOPTS_VALUE) {
674  break;
675  }
676  avio_skip(s->pb, len);
677  }
678  if (s->debug & FF_FDEBUG_TS)
679  av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
680  pos, dts, dts / 90000.0);
681  *ppos = pos;
682  return dts;
683 }
684 
686  .name = "mpeg",
687  .long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),
688  .priv_data_size = sizeof(MpegDemuxContext),
692  .read_timestamp = mpegps_read_dts,
694 };
695 
696 #if CONFIG_VOBSUB_DEMUXER
697 
698 #include "subtitles.h"
699 #include "libavutil/avassert.h"
700 #include "libavutil/bprint.h"
701 #include "libavutil/opt.h"
702 
703 #define REF_STRING "# VobSub index file,"
704 #define MAX_LINE_SIZE 2048
705 
706 typedef struct VobSubDemuxContext {
707  const AVClass *class;
708  AVFormatContext *sub_ctx;
709  FFDemuxSubtitlesQueue q[32];
710  char *sub_name;
711 } VobSubDemuxContext;
712 
713 static int vobsub_probe(const AVProbeData *p)
714 {
715  if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))
716  return AVPROBE_SCORE_MAX;
717  return 0;
718 }
719 
720 static int vobsub_read_close(AVFormatContext *s)
721 {
722  VobSubDemuxContext *vobsub = s->priv_data;
723  int i;
724 
725  for (i = 0; i < s->nb_streams; i++)
726  ff_subtitles_queue_clean(&vobsub->q[i]);
727  avformat_close_input(&vobsub->sub_ctx);
728  return 0;
729 }
730 
731 static int vobsub_read_header(AVFormatContext *s)
732 {
733  int i, ret = 0, header_parsed = 0, langidx = 0;
734  VobSubDemuxContext *vobsub = s->priv_data;
735  const AVInputFormat *iformat;
736  size_t fname_len;
737  AVBPrint header;
738  int64_t delay = 0;
739  AVStream *st = NULL;
740  int stream_id = -1;
741  char id[64] = {0};
742  char alt[MAX_LINE_SIZE] = {0};
743 
744  if (!vobsub->sub_name) {
745  char *ext;
746  vobsub->sub_name = av_strdup(s->url);
747  if (!vobsub->sub_name) {
748  return AVERROR(ENOMEM);
749  }
750 
751  fname_len = strlen(vobsub->sub_name);
752  ext = vobsub->sub_name - 3 + fname_len;
753  if (fname_len < 4 || *(ext - 1) != '.') {
754  av_log(s, AV_LOG_ERROR, "The input index filename is too short "
755  "to guess the associated .SUB file\n");
756  return AVERROR_INVALIDDATA;
757  }
758  memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3);
759  av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->url, vobsub->sub_name);
760  }
761 
762  if (!(iformat = av_find_input_format("mpeg"))) {
764  }
765 
766  vobsub->sub_ctx = avformat_alloc_context();
767  if (!vobsub->sub_ctx) {
768  return AVERROR(ENOMEM);
769  }
770 
771  if ((ret = ff_copy_whiteblacklists(vobsub->sub_ctx, s)) < 0)
772  return ret;
773 
774  ret = avformat_open_input(&vobsub->sub_ctx, vobsub->sub_name, iformat, NULL);
775  if (ret < 0) {
776  av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", vobsub->sub_name);
777  return ret;
778  }
779 
781 
782  while (!avio_feof(s->pb)) {
783  char line[MAX_LINE_SIZE];
784  int len = ff_get_line(s->pb, line, sizeof(line));
785 
786  if (!len)
787  break;
788 
789  line[strcspn(line, "\r\n")] = 0;
790 
791  if (!strncmp(line, "id:", 3)) {
792  if (sscanf(line, "id: %63[^,], index: %u", id, &stream_id) != 2) {
793  av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', "
794  "assuming 'id: und, index: 0'\n", line);
795  strcpy(id, "und");
796  stream_id = 0;
797  }
798 
799  if (stream_id >= FF_ARRAY_ELEMS(vobsub->q)) {
800  av_log(s, AV_LOG_ERROR, "Maximum number of subtitles streams reached\n");
801  ret = AVERROR(EINVAL);
802  goto end;
803  }
804 
805  header_parsed = 1;
806  alt[0] = '\0';
807  /* We do not create the stream immediately to avoid adding empty
808  * streams. See the following timestamp entry. */
809 
810  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);
811 
812  } else if (!strncmp(line, "timestamp:", 10)) {
813  AVPacket *sub;
814  int hh, mm, ss, ms;
815  int64_t pos, timestamp;
816  const char *p = line + 10;
817 
818  if (stream_id == -1) {
819  av_log(s, AV_LOG_ERROR, "Timestamp declared before any stream\n");
821  goto end;
822  }
823 
824  if (!st || st->id != stream_id) {
825  st = avformat_new_stream(s, NULL);
826  if (!st) {
827  ret = AVERROR(ENOMEM);
828  goto end;
829  }
830  st->id = stream_id;
833  avpriv_set_pts_info(st, 64, 1, 1000);
834  av_dict_set(&st->metadata, "language", id, 0);
835  if (alt[0])
836  av_dict_set(&st->metadata, "title", alt, 0);
837  }
838 
839  if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"SCNx64,
840  &hh, &mm, &ss, &ms, &pos) != 5) {
841  av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "
842  "abort parsing\n", line);
844  goto end;
845  }
846  timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay;
847  timestamp = av_rescale_q(timestamp, av_make_q(1, 1000), st->time_base);
848 
849  sub = ff_subtitles_queue_insert(&vobsub->q[s->nb_streams - 1], "", 0, 0);
850  if (!sub) {
851  ret = AVERROR(ENOMEM);
852  goto end;
853  }
854  sub->pos = pos;
855  sub->pts = timestamp;
856  sub->stream_index = s->nb_streams - 1;
857 
858  } else if (!strncmp(line, "alt:", 4)) {
859  const char *p = line + 4;
860 
861  while (*p == ' ')
862  p++;
863  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", stream_id, p);
864  av_strlcpy(alt, p, sizeof(alt));
865  header_parsed = 1;
866 
867  } else if (!strncmp(line, "delay:", 6)) {
868  int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0;
869  const char *p = line + 6;
870 
871  while (*p == ' ')
872  p++;
873  if (*p == '-' || *p == '+') {
874  sign = *p == '-' ? -1 : 1;
875  p++;
876  }
877  sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms);
878  delay = ((hh*3600LL + mm*60LL + ss) * 1000LL + ms) * sign;
879 
880  } else if (!strncmp(line, "langidx:", 8)) {
881  const char *p = line + 8;
882 
883  if (sscanf(p, "%d", &langidx) != 1)
884  av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n");
885 
886  } else if (!header_parsed) {
887  if (line[0] && line[0] != '#')
888  av_bprintf(&header, "%s\n", line);
889  }
890  }
891 
892  if (langidx < s->nb_streams)
893  s->streams[langidx]->disposition |= AV_DISPOSITION_DEFAULT;
894 
895  for (i = 0; i < s->nb_streams; i++) {
896  vobsub->q[i].sort = SUB_SORT_POS_TS;
897  vobsub->q[i].keep_duplicates = 1;
898  ff_subtitles_queue_finalize(s, &vobsub->q[i]);
899  }
900 
901  if (!av_bprint_is_complete(&header)) {
902  ret = AVERROR(ENOMEM);
903  goto end;
904  }
905  for (i = 0; i < s->nb_streams; i++) {
906  AVCodecParameters *par = s->streams[i]->codecpar;
907  ret = ff_alloc_extradata(par, header.len);
908  if (ret < 0) {
909  goto end;
910  }
911  memcpy(par->extradata, header.str, header.len);
912  }
913 end:
915  return ret;
916 }
917 
918 static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt)
919 {
920  VobSubDemuxContext *vobsub = s->priv_data;
922  AVIOContext *pb = vobsub->sub_ctx->pb;
923  int ret, psize, total_read = 0, i;
924 
925  int64_t min_ts = INT64_MAX;
926  int sid = 0;
927  for (i = 0; i < s->nb_streams; i++) {
928  FFDemuxSubtitlesQueue *tmpq = &vobsub->q[i];
929  int64_t ts;
930  av_assert0(tmpq->nb_subs);
931 
932  if (tmpq->current_sub_idx >= tmpq->nb_subs)
933  continue;
934 
935  ts = tmpq->subs[tmpq->current_sub_idx]->pts;
936  if (ts < min_ts) {
937  min_ts = ts;
938  sid = i;
939  }
940  }
941  q = &vobsub->q[sid];
942  /* The returned packet will have size zero,
943  * so that it can be directly used with av_grow_packet. */
945  if (ret < 0)
946  return ret;
947 
948  /* compute maximum packet size using the next packet position. This is
949  * useful when the len in the header is non-sense */
950  if (q->current_sub_idx < q->nb_subs) {
951  psize = q->subs[q->current_sub_idx]->pos - pkt->pos;
952  } else {
953  int64_t fsize = avio_size(pb);
954  psize = fsize < 0 ? 0xffff : fsize - pkt->pos;
955  }
956 
957  avio_seek(pb, pkt->pos, SEEK_SET);
958 
959  do {
960  int n, to_read, startcode;
961  int64_t pts, dts;
962  int64_t old_pos = avio_tell(pb), new_pos;
963  int pkt_size;
964 
965  ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);
966  if (ret < 0) {
967  if (pkt->size) // raise packet even if incomplete
968  break;
969  return ret;
970  }
971  to_read = ret & 0xffff;
972  new_pos = avio_tell(pb);
973  pkt_size = ret + (new_pos - old_pos);
974 
975  /* this prevents reads above the current packet */
976  if (total_read + pkt_size > psize)
977  break;
978  total_read += pkt_size;
979 
980  /* the current chunk doesn't match the stream index (unlikely) */
981  if ((startcode & 0x1f) != s->streams[pkt->stream_index]->id)
982  break;
983 
984  ret = av_grow_packet(pkt, to_read);
985  if (ret < 0)
986  return ret;
987 
988  n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);
989  if (n < to_read)
990  pkt->size -= to_read - n;
991  } while (total_read < psize);
992 
993  return 0;
994 }
995 
996 static int vobsub_read_seek(AVFormatContext *s, int stream_index,
997  int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
998 {
999  VobSubDemuxContext *vobsub = s->priv_data;
1000 
1001  /* Rescale requested timestamps based on the first stream (timebase is the
1002  * same for all subtitles stream within a .idx/.sub). Rescaling is done just
1003  * like in avformat_seek_file(). */
1004  if (stream_index == -1 && s->nb_streams != 1) {
1005  int i, ret = 0;
1006  AVRational time_base = s->streams[0]->time_base;
1007  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
1008  min_ts = av_rescale_rnd(min_ts, time_base.den,
1009  time_base.num * (int64_t)AV_TIME_BASE,
1011  max_ts = av_rescale_rnd(max_ts, time_base.den,
1012  time_base.num * (int64_t)AV_TIME_BASE,
1014  for (i = 0; i < s->nb_streams; i++) {
1015  int r = ff_subtitles_queue_seek(&vobsub->q[i], s, stream_index,
1016  min_ts, ts, max_ts, flags);
1017  if (r < 0)
1018  ret = r;
1019  }
1020  return ret;
1021  }
1022 
1023  if (stream_index == -1) // only 1 stream
1024  stream_index = 0;
1025  return ff_subtitles_queue_seek(&vobsub->q[stream_index], s, stream_index,
1026  min_ts, ts, max_ts, flags);
1027 }
1028 
1029 static const AVOption options[] = {
1030  { "sub_name", "URI for .sub file", offsetof(VobSubDemuxContext, sub_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_DECODING_PARAM },
1031  { NULL }
1032 };
1033 
1034 static const AVClass vobsub_demuxer_class = {
1035  .class_name = "vobsub",
1036  .item_name = av_default_item_name,
1037  .option = options,
1038  .version = LIBAVUTIL_VERSION_INT,
1039 };
1040 
1042  .name = "vobsub",
1043  .long_name = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),
1044  .priv_data_size = sizeof(VobSubDemuxContext),
1045  .flags_internal = FF_FMT_INIT_CLEANUP,
1046  .read_probe = vobsub_probe,
1047  .read_header = vobsub_read_header,
1048  .read_packet = vobsub_read_packet,
1049  .read_seek2 = vobsub_read_seek,
1050  .read_close = vobsub_read_close,
1051  .flags = AVFMT_SHOW_IDS,
1052  .extensions = "idx",
1053  .priv_class = &vobsub_demuxer_class,
1054 };
1055 #endif
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
MAX_LINE_SIZE
#define MAX_LINE_SIZE
Definition: vf_lut3d.c:601
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:425
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:685
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:4347
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:1380
FFERROR_REDO
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data).
Definition: internal.h:841
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:896
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:792
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
AVStream::internal
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1009
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:466
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:785
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: utils.c:4321
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
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: utils.c:1913
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:423
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:626
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: utils.c:458
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:631
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:422
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:319
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:332
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:559
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
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
AVFormatContext
Format I/O context.
Definition: avformat.h:1107
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:320
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:994
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:870
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:1056
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
state
static struct @317 state
AV_CODEC_ID_DVD_SUBTITLE
@ AV_CODEC_ID_DVD_SUBTITLE
Definition: codec_id.h:521
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:905
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:424
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:361
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:166
STREAM_TYPE_VIDEO_HEVC
#define STREAM_TYPE_VIDEO_HEVC
Definition: mpeg.h:58
AVStreamInternal::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: internal.h:270
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *s, 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:4771
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:426
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:146
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:852
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:990
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
i
int i
Definition: input.c:406
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
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:257
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:854
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:847
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
AVStreamInternal::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:384
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:848
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: utils.c:1841
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
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:277
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
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:768
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:655
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:451
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:3243
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:360