Libav
mpeg.c
Go to the documentation of this file.
1 /*
2  * MPEG1/2 demuxer
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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 "internal.h"
24 #include "mpeg.h"
25 
26 #undef NDEBUG
27 #include <assert.h>
28 
29 /*********************************************/
30 /* demux code */
31 
32 #define MAX_SYNC_SIZE 100000
33 
34 static int check_pes(uint8_t *p, uint8_t *end)
35 {
36  int pes1;
37  int pes2 = (p[3] & 0xC0) == 0x80 &&
38  (p[4] & 0xC0) != 0x40 &&
39  ((p[4] & 0xC0) == 0x00 ||
40  (p[4] & 0xC0) >> 2 == (p[6] & 0xF0));
41 
42  for (p += 3; p < end && *p == 0xFF; p++) ;
43  if ((*p & 0xC0) == 0x40)
44  p += 2;
45 
46  if ((*p & 0xF0) == 0x20)
47  pes1 = p[0] & p[2] & p[4] & 1;
48  else if ((*p & 0xF0) == 0x30)
49  pes1 = p[0] & p[2] & p[4] & p[5] & p[7] & p[9] & 1;
50  else
51  pes1 = *p == 0x0F;
52 
53  return pes1 || pes2;
54 }
55 
56 static int check_pack_header(const uint8_t *buf)
57 {
58  return (buf[1] & 0xC0) == 0x40 || (buf[1] & 0xF0) == 0x20;
59 }
60 
61 static int mpegps_probe(AVProbeData *p)
62 {
63  uint32_t code = -1;
64  int i;
65  int sys = 0, pspack = 0, priv1 = 0, vid = 0;
66  int audio = 0, invalid = 0, score = 0;
67 
68  for (i = 0; i < p->buf_size; i++) {
69  code = (code << 8) + p->buf[i];
70  if ((code & 0xffffff00) == 0x100) {
71  int len = p->buf[i + 1] << 8 | p->buf[i + 2];
72  int pes = check_pes(p->buf + i, p->buf + p->buf_size);
73  int pack = check_pack_header(p->buf + i);
74 
75  if (code == SYSTEM_HEADER_START_CODE)
76  sys++;
77  else if (code == PACK_START_CODE && pack)
78  pspack++;
79  else if ((code & 0xf0) == VIDEO_ID && pes)
80  vid++;
81  // skip pes payload to avoid start code emulation for private
82  // and audio streams
83  else if ((code & 0xe0) == AUDIO_ID && pes) {
84  audio++;
85  i += len;
86  } else if (code == PRIVATE_STREAM_1 && pes) {
87  priv1++;
88  i += len;
89  } else if ((code & 0xf0) == VIDEO_ID && !pes)
90  invalid++;
91  else if ((code & 0xe0) == AUDIO_ID && !pes)
92  invalid++;
93  else if (code == PRIVATE_STREAM_1 && !pes)
94  invalid++;
95  }
96  }
97 
98  if (vid + audio > invalid) /* invalid VDR files nd short PES streams */
99  score = AVPROBE_SCORE_EXTENSION / 2;
100 
101  if (sys > invalid && sys * 9 <= pspack * 10)
102  return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2
103  : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg
104  if (pspack > invalid && (priv1 + vid + audio) * 10 >= pspack * 9)
105  return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2
106  : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg
107  if ((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys &&
108  !pspack && p->buf_size > 2048 && vid + audio > invalid) /* PES stream */
109  return (audio > 12 || vid > 3) ? AVPROBE_SCORE_EXTENSION + 2
111 
112  // 02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
113  // mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6
114  return score;
115 }
116 
117 typedef struct MpegDemuxContext {
119  unsigned char psm_es_type[256];
120  int sofdec;
122 
124 {
125  MpegDemuxContext *m = s->priv_data;
126  const char *sofdec = "Sofdec";
127  int v, i = 0;
128 
129  m->header_state = 0xff;
131 
132  m->sofdec = -1;
133  do {
134  v = avio_r8(s->pb);
135  m->header_state = m->header_state << 8 | v;
136  m->sofdec++;
137  } while (v == sofdec[i] && i++ < 6);
138 
139  m->sofdec = (m->sofdec == 6) ? 1 : 0;
140 
141  /* no need to do more */
142  return 0;
143 }
144 
145 static int64_t get_pts(AVIOContext *pb, int c)
146 {
147  uint8_t buf[5];
148 
149  buf[0] = c < 0 ? avio_r8(pb) : c;
150  avio_read(pb, buf + 1, 4);
151 
152  return ff_parse_pes_pts(buf);
153 }
154 
155 static int find_next_start_code(AVIOContext *pb, int *size_ptr,
156  int32_t *header_state)
157 {
158  unsigned int state, v;
159  int val, n;
160 
161  state = *header_state;
162  n = *size_ptr;
163  while (n > 0) {
164  if (pb->eof_reached)
165  break;
166  v = avio_r8(pb);
167  n--;
168  if (state == 0x000001) {
169  state = ((state << 8) | v) & 0xffffff;
170  val = state;
171  goto found;
172  }
173  state = ((state << 8) | v) & 0xffffff;
174  }
175  val = -1;
176 
177 found:
178  *header_state = state;
179  *size_ptr = n;
180  return val;
181 }
182 
190 {
191  int psm_length, ps_info_length, es_map_length;
192 
193  psm_length = avio_rb16(pb);
194  avio_r8(pb);
195  avio_r8(pb);
196  ps_info_length = avio_rb16(pb);
197 
198  /* skip program_stream_info */
199  avio_skip(pb, ps_info_length);
200  es_map_length = avio_rb16(pb);
201 
202  /* at least one es available? */
203  while (es_map_length >= 4) {
204  unsigned char type = avio_r8(pb);
205  unsigned char es_id = avio_r8(pb);
206  uint16_t es_info_length = avio_rb16(pb);
207 
208  /* remember mapping from stream id to stream type */
209  m->psm_es_type[es_id] = type;
210  /* skip program_stream_info */
211  avio_skip(pb, es_info_length);
212  es_map_length -= 4 + es_info_length;
213  }
214  avio_rb32(pb); /* crc32 */
215  return 2 + psm_length;
216 }
217 
218 /* read the next PES header. Return its position in ppos
219  * (if not NULL), and its start code, pts and dts.
220  */
222  int64_t *ppos, int *pstart_code,
223  int64_t *ppts, int64_t *pdts)
224 {
225  MpegDemuxContext *m = s->priv_data;
226  int len, size, startcode, c, flags, header_len;
227  int pes_ext, ext2_len, id_ext, skip;
228  int64_t pts, dts;
229  int64_t last_sync = avio_tell(s->pb);
230 
231 error_redo:
232  avio_seek(s->pb, last_sync, SEEK_SET);
233 redo:
234  /* next start code (should be immediately after) */
235  m->header_state = 0xff;
236  size = MAX_SYNC_SIZE;
237  startcode = find_next_start_code(s->pb, &size, &m->header_state);
238  last_sync = avio_tell(s->pb);
239  if (startcode < 0) {
240  if (s->pb->eof_reached)
241  return AVERROR_EOF;
242  // FIXME we should remember header_state
243  return AVERROR(EAGAIN);
244  }
245 
246  if (startcode == PACK_START_CODE)
247  goto redo;
248  if (startcode == SYSTEM_HEADER_START_CODE)
249  goto redo;
250  if (startcode == PADDING_STREAM) {
251  avio_skip(s->pb, avio_rb16(s->pb));
252  goto redo;
253  }
254  if (startcode == PRIVATE_STREAM_2) {
255  len = avio_rb16(s->pb);
256  if (!m->sofdec) {
257  while (len-- >= 6) {
258  if (avio_r8(s->pb) == 'S') {
259  uint8_t buf[5];
260  avio_read(s->pb, buf, sizeof(buf));
261  m->sofdec = !memcmp(buf, "ofdec", 5);
262  len -= sizeof(buf);
263  break;
264  }
265  }
266  m->sofdec -= !m->sofdec;
267  }
268  avio_skip(s->pb, len);
269  goto redo;
270  }
271  if (startcode == PROGRAM_STREAM_MAP) {
272  mpegps_psm_parse(m, s->pb);
273  goto redo;
274  }
275 
276  /* find matching stream */
277  if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
278  (startcode >= 0x1e0 && startcode <= 0x1ef) ||
279  (startcode == 0x1bd) || (startcode == 0x1fd)))
280  goto redo;
281  if (ppos) {
282  *ppos = avio_tell(s->pb) - 4;
283  }
284  len = avio_rb16(s->pb);
285  pts =
286  dts = AV_NOPTS_VALUE;
287  /* stuffing */
288  for (;;) {
289  if (len < 1)
290  goto error_redo;
291  c = avio_r8(s->pb);
292  len--;
293  /* XXX: for mpeg1, should test only bit 7 */
294  if (c != 0xff)
295  break;
296  }
297  if ((c & 0xc0) == 0x40) {
298  /* buffer scale & size */
299  avio_r8(s->pb);
300  c = avio_r8(s->pb);
301  len -= 2;
302  }
303  if ((c & 0xe0) == 0x20) {
304  dts =
305  pts = get_pts(s->pb, c);
306  len -= 4;
307  if (c & 0x10) {
308  dts = get_pts(s->pb, -1);
309  len -= 5;
310  }
311  } else if ((c & 0xc0) == 0x80) {
312  /* mpeg 2 PES */
313  flags = avio_r8(s->pb);
314  header_len = avio_r8(s->pb);
315  len -= 2;
316  if (header_len > len)
317  goto error_redo;
318  len -= header_len;
319  if (flags & 0x80) {
320  dts = pts = get_pts(s->pb, -1);
321  header_len -= 5;
322  if (flags & 0x40) {
323  dts = get_pts(s->pb, -1);
324  header_len -= 5;
325  }
326  }
327  if (flags & 0x3f && header_len == 0) {
328  flags &= 0xC0;
329  av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");
330  }
331  if (flags & 0x01) { /* PES extension */
332  pes_ext = avio_r8(s->pb);
333  header_len--;
334  /* Skip PES private data, program packet sequence counter
335  * and P-STD buffer */
336  skip = (pes_ext >> 4) & 0xb;
337  skip += skip & 0x9;
338  if (pes_ext & 0x40 || skip > header_len) {
339  av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext);
340  pes_ext = skip = 0;
341  }
342  avio_skip(s->pb, skip);
343  header_len -= skip;
344 
345  if (pes_ext & 0x01) { /* PES extension 2 */
346  ext2_len = avio_r8(s->pb);
347  header_len--;
348  if ((ext2_len & 0x7f) > 0) {
349  id_ext = avio_r8(s->pb);
350  if ((id_ext & 0x80) == 0)
351  startcode = ((startcode & 0xff) << 8) | id_ext;
352  header_len--;
353  }
354  }
355  }
356  if (header_len < 0)
357  goto error_redo;
358  avio_skip(s->pb, header_len);
359  } else if (c != 0xf)
360  goto redo;
361 
362  if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) {
363  startcode = avio_r8(s->pb);
364  len--;
365  if (startcode >= 0x80 && startcode <= 0xcf) {
366  /* audio: skip header */
367  avio_r8(s->pb);
368  avio_r8(s->pb);
369  avio_r8(s->pb);
370  len -= 3;
371  if (startcode >= 0xb0 && startcode <= 0xbf) {
372  /* MLP/TrueHD audio has a 4-byte header */
373  avio_r8(s->pb);
374  len--;
375  }
376  }
377  }
378  if (len < 0)
379  goto error_redo;
380  if (dts != AV_NOPTS_VALUE && ppos) {
381  int i;
382  for (i = 0; i < s->nb_streams; i++) {
383  if (startcode == s->streams[i]->id &&
384  s->pb->seekable /* index useless on streams anyway */) {
385  ff_reduce_index(s, i);
386  av_add_index_entry(s->streams[i], *ppos, dts, 0, 0,
387  AVINDEX_KEYFRAME /* FIXME keyframe? */);
388  }
389  }
390  }
391 
392  *pstart_code = startcode;
393  *ppts = pts;
394  *pdts = dts;
395  return len;
396 }
397 
399  AVPacket *pkt)
400 {
401  MpegDemuxContext *m = s->priv_data;
402  AVStream *st;
403  int len, startcode, i, es_type, ret;
405  enum AVMediaType type;
406  int64_t pts, dts, dummy_pos; // dummy_pos is needed for the index building to work
407  uint8_t av_uninit(dvdaudio_substream_type);
408 
409 redo:
410  len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
411  if (len < 0)
412  return len;
413 
414  if (startcode == 0x1bd) {
415  dvdaudio_substream_type = avio_r8(s->pb);
416  avio_skip(s->pb, 3);
417  len -= 4;
418  }
419 
420  /* now find stream */
421  for (i = 0; i < s->nb_streams; i++) {
422  st = s->streams[i];
423  if (st->id == startcode)
424  goto found;
425  }
426 
427  es_type = m->psm_es_type[startcode & 0xff];
428  if (es_type > 0 && es_type != STREAM_TYPE_PRIVATE_DATA) {
429  if (es_type == STREAM_TYPE_VIDEO_MPEG1) {
430  codec_id = AV_CODEC_ID_MPEG2VIDEO;
431  type = AVMEDIA_TYPE_VIDEO;
432  } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {
433  codec_id = AV_CODEC_ID_MPEG2VIDEO;
434  type = AVMEDIA_TYPE_VIDEO;
435  } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||
436  es_type == STREAM_TYPE_AUDIO_MPEG2) {
437  codec_id = AV_CODEC_ID_MP3;
438  type = AVMEDIA_TYPE_AUDIO;
439  } else if (es_type == STREAM_TYPE_AUDIO_AAC) {
440  codec_id = AV_CODEC_ID_AAC;
441  type = AVMEDIA_TYPE_AUDIO;
442  } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {
443  codec_id = AV_CODEC_ID_MPEG4;
444  type = AVMEDIA_TYPE_VIDEO;
445  } else if (es_type == STREAM_TYPE_VIDEO_H264) {
446  codec_id = AV_CODEC_ID_H264;
447  type = AVMEDIA_TYPE_VIDEO;
448  } else if (es_type == STREAM_TYPE_AUDIO_AC3) {
449  codec_id = AV_CODEC_ID_AC3;
450  type = AVMEDIA_TYPE_AUDIO;
451  } else {
452  goto skip;
453  }
454  } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
455  static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
456  unsigned char buf[8];
457 
458  avio_read(s->pb, buf, 8);
459  avio_seek(s->pb, -8, SEEK_CUR);
460  if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
461  codec_id = AV_CODEC_ID_CAVS;
462  else
463  codec_id = AV_CODEC_ID_PROBE;
464  type = AVMEDIA_TYPE_VIDEO;
465  } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
466  type = AVMEDIA_TYPE_AUDIO;
467  codec_id = m->sofdec > 0 ? AV_CODEC_ID_ADPCM_ADX : AV_CODEC_ID_MP2;
468  } else if (startcode >= 0x80 && startcode <= 0x87) {
469  type = AVMEDIA_TYPE_AUDIO;
470  codec_id = AV_CODEC_ID_AC3;
471  } else if ((startcode >= 0x88 && startcode <= 0x8f) ||
472  (startcode >= 0x98 && startcode <= 0x9f)) {
473  /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
474  type = AVMEDIA_TYPE_AUDIO;
475  codec_id = AV_CODEC_ID_DTS;
476  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
477  type = AVMEDIA_TYPE_AUDIO;
478  codec_id = AV_CODEC_ID_PCM_DVD;
479  } else if (startcode >= 0xb0 && startcode <= 0xbf) {
480  type = AVMEDIA_TYPE_AUDIO;
481  codec_id = AV_CODEC_ID_TRUEHD;
482  } else if (startcode >= 0xc0 && startcode <= 0xcf) {
483  /* Used for both AC-3 and E-AC-3 in EVOB files */
484  type = AVMEDIA_TYPE_AUDIO;
485  codec_id = AV_CODEC_ID_AC3;
486  } else if (startcode >= 0x20 && startcode <= 0x3f) {
487  type = AVMEDIA_TYPE_SUBTITLE;
488  codec_id = AV_CODEC_ID_DVD_SUBTITLE;
489  } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
490  type = AVMEDIA_TYPE_VIDEO;
491  codec_id = AV_CODEC_ID_VC1;
492  } else if (startcode == 0x1bd) {
493  // check dvd audio substream type
494  type = AVMEDIA_TYPE_AUDIO;
495  switch (dvdaudio_substream_type & 0xe0) {
496  case 0xa0:
497  codec_id = AV_CODEC_ID_PCM_DVD;
498  break;
499  case 0x80:
500  if ((dvdaudio_substream_type & 0xf8) == 0x88)
501  codec_id = AV_CODEC_ID_DTS;
502  else
503  codec_id = AV_CODEC_ID_AC3;
504  break;
505  default:
506  av_log(s, AV_LOG_ERROR, "Unknown 0x1bd sub-stream\n");
507  goto skip;
508  }
509  } else {
510 skip:
511  /* skip packet */
512  avio_skip(s->pb, len);
513  goto redo;
514  }
515  /* no stream found: add a new stream */
516  st = avformat_new_stream(s, NULL);
517  if (!st)
518  goto skip;
519  st->id = startcode;
520  st->codec->codec_type = type;
521  st->codec->codec_id = codec_id;
523 
524 found:
525  if (st->discard >= AVDISCARD_ALL)
526  goto skip;
527  ret = av_get_packet(s->pb, pkt, len);
528 
529  pkt->pts = pts;
530  pkt->dts = dts;
531  pkt->pos = dummy_pos;
532  pkt->stream_index = st->index;
533  av_dlog(s, "%d: pts=%0.3f dts=%0.3f size=%d\n",
534  pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
535  pkt->size);
536 
537  return (ret < 0) ? ret : 0;
538 }
539 
540 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
541  int64_t *ppos, int64_t pos_limit)
542 {
543  int len, startcode;
544  int64_t pos, pts, dts;
545 
546  pos = *ppos;
547  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
548  return AV_NOPTS_VALUE;
549 
550  for (;;) {
551  len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
552  if (len < 0) {
553  av_dlog(s, "none (ret=%d)\n", len);
554  return AV_NOPTS_VALUE;
555  }
556  if (startcode == s->streams[stream_index]->id &&
557  dts != AV_NOPTS_VALUE) {
558  break;
559  }
560  avio_skip(s->pb, len);
561  }
562  av_dlog(s, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
563  pos, dts, dts / 90000.0);
564  *ppos = pos;
565  return dts;
566 }
567 
569  .name = "mpeg",
570  .long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),
571  .priv_data_size = sizeof(MpegDemuxContext),
575  .read_timestamp = mpegps_read_dts,
577 };
codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it ...
Definition: avcodec.h:464
Bytestream IO Context.
Definition: avio.h:68
int size
#define STREAM_TYPE_AUDIO_MPEG2
Definition: mpeg.h:51
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:1181
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:129
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:998
#define MAX_SYNC_SIZE
Definition: mpeg.c:32
int index
stream index in AVFormatContext
Definition: avformat.h:700
int size
Definition: avcodec.h:974
#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:186
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
static int mpegps_read_pes_header(AVFormatContext *s, int64_t *ppos, int *pstart_code, int64_t *ppts, int64_t *pdts)
Definition: mpeg.c:221
#define STREAM_TYPE_VIDEO_MPEG1
Definition: mpeg.h:48
discard all
Definition: avcodec.h:568
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:591
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:971
static int mpegps_read_header(AVFormatContext *s)
Definition: mpeg.c:123
#define AUDIO_ID
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:411
Format I/O context.
Definition: avformat.h:922
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:1118
uint8_t
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:901
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:606
enum AVStreamParseType need_parsing
Definition: avformat.h:867
int id
Format-specific stream ID.
Definition: avformat.h:706
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:2521
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:990
#define SYSTEM_HEADER_START_CODE
Definition: mpeg.h:29
static int flags
Definition: log.c:44
#define AVERROR_EOF
End of file.
Definition: error.h:51
#define PRIVATE_STREAM_1
Definition: mpeg.h:37
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:117
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:219
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
Definition: mpeg.c:540
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:463
#define STREAM_TYPE_AUDIO_AAC
Definition: mpeg.h:54
#define AVINDEX_KEYFRAME
Definition: avformat.h:662
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:105
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
#define PRIVATE_STREAM_2
Definition: mpeg.h:39
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:418
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:145
static int check_pack_header(const uint8_t *buf)
Definition: mpeg.c:56
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:379
#define PADDING_STREAM
Definition: mpeg.h:38
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:169
enum AVCodecID codec_id
Definition: mov_chan.c:432
static int64_t ff_parse_pes_pts(const uint8_t *buf)
Parse MPEG-PES five-byte timestamp.
Definition: mpeg.h:67
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:454
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:718
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:398
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:397
static int check_pes(uint8_t *p, uint8_t *end)
Definition: mpeg.c:34
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:978
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:117
#define STREAM_TYPE_VIDEO_H264
Definition: mpeg.h:56
static int read_probe(AVProbeData *pd)
Definition: jvdec.c:55
static int find_next_start_code(AVIOContext *pb, int *size_ptr, int32_t *header_state)
Definition: mpeg.c:155
static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb)
Extract stream types from a program stream map According to ISO/IEC 13818-1 ('MPEG-2 Systems') table ...
Definition: mpeg.c:189
static av_always_inline int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: avio.h:210
int32_t
#define VIDEO_ID
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:110
#define STREAM_TYPE_VIDEO_MPEG4
Definition: mpeg.h:55
unsigned char psm_es_type[256]
Definition: mpeg.c:119
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:544
if(ac->has_optimized_func)
Stream structure.
Definition: avformat.h:699
int32_t header_state
Definition: mpeg.c:118
NULL
Definition: eval.c:55
enum AVMediaType codec_type
Definition: avcodec.h:1058
enum AVCodecID codec_id
Definition: avcodec.h:1067
AVIOContext * pb
I/O context.
Definition: avformat.h:964
#define STREAM_TYPE_PRIVATE_DATA
Definition: mpeg.h:53
static int read_packet(AVFormatContext *ctx, AVPacket *pkt)
Definition: libcdio.c:114
#define PROGRAM_STREAM_MAP
Definition: mpeg.h:36
AVMediaType
Definition: avutil.h:185
#define STREAM_TYPE_AUDIO_AC3
Definition: mpeg.h:59
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:402
This structure contains the data a format has to probe a file.
Definition: avformat.h:395
static int64_t get_pts(AVIOContext *pb, int c)
Definition: mpeg.c:145
static uint32_t state
Definition: trasher.c:27
static int mpegps_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpeg.c:398
full parsing and repack
Definition: avformat.h:653
Main libavformat public API header.
int eof_reached
true if eof reached
Definition: avio.h:96
int len
#define STREAM_TYPE_VIDEO_MPEG2
Definition: mpeg.h:49
void * priv_data
Format private data.
Definition: avformat.h:950
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:972
#define av_uninit(x)
Definition: attributes.h:109
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:525
int stream_index
Definition: avcodec.h:975
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:762
#define STREAM_TYPE_AUDIO_MPEG1
Definition: mpeg.h:50
This structure stores compressed data.
Definition: avcodec.h:950
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:966
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:228
AVInputFormat ff_mpegps_demuxer
Definition: mpeg.c:568
static int mpegps_probe(AVProbeData *p)
Definition: mpeg.c:61