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