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_AUDIO_AC3) {
552  } else if (m->imkh_cctv && es_type == 0x91) {
555  } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
556  static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
557  unsigned char buf[8];
558 
559  avio_read(s->pb, buf, 8);
560  avio_seek(s->pb, -8, SEEK_CUR);
561  if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
563  else
564  request_probe= 1;
566  } else if (startcode == PRIVATE_STREAM_2) {
569  } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
571  if (m->sofdec > 0) {
573  // Auto-detect AC-3
574  request_probe = 50;
575  } else if (m->imkh_cctv && startcode == 0x1c0 && len > 80) {
577  request_probe = 50;
578  } else {
580  if (m->imkh_cctv)
581  request_probe = 25;
582  }
583  } else if (startcode >= 0x80 && startcode <= 0x87) {
586  } else if ((startcode >= 0x88 && startcode <= 0x8f) ||
587  (startcode >= 0x98 && startcode <= 0x9f)) {
588  /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
591  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
593  if (!pcm_dvd) {
595  } else {
597  }
598  } else if (startcode >= 0xb0 && startcode <= 0xbf) {
601  } else if (startcode >= 0xc0 && startcode <= 0xcf) {
602  /* Used for both AC-3 and E-AC-3 in EVOB files */
605  } else if (startcode >= 0x20 && startcode <= 0x3f) {
608  } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
611  } else {
612 skip:
613  /* skip packet */
614  avio_skip(s->pb, len);
615  goto redo;
616  }
617  /* no stream found: add a new stream */
618  st = avformat_new_stream(s, NULL);
619  if (!st)
620  goto skip;
621  sti = ffstream(st);
622  st->id = startcode;
623  st->codecpar->codec_type = type;
624  st->codecpar->codec_id = codec_id;
628  st->codecpar->sample_rate = 8000;
629  }
630  sti->request_probe = request_probe;
632 
633 found:
634  if (st->discard >= AVDISCARD_ALL)
635  goto skip;
636  if (startcode >= 0xa0 && startcode <= 0xaf) {
637  if (st->codecpar->codec_id == AV_CODEC_ID_MLP) {
638  if (len < 6)
639  goto skip;
640  avio_skip(s->pb, 6);
641  len -=6;
642  }
643  }
644  ret = av_get_packet(s->pb, pkt, len);
645 
646  pkt->pts = pts;
647  pkt->dts = dts;
648  pkt->pos = dummy_pos;
649  pkt->stream_index = st->index;
650 
651  if (s->debug & FF_FDEBUG_TS)
652  av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
653  pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
654  pkt->size);
655 
656  return (ret < 0) ? ret : 0;
657 }
658 
659 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
660  int64_t *ppos, int64_t pos_limit)
661 {
662  int len, startcode;
663  int64_t pos, pts, dts;
664 
665  pos = *ppos;
666  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
667  return AV_NOPTS_VALUE;
668 
669  for (;;) {
670  len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
671  if (len < 0) {
672  if (s->debug & FF_FDEBUG_TS)
673  av_log(s, AV_LOG_DEBUG, "none (ret=%d)\n", len);
674  return AV_NOPTS_VALUE;
675  }
676  if (startcode == s->streams[stream_index]->id &&
677  dts != AV_NOPTS_VALUE) {
678  break;
679  }
680  avio_skip(s->pb, len);
681  }
682  if (s->debug & FF_FDEBUG_TS)
683  av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
684  pos, dts, dts / 90000.0);
685  *ppos = pos;
686  return dts;
687 }
688 
690  .name = "mpeg",
691  .long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),
692  .priv_data_size = sizeof(MpegDemuxContext),
698 };
699 
700 #if CONFIG_VOBSUB_DEMUXER
701 
702 #include "subtitles.h"
703 #include "libavutil/avassert.h"
704 #include "libavutil/bprint.h"
705 #include "libavutil/opt.h"
706 
707 #define REF_STRING "# VobSub index file,"
708 #define MAX_LINE_SIZE 2048
709 
710 typedef struct VobSubDemuxContext {
711  const AVClass *class;
712  AVFormatContext *sub_ctx;
713  FFDemuxSubtitlesQueue q[32];
714  char *sub_name;
715 } VobSubDemuxContext;
716 
717 static int vobsub_probe(const AVProbeData *p)
718 {
719  if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))
720  return AVPROBE_SCORE_MAX;
721  return 0;
722 }
723 
724 static int vobsub_read_close(AVFormatContext *s)
725 {
726  VobSubDemuxContext *vobsub = s->priv_data;
727  int i;
728 
729  for (i = 0; i < s->nb_streams; i++)
730  ff_subtitles_queue_clean(&vobsub->q[i]);
731  avformat_close_input(&vobsub->sub_ctx);
732  return 0;
733 }
734 
735 static int vobsub_read_header(AVFormatContext *s)
736 {
737  int i, ret = 0, header_parsed = 0, langidx = 0;
738  VobSubDemuxContext *vobsub = s->priv_data;
739  const AVInputFormat *iformat;
740  size_t fname_len;
741  AVBPrint header;
742  int64_t delay = 0;
743  AVStream *st = NULL;
744  int stream_id = -1;
745  char id[64] = {0};
746  char alt[MAX_LINE_SIZE] = {0};
747 
748  if (!vobsub->sub_name) {
749  char *ext;
750  vobsub->sub_name = av_strdup(s->url);
751  if (!vobsub->sub_name) {
752  return AVERROR(ENOMEM);
753  }
754 
755  fname_len = strlen(vobsub->sub_name);
756  ext = vobsub->sub_name - 3 + fname_len;
757  if (fname_len < 4 || *(ext - 1) != '.') {
758  av_log(s, AV_LOG_ERROR, "The input index filename is too short "
759  "to guess the associated .SUB file\n");
760  return AVERROR_INVALIDDATA;
761  }
762  memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3);
763  av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->url, vobsub->sub_name);
764  }
765 
766  if (!(iformat = av_find_input_format("mpeg"))) {
768  }
769 
770  vobsub->sub_ctx = avformat_alloc_context();
771  if (!vobsub->sub_ctx) {
772  return AVERROR(ENOMEM);
773  }
774 
775  if ((ret = ff_copy_whiteblacklists(vobsub->sub_ctx, s)) < 0)
776  return ret;
777 
778  ret = avformat_open_input(&vobsub->sub_ctx, vobsub->sub_name, iformat, NULL);
779  if (ret < 0) {
780  av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", vobsub->sub_name);
781  return ret;
782  }
783 
785 
786  while (!avio_feof(s->pb)) {
787  char line[MAX_LINE_SIZE];
788  int len = ff_get_line(s->pb, line, sizeof(line));
789 
790  if (!len)
791  break;
792 
793  line[strcspn(line, "\r\n")] = 0;
794 
795  if (!strncmp(line, "id:", 3)) {
796  if (sscanf(line, "id: %63[^,], index: %u", id, &stream_id) != 2) {
797  av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', "
798  "assuming 'id: und, index: 0'\n", line);
799  strcpy(id, "und");
800  stream_id = 0;
801  }
802 
803  if (stream_id >= FF_ARRAY_ELEMS(vobsub->q)) {
804  av_log(s, AV_LOG_ERROR, "Maximum number of subtitles streams reached\n");
805  ret = AVERROR(EINVAL);
806  goto end;
807  }
808 
809  header_parsed = 1;
810  alt[0] = '\0';
811  /* We do not create the stream immediately to avoid adding empty
812  * streams. See the following timestamp entry. */
813 
814  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);
815 
816  } else if (!strncmp(line, "timestamp:", 10)) {
817  AVPacket *sub;
818  int hh, mm, ss, ms;
819  int64_t pos, timestamp;
820  const char *p = line + 10;
821 
822  if (stream_id == -1) {
823  av_log(s, AV_LOG_ERROR, "Timestamp declared before any stream\n");
825  goto end;
826  }
827 
828  if (!st || st->id != stream_id) {
829  st = avformat_new_stream(s, NULL);
830  if (!st) {
831  ret = AVERROR(ENOMEM);
832  goto end;
833  }
834  st->id = stream_id;
837  avpriv_set_pts_info(st, 64, 1, 1000);
838  av_dict_set(&st->metadata, "language", id, 0);
839  if (alt[0])
840  av_dict_set(&st->metadata, "title", alt, 0);
841  }
842 
843  if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"SCNx64,
844  &hh, &mm, &ss, &ms, &pos) != 5) {
845  av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "
846  "abort parsing\n", line);
848  goto end;
849  }
850  timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay;
851  timestamp = av_rescale_q(timestamp, av_make_q(1, 1000), st->time_base);
852 
853  sub = ff_subtitles_queue_insert(&vobsub->q[s->nb_streams - 1], "", 0, 0);
854  if (!sub) {
855  ret = AVERROR(ENOMEM);
856  goto end;
857  }
858  sub->pos = pos;
859  sub->pts = timestamp;
860  sub->stream_index = s->nb_streams - 1;
861 
862  } else if (!strncmp(line, "alt:", 4)) {
863  const char *p = line + 4;
864 
865  while (*p == ' ')
866  p++;
867  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", stream_id, p);
868  av_strlcpy(alt, p, sizeof(alt));
869  header_parsed = 1;
870 
871  } else if (!strncmp(line, "delay:", 6)) {
872  int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0;
873  const char *p = line + 6;
874 
875  while (*p == ' ')
876  p++;
877  if (*p == '-' || *p == '+') {
878  sign = *p == '-' ? -1 : 1;
879  p++;
880  }
881  sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms);
882  delay = ((hh*3600LL + mm*60LL + ss) * 1000LL + ms) * sign;
883 
884  } else if (!strncmp(line, "langidx:", 8)) {
885  const char *p = line + 8;
886 
887  if (sscanf(p, "%d", &langidx) != 1)
888  av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n");
889 
890  } else if (!header_parsed) {
891  if (line[0] && line[0] != '#')
892  av_bprintf(&header, "%s\n", line);
893  }
894  }
895 
896  if (langidx < s->nb_streams)
897  s->streams[langidx]->disposition |= AV_DISPOSITION_DEFAULT;
898 
899  for (i = 0; i < s->nb_streams; i++) {
900  vobsub->q[i].sort = SUB_SORT_POS_TS;
901  vobsub->q[i].keep_duplicates = 1;
902  ff_subtitles_queue_finalize(s, &vobsub->q[i]);
903  }
904 
905  if (!av_bprint_is_complete(&header)) {
906  ret = AVERROR(ENOMEM);
907  goto end;
908  }
909  for (i = 0; i < s->nb_streams; i++) {
910  AVCodecParameters *par = s->streams[i]->codecpar;
911  ret = ff_alloc_extradata(par, header.len);
912  if (ret < 0) {
913  goto end;
914  }
915  memcpy(par->extradata, header.str, header.len);
916  }
917 end:
919  return ret;
920 }
921 
922 static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt)
923 {
924  VobSubDemuxContext *vobsub = s->priv_data;
926  AVIOContext *pb = vobsub->sub_ctx->pb;
927  int ret, psize, total_read = 0, i;
928 
929  int64_t min_ts = INT64_MAX;
930  int sid = 0;
931  for (i = 0; i < s->nb_streams; i++) {
932  FFDemuxSubtitlesQueue *tmpq = &vobsub->q[i];
933  int64_t ts;
934  av_assert0(tmpq->nb_subs);
935 
936  if (tmpq->current_sub_idx >= tmpq->nb_subs)
937  continue;
938 
939  ts = tmpq->subs[tmpq->current_sub_idx]->pts;
940  if (ts < min_ts) {
941  min_ts = ts;
942  sid = i;
943  }
944  }
945  q = &vobsub->q[sid];
946  /* The returned packet will have size zero,
947  * so that it can be directly used with av_grow_packet. */
949  if (ret < 0)
950  return ret;
951 
952  /* compute maximum packet size using the next packet position. This is
953  * useful when the len in the header is non-sense */
954  if (q->current_sub_idx < q->nb_subs) {
955  psize = q->subs[q->current_sub_idx]->pos - pkt->pos;
956  } else {
957  int64_t fsize = avio_size(pb);
958  psize = fsize < 0 ? 0xffff : fsize - pkt->pos;
959  }
960 
961  avio_seek(pb, pkt->pos, SEEK_SET);
962 
963  do {
964  int n, to_read, startcode;
965  int64_t pts, dts;
966  int64_t old_pos = avio_tell(pb), new_pos;
967  int pkt_size;
968 
969  ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);
970  if (ret < 0) {
971  if (pkt->size) // raise packet even if incomplete
972  break;
973  return ret;
974  }
975  to_read = ret & 0xffff;
976  new_pos = avio_tell(pb);
977  pkt_size = ret + (new_pos - old_pos);
978 
979  /* this prevents reads above the current packet */
980  if (total_read + pkt_size > psize)
981  break;
982  total_read += pkt_size;
983 
984  /* the current chunk doesn't match the stream index (unlikely) */
985  if ((startcode & 0x1f) != s->streams[pkt->stream_index]->id)
986  break;
987 
988  ret = av_grow_packet(pkt, to_read);
989  if (ret < 0)
990  return ret;
991 
992  n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);
993  if (n < to_read)
994  pkt->size -= to_read - n;
995  } while (total_read < psize);
996 
997  return 0;
998 }
999 
1000 static int vobsub_read_seek(AVFormatContext *s, int stream_index,
1001  int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1002 {
1003  VobSubDemuxContext *vobsub = s->priv_data;
1004 
1005  /* Rescale requested timestamps based on the first stream (timebase is the
1006  * same for all subtitles stream within a .idx/.sub). Rescaling is done just
1007  * like in avformat_seek_file(). */
1008  if (stream_index == -1 && s->nb_streams != 1) {
1009  int i, ret = 0;
1010  AVRational time_base = s->streams[0]->time_base;
1011  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
1012  min_ts = av_rescale_rnd(min_ts, time_base.den,
1013  time_base.num * (int64_t)AV_TIME_BASE,
1015  max_ts = av_rescale_rnd(max_ts, time_base.den,
1016  time_base.num * (int64_t)AV_TIME_BASE,
1018  for (i = 0; i < s->nb_streams; i++) {
1019  int r = ff_subtitles_queue_seek(&vobsub->q[i], s, stream_index,
1020  min_ts, ts, max_ts, flags);
1021  if (r < 0)
1022  ret = r;
1023  }
1024  return ret;
1025  }
1026 
1027  if (stream_index == -1) // only 1 stream
1028  stream_index = 0;
1029  return ff_subtitles_queue_seek(&vobsub->q[stream_index], s, stream_index,
1030  min_ts, ts, max_ts, flags);
1031 }
1032 
1033 static const AVOption options[] = {
1034  { "sub_name", "URI for .sub file", offsetof(VobSubDemuxContext, sub_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_DECODING_PARAM },
1035  { NULL }
1036 };
1037 
1038 static const AVClass vobsub_demuxer_class = {
1039  .class_name = "vobsub",
1040  .item_name = av_default_item_name,
1041  .option = options,
1042  .version = LIBAVUTIL_VERSION_INT,
1043 };
1044 
1046  .name = "vobsub",
1047  .long_name = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),
1048  .priv_data_size = sizeof(VobSubDemuxContext),
1049  .flags_internal = FF_FMT_INIT_CLEANUP,
1050  .read_probe = vobsub_probe,
1051  .read_header = vobsub_read_header,
1052  .read_packet = vobsub_read_packet,
1053  .read_seek2 = vobsub_read_seek,
1054  .read_close = vobsub_read_close,
1055  .flags = AVFMT_SHOW_IDS,
1056  .extensions = "idx",
1057  .priv_class = &vobsub_demuxer_class,
1058 };
1059 #endif
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
MAX_LINE_SIZE
#define MAX_LINE_SIZE
Definition: vf_lut3d.c:548
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:75
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:432
SYSTEM_HEADER_START_CODE
#define SYSTEM_HEADER_START_CODE
Definition: mpeg.h:29
FF_FMT_INIT_CLEANUP
#define FF_FMT_INIT_CLEANUP
For an AVInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: internal.h:48
ff_mpegps_demuxer
const AVInputFormat ff_mpegps_demuxer
Definition: mpeg.c:689
mpegps_read_packet
static int mpegps_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpeg.c:479
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: options.c:237
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:479
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:1486
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:53
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:31
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:1010
FFDemuxSubtitlesQueue::nb_subs
int nb_subs
number of subtitles packets
Definition: subtitles.h:105
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:120
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:826
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:374
AVOption
AVOption.
Definition: opt.h:251
find_next_start_code
static int find_next_start_code(AVIOContext *pb, int *size_ptr, int32_t *header_state)
Definition: mpeg.c:164
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:353
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:456
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:352
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:473
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:815
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:465
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:368
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:763
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:407
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:118
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:505
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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:654
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:430
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:260
AVRational::num
int num
Numerator.
Definition: rational.h:59
ff_subtitles_queue_seek
int ff_subtitles_queue_seek(FFDemuxSubtitlesQueue *q, AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Update current_sub_idx to emulate a seek.
Definition: subtitles.c:253
avassert.h
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:790
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:656
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:220
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:256
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:661
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:455
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:429
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:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
nb_streams
static int nb_streams
Definition: ffprobe.c:307
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:326
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:374
AV_CODEC_ID_PCM_DVD
@ AV_CODEC_ID_PCM_DVD
Definition: codec_id.h:339
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
STREAM_TYPE_VIDEO_MPEG1
#define STREAM_TYPE_VIDEO_MPEG1
Definition: mpeg.h:49
fsize
static int64_t fsize(FILE *f)
Definition: audiomatch.c:29
ff_subtitles_queue_read_packet
int ff_subtitles_queue_read_packet(FFDemuxSubtitlesQueue *q, AVPacket *pkt)
Generic read_packet() callback for subtitles demuxers using this queue system.
Definition: subtitles.c:214
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
AV_CODEC_ID_DVD_NAV
@ AV_CODEC_ID_DVD_NAV
Definition: codec_id.h:567
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:380
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
AVFormatContext
Format I/O context.
Definition: avformat.h:1213
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:327
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:1108
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:532
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:978
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
state
static struct @334 state
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1164
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:807
AV_CODEC_ID_DVD_SUBTITLE
@ AV_CODEC_ID_DVD_SUBTITLE
Definition: codec_id.h:529
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:453
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:1019
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:212
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:463
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:177
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:431
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:162
avio_rb24
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:783
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:368
AVPacket::size
int size
Definition: packet.h:375
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:58
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:164
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:290
FFStream
Definition: internal.h:197
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:433
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:895
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:196
FFDemuxSubtitlesQueue
Definition: subtitles.h:103
header
static const uint8_t header[24]
Definition: sdr2.c:67
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:632
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:1055
ff_subtitles_queue_clean
void ff_subtitles_queue_clean(FFDemuxSubtitlesQueue *q)
Remove and destroy all the subtitles packets.
Definition: subtitles.c:305
mpeg.h
line
Definition: graph2dot.c:48
MpegDemuxContext::imkh_cctv
int imkh_cctv
Definition: mpeg.c: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:62
iformat
static const AVInputFormat * iformat
Definition: ffprobe.c:283
PRIVATE_STREAM_2
#define PRIVATE_STREAM_2
Definition: mpeg.h:39
bprint.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
FFDemuxSubtitlesQueue::subs
AVPacket ** subs
array of subtitles packets
Definition: subtitles.h:104
avio_internal.h
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
AV_CODEC_ID_CAVS
@ AV_CODEC_ID_CAVS
Definition: codec_id.h:137
AV_ROUND_DOWN
@ AV_ROUND_DOWN
Round toward -infinity.
Definition: mathematics.h:82
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:224
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:664
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:282
ff_get_line
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
Definition: aviobuf.c:798
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:120
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:102
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:962
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:948
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
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:775
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:198
VIDEO_ID
#define VIDEO_ID
Definition: mpeg.h:42
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:956
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:641
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:120
AVPacket::stream_index
int stream_index
Definition: packet.h:376
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:347
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:483
FFStream::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: internal.h:266
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:108
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:61
AVPacket
This structure stores compressed data.
Definition: packet.h:351
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:70
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:394
mpegps_probe
static int mpegps_probe(const AVProbeData *p)
Definition: mpeg.c:63
int32_t
int32_t
Definition: audioconvert.c:56
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:798
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:86
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:659
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:274
MAX_SYNC_SIZE
#define MAX_SYNC_SIZE
Definition: mpeg.c:34
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
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:46
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:52
AV_CODEC_ID_MLP
@ AV_CODEC_ID_MLP
Definition: codec_id.h:458
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:238
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:375