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