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