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 pcm_dvd = 0;
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_skip(s->pb, 3);
510  len -= 3;
511  if (startcode >= 0xb0 && startcode <= 0xbf) {
512  /* MLP/TrueHD audio has a 4-byte header */
513  avio_r8(s->pb);
514  len--;
515  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
516  ret = ffio_ensure_seekback(s->pb, 3);
517  if (ret < 0)
518  return ret;
519  pcm_dvd = (avio_rb24(s->pb) & 0xFF) == 0x80;
520  avio_skip(s->pb, -3);
521  }
522  }
523  }
524 
525  /* now find stream */
526  for (i = 0; i < s->nb_streams; i++) {
527  st = s->streams[i];
528  if (st->id == startcode)
529  goto found;
530  }
531 
532  es_type = m->psm_es_type[startcode & 0xff];
533  if (es_type == STREAM_TYPE_VIDEO_MPEG1) {
534  codec_id = AV_CODEC_ID_MPEG2VIDEO;
535  type = AVMEDIA_TYPE_VIDEO;
536  } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {
537  codec_id = AV_CODEC_ID_MPEG2VIDEO;
538  type = AVMEDIA_TYPE_VIDEO;
539  } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||
540  es_type == STREAM_TYPE_AUDIO_MPEG2) {
541  codec_id = AV_CODEC_ID_MP3;
542  type = AVMEDIA_TYPE_AUDIO;
543  } else if (es_type == STREAM_TYPE_AUDIO_AAC) {
544  codec_id = AV_CODEC_ID_AAC;
545  type = AVMEDIA_TYPE_AUDIO;
546  } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {
547  codec_id = AV_CODEC_ID_MPEG4;
548  type = AVMEDIA_TYPE_VIDEO;
549  } else if (es_type == STREAM_TYPE_VIDEO_H264) {
550  codec_id = AV_CODEC_ID_H264;
551  type = AVMEDIA_TYPE_VIDEO;
552  } else if (es_type == STREAM_TYPE_VIDEO_HEVC) {
553  codec_id = AV_CODEC_ID_HEVC;
554  type = AVMEDIA_TYPE_VIDEO;
555  } else if (es_type == STREAM_TYPE_AUDIO_AC3) {
556  codec_id = AV_CODEC_ID_AC3;
557  type = AVMEDIA_TYPE_AUDIO;
558  } else if (m->imkh_cctv && es_type == 0x91) {
559  codec_id = AV_CODEC_ID_PCM_MULAW;
560  type = AVMEDIA_TYPE_AUDIO;
561  } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
562  static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
563  unsigned char buf[8];
564 
565  avio_read(s->pb, buf, 8);
566  avio_seek(s->pb, -8, SEEK_CUR);
567  if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
568  codec_id = AV_CODEC_ID_CAVS;
569  else
570  request_probe= 1;
571  type = AVMEDIA_TYPE_VIDEO;
572  } else if (startcode == PRIVATE_STREAM_2) {
573  type = AVMEDIA_TYPE_DATA;
574  codec_id = AV_CODEC_ID_DVD_NAV;
575  } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
576  type = AVMEDIA_TYPE_AUDIO;
577  if (m->sofdec > 0) {
578  codec_id = AV_CODEC_ID_ADPCM_ADX;
579  // Auto-detect AC-3
580  request_probe = 50;
581  } else if (m->imkh_cctv && startcode == 0x1c0 && len > 80) {
582  codec_id = AV_CODEC_ID_PCM_ALAW;
583  request_probe = 50;
584  } else {
585  codec_id = AV_CODEC_ID_MP2;
586  if (m->imkh_cctv)
587  request_probe = 25;
588  }
589  } else if (startcode >= 0x80 && startcode <= 0x87) {
590  type = AVMEDIA_TYPE_AUDIO;
591  codec_id = AV_CODEC_ID_AC3;
592  } else if ((startcode >= 0x88 && startcode <= 0x8f) ||
593  (startcode >= 0x98 && startcode <= 0x9f)) {
594  /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
595  type = AVMEDIA_TYPE_AUDIO;
596  codec_id = AV_CODEC_ID_DTS;
597  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
598  type = AVMEDIA_TYPE_AUDIO;
599  if (!pcm_dvd) {
600  codec_id = AV_CODEC_ID_MLP;
601  } else {
602  codec_id = AV_CODEC_ID_PCM_DVD;
603  }
604  } else if (startcode >= 0xb0 && startcode <= 0xbf) {
605  type = AVMEDIA_TYPE_AUDIO;
606  codec_id = AV_CODEC_ID_TRUEHD;
607  } else if (startcode >= 0xc0 && startcode <= 0xcf) {
608  /* Used for both AC-3 and E-AC-3 in EVOB files */
609  type = AVMEDIA_TYPE_AUDIO;
610  codec_id = AV_CODEC_ID_AC3;
611  } else if (startcode >= 0x20 && startcode <= 0x3f) {
612  type = AVMEDIA_TYPE_SUBTITLE;
613  codec_id = AV_CODEC_ID_DVD_SUBTITLE;
614  } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
615  type = AVMEDIA_TYPE_VIDEO;
616  codec_id = AV_CODEC_ID_VC1;
617  } else {
618 skip:
619  /* skip packet */
620  avio_skip(s->pb, len);
621  goto redo;
622  }
623  /* no stream found: add a new stream */
624  st = avformat_new_stream(s, NULL);
625  if (!st)
626  goto skip;
627  st->id = startcode;
628  st->codecpar->codec_type = type;
629  st->codecpar->codec_id = codec_id;
632  st->codecpar->channels = 1;
634  st->codecpar->sample_rate = 8000;
635  }
636  st->request_probe = request_probe;
638 
639 found:
640  if (st->discard >= AVDISCARD_ALL)
641  goto skip;
642  if (startcode >= 0xa0 && startcode <= 0xaf) {
643  if (st->codecpar->codec_id == AV_CODEC_ID_MLP) {
644  if (len < 6)
645  goto skip;
646  avio_skip(s->pb, 6);
647  len -=6;
648  }
649  }
650  ret = av_get_packet(s->pb, pkt, len);
651 
652  pkt->pts = pts;
653  pkt->dts = dts;
654  pkt->pos = dummy_pos;
655  pkt->stream_index = st->index;
656 
657  if (s->debug & FF_FDEBUG_TS)
658  av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
659  pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
660  pkt->size);
661 
662  return (ret < 0) ? ret : 0;
663 }
664 
665 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
666  int64_t *ppos, int64_t pos_limit)
667 {
668  int len, startcode;
669  int64_t pos, pts, dts;
670 
671  pos = *ppos;
672  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
673  return AV_NOPTS_VALUE;
674 
675  for (;;) {
676  len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
677  if (len < 0) {
678  if (s->debug & FF_FDEBUG_TS)
679  av_log(s, AV_LOG_DEBUG, "none (ret=%d)\n", len);
680  return AV_NOPTS_VALUE;
681  }
682  if (startcode == s->streams[stream_index]->id &&
683  dts != AV_NOPTS_VALUE) {
684  break;
685  }
686  avio_skip(s->pb, len);
687  }
688  if (s->debug & FF_FDEBUG_TS)
689  av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
690  pos, dts, dts / 90000.0);
691  *ppos = pos;
692  return dts;
693 }
694 
696  .name = "mpeg",
697  .long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),
698  .priv_data_size = sizeof(MpegDemuxContext),
702  .read_timestamp = mpegps_read_dts,
704 };
705 
706 #if CONFIG_VOBSUB_DEMUXER
707 
708 #define REF_STRING "# VobSub index file,"
709 #define MAX_LINE_SIZE 2048
710 
711 static int vobsub_probe(const AVProbeData *p)
712 {
713  if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))
714  return AVPROBE_SCORE_MAX;
715  return 0;
716 }
717 
718 static int vobsub_read_header(AVFormatContext *s)
719 {
720  int i, ret = 0, header_parsed = 0, langidx = 0;
721  MpegDemuxContext *vobsub = s->priv_data;
722  size_t fname_len;
723  char *header_str = NULL;
724  AVBPrint header;
725  int64_t delay = 0;
726  AVStream *st = NULL;
727  int stream_id = -1;
728  char id[64] = {0};
729  char alt[MAX_LINE_SIZE] = {0};
731 
732  if (!vobsub->sub_name) {
733  char *ext;
734  vobsub->sub_name = av_strdup(s->url);
735  if (!vobsub->sub_name) {
736  ret = AVERROR(ENOMEM);
737  goto end;
738  }
739 
740  fname_len = strlen(vobsub->sub_name);
741  ext = vobsub->sub_name - 3 + fname_len;
742  if (fname_len < 4 || *(ext - 1) != '.') {
743  av_log(s, AV_LOG_ERROR, "The input index filename is too short "
744  "to guess the associated .SUB file\n");
745  ret = AVERROR_INVALIDDATA;
746  goto end;
747  }
748  memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3);
749  av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->url, vobsub->sub_name);
750  }
751 
752  if (!(iformat = av_find_input_format("mpeg"))) {
754  goto end;
755  }
756 
757  vobsub->sub_ctx = avformat_alloc_context();
758  if (!vobsub->sub_ctx) {
759  ret = AVERROR(ENOMEM);
760  goto end;
761  }
762 
763  if ((ret = ff_copy_whiteblacklists(vobsub->sub_ctx, s)) < 0)
764  goto end;
765 
766  ret = avformat_open_input(&vobsub->sub_ctx, vobsub->sub_name, iformat, NULL);
767  if (ret < 0) {
768  av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", vobsub->sub_name);
769  goto end;
770  }
771 
772  av_bprint_init(&header, 0, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
773  while (!avio_feof(s->pb)) {
774  char line[MAX_LINE_SIZE];
775  int len = ff_get_line(s->pb, line, sizeof(line));
776 
777  if (!len)
778  break;
779 
780  line[strcspn(line, "\r\n")] = 0;
781 
782  if (!strncmp(line, "id:", 3)) {
783  if (sscanf(line, "id: %63[^,], index: %u", id, &stream_id) != 2) {
784  av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', "
785  "assuming 'id: und, index: 0'\n", line);
786  strcpy(id, "und");
787  stream_id = 0;
788  }
789 
790  if (stream_id >= FF_ARRAY_ELEMS(vobsub->q)) {
791  av_log(s, AV_LOG_ERROR, "Maximum number of subtitles streams reached\n");
792  ret = AVERROR(EINVAL);
793  goto end;
794  }
795 
796  header_parsed = 1;
797  alt[0] = '\0';
798  /* We do not create the stream immediately to avoid adding empty
799  * streams. See the following timestamp entry. */
800 
801  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);
802 
803  } else if (!strncmp(line, "timestamp:", 10)) {
804  AVPacket *sub;
805  int hh, mm, ss, ms;
806  int64_t pos, timestamp;
807  const char *p = line + 10;
808 
809  if (stream_id == -1) {
810  av_log(s, AV_LOG_ERROR, "Timestamp declared before any stream\n");
811  ret = AVERROR_INVALIDDATA;
812  goto end;
813  }
814 
815  if (!st || st->id != stream_id) {
816  st = avformat_new_stream(s, NULL);
817  if (!st) {
818  ret = AVERROR(ENOMEM);
819  goto end;
820  }
821  st->id = stream_id;
824  avpriv_set_pts_info(st, 64, 1, 1000);
825  av_dict_set(&st->metadata, "language", id, 0);
826  if (alt[0])
827  av_dict_set(&st->metadata, "title", alt, 0);
828  }
829 
830  if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"SCNx64,
831  &hh, &mm, &ss, &ms, &pos) != 5) {
832  av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "
833  "abort parsing\n", line);
834  ret = AVERROR_INVALIDDATA;
835  goto end;
836  }
837  timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay;
838  timestamp = av_rescale_q(timestamp, av_make_q(1, 1000), st->time_base);
839 
840  sub = ff_subtitles_queue_insert(&vobsub->q[s->nb_streams - 1], "", 0, 0);
841  if (!sub) {
842  ret = AVERROR(ENOMEM);
843  goto end;
844  }
845  sub->pos = pos;
846  sub->pts = timestamp;
847  sub->stream_index = s->nb_streams - 1;
848 
849  } else if (!strncmp(line, "alt:", 4)) {
850  const char *p = line + 4;
851 
852  while (*p == ' ')
853  p++;
854  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", stream_id, p);
855  av_strlcpy(alt, p, sizeof(alt));
856  header_parsed = 1;
857 
858  } else if (!strncmp(line, "delay:", 6)) {
859  int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0;
860  const char *p = line + 6;
861 
862  while (*p == ' ')
863  p++;
864  if (*p == '-' || *p == '+') {
865  sign = *p == '-' ? -1 : 1;
866  p++;
867  }
868  sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms);
869  delay = ((hh*3600LL + mm*60LL + ss) * 1000LL + ms) * sign;
870 
871  } else if (!strncmp(line, "langidx:", 8)) {
872  const char *p = line + 8;
873 
874  if (sscanf(p, "%d", &langidx) != 1)
875  av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n");
876 
877  } else if (!header_parsed) {
878  if (line[0] && line[0] != '#')
879  av_bprintf(&header, "%s\n", line);
880  }
881  }
882 
883  if (langidx < s->nb_streams)
885 
886  for (i = 0; i < s->nb_streams; i++) {
887  vobsub->q[i].sort = SUB_SORT_POS_TS;
888  vobsub->q[i].keep_duplicates = 1;
889  ff_subtitles_queue_finalize(s, &vobsub->q[i]);
890  }
891 
892  if (!av_bprint_is_complete(&header)) {
893  av_bprint_finalize(&header, NULL);
894  ret = AVERROR(ENOMEM);
895  goto end;
896  }
897  av_bprint_finalize(&header, &header_str);
898  for (i = 0; i < s->nb_streams; i++) {
899  AVCodecParameters *par = s->streams[i]->codecpar;
900  ret = ff_alloc_extradata(par, header.len);
901  if (ret < 0) {
902  goto end;
903  }
904  memcpy(par->extradata, header_str, header.len);
905  }
906 end:
907 
908  av_free(header_str);
909  return ret;
910 }
911 
912 static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt)
913 {
914  MpegDemuxContext *vobsub = s->priv_data;
916  AVIOContext *pb = vobsub->sub_ctx->pb;
917  int ret, psize, total_read = 0, i;
918  AVPacket idx_pkt = { 0 };
919 
920  int64_t min_ts = INT64_MAX;
921  int sid = 0;
922  for (i = 0; i < s->nb_streams; i++) {
923  FFDemuxSubtitlesQueue *tmpq = &vobsub->q[i];
924  int64_t ts;
925  av_assert0(tmpq->nb_subs);
926  ts = tmpq->subs[tmpq->current_sub_idx].pts;
927  if (ts < min_ts) {
928  min_ts = ts;
929  sid = i;
930  }
931  }
932  q = &vobsub->q[sid];
933  ret = ff_subtitles_queue_read_packet(q, &idx_pkt);
934  if (ret < 0)
935  return ret;
936 
937  /* compute maximum packet size using the next packet position. This is
938  * useful when the len in the header is non-sense */
939  if (q->current_sub_idx < q->nb_subs) {
940  psize = q->subs[q->current_sub_idx].pos - idx_pkt.pos;
941  } else {
942  int64_t fsize = avio_size(pb);
943  psize = fsize < 0 ? 0xffff : fsize - idx_pkt.pos;
944  }
945 
946  avio_seek(pb, idx_pkt.pos, SEEK_SET);
947 
948  av_init_packet(pkt);
949  pkt->size = 0;
950  pkt->data = NULL;
951 
952  do {
953  int n, to_read, startcode;
954  int64_t pts, dts;
955  int64_t old_pos = avio_tell(pb), new_pos;
956  int pkt_size;
957 
958  ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);
959  if (ret < 0) {
960  if (pkt->size) // raise packet even if incomplete
961  break;
962  goto fail;
963  }
964  to_read = ret & 0xffff;
965  new_pos = avio_tell(pb);
966  pkt_size = ret + (new_pos - old_pos);
967 
968  /* this prevents reads above the current packet */
969  if (total_read + pkt_size > psize)
970  break;
971  total_read += pkt_size;
972 
973  /* the current chunk doesn't match the stream index (unlikely) */
974  if ((startcode & 0x1f) != s->streams[idx_pkt.stream_index]->id)
975  break;
976 
977  ret = av_grow_packet(pkt, to_read);
978  if (ret < 0)
979  goto fail;
980 
981  n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);
982  if (n < to_read)
983  pkt->size -= to_read - n;
984  } while (total_read < psize);
985 
986  pkt->pts = pkt->dts = idx_pkt.pts;
987  pkt->pos = idx_pkt.pos;
988  pkt->stream_index = idx_pkt.stream_index;
989 
990  av_packet_unref(&idx_pkt);
991  return 0;
992 
993 fail:
994  av_packet_unref(pkt);
995  av_packet_unref(&idx_pkt);
996  return ret;
997 }
998 
999 static int vobsub_read_seek(AVFormatContext *s, int stream_index,
1000  int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1001 {
1002  MpegDemuxContext *vobsub = s->priv_data;
1003 
1004  /* Rescale requested timestamps based on the first stream (timebase is the
1005  * same for all subtitles stream within a .idx/.sub). Rescaling is done just
1006  * like in avformat_seek_file(). */
1007  if (stream_index == -1 && s->nb_streams != 1) {
1008  int i, ret = 0;
1009  AVRational time_base = s->streams[0]->time_base;
1010  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
1011  min_ts = av_rescale_rnd(min_ts, time_base.den,
1012  time_base.num * (int64_t)AV_TIME_BASE,
1014  max_ts = av_rescale_rnd(max_ts, time_base.den,
1015  time_base.num * (int64_t)AV_TIME_BASE,
1017  for (i = 0; i < s->nb_streams; i++) {
1018  int r = ff_subtitles_queue_seek(&vobsub->q[i], s, stream_index,
1019  min_ts, ts, max_ts, flags);
1020  if (r < 0)
1021  ret = r;
1022  }
1023  return ret;
1024  }
1025 
1026  if (stream_index == -1) // only 1 stream
1027  stream_index = 0;
1028  return ff_subtitles_queue_seek(&vobsub->q[stream_index], s, stream_index,
1029  min_ts, ts, max_ts, flags);
1030 }
1031 
1032 static int vobsub_read_close(AVFormatContext *s)
1033 {
1034  int i;
1035  MpegDemuxContext *vobsub = s->priv_data;
1036 
1037  for (i = 0; i < s->nb_streams; i++)
1038  ff_subtitles_queue_clean(&vobsub->q[i]);
1039  if (vobsub->sub_ctx)
1040  avformat_close_input(&vobsub->sub_ctx);
1041  return 0;
1042 }
1043 
1044 static const AVOption options[] = {
1045  { "sub_name", "URI for .sub file", offsetof(MpegDemuxContext, sub_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_DECODING_PARAM },
1046  { NULL }
1047 };
1048 
1049 static const AVClass vobsub_demuxer_class = {
1050  .class_name = "vobsub",
1051  .item_name = av_default_item_name,
1052  .option = options,
1053  .version = LIBAVUTIL_VERSION_INT,
1054 };
1055 
1057  .name = "vobsub",
1058  .long_name = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),
1059  .priv_data_size = sizeof(MpegDemuxContext),
1060  .read_probe = vobsub_probe,
1061  .read_header = vobsub_read_header,
1062  .read_packet = vobsub_read_packet,
1063  .read_seek2 = vobsub_read_seek,
1064  .read_close = vobsub_read_close,
1065  .flags = AVFMT_SHOW_IDS,
1066  .extensions = "idx",
1067  .priv_class = &vobsub_demuxer_class,
1068 };
1069 #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:2049
#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:1500
#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:4929
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:3968
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:882
int size
Definition: avcodec.h:1481
#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:300
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:539
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:814
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
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3960
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: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:1977
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:211
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:4502
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data)...
Definition: internal.h:655
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:1480
#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:665
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4070
#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 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:338
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:566
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3964
#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:122
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
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:3321
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:796
#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:248
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
static struct @320 state
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:4078
#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:3374
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:4474
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:793
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:3982
int channels
Audio only.
Definition: avcodec.h:4074
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1479
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:1482
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:1457
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:1473
#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:695