3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
30 /*********************************************/
33 #define MAX_SYNC_SIZE 100000
35 static int check_pes(uint8_t *p
, uint8_t *end
){
37 int pes2
= (p
[3] & 0xC0) == 0x80
38 && (p
[4] & 0xC0) != 0x40
39 &&((p
[4] & 0xC0) == 0x00 || (p
[4]&0xC0)>>2 == (p
[6]&0xF0));
41 for(p
+=3; p
<end
&& *p
== 0xFF; p
++);
42 if((*p
&0xC0) == 0x40) p
+=2;
43 if((*p
&0xF0) == 0x20){
44 pes1
= p
[0]&p
[2]&p
[4]&1;
45 }else if((*p
&0xF0) == 0x30){
46 pes1
= p
[0]&p
[2]&p
[4]&p
[5]&p
[7]&p
[9]&1;
53 static int mpegps_probe(AVProbeData
*p
)
56 int sys
=0, pspack
=0, priv1
=0, vid
=0, audio
=0, invalid
=0;
60 for(i
=0; i
<p
->buf_size
; i
++){
61 code
= (code
<<8) + p
->buf
[i
];
62 if ((code
& 0xffffff00) == 0x100) {
63 int pes
= check_pes(p
->buf
+i
, p
->buf
+p
->buf_size
);
65 if(code
== SYSTEM_HEADER_START_CODE
) sys
++;
66 else if(code
== PRIVATE_STREAM_1
) priv1
++;
67 else if(code
== PACK_START_CODE
) pspack
++;
68 else if((code
& 0xf0) == VIDEO_ID
&& pes
) vid
++;
69 else if((code
& 0xe0) == AUDIO_ID
&& pes
) audio
++;
71 else if((code
& 0xf0) == VIDEO_ID
&& !pes
) invalid
++;
72 else if((code
& 0xe0) == AUDIO_ID
&& !pes
) invalid
++;
76 if(vid
+audio
> invalid
) /* invalid VDR files nd short PES streams */
77 score
= AVPROBE_SCORE_MAX
/4;
79 //av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d len:%d\n", sys, priv1, pspack,vid, audio, p->buf_size);
80 if(sys
>invalid
&& sys
*9 <= pspack
*10)
81 return pspack
> 2 ? AVPROBE_SCORE_MAX
/2+2 : AVPROBE_SCORE_MAX
/4; // +1 for .mpg
82 if(priv1
+ vid
+ audio
> invalid
&& (priv1
+vid
+audio
)*9 <= pspack
*10)
83 return pspack
> 2 ? AVPROBE_SCORE_MAX
/2+2 : AVPROBE_SCORE_MAX
/4; // +1 for .mpg
84 if((!!vid
^ !!audio
) && (audio
> 4 || vid
> 1) && !sys
&& !pspack
&& p
->buf_size
>2048 && vid
+ audio
> invalid
) /* PES stream */
85 return (audio
> 12 || vid
> 3) ? AVPROBE_SCORE_MAX
/2+2 : AVPROBE_SCORE_MAX
/4;
87 //02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
88 //mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6
93 typedef struct MpegDemuxContext
{
95 unsigned char psm_es_type
[256];
99 static int mpegps_read_header(AVFormatContext
*s
,
100 AVFormatParameters
*ap
)
102 MpegDemuxContext
*m
= s
->priv_data
;
103 const char *sofdec
= "Sofdec";
106 m
->header_state
= 0xff;
107 s
->ctx_flags
|= AVFMTCTX_NOHEADER
;
112 m
->header_state
= m
->header_state
<< 8 | v
;
114 } while (v
== sofdec
[i
] && i
++ < 6);
116 m
->sofdec
= (m
->sofdec
== 6) ? 1 : 0;
118 /* no need to do more */
122 static int64_t get_pts(ByteIOContext
*pb
, int c
)
126 buf
[0] = c
<0 ? get_byte(pb
) : c
;
127 get_buffer(pb
, buf
+1, 4);
129 return ff_parse_pes_pts(buf
);
132 static int find_next_start_code(ByteIOContext
*pb
, int *size_ptr
,
133 int32_t *header_state
)
135 unsigned int state
, v
;
138 state
= *header_state
;
145 if (state
== 0x000001) {
146 state
= ((state
<< 8) | v
) & 0xffffff;
150 state
= ((state
<< 8) | v
) & 0xffffff;
154 *header_state
= state
;
159 #if 0 /* unused, remove? */
161 static int find_prev_start_code(ByteIOContext
*pb
, int *size_ptr
)
163 int64_t pos
, pos_start
;
164 int max_size
, start_code
;
166 max_size
= *size_ptr
;
167 pos_start
= url_ftell(pb
);
169 /* in order to go faster, we fill the buffer */
170 pos
= pos_start
- 16386;
173 url_fseek(pb
, pos
, SEEK_SET
);
179 if (pos
< 0 || (pos_start
- pos
) >= max_size
) {
183 url_fseek(pb
, pos
, SEEK_SET
);
184 start_code
= get_be32(pb
);
185 if ((start_code
& 0xffffff00) == 0x100)
189 *size_ptr
= pos_start
- pos
;
195 * Extracts stream types from a program stream map
196 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
198 * @return number of bytes occupied by PSM in the bitstream
200 static long mpegps_psm_parse(MpegDemuxContext
*m
, ByteIOContext
*pb
)
202 int psm_length
, ps_info_length
, es_map_length
;
204 psm_length
= get_be16(pb
);
207 ps_info_length
= get_be16(pb
);
209 /* skip program_stream_info */
210 url_fskip(pb
, ps_info_length
);
211 es_map_length
= get_be16(pb
);
213 /* at least one es available? */
214 while (es_map_length
>= 4){
215 unsigned char type
= get_byte(pb
);
216 unsigned char es_id
= get_byte(pb
);
217 uint16_t es_info_length
= get_be16(pb
);
218 /* remember mapping from stream id to stream type */
219 m
->psm_es_type
[es_id
] = type
;
220 /* skip program_stream_info */
221 url_fskip(pb
, es_info_length
);
222 es_map_length
-= 4 + es_info_length
;
224 get_be32(pb
); /* crc32 */
225 return 2 + psm_length
;
228 /* read the next PES header. Return its position in ppos
229 (if not NULL), and its start code, pts and dts.
231 static int mpegps_read_pes_header(AVFormatContext
*s
,
232 int64_t *ppos
, int *pstart_code
,
233 int64_t *ppts
, int64_t *pdts
)
235 MpegDemuxContext
*m
= s
->priv_data
;
236 int len
, size
, startcode
, c
, flags
, header_len
;
237 int pes_ext
, ext2_len
, id_ext
, skip
;
239 int64_t last_sync
= url_ftell(s
->pb
);
242 url_fseek(s
->pb
, last_sync
, SEEK_SET
);
244 /* next start code (should be immediately after) */
245 m
->header_state
= 0xff;
246 size
= MAX_SYNC_SIZE
;
247 startcode
= find_next_start_code(s
->pb
, &size
, &m
->header_state
);
248 last_sync
= url_ftell(s
->pb
);
249 //printf("startcode=%x pos=0x%"PRIx64"\n", startcode, url_ftell(s->pb));
252 if (startcode
== PACK_START_CODE
)
254 if (startcode
== SYSTEM_HEADER_START_CODE
)
256 if (startcode
== PADDING_STREAM
) {
257 url_fskip(s
->pb
, get_be16(s
->pb
));
260 if (startcode
== PRIVATE_STREAM_2
) {
261 len
= get_be16(s
->pb
);
264 if (get_byte(s
->pb
) == 'S') {
266 get_buffer(s
->pb
, buf
, sizeof(buf
));
267 m
->sofdec
= !memcmp(buf
, "ofdec", 5);
272 m
->sofdec
-= !m
->sofdec
;
274 url_fskip(s
->pb
, len
);
277 if (startcode
== PROGRAM_STREAM_MAP
) {
278 mpegps_psm_parse(m
, s
->pb
);
282 /* find matching stream */
283 if (!((startcode
>= 0x1c0 && startcode
<= 0x1df) ||
284 (startcode
>= 0x1e0 && startcode
<= 0x1ef) ||
285 (startcode
== 0x1bd) || (startcode
== 0x1fd)))
288 *ppos
= url_ftell(s
->pb
) - 4;
290 len
= get_be16(s
->pb
);
292 dts
= AV_NOPTS_VALUE
;
299 /* XXX: for mpeg1, should test only bit 7 */
303 if ((c
& 0xc0) == 0x40) {
304 /* buffer scale & size */
309 if ((c
& 0xe0) == 0x20) {
310 dts
= pts
= get_pts(s
->pb
, c
);
313 dts
= get_pts(s
->pb
, -1);
316 } else if ((c
& 0xc0) == 0x80) {
318 #if 0 /* some streams have this field set for no apparent reason */
319 if ((c
& 0x30) != 0) {
320 /* Encrypted multiplex not handled */
324 flags
= get_byte(s
->pb
);
325 header_len
= get_byte(s
->pb
);
327 if (header_len
> len
)
331 dts
= pts
= get_pts(s
->pb
, -1);
334 dts
= get_pts(s
->pb
, -1);
338 if (flags
& 0x3f && header_len
== 0){
340 av_log(s
, AV_LOG_WARNING
, "Further flags set but no bytes left\n");
342 if (flags
& 0x01) { /* PES extension */
343 pes_ext
= get_byte(s
->pb
);
345 /* Skip PES private data, program packet sequence counter and P-STD buffer */
346 skip
= (pes_ext
>> 4) & 0xb;
348 if (pes_ext
& 0x40 || skip
> header_len
){
349 av_log(s
, AV_LOG_WARNING
, "pes_ext %X is invalid\n", pes_ext
);
352 url_fskip(s
->pb
, skip
);
355 if (pes_ext
& 0x01) { /* PES extension 2 */
356 ext2_len
= get_byte(s
->pb
);
358 if ((ext2_len
& 0x7f) > 0) {
359 id_ext
= get_byte(s
->pb
);
360 if ((id_ext
& 0x80) == 0)
361 startcode
= ((startcode
& 0xff) << 8) | id_ext
;
368 url_fskip(s
->pb
, header_len
);
373 if (startcode
== PRIVATE_STREAM_1
&& !m
->psm_es_type
[startcode
& 0xff]) {
374 startcode
= get_byte(s
->pb
);
376 if (startcode
>= 0x80 && startcode
<= 0xcf) {
377 /* audio: skip header */
382 if (startcode
>= 0xb0 && startcode
<= 0xbf) {
383 /* MLP/TrueHD audio has a 4-byte header */
391 if(dts
!= AV_NOPTS_VALUE
&& ppos
){
393 for(i
=0; i
<s
->nb_streams
; i
++){
394 if(startcode
== s
->streams
[i
]->id
&&
395 !url_is_streamed(s
->pb
) /* index useless on streams anyway */) {
396 ff_reduce_index(s
, i
);
397 av_add_index_entry(s
->streams
[i
], *ppos
, dts
, 0, 0, AVINDEX_KEYFRAME
/* FIXME keyframe? */);
402 *pstart_code
= startcode
;
408 static int mpegps_read_packet(AVFormatContext
*s
,
411 MpegDemuxContext
*m
= s
->priv_data
;
413 int len
, startcode
, i
, es_type
;
414 enum CodecID codec_id
= CODEC_ID_NONE
;
416 int64_t pts
, dts
, dummy_pos
; //dummy_pos is needed for the index building to work
417 uint8_t av_uninit(dvdaudio_substream_type
);
420 len
= mpegps_read_pes_header(s
, &dummy_pos
, &startcode
, &pts
, &dts
);
424 if(startcode
== 0x1bd) {
425 dvdaudio_substream_type
= get_byte(s
->pb
);
430 /* now find stream */
431 for(i
=0;i
<s
->nb_streams
;i
++) {
433 if (st
->id
== startcode
)
437 es_type
= m
->psm_es_type
[startcode
& 0xff];
438 if(es_type
> 0 && es_type
!= STREAM_TYPE_PRIVATE_DATA
){
439 if(es_type
== STREAM_TYPE_VIDEO_MPEG1
){
440 codec_id
= CODEC_ID_MPEG2VIDEO
;
441 type
= CODEC_TYPE_VIDEO
;
442 } else if(es_type
== STREAM_TYPE_VIDEO_MPEG2
){
443 codec_id
= CODEC_ID_MPEG2VIDEO
;
444 type
= CODEC_TYPE_VIDEO
;
445 } else if(es_type
== STREAM_TYPE_AUDIO_MPEG1
||
446 es_type
== STREAM_TYPE_AUDIO_MPEG2
){
447 codec_id
= CODEC_ID_MP3
;
448 type
= CODEC_TYPE_AUDIO
;
449 } else if(es_type
== STREAM_TYPE_AUDIO_AAC
){
450 codec_id
= CODEC_ID_AAC
;
451 type
= CODEC_TYPE_AUDIO
;
452 } else if(es_type
== STREAM_TYPE_VIDEO_MPEG4
){
453 codec_id
= CODEC_ID_MPEG4
;
454 type
= CODEC_TYPE_VIDEO
;
455 } else if(es_type
== STREAM_TYPE_VIDEO_H264
){
456 codec_id
= CODEC_ID_H264
;
457 type
= CODEC_TYPE_VIDEO
;
458 } else if(es_type
== STREAM_TYPE_AUDIO_AC3
){
459 codec_id
= CODEC_ID_AC3
;
460 type
= CODEC_TYPE_AUDIO
;
464 } else if (startcode
>= 0x1e0 && startcode
<= 0x1ef) {
465 static const unsigned char avs_seqh
[4] = { 0, 0, 1, 0xb0 };
466 unsigned char buf
[8];
467 get_buffer(s
->pb
, buf
, 8);
468 url_fseek(s
->pb
, -8, SEEK_CUR
);
469 if(!memcmp(buf
, avs_seqh
, 4) && (buf
[6] != 0 || buf
[7] != 1))
470 codec_id
= CODEC_ID_CAVS
;
472 codec_id
= CODEC_ID_PROBE
;
473 type
= CODEC_TYPE_VIDEO
;
474 } else if (startcode
>= 0x1c0 && startcode
<= 0x1df) {
475 type
= CODEC_TYPE_AUDIO
;
476 codec_id
= m
->sofdec
> 0 ? CODEC_ID_ADPCM_ADX
: CODEC_ID_MP2
;
477 } else if (startcode
>= 0x80 && startcode
<= 0x87) {
478 type
= CODEC_TYPE_AUDIO
;
479 codec_id
= CODEC_ID_AC3
;
480 } else if ( ( startcode
>= 0x88 && startcode
<= 0x8f)
481 ||( startcode
>= 0x98 && startcode
<= 0x9f)) {
482 /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
483 type
= CODEC_TYPE_AUDIO
;
484 codec_id
= CODEC_ID_DTS
;
485 } else if (startcode
>= 0xa0 && startcode
<= 0xaf) {
486 type
= CODEC_TYPE_AUDIO
;
487 /* 16 bit form will be handled as CODEC_ID_PCM_S16BE */
488 codec_id
= CODEC_ID_PCM_DVD
;
489 } else if (startcode
>= 0xb0 && startcode
<= 0xbf) {
490 type
= CODEC_TYPE_AUDIO
;
491 codec_id
= CODEC_ID_TRUEHD
;
492 } else if (startcode
>= 0xc0 && startcode
<= 0xcf) {
493 /* Used for both AC-3 and E-AC-3 in EVOB files */
494 type
= CODEC_TYPE_AUDIO
;
495 codec_id
= CODEC_ID_AC3
;
496 } else if (startcode
>= 0x20 && startcode
<= 0x3f) {
497 type
= CODEC_TYPE_SUBTITLE
;
498 codec_id
= CODEC_ID_DVD_SUBTITLE
;
499 } else if (startcode
>= 0xfd55 && startcode
<= 0xfd5f) {
500 type
= CODEC_TYPE_VIDEO
;
501 codec_id
= CODEC_ID_VC1
;
502 } else if (startcode
== 0x1bd) {
503 // check dvd audio substream type
504 type
= CODEC_TYPE_AUDIO
;
505 switch(dvdaudio_substream_type
& 0xe0) {
506 case 0xa0: codec_id
= CODEC_ID_PCM_DVD
;
508 case 0x80: if((dvdaudio_substream_type
& 0xf8) == 0x88)
509 codec_id
= CODEC_ID_DTS
;
510 else codec_id
= CODEC_ID_AC3
;
512 default: av_log(s
, AV_LOG_ERROR
, "Unknown 0x1bd sub-stream\n");
518 url_fskip(s
->pb
, len
);
521 /* no stream found: add a new stream */
522 st
= av_new_stream(s
, startcode
);
525 st
->codec
->codec_type
= type
;
526 st
->codec
->codec_id
= codec_id
;
527 if (codec_id
!= CODEC_ID_PCM_S16BE
)
528 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
530 if(st
->discard
>= AVDISCARD_ALL
)
532 if ((startcode
>= 0xa0 && startcode
<= 0xaf) ||
533 (startcode
== 0x1bd && ((dvdaudio_substream_type
& 0xe0) == 0xa0))) {
536 /* for LPCM, we just skip the header and consider it is raw
540 get_byte(s
->pb
); /* emphasis (1), muse(1), reserved(1), frame number(5) */
541 b1
= get_byte(s
->pb
); /* quant (2), freq(2), reserved(1), channels(3) */
542 get_byte(s
->pb
); /* dynamic range control (0x80 = off) */
544 freq
= (b1
>> 4) & 3;
545 st
->codec
->sample_rate
= lpcm_freq_tab
[freq
];
546 st
->codec
->channels
= 1 + (b1
& 7);
547 st
->codec
->bits_per_coded_sample
= 16 + ((b1
>> 6) & 3) * 4;
548 st
->codec
->bit_rate
= st
->codec
->channels
*
549 st
->codec
->sample_rate
*
550 st
->codec
->bits_per_coded_sample
;
551 if (st
->codec
->bits_per_coded_sample
== 16)
552 st
->codec
->codec_id
= CODEC_ID_PCM_S16BE
;
553 else if (st
->codec
->bits_per_coded_sample
== 28)
554 return AVERROR(EINVAL
);
556 av_new_packet(pkt
, len
);
557 get_buffer(s
->pb
, pkt
->data
, pkt
->size
);
560 pkt
->stream_index
= st
->index
;
562 av_log(s
, AV_LOG_DEBUG
, "%d: pts=%0.3f dts=%0.3f size=%d\n",
563 pkt
->stream_index
, pkt
->pts
/ 90000.0, pkt
->dts
/ 90000.0, pkt
->size
);
569 static int64_t mpegps_read_dts(AVFormatContext
*s
, int stream_index
,
570 int64_t *ppos
, int64_t pos_limit
)
573 int64_t pos
, pts
, dts
;
577 printf("read_dts: pos=0x%"PRIx64
" next=%d -> ", pos
, find_next
);
579 if (url_fseek(s
->pb
, pos
, SEEK_SET
) < 0)
580 return AV_NOPTS_VALUE
;
583 len
= mpegps_read_pes_header(s
, &pos
, &startcode
, &pts
, &dts
);
586 printf("none (ret=%d)\n", len
);
588 return AV_NOPTS_VALUE
;
590 if (startcode
== s
->streams
[stream_index
]->id
&&
591 dts
!= AV_NOPTS_VALUE
) {
594 url_fskip(s
->pb
, len
);
597 printf("pos=0x%"PRIx64
" dts=0x%"PRIx64
" %0.3f\n", pos
, dts
, dts
/ 90000.0);
603 AVInputFormat mpegps_demuxer
= {
605 NULL_IF_CONFIG_SMALL("MPEG-PS format"),
606 sizeof(MpegDemuxContext
),
611 NULL
, //mpegps_read_seek,
613 .flags
= AVFMT_SHOW_IDS
|AVFMT_TS_DISCONT
,