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 + 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 
151  buf[0] = c < 0 ? avio_r8(pb) : c;
152  avio_read(pb, buf + 1, 4);
153 
154  return ff_parse_pes_pts(buf);
155 }
156 
157 static int find_next_start_code(AVIOContext *pb, int *size_ptr,
159 {
160  unsigned int state, v;
161  int val, n;
162 
163  state = *header_state;
164  n = *size_ptr;
165  while (n > 0) {
166  if (avio_feof(pb))
167  break;
168  v = avio_r8(pb);
169  n--;
170  if (state == 0x000001) {
171  state = ((state << 8) | v) & 0xffffff;
172  val = state;
173  goto found;
174  }
175  state = ((state << 8) | v) & 0xffffff;
176  }
177  val = -1;
178 
179 found:
180  *header_state = state;
181  *size_ptr = n;
182  return val;
183 }
184 
185 /**
186  * Extract stream types from a program stream map
187  * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
188  *
189  * @return number of bytes occupied by PSM in the bitstream
190  */
192 {
193  int psm_length, ps_info_length, es_map_length;
194 
195  psm_length = avio_rb16(pb);
196  avio_r8(pb);
197  avio_r8(pb);
198  ps_info_length = avio_rb16(pb);
199 
200  /* skip program_stream_info */
201  avio_skip(pb, ps_info_length);
202  /*es_map_length = */avio_rb16(pb);
203  /* Ignore es_map_length, trust psm_length */
204  es_map_length = psm_length - ps_info_length - 10;
205 
206  /* at least one es available? */
207  while (es_map_length >= 4) {
208  unsigned char type = avio_r8(pb);
209  unsigned char es_id = avio_r8(pb);
210  uint16_t es_info_length = avio_rb16(pb);
211 
212  /* remember mapping from stream id to stream type */
213  m->psm_es_type[es_id] = type;
214  /* skip program_stream_info */
215  avio_skip(pb, es_info_length);
216  es_map_length -= 4 + es_info_length;
217  }
218  avio_rb32(pb); /* crc32 */
219  return 2 + psm_length;
220 }
221 
222 /* read the next PES header. Return its position in ppos
223  * (if not NULL), and its start code, pts and dts.
224  */
226  int64_t *ppos, int *pstart_code,
227  int64_t *ppts, int64_t *pdts)
228 {
229  MpegDemuxContext *m = s->priv_data;
230  int len, size, startcode, c, flags, header_len;
231  int pes_ext, ext2_len, id_ext, skip;
232  int64_t pts, dts;
233  int64_t last_sync = avio_tell(s->pb);
234 
235 error_redo:
236  avio_seek(s->pb, last_sync, SEEK_SET);
237 redo:
238  /* next start code (should be immediately after) */
239  m->header_state = 0xff;
240  size = MAX_SYNC_SIZE;
241  startcode = find_next_start_code(s->pb, &size, &m->header_state);
242  last_sync = avio_tell(s->pb);
243  if (startcode < 0) {
244  if (avio_feof(s->pb))
245  return AVERROR_EOF;
246  // FIXME we should remember header_state
247  return FFERROR_REDO;
248  }
249 
250  if (startcode == PACK_START_CODE)
251  goto redo;
252  if (startcode == SYSTEM_HEADER_START_CODE)
253  goto redo;
254  if (startcode == PADDING_STREAM) {
255  avio_skip(s->pb, avio_rb16(s->pb));
256  goto redo;
257  }
258  if (startcode == PRIVATE_STREAM_2) {
259  if (!m->sofdec) {
260  /* Need to detect whether this from a DVD or a 'Sofdec' stream */
261  int len = avio_rb16(s->pb);
262  int bytesread = 0;
263  uint8_t *ps2buf = av_malloc(len);
264 
265  if (ps2buf) {
266  bytesread = avio_read(s->pb, ps2buf, len);
267 
268  if (bytesread != len) {
269  avio_skip(s->pb, len - bytesread);
270  } else {
271  uint8_t *p = 0;
272  if (len >= 6)
273  p = memchr(ps2buf, 'S', len - 5);
274 
275  if (p)
276  m->sofdec = !memcmp(p+1, "ofdec", 5);
277 
278  m->sofdec -= !m->sofdec;
279 
280  if (m->sofdec < 0) {
281  if (len == 980 && ps2buf[0] == 0) {
282  /* PCI structure? */
283  uint32_t startpts = AV_RB32(ps2buf + 0x0d);
284  uint32_t endpts = AV_RB32(ps2buf + 0x11);
285  uint8_t hours = ((ps2buf[0x19] >> 4) * 10) + (ps2buf[0x19] & 0x0f);
286  uint8_t mins = ((ps2buf[0x1a] >> 4) * 10) + (ps2buf[0x1a] & 0x0f);
287  uint8_t secs = ((ps2buf[0x1b] >> 4) * 10) + (ps2buf[0x1b] & 0x0f);
288 
289  m->dvd = (hours <= 23 &&
290  mins <= 59 &&
291  secs <= 59 &&
292  (ps2buf[0x19] & 0x0f) < 10 &&
293  (ps2buf[0x1a] & 0x0f) < 10 &&
294  (ps2buf[0x1b] & 0x0f) < 10 &&
295  endpts >= startpts);
296  } else if (len == 1018 && ps2buf[0] == 1) {
297  /* DSI structure? */
298  uint8_t hours = ((ps2buf[0x1d] >> 4) * 10) + (ps2buf[0x1d] & 0x0f);
299  uint8_t mins = ((ps2buf[0x1e] >> 4) * 10) + (ps2buf[0x1e] & 0x0f);
300  uint8_t secs = ((ps2buf[0x1f] >> 4) * 10) + (ps2buf[0x1f] & 0x0f);
301 
302  m->dvd = (hours <= 23 &&
303  mins <= 59 &&
304  secs <= 59 &&
305  (ps2buf[0x1d] & 0x0f) < 10 &&
306  (ps2buf[0x1e] & 0x0f) < 10 &&
307  (ps2buf[0x1f] & 0x0f) < 10);
308  }
309  }
310  }
311 
312  av_free(ps2buf);
313 
314  /* If this isn't a DVD packet or no memory
315  * could be allocated, just ignore it.
316  * If we did, move back to the start of the
317  * packet (plus 'length' field) */
318  if (!m->dvd || avio_skip(s->pb, -(len + 2)) < 0) {
319  /* Skip back failed.
320  * This packet will be lost but that can't be helped
321  * if we can't skip back
322  */
323  goto redo;
324  }
325  } else {
326  /* No memory */
327  avio_skip(s->pb, len);
328  goto redo;
329  }
330  } else if (!m->dvd) {
331  int len = avio_rb16(s->pb);
332  avio_skip(s->pb, len);
333  goto redo;
334  }
335  }
336  if (startcode == PROGRAM_STREAM_MAP) {
337  mpegps_psm_parse(m, s->pb);
338  goto redo;
339  }
340 
341  /* find matching stream */
342  if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
343  (startcode >= 0x1e0 && startcode <= 0x1ef) ||
344  (startcode == 0x1bd) ||
345  (startcode == PRIVATE_STREAM_2) ||
346  (startcode == 0x1fd)))
347  goto redo;
348  if (ppos) {
349  *ppos = avio_tell(s->pb) - 4;
350  }
351  len = avio_rb16(s->pb);
352  pts =
353  dts = AV_NOPTS_VALUE;
354  if (startcode != PRIVATE_STREAM_2)
355  {
356  /* stuffing */
357  for (;;) {
358  if (len < 1)
359  goto error_redo;
360  c = avio_r8(s->pb);
361  len--;
362  /* XXX: for MPEG-1, should test only bit 7 */
363  if (c != 0xff)
364  break;
365  }
366  if ((c & 0xc0) == 0x40) {
367  /* buffer scale & size */
368  avio_r8(s->pb);
369  c = avio_r8(s->pb);
370  len -= 2;
371  }
372  if ((c & 0xe0) == 0x20) {
373  dts =
374  pts = get_pts(s->pb, c);
375  len -= 4;
376  if (c & 0x10) {
377  dts = get_pts(s->pb, -1);
378  len -= 5;
379  }
380  } else if ((c & 0xc0) == 0x80) {
381  /* mpeg 2 PES */
382  flags = avio_r8(s->pb);
383  header_len = avio_r8(s->pb);
384  len -= 2;
385  if (header_len > len)
386  goto error_redo;
387  len -= header_len;
388  if (flags & 0x80) {
389  dts = pts = get_pts(s->pb, -1);
390  header_len -= 5;
391  if (flags & 0x40) {
392  dts = get_pts(s->pb, -1);
393  header_len -= 5;
394  }
395  }
396  if (flags & 0x3f && header_len == 0) {
397  flags &= 0xC0;
398  av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");
399  }
400  if (flags & 0x01) { /* PES extension */
401  pes_ext = avio_r8(s->pb);
402  header_len--;
403  /* Skip PES private data, program packet sequence counter
404  * and P-STD buffer */
405  skip = (pes_ext >> 4) & 0xb;
406  skip += skip & 0x9;
407  if (pes_ext & 0x40 || skip > header_len) {
408  av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext);
409  pes_ext = skip = 0;
410  }
411  avio_skip(s->pb, skip);
412  header_len -= skip;
413 
414  if (pes_ext & 0x01) { /* PES extension 2 */
415  ext2_len = avio_r8(s->pb);
416  header_len--;
417  if ((ext2_len & 0x7f) > 0) {
418  id_ext = avio_r8(s->pb);
419  if ((id_ext & 0x80) == 0)
420  startcode = ((startcode & 0xff) << 8) | id_ext;
421  header_len--;
422  }
423  }
424  }
425  if (header_len < 0)
426  goto error_redo;
427  avio_skip(s->pb, header_len);
428  } else if (c != 0xf)
429  goto redo;
430  }
431 
432  if (startcode == PRIVATE_STREAM_1) {
433  int ret = ffio_ensure_seekback(s->pb, 2);
434 
435  if (ret < 0)
436  return ret;
437 
438  startcode = avio_r8(s->pb);
439  m->raw_ac3 = 0;
440  if (startcode == 0x0b) {
441  if (avio_r8(s->pb) == 0x77) {
442  startcode = 0x80;
443  m->raw_ac3 = 1;
444  avio_skip(s->pb, -2);
445  } else {
446  avio_skip(s->pb, -1);
447  }
448  } else {
449  len--;
450  }
451  }
452  if (len < 0)
453  goto error_redo;
454  if (dts != AV_NOPTS_VALUE && ppos) {
455  int i;
456  for (i = 0; i < s->nb_streams; i++) {
457  if (startcode == s->streams[i]->id &&
458  (s->pb->seekable & AVIO_SEEKABLE_NORMAL) /* index useless on streams anyway */) {
459  ff_reduce_index(s, i);
460  av_add_index_entry(s->streams[i], *ppos, dts, 0, 0,
461  AVINDEX_KEYFRAME /* FIXME keyframe? */);
462  }
463  }
464  }
465 
466  *pstart_code = startcode;
467  *ppts = pts;
468  *pdts = dts;
469  return len;
470 }
471 
473  AVPacket *pkt)
474 {
475  MpegDemuxContext *m = s->priv_data;
476  AVStream *st;
477  int len, startcode, i, es_type, ret;
478  int pcm_dvd = 0;
479  int request_probe= 0;
481  enum AVMediaType type;
482  int64_t pts, dts, dummy_pos; // dummy_pos is needed for the index building to work
483 
484 redo:
485  len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
486  if (len < 0)
487  return len;
488 
489  if (startcode >= 0x80 && startcode <= 0xcf) {
490  if (len < 4)
491  goto skip;
492 
493  if (!m->raw_ac3) {
494  /* audio: skip header */
495  avio_skip(s->pb, 3);
496  len -= 3;
497  if (startcode >= 0xb0 && startcode <= 0xbf) {
498  /* MLP/TrueHD audio has a 4-byte header */
499  avio_r8(s->pb);
500  len--;
501  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
502  ret = ffio_ensure_seekback(s->pb, 3);
503  if (ret < 0)
504  return ret;
505  pcm_dvd = (avio_rb24(s->pb) & 0xFF) == 0x80;
506  avio_skip(s->pb, -3);
507  }
508  }
509  }
510 
511  /* now find stream */
512  for (i = 0; i < s->nb_streams; i++) {
513  st = s->streams[i];
514  if (st->id == startcode)
515  goto found;
516  }
517 
518  es_type = m->psm_es_type[startcode & 0xff];
519  if (es_type == STREAM_TYPE_VIDEO_MPEG1) {
520  codec_id = AV_CODEC_ID_MPEG2VIDEO;
521  type = AVMEDIA_TYPE_VIDEO;
522  } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {
523  codec_id = AV_CODEC_ID_MPEG2VIDEO;
524  type = AVMEDIA_TYPE_VIDEO;
525  } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||
526  es_type == STREAM_TYPE_AUDIO_MPEG2) {
527  codec_id = AV_CODEC_ID_MP3;
528  type = AVMEDIA_TYPE_AUDIO;
529  } else if (es_type == STREAM_TYPE_AUDIO_AAC) {
530  codec_id = AV_CODEC_ID_AAC;
531  type = AVMEDIA_TYPE_AUDIO;
532  } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {
533  codec_id = AV_CODEC_ID_MPEG4;
534  type = AVMEDIA_TYPE_VIDEO;
535  } else if (es_type == STREAM_TYPE_VIDEO_H264) {
536  codec_id = AV_CODEC_ID_H264;
537  type = AVMEDIA_TYPE_VIDEO;
538  } else if (es_type == STREAM_TYPE_VIDEO_HEVC) {
539  codec_id = AV_CODEC_ID_HEVC;
540  type = AVMEDIA_TYPE_VIDEO;
541  } else if (es_type == STREAM_TYPE_AUDIO_AC3) {
542  codec_id = AV_CODEC_ID_AC3;
543  type = AVMEDIA_TYPE_AUDIO;
544  } else if (m->imkh_cctv && es_type == 0x91) {
545  codec_id = AV_CODEC_ID_PCM_MULAW;
546  type = AVMEDIA_TYPE_AUDIO;
547  } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
548  static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
549  unsigned char buf[8];
550 
551  avio_read(s->pb, buf, 8);
552  avio_seek(s->pb, -8, SEEK_CUR);
553  if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
554  codec_id = AV_CODEC_ID_CAVS;
555  else
556  request_probe= 1;
557  type = AVMEDIA_TYPE_VIDEO;
558  } else if (startcode == PRIVATE_STREAM_2) {
559  type = AVMEDIA_TYPE_DATA;
560  codec_id = AV_CODEC_ID_DVD_NAV;
561  } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
562  type = AVMEDIA_TYPE_AUDIO;
563  if (m->sofdec > 0) {
564  codec_id = AV_CODEC_ID_ADPCM_ADX;
565  // Auto-detect AC-3
566  request_probe = 50;
567  } else if (m->imkh_cctv && startcode == 0x1c0 && len > 80) {
568  codec_id = AV_CODEC_ID_PCM_ALAW;
569  request_probe = 50;
570  } else {
571  codec_id = AV_CODEC_ID_MP2;
572  if (m->imkh_cctv)
573  request_probe = 25;
574  }
575  } else if (startcode >= 0x80 && startcode <= 0x87) {
576  type = AVMEDIA_TYPE_AUDIO;
577  codec_id = AV_CODEC_ID_AC3;
578  } else if ((startcode >= 0x88 && startcode <= 0x8f) ||
579  (startcode >= 0x98 && startcode <= 0x9f)) {
580  /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
581  type = AVMEDIA_TYPE_AUDIO;
582  codec_id = AV_CODEC_ID_DTS;
583  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
584  type = AVMEDIA_TYPE_AUDIO;
585  if (!pcm_dvd) {
586  codec_id = AV_CODEC_ID_MLP;
587  } else {
588  codec_id = AV_CODEC_ID_PCM_DVD;
589  }
590  } else if (startcode >= 0xb0 && startcode <= 0xbf) {
591  type = AVMEDIA_TYPE_AUDIO;
592  codec_id = AV_CODEC_ID_TRUEHD;
593  } else if (startcode >= 0xc0 && startcode <= 0xcf) {
594  /* Used for both AC-3 and E-AC-3 in EVOB files */
595  type = AVMEDIA_TYPE_AUDIO;
596  codec_id = AV_CODEC_ID_AC3;
597  } else if (startcode >= 0x20 && startcode <= 0x3f) {
598  type = AVMEDIA_TYPE_SUBTITLE;
599  codec_id = AV_CODEC_ID_DVD_SUBTITLE;
600  } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
601  type = AVMEDIA_TYPE_VIDEO;
602  codec_id = AV_CODEC_ID_VC1;
603  } else {
604 skip:
605  /* skip packet */
606  avio_skip(s->pb, len);
607  goto redo;
608  }
609  /* no stream found: add a new stream */
610  st = avformat_new_stream(s, NULL);
611  if (!st)
612  goto skip;
613  st->id = startcode;
614  st->codecpar->codec_type = type;
615  st->codecpar->codec_id = codec_id;
618  st->codecpar->channels = 1;
620  st->codecpar->sample_rate = 8000;
621  }
622  st->request_probe = request_probe;
624 
625 found:
626  if (st->discard >= AVDISCARD_ALL)
627  goto skip;
628  if (startcode >= 0xa0 && startcode <= 0xaf) {
629  if (st->codecpar->codec_id == AV_CODEC_ID_MLP) {
630  if (len < 6)
631  goto skip;
632  avio_skip(s->pb, 6);
633  len -=6;
634  }
635  }
636  ret = av_get_packet(s->pb, pkt, len);
637 
638  pkt->pts = pts;
639  pkt->dts = dts;
640  pkt->pos = dummy_pos;
641  pkt->stream_index = st->index;
642 
643  if (s->debug & FF_FDEBUG_TS)
644  av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
645  pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
646  pkt->size);
647 
648  return (ret < 0) ? ret : 0;
649 }
650 
651 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
652  int64_t *ppos, int64_t pos_limit)
653 {
654  int len, startcode;
655  int64_t pos, pts, dts;
656 
657  pos = *ppos;
658  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
659  return AV_NOPTS_VALUE;
660 
661  for (;;) {
662  len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
663  if (len < 0) {
664  if (s->debug & FF_FDEBUG_TS)
665  av_log(s, AV_LOG_DEBUG, "none (ret=%d)\n", len);
666  return AV_NOPTS_VALUE;
667  }
668  if (startcode == s->streams[stream_index]->id &&
669  dts != AV_NOPTS_VALUE) {
670  break;
671  }
672  avio_skip(s->pb, len);
673  }
674  if (s->debug & FF_FDEBUG_TS)
675  av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
676  pos, dts, dts / 90000.0);
677  *ppos = pos;
678  return dts;
679 }
680 
682  .name = "mpeg",
683  .long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),
684  .priv_data_size = sizeof(MpegDemuxContext),
688  .read_timestamp = mpegps_read_dts,
690 };
691 
692 #if CONFIG_VOBSUB_DEMUXER
693 
694 #include "subtitles.h"
695 #include "libavutil/avassert.h"
696 #include "libavutil/bprint.h"
697 #include "libavutil/opt.h"
698 
699 #define REF_STRING "# VobSub index file,"
700 #define MAX_LINE_SIZE 2048
701 
702 typedef struct VobSubDemuxContext {
703  const AVClass *class;
704  AVFormatContext *sub_ctx;
705  FFDemuxSubtitlesQueue q[32];
706  char *sub_name;
707 } VobSubDemuxContext;
708 
709 static int vobsub_probe(const AVProbeData *p)
710 {
711  if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))
712  return AVPROBE_SCORE_MAX;
713  return 0;
714 }
715 
716 static int vobsub_read_close(AVFormatContext *s)
717 {
718  VobSubDemuxContext *vobsub = s->priv_data;
719  int i;
720 
721  for (i = 0; i < s->nb_streams; i++)
722  ff_subtitles_queue_clean(&vobsub->q[i]);
723  if (vobsub->sub_ctx)
724  avformat_close_input(&vobsub->sub_ctx);
725  return 0;
726 }
727 
728 static int vobsub_read_header(AVFormatContext *s)
729 {
730  int i, ret = 0, header_parsed = 0, langidx = 0;
731  VobSubDemuxContext *vobsub = s->priv_data;
732  size_t fname_len;
733  AVBPrint header;
734  int64_t delay = 0;
735  AVStream *st = NULL;
736  int stream_id = -1;
737  char id[64] = {0};
738  char alt[MAX_LINE_SIZE] = {0};
740 
741  if (!vobsub->sub_name) {
742  char *ext;
743  vobsub->sub_name = av_strdup(s->url);
744  if (!vobsub->sub_name) {
745  return AVERROR(ENOMEM);
746  }
747 
748  fname_len = strlen(vobsub->sub_name);
749  ext = vobsub->sub_name - 3 + fname_len;
750  if (fname_len < 4 || *(ext - 1) != '.') {
751  av_log(s, AV_LOG_ERROR, "The input index filename is too short "
752  "to guess the associated .SUB file\n");
753  return AVERROR_INVALIDDATA;
754  }
755  memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3);
756  av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->url, vobsub->sub_name);
757  }
758 
759  if (!(iformat = av_find_input_format("mpeg"))) {
761  }
762 
763  vobsub->sub_ctx = avformat_alloc_context();
764  if (!vobsub->sub_ctx) {
765  return AVERROR(ENOMEM);
766  }
767 
768  av_bprint_init(&header, 0, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
769 
770  if ((ret = ff_copy_whiteblacklists(vobsub->sub_ctx, s)) < 0)
771  goto end;
772 
773  ret = avformat_open_input(&vobsub->sub_ctx, vobsub->sub_name, iformat, NULL);
774  if (ret < 0) {
775  av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", vobsub->sub_name);
776  goto end;
777  }
778 
779  while (!avio_feof(s->pb)) {
780  char line[MAX_LINE_SIZE];
781  int len = ff_get_line(s->pb, line, sizeof(line));
782 
783  if (!len)
784  break;
785 
786  line[strcspn(line, "\r\n")] = 0;
787 
788  if (!strncmp(line, "id:", 3)) {
789  if (sscanf(line, "id: %63[^,], index: %u", id, &stream_id) != 2) {
790  av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', "
791  "assuming 'id: und, index: 0'\n", line);
792  strcpy(id, "und");
793  stream_id = 0;
794  }
795 
796  if (stream_id >= FF_ARRAY_ELEMS(vobsub->q)) {
797  av_log(s, AV_LOG_ERROR, "Maximum number of subtitles streams reached\n");
798  ret = AVERROR(EINVAL);
799  goto end;
800  }
801 
802  header_parsed = 1;
803  alt[0] = '\0';
804  /* We do not create the stream immediately to avoid adding empty
805  * streams. See the following timestamp entry. */
806 
807  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);
808 
809  } else if (!strncmp(line, "timestamp:", 10)) {
810  AVPacket *sub;
811  int hh, mm, ss, ms;
812  int64_t pos, timestamp;
813  const char *p = line + 10;
814 
815  if (stream_id == -1) {
816  av_log(s, AV_LOG_ERROR, "Timestamp declared before any stream\n");
817  ret = AVERROR_INVALIDDATA;
818  goto end;
819  }
820 
821  if (!st || st->id != stream_id) {
822  st = avformat_new_stream(s, NULL);
823  if (!st) {
824  ret = AVERROR(ENOMEM);
825  goto end;
826  }
827  st->id = stream_id;
830  avpriv_set_pts_info(st, 64, 1, 1000);
831  av_dict_set(&st->metadata, "language", id, 0);
832  if (alt[0])
833  av_dict_set(&st->metadata, "title", alt, 0);
834  }
835 
836  if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"SCNx64,
837  &hh, &mm, &ss, &ms, &pos) != 5) {
838  av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "
839  "abort parsing\n", line);
840  ret = AVERROR_INVALIDDATA;
841  goto end;
842  }
843  timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay;
844  timestamp = av_rescale_q(timestamp, av_make_q(1, 1000), st->time_base);
845 
846  sub = ff_subtitles_queue_insert(&vobsub->q[s->nb_streams - 1], "", 0, 0);
847  if (!sub) {
848  ret = AVERROR(ENOMEM);
849  goto end;
850  }
851  sub->pos = pos;
852  sub->pts = timestamp;
853  sub->stream_index = s->nb_streams - 1;
854 
855  } else if (!strncmp(line, "alt:", 4)) {
856  const char *p = line + 4;
857 
858  while (*p == ' ')
859  p++;
860  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", stream_id, p);
861  av_strlcpy(alt, p, sizeof(alt));
862  header_parsed = 1;
863 
864  } else if (!strncmp(line, "delay:", 6)) {
865  int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0;
866  const char *p = line + 6;
867 
868  while (*p == ' ')
869  p++;
870  if (*p == '-' || *p == '+') {
871  sign = *p == '-' ? -1 : 1;
872  p++;
873  }
874  sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms);
875  delay = ((hh*3600LL + mm*60LL + ss) * 1000LL + ms) * sign;
876 
877  } else if (!strncmp(line, "langidx:", 8)) {
878  const char *p = line + 8;
879 
880  if (sscanf(p, "%d", &langidx) != 1)
881  av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n");
882 
883  } else if (!header_parsed) {
884  if (line[0] && line[0] != '#')
885  av_bprintf(&header, "%s\n", line);
886  }
887  }
888 
889  if (langidx < s->nb_streams)
891 
892  for (i = 0; i < s->nb_streams; i++) {
893  vobsub->q[i].sort = SUB_SORT_POS_TS;
894  vobsub->q[i].keep_duplicates = 1;
895  ff_subtitles_queue_finalize(s, &vobsub->q[i]);
896  }
897 
898  if (!av_bprint_is_complete(&header)) {
899  ret = AVERROR(ENOMEM);
900  goto end;
901  }
902  for (i = 0; i < s->nb_streams; i++) {
903  AVCodecParameters *par = s->streams[i]->codecpar;
904  ret = ff_alloc_extradata(par, header.len);
905  if (ret < 0) {
906  goto end;
907  }
908  memcpy(par->extradata, header.str, header.len);
909  }
910 end:
911  if (ret < 0)
912  vobsub_read_close(s);
913  av_bprint_finalize(&header, NULL);
914  return ret;
915 }
916 
917 static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt)
918 {
919  VobSubDemuxContext *vobsub = s->priv_data;
921  AVIOContext *pb = vobsub->sub_ctx->pb;
922  int ret, psize, total_read = 0, i;
923 
924  int64_t min_ts = INT64_MAX;
925  int sid = 0;
926  for (i = 0; i < s->nb_streams; i++) {
927  FFDemuxSubtitlesQueue *tmpq = &vobsub->q[i];
928  int64_t ts;
929  av_assert0(tmpq->nb_subs);
930  ts = tmpq->subs[tmpq->current_sub_idx].pts;
931  if (ts < min_ts) {
932  min_ts = ts;
933  sid = i;
934  }
935  }
936  q = &vobsub->q[sid];
937  /* The returned packet will have size zero,
938  * so that it can be directly used with av_grow_packet. */
939  ret = ff_subtitles_queue_read_packet(q, pkt);
940  if (ret < 0)
941  return ret;
942 
943  /* compute maximum packet size using the next packet position. This is
944  * useful when the len in the header is non-sense */
945  if (q->current_sub_idx < q->nb_subs) {
946  psize = q->subs[q->current_sub_idx].pos - pkt->pos;
947  } else {
948  int64_t fsize = avio_size(pb);
949  psize = fsize < 0 ? 0xffff : fsize - pkt->pos;
950  }
951 
952  avio_seek(pb, pkt->pos, SEEK_SET);
953 
954  do {
955  int n, to_read, startcode;
956  int64_t pts, dts;
957  int64_t old_pos = avio_tell(pb), new_pos;
958  int pkt_size;
959 
960  ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);
961  if (ret < 0) {
962  if (pkt->size) // raise packet even if incomplete
963  break;
964  return ret;
965  }
966  to_read = ret & 0xffff;
967  new_pos = avio_tell(pb);
968  pkt_size = ret + (new_pos - old_pos);
969 
970  /* this prevents reads above the current packet */
971  if (total_read + pkt_size > psize)
972  break;
973  total_read += pkt_size;
974 
975  /* the current chunk doesn't match the stream index (unlikely) */
976  if ((startcode & 0x1f) != s->streams[pkt->stream_index]->id)
977  break;
978 
979  ret = av_grow_packet(pkt, to_read);
980  if (ret < 0)
981  return ret;
982 
983  n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);
984  if (n < to_read)
985  pkt->size -= to_read - n;
986  } while (total_read < psize);
987 
988  return 0;
989 }
990 
991 static int vobsub_read_seek(AVFormatContext *s, int stream_index,
992  int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
993 {
994  VobSubDemuxContext *vobsub = s->priv_data;
995 
996  /* Rescale requested timestamps based on the first stream (timebase is the
997  * same for all subtitles stream within a .idx/.sub). Rescaling is done just
998  * like in avformat_seek_file(). */
999  if (stream_index == -1 && s->nb_streams != 1) {
1000  int i, ret = 0;
1001  AVRational time_base = s->streams[0]->time_base;
1002  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
1003  min_ts = av_rescale_rnd(min_ts, time_base.den,
1004  time_base.num * (int64_t)AV_TIME_BASE,
1006  max_ts = av_rescale_rnd(max_ts, time_base.den,
1007  time_base.num * (int64_t)AV_TIME_BASE,
1009  for (i = 0; i < s->nb_streams; i++) {
1010  int r = ff_subtitles_queue_seek(&vobsub->q[i], s, stream_index,
1011  min_ts, ts, max_ts, flags);
1012  if (r < 0)
1013  ret = r;
1014  }
1015  return ret;
1016  }
1017 
1018  if (stream_index == -1) // only 1 stream
1019  stream_index = 0;
1020  return ff_subtitles_queue_seek(&vobsub->q[stream_index], s, stream_index,
1021  min_ts, ts, max_ts, flags);
1022 }
1023 
1024 static const AVOption options[] = {
1025  { "sub_name", "URI for .sub file", offsetof(VobSubDemuxContext, sub_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_DECODING_PARAM },
1026  { NULL }
1027 };
1028 
1029 static const AVClass vobsub_demuxer_class = {
1030  .class_name = "vobsub",
1031  .item_name = av_default_item_name,
1032  .option = options,
1033  .version = LIBAVUTIL_VERSION_INT,
1034 };
1035 
1037  .name = "vobsub",
1038  .long_name = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),
1039  .priv_data_size = sizeof(VobSubDemuxContext),
1040  .read_probe = vobsub_probe,
1041  .read_header = vobsub_read_header,
1042  .read_packet = vobsub_read_packet,
1043  .read_seek2 = vobsub_read_seek,
1044  .read_close = vobsub_read_close,
1045  .flags = AVFMT_SHOW_IDS,
1046  .extensions = "idx",
1047  .priv_class = &vobsub_demuxer_class,
1048 };
1049 #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:334
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:1553
#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:4943
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:30
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4036
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:877
int size
Definition: avcodec.h:1534
#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:241
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:537
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
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:225
#define STREAM_TYPE_VIDEO_MPEG1
Definition: mpeg.h:49
discard all
Definition: avcodec.h:829
static AVPacket pkt
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:783
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1402
static int mpegps_read_header(AVFormatContext *s)
Definition: mpeg.c:126
This struct describes the properties of an encoded stream.
Definition: avcodec.h:4028
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:1353
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:281
#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:1297
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:798
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:1094
int id
Format-specific stream ID.
Definition: avformat.h:883
#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:4524
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data)...
Definition: internal.h:643
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:1421
#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:1533
#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:308
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:651
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4138
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:645
#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:812
#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:217
#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:464
#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: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:1449
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:197
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:578
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4032
#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:636
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:1409
#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:3323
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:791
#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:157
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:191
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:940
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
Definition: aviobuf.c:806
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: avcodec.h:222
#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:876
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:821
#define FF_FDEBUG_TS
Definition: avformat.h:1637
static AVInputFormat * iformat
Definition: ffprobe.c:258
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:251
int debug
Flags to enable debugging.
Definition: avformat.h:1636
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVIOContext * pb
I/O context.
Definition: avformat.h:1395
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
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
static struct @327 state
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: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:564
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:472
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:1002
int sample_rate
Audio only.
Definition: avcodec.h:4146
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
full parsing and repack
Definition: avformat.h:795
Main libavformat public API header.
const OptionDef options[]
Definition: ffmpeg_opt.c:3439
AVPacket * subs
array of subtitles packets
Definition: subtitles.h:103
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:929
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
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:4496
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:808
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:667
#define av_free(p)
int len
#define STREAM_TYPE_VIDEO_MPEG2
Definition: mpeg.h:50
void * priv_data
Format private data.
Definition: avformat.h:1381
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:4050
int channels
Audio only.
Definition: avcodec.h:4142
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1532
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition: aviobuf.c:877
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:356
static int64_t fsize(FILE *f)
Definition: audiomatch.c:28
int stream_index
Definition: avcodec.h:1535
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:905
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:931
#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:1134
This structure stores compressed data.
Definition: avcodec.h:1510
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: avcodec.h:1526
#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:681