FFmpeg
mpeg.c
Go to the documentation of this file.
1 /*
2  * MPEG-1/2 demuxer
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "avformat.h"
23 #include "avio_internal.h"
24 #include "internal.h"
25 #include "mpeg.h"
26 
27 /*********************************************/
28 /* demux code */
29 
30 #define MAX_SYNC_SIZE 100000
31 
32 static int check_pes(const uint8_t *p, const uint8_t *end)
33 {
34  int pes1;
35  int pes2 = (p[3] & 0xC0) == 0x80 &&
36  (p[4] & 0xC0) != 0x40 &&
37  ((p[4] & 0xC0) == 0x00 ||
38  (p[4] & 0xC0) >> 2 == (p[6] & 0xF0));
39 
40  for (p += 3; p < end && *p == 0xFF; p++) ;
41  if ((*p & 0xC0) == 0x40)
42  p += 2;
43 
44  if ((*p & 0xF0) == 0x20)
45  pes1 = p[0] & p[2] & p[4] & 1;
46  else if ((*p & 0xF0) == 0x30)
47  pes1 = p[0] & p[2] & p[4] & p[5] & p[7] & p[9] & 1;
48  else
49  pes1 = *p == 0x0F;
50 
51  return pes1 || pes2;
52 }
53 
54 static int check_pack_header(const uint8_t *buf)
55 {
56  return (buf[1] & 0xC0) == 0x40 || (buf[1] & 0xF0) == 0x20;
57 }
58 
59 static int mpegps_probe(const AVProbeData *p)
60 {
61  uint32_t code = -1;
62  int i;
63  int sys = 0, pspack = 0, priv1 = 0, vid = 0;
64  int audio = 0, invalid = 0, score = 0;
65  int endpes = 0;
66 
67  for (i = 0; i < p->buf_size; i++) {
68  code = (code << 8) + p->buf[i];
69  if ((code & 0xffffff00) == 0x100) {
70  int len = p->buf[i + 1] << 8 | p->buf[i + 2];
71  int pes = endpes <= i && check_pes(p->buf + i, p->buf + p->buf_size);
72  int pack = check_pack_header(p->buf + i);
73 
75  sys++;
76  else if (code == PACK_START_CODE && pack)
77  pspack++;
78  else if ((code & 0xf0) == VIDEO_ID && pes) {
79  endpes = i + len;
80  vid++;
81  }
82  // skip pes payload to avoid start code emulation for private
83  // and audio streams
84  else if ((code & 0xe0) == AUDIO_ID && pes) {audio++; i+=len;}
85  else if (code == PRIVATE_STREAM_1 && pes) {priv1++; i+=len;}
86  else if (code == 0x1fd && pes) vid++; //VC1
87 
88  else if ((code & 0xf0) == VIDEO_ID && !pes) invalid++;
89  else if ((code & 0xe0) == AUDIO_ID && !pes) invalid++;
90  else if (code == PRIVATE_STREAM_1 && !pes) invalid++;
91  }
92  }
93 
94  if (vid + audio > invalid + 1) /* invalid VDR files nd short PES streams */
95  score = AVPROBE_SCORE_EXTENSION / 2;
96 
97 // av_log(NULL, AV_LOG_ERROR, "vid:%d aud:%d sys:%d pspack:%d invalid:%d size:%d \n",
98 // vid, audio, sys, pspack, invalid, p->buf_size);
99 
100  if (sys > invalid && sys * 9 <= pspack * 10)
101  return (audio > 12 || vid > 3 || pspack > 2) ? AVPROBE_SCORE_EXTENSION + 2
102  : AVPROBE_SCORE_EXTENSION / 2 + (audio + vid + pspack > 1); // 1 more than mp3
103  if (pspack > invalid && (priv1 + vid + audio) * 10 >= pspack * 9)
104  return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2
105  : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg
106  if ((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys &&
107  !pspack && p->buf_size > 2048 && vid + audio > invalid) /* PES stream */
108  return (audio > 12 || vid > 6 + 2 * invalid) ? AVPROBE_SCORE_EXTENSION + 2
110 
111  // 02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
112  // mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6
113  // Have\ Yourself\ a\ Merry\ Little\ Christmas.mp3 0 0 0 5 0 1 len:21618
114  return score;
115 }
116 
117 typedef struct MpegDemuxContext {
119  unsigned char psm_es_type[256];
120  int sofdec;
121  int dvd;
123  int raw_ac3;
125 
127 {
128  MpegDemuxContext *m = s->priv_data;
129  char buffer[7] = { 0 };
130  int64_t last_pos = avio_tell(s->pb);
131 
132  m->header_state = 0xff;
133  s->ctx_flags |= AVFMTCTX_NOHEADER;
134 
135  avio_get_str(s->pb, 6, buffer, sizeof(buffer));
136  if (!memcmp("IMKH", buffer, 4)) {
137  m->imkh_cctv = 1;
138  } else if (!memcmp("Sofdec", buffer, 6)) {
139  m->sofdec = 1;
140  } else
141  avio_seek(s->pb, last_pos, SEEK_SET);
142 
143  /* no need to do more */
144  return 0;
145 }
146 
147 static int64_t get_pts(AVIOContext *pb, int c)
148 {
149  uint8_t buf[5];
150  int ret;
151 
152  buf[0] = c < 0 ? avio_r8(pb) : c;
153  ret = avio_read(pb, buf + 1, 4);
154  if (ret < 4)
155  return AV_NOPTS_VALUE;
156 
157  return ff_parse_pes_pts(buf);
158 }
159 
160 static int find_next_start_code(AVIOContext *pb, int *size_ptr,
161  int32_t *header_state)
162 {
163  unsigned int state, v;
164  int val, n;
165 
166  state = *header_state;
167  n = *size_ptr;
168  while (n > 0) {
169  if (avio_feof(pb))
170  break;
171  v = avio_r8(pb);
172  n--;
173  if (state == 0x000001) {
174  state = ((state << 8) | v) & 0xffffff;
175  val = state;
176  goto found;
177  }
178  state = ((state << 8) | v) & 0xffffff;
179  }
180  val = -1;
181 
182 found:
183  *header_state = state;
184  *size_ptr = n;
185  return val;
186 }
187 
188 /**
189  * Extract stream types from a program stream map
190  * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
191  *
192  * @return number of bytes occupied by PSM in the bitstream
193  */
195 {
196  int psm_length, ps_info_length, es_map_length;
197 
198  psm_length = avio_rb16(pb);
199  avio_r8(pb);
200  avio_r8(pb);
201  ps_info_length = avio_rb16(pb);
202 
203  /* skip program_stream_info */
204  avio_skip(pb, ps_info_length);
205  /*es_map_length = */avio_rb16(pb);
206  /* Ignore es_map_length, trust psm_length */
207  es_map_length = psm_length - ps_info_length - 10;
208 
209  /* at least one es available? */
210  while (es_map_length >= 4) {
211  unsigned char type = avio_r8(pb);
212  unsigned char es_id = avio_r8(pb);
213  uint16_t es_info_length = avio_rb16(pb);
214 
215  /* remember mapping from stream id to stream type */
216  m->psm_es_type[es_id] = type;
217  /* skip program_stream_info */
218  avio_skip(pb, es_info_length);
219  es_map_length -= 4 + es_info_length;
220  }
221  avio_rb32(pb); /* crc32 */
222  return 2 + psm_length;
223 }
224 
225 /* read the next PES header. Return its position in ppos
226  * (if not NULL), and its start code, pts and dts.
227  */
229  int64_t *ppos, int *pstart_code,
230  int64_t *ppts, int64_t *pdts)
231 {
232  MpegDemuxContext *m = s->priv_data;
233  int len, size, startcode, c, flags, header_len;
234  int pes_ext, ext2_len, id_ext, skip;
235  int64_t pts, dts;
236  int64_t last_sync = avio_tell(s->pb);
237 
238 error_redo:
239  avio_seek(s->pb, last_sync, SEEK_SET);
240 redo:
241  /* next start code (should be immediately after) */
242  m->header_state = 0xff;
244  startcode = find_next_start_code(s->pb, &size, &m->header_state);
245  last_sync = avio_tell(s->pb);
246  if (startcode < 0) {
247  if (avio_feof(s->pb))
248  return AVERROR_EOF;
249  // FIXME we should remember header_state
250  return FFERROR_REDO;
251  }
252 
253  if (startcode == PACK_START_CODE)
254  goto redo;
255  if (startcode == SYSTEM_HEADER_START_CODE)
256  goto redo;
257  if (startcode == PADDING_STREAM) {
258  avio_skip(s->pb, avio_rb16(s->pb));
259  goto redo;
260  }
261  if (startcode == PRIVATE_STREAM_2) {
262  if (!m->sofdec) {
263  /* Need to detect whether this from a DVD or a 'Sofdec' stream */
264  int len = avio_rb16(s->pb);
265  int bytesread = 0;
266  uint8_t *ps2buf = av_malloc(len);
267 
268  if (ps2buf) {
269  bytesread = avio_read(s->pb, ps2buf, len);
270 
271  if (bytesread != len) {
272  avio_skip(s->pb, len - bytesread);
273  } else {
274  uint8_t *p = 0;
275  if (len >= 6)
276  p = memchr(ps2buf, 'S', len - 5);
277 
278  if (p)
279  m->sofdec = !memcmp(p+1, "ofdec", 5);
280 
281  m->sofdec -= !m->sofdec;
282 
283  if (m->sofdec < 0) {
284  if (len == 980 && ps2buf[0] == 0) {
285  /* PCI structure? */
286  uint32_t startpts = AV_RB32(ps2buf + 0x0d);
287  uint32_t endpts = AV_RB32(ps2buf + 0x11);
288  uint8_t hours = ((ps2buf[0x19] >> 4) * 10) + (ps2buf[0x19] & 0x0f);
289  uint8_t mins = ((ps2buf[0x1a] >> 4) * 10) + (ps2buf[0x1a] & 0x0f);
290  uint8_t secs = ((ps2buf[0x1b] >> 4) * 10) + (ps2buf[0x1b] & 0x0f);
291 
292  m->dvd = (hours <= 23 &&
293  mins <= 59 &&
294  secs <= 59 &&
295  (ps2buf[0x19] & 0x0f) < 10 &&
296  (ps2buf[0x1a] & 0x0f) < 10 &&
297  (ps2buf[0x1b] & 0x0f) < 10 &&
298  endpts >= startpts);
299  } else if (len == 1018 && ps2buf[0] == 1) {
300  /* DSI structure? */
301  uint8_t hours = ((ps2buf[0x1d] >> 4) * 10) + (ps2buf[0x1d] & 0x0f);
302  uint8_t mins = ((ps2buf[0x1e] >> 4) * 10) + (ps2buf[0x1e] & 0x0f);
303  uint8_t secs = ((ps2buf[0x1f] >> 4) * 10) + (ps2buf[0x1f] & 0x0f);
304 
305  m->dvd = (hours <= 23 &&
306  mins <= 59 &&
307  secs <= 59 &&
308  (ps2buf[0x1d] & 0x0f) < 10 &&
309  (ps2buf[0x1e] & 0x0f) < 10 &&
310  (ps2buf[0x1f] & 0x0f) < 10);
311  }
312  }
313  }
314 
315  av_free(ps2buf);
316 
317  /* If this isn't a DVD packet or no memory
318  * could be allocated, just ignore it.
319  * If we did, move back to the start of the
320  * packet (plus 'length' field) */
321  if (!m->dvd || avio_skip(s->pb, -(len + 2)) < 0) {
322  /* Skip back failed.
323  * This packet will be lost but that can't be helped
324  * if we can't skip back
325  */
326  goto redo;
327  }
328  } else {
329  /* No memory */
330  avio_skip(s->pb, len);
331  goto redo;
332  }
333  } else if (!m->dvd) {
334  int len = avio_rb16(s->pb);
335  avio_skip(s->pb, len);
336  goto redo;
337  }
338  }
339  if (startcode == PROGRAM_STREAM_MAP) {
340  mpegps_psm_parse(m, s->pb);
341  goto redo;
342  }
343 
344  /* find matching stream */
345  if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
346  (startcode >= 0x1e0 && startcode <= 0x1ef) ||
347  (startcode == 0x1bd) ||
348  (startcode == PRIVATE_STREAM_2) ||
349  (startcode == 0x1fd)))
350  goto redo;
351  if (ppos) {
352  *ppos = avio_tell(s->pb) - 4;
353  }
354  len = avio_rb16(s->pb);
355  pts =
356  dts = AV_NOPTS_VALUE;
357  if (startcode != PRIVATE_STREAM_2)
358  {
359  /* stuffing */
360  for (;;) {
361  if (len < 1)
362  goto error_redo;
363  c = avio_r8(s->pb);
364  len--;
365  /* XXX: for MPEG-1, should test only bit 7 */
366  if (c != 0xff)
367  break;
368  }
369  if ((c & 0xc0) == 0x40) {
370  /* buffer scale & size */
371  avio_r8(s->pb);
372  c = avio_r8(s->pb);
373  len -= 2;
374  }
375  if ((c & 0xe0) == 0x20) {
376  dts =
377  pts = get_pts(s->pb, c);
378  len -= 4;
379  if (c & 0x10) {
380  dts = get_pts(s->pb, -1);
381  len -= 5;
382  }
383  } else if ((c & 0xc0) == 0x80) {
384  /* mpeg 2 PES */
385  flags = avio_r8(s->pb);
386  header_len = avio_r8(s->pb);
387  len -= 2;
388  if (header_len > len)
389  goto error_redo;
390  len -= header_len;
391  if (flags & 0x80) {
392  dts = pts = get_pts(s->pb, -1);
393  header_len -= 5;
394  if (flags & 0x40) {
395  dts = get_pts(s->pb, -1);
396  header_len -= 5;
397  }
398  }
399  if (flags & 0x3f && header_len == 0) {
400  flags &= 0xC0;
401  av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");
402  }
403  if (flags & 0x01) { /* PES extension */
404  pes_ext = avio_r8(s->pb);
405  header_len--;
406  /* Skip PES private data, program packet sequence counter
407  * and P-STD buffer */
408  skip = (pes_ext >> 4) & 0xb;
409  skip += skip & 0x9;
410  if (pes_ext & 0x40 || skip > header_len) {
411  av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext);
412  pes_ext = skip = 0;
413  }
414  avio_skip(s->pb, skip);
415  header_len -= skip;
416 
417  if (pes_ext & 0x01) { /* PES extension 2 */
418  ext2_len = avio_r8(s->pb);
419  header_len--;
420  if ((ext2_len & 0x7f) > 0) {
421  id_ext = avio_r8(s->pb);
422  if ((id_ext & 0x80) == 0)
423  startcode = ((startcode & 0xff) << 8) | id_ext;
424  header_len--;
425  }
426  }
427  }
428  if (header_len < 0)
429  goto error_redo;
430  avio_skip(s->pb, header_len);
431  } else if (c != 0xf)
432  goto redo;
433  }
434 
435  if (startcode == PRIVATE_STREAM_1) {
436  int ret = ffio_ensure_seekback(s->pb, 2);
437 
438  if (ret < 0)
439  return ret;
440 
441  startcode = avio_r8(s->pb);
442  m->raw_ac3 = 0;
443  if (startcode == 0x0b) {
444  if (avio_r8(s->pb) == 0x77) {
445  startcode = 0x80;
446  m->raw_ac3 = 1;
447  avio_skip(s->pb, -2);
448  } else {
449  avio_skip(s->pb, -1);
450  }
451  } else {
452  len--;
453  }
454  }
455  if (len < 0)
456  goto error_redo;
457  if (dts != AV_NOPTS_VALUE && ppos) {
458  int i;
459  for (i = 0; i < s->nb_streams; i++) {
460  if (startcode == s->streams[i]->id &&
461  (s->pb->seekable & AVIO_SEEKABLE_NORMAL) /* index useless on streams anyway */) {
462  ff_reduce_index(s, i);
463  av_add_index_entry(s->streams[i], *ppos, dts, 0, 0,
464  AVINDEX_KEYFRAME /* FIXME keyframe? */);
465  }
466  }
467  }
468 
469  *pstart_code = startcode;
470  *ppts = pts;
471  *pdts = dts;
472  return len;
473 }
474 
476  AVPacket *pkt)
477 {
478  MpegDemuxContext *m = s->priv_data;
479  AVStream *st;
480  int len, startcode, i, es_type, ret;
481  int pcm_dvd = 0;
482  int request_probe= 0;
484  enum AVMediaType type;
485  int64_t pts, dts, dummy_pos; // dummy_pos is needed for the index building to work
486 
487 redo:
488  len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
489  if (len < 0)
490  return len;
491 
492  if (startcode >= 0x80 && startcode <= 0xcf) {
493  if (len < 4)
494  goto skip;
495 
496  if (!m->raw_ac3) {
497  /* audio: skip header */
498  avio_skip(s->pb, 3);
499  len -= 3;
500  if (startcode >= 0xb0 && startcode <= 0xbf) {
501  /* MLP/TrueHD audio has a 4-byte header */
502  avio_r8(s->pb);
503  len--;
504  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
505  ret = ffio_ensure_seekback(s->pb, 3);
506  if (ret < 0)
507  return ret;
508  pcm_dvd = (avio_rb24(s->pb) & 0xFF) == 0x80;
509  avio_skip(s->pb, -3);
510  }
511  }
512  }
513 
514  /* now find stream */
515  for (i = 0; i < s->nb_streams; i++) {
516  st = s->streams[i];
517  if (st->id == startcode)
518  goto found;
519  }
520 
521  es_type = m->psm_es_type[startcode & 0xff];
522  if (es_type == STREAM_TYPE_VIDEO_MPEG1) {
525  } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {
528  } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||
529  es_type == STREAM_TYPE_AUDIO_MPEG2) {
532  } else if (es_type == STREAM_TYPE_AUDIO_AAC) {
535  } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {
538  } else if (es_type == STREAM_TYPE_VIDEO_H264) {
541  } else if (es_type == STREAM_TYPE_VIDEO_HEVC) {
544  } else if (es_type == STREAM_TYPE_AUDIO_AC3) {
547  } else if (m->imkh_cctv && es_type == 0x91) {
550  } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
551  static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
552  unsigned char buf[8];
553 
554  avio_read(s->pb, buf, 8);
555  avio_seek(s->pb, -8, SEEK_CUR);
556  if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
558  else
559  request_probe= 1;
561  } else if (startcode == PRIVATE_STREAM_2) {
564  } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
566  if (m->sofdec > 0) {
568  // Auto-detect AC-3
569  request_probe = 50;
570  } else if (m->imkh_cctv && startcode == 0x1c0 && len > 80) {
572  request_probe = 50;
573  } else {
575  if (m->imkh_cctv)
576  request_probe = 25;
577  }
578  } else if (startcode >= 0x80 && startcode <= 0x87) {
581  } else if ((startcode >= 0x88 && startcode <= 0x8f) ||
582  (startcode >= 0x98 && startcode <= 0x9f)) {
583  /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
586  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
588  if (!pcm_dvd) {
590  } else {
592  }
593  } else if (startcode >= 0xb0 && startcode <= 0xbf) {
596  } else if (startcode >= 0xc0 && startcode <= 0xcf) {
597  /* Used for both AC-3 and E-AC-3 in EVOB files */
600  } else if (startcode >= 0x20 && startcode <= 0x3f) {
603  } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
606  } else {
607 skip:
608  /* skip packet */
609  avio_skip(s->pb, len);
610  goto redo;
611  }
612  /* no stream found: add a new stream */
613  st = avformat_new_stream(s, NULL);
614  if (!st)
615  goto skip;
616  st->id = startcode;
617  st->codecpar->codec_type = type;
618  st->codecpar->codec_id = codec_id;
621  st->codecpar->channels = 1;
623  st->codecpar->sample_rate = 8000;
624  }
625  st->internal->request_probe = request_probe;
627 
628 found:
629  if (st->discard >= AVDISCARD_ALL)
630  goto skip;
631  if (startcode >= 0xa0 && startcode <= 0xaf) {
632  if (st->codecpar->codec_id == AV_CODEC_ID_MLP) {
633  if (len < 6)
634  goto skip;
635  avio_skip(s->pb, 6);
636  len -=6;
637  }
638  }
639  ret = av_get_packet(s->pb, pkt, len);
640 
641  pkt->pts = pts;
642  pkt->dts = dts;
643  pkt->pos = dummy_pos;
644  pkt->stream_index = st->index;
645 
646  if (s->debug & FF_FDEBUG_TS)
647  av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
648  pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
649  pkt->size);
650 
651  return (ret < 0) ? ret : 0;
652 }
653 
654 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
655  int64_t *ppos, int64_t pos_limit)
656 {
657  int len, startcode;
658  int64_t pos, pts, dts;
659 
660  pos = *ppos;
661  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
662  return AV_NOPTS_VALUE;
663 
664  for (;;) {
665  len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
666  if (len < 0) {
667  if (s->debug & FF_FDEBUG_TS)
668  av_log(s, AV_LOG_DEBUG, "none (ret=%d)\n", len);
669  return AV_NOPTS_VALUE;
670  }
671  if (startcode == s->streams[stream_index]->id &&
672  dts != AV_NOPTS_VALUE) {
673  break;
674  }
675  avio_skip(s->pb, len);
676  }
677  if (s->debug & FF_FDEBUG_TS)
678  av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
679  pos, dts, dts / 90000.0);
680  *ppos = pos;
681  return dts;
682 }
683 
685  .name = "mpeg",
686  .long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),
687  .priv_data_size = sizeof(MpegDemuxContext),
691  .read_timestamp = mpegps_read_dts,
693 };
694 
695 #if CONFIG_VOBSUB_DEMUXER
696 
697 #include "subtitles.h"
698 #include "libavutil/avassert.h"
699 #include "libavutil/bprint.h"
700 #include "libavutil/opt.h"
701 
702 #define REF_STRING "# VobSub index file,"
703 #define MAX_LINE_SIZE 2048
704 
705 typedef struct VobSubDemuxContext {
706  const AVClass *class;
707  AVFormatContext *sub_ctx;
708  FFDemuxSubtitlesQueue q[32];
709  char *sub_name;
710 } VobSubDemuxContext;
711 
712 static int vobsub_probe(const AVProbeData *p)
713 {
714  if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))
715  return AVPROBE_SCORE_MAX;
716  return 0;
717 }
718 
719 static int vobsub_read_close(AVFormatContext *s)
720 {
721  VobSubDemuxContext *vobsub = s->priv_data;
722  int i;
723 
724  for (i = 0; i < s->nb_streams; i++)
725  ff_subtitles_queue_clean(&vobsub->q[i]);
726  if (vobsub->sub_ctx)
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 
772 
773  if ((ret = ff_copy_whiteblacklists(vobsub->sub_ctx, s)) < 0)
774  goto end;
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  goto end;
780  }
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:
914  if (ret < 0)
915  vobsub_read_close(s);
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  .read_probe = vobsub_probe,
1048  .read_header = vobsub_read_header,
1049  .read_packet = vobsub_read_packet,
1050  .read_seek2 = vobsub_read_seek,
1051  .read_close = vobsub_read_close,
1052  .flags = AVFMT_SHOW_IDS,
1053  .extensions = "idx",
1054  .priv_class = &vobsub_demuxer_class,
1055 };
1056 #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:187
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_mpegps_demuxer
const AVInputFormat ff_mpegps_demuxer
Definition: mpeg.c:684
mpegps_read_packet
static int mpegps_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpeg.c:475
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:4376
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:235
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1370
FFERROR_REDO
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data).
Definition: internal.h:869
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:69
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:32
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:886
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:104
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:117
AV_DISPOSITION_DEFAULT
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:782
state
static struct @321 state
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:365
AVStream::internal
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:999
AVOption
AVOption.
Definition: opt.h:248
find_next_start_code
static int find_next_start_code(AVIOContext *pb, int *size_ptr, int32_t *header_state)
Definition: mpeg.c:160
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:197
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:332
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:466
MpegDemuxContext::dvd
int dvd
Definition: mpeg.c:121
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:106
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:775
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:4348
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:1939
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:142
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:538
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:652
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:255
avassert.h
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:764
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:181
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:621
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:481
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:626
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:147
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:202
nb_streams
static int nb_streams
Definition: ffprobe.c:288
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h: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:216
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:558
if
if(ret)
Definition: filter_design.txt:179
AVERROR_DEMUXER_NOT_FOUND
#define AVERROR_DEMUXER_NOT_FOUND
Demuxer not found.
Definition: error.h:53
SUB_SORT_POS_TS
@ SUB_SORT_POS_TS
sort by position, then timestamps
Definition: subtitles.h:31
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
AVFormatContext
Format I/O context.
Definition: avformat.h:1097
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:126
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:984
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:67
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:860
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:1046
check_pes
static int check_pes(const uint8_t *p, const uint8_t *end)
Definition: mpeg.c:32
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:520
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:895
PACK_START_CODE
#define PACK_START_CODE
Definition: mpeg.h:28
ff_subtitles_queue_insert
AVPacket * ff_subtitles_queue_insert(FFDemuxSubtitlesQueue *q, const uint8_t *event, size_t len, int merge)
Insert a new subtitle event.
Definition: subtitles.c:111
MpegDemuxContext::sofdec
int sofdec
Definition: mpeg.c:120
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:58
options
const OptionDef options[]
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
avio_rb24
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:757
MpegDemuxContext::psm_es_type
unsigned char psm_es_type[256]
Definition: mpeg.c:119
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:366
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:54
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:267
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:4801
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:144
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:843
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:118
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:198
FFDemuxSubtitlesQueue
Definition: subtitles.h:102
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:364
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:607
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:981
ff_subtitles_queue_clean
void ff_subtitles_queue_clean(FFDemuxSubtitlesQueue *q)
Remove and destroy all the subtitles packets.
Definition: subtitles.c:307
mpeg.h
line
Definition: graph2dot.c:48
MpegDemuxContext::imkh_cctv
int imkh_cctv
Definition: mpeg.c:122
MpegDemuxContext::raw_ac3
int raw_ac3
Definition: mpeg.c:123
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:265
PRIVATE_STREAM_2
#define PRIVATE_STREAM_2
Definition: mpeg.h:39
bprint.h
i
int i
Definition: input.c:407
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:358
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:103
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:279
ff_get_line
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
Definition: aviobuf.c:772
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:280
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:844
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:837
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:243
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:72
AVStreamInternal::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:381
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:749
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
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:194
VIDEO_ID
#define VIDEO_ID
Definition: mpeg.h:42
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:838
STREAM_TYPE_VIDEO_H264
#define STREAM_TYPE_VIDEO_H264
Definition: mpeg.h:57
subtitles.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:1867
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:616
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:367
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:327
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:260
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:342
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:228
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:385
mpegps_probe
static int mpegps_probe(const AVProbeData *p)
Definition: mpeg.c:59
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:758
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:59
mpegps_read_dts
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
Definition: mpeg.c:654
MAX_SYNC_SIZE
#define MAX_SYNC_SIZE
Definition: mpeg.c:30
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
MpegDemuxContext
Definition: mpeg.c:117
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:3263
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:354