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 /* no need to do more */
120 static int64_t get_pts(ByteIOContext
*pb
, int c
)
124 buf
[0] = c
<0 ? get_byte(pb
) : c
;
125 get_buffer(pb
, buf
+1, 4);
127 return ff_parse_pes_pts(buf
);
130 static int find_next_start_code(ByteIOContext
*pb
, int *size_ptr
,
131 int32_t *header_state
)
133 unsigned int state
, v
;
136 state
= *header_state
;
143 if (state
== 0x000001) {
144 state
= ((state
<< 8) | v
) & 0xffffff;
148 state
= ((state
<< 8) | v
) & 0xffffff;
152 *header_state
= state
;
157 #if 0 /* unused, remove? */
159 static int find_prev_start_code(ByteIOContext
*pb
, int *size_ptr
)
161 int64_t pos
, pos_start
;
162 int max_size
, start_code
;
164 max_size
= *size_ptr
;
165 pos_start
= url_ftell(pb
);
167 /* in order to go faster, we fill the buffer */
168 pos
= pos_start
- 16386;
171 url_fseek(pb
, pos
, SEEK_SET
);
177 if (pos
< 0 || (pos_start
- pos
) >= max_size
) {
181 url_fseek(pb
, pos
, SEEK_SET
);
182 start_code
= get_be32(pb
);
183 if ((start_code
& 0xffffff00) == 0x100)
187 *size_ptr
= pos_start
- pos
;
193 * Extracts stream types from a program stream map
194 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
196 * @return number of bytes occupied by PSM in the bitstream
198 static long mpegps_psm_parse(MpegDemuxContext
*m
, ByteIOContext
*pb
)
200 int psm_length
, ps_info_length
, es_map_length
;
202 psm_length
= get_be16(pb
);
205 ps_info_length
= get_be16(pb
);
207 /* skip program_stream_info */
208 url_fskip(pb
, ps_info_length
);
209 es_map_length
= get_be16(pb
);
211 /* at least one es available? */
212 while (es_map_length
>= 4){
213 unsigned char type
= get_byte(pb
);
214 unsigned char es_id
= get_byte(pb
);
215 uint16_t es_info_length
= get_be16(pb
);
216 /* remember mapping from stream id to stream type */
217 m
->psm_es_type
[es_id
] = type
;
218 /* skip program_stream_info */
219 url_fskip(pb
, es_info_length
);
220 es_map_length
-= 4 + es_info_length
;
222 get_be32(pb
); /* crc32 */
223 return 2 + psm_length
;
226 /* read the next PES header. Return its position in ppos
227 (if not NULL), and its start code, pts and dts.
229 static int mpegps_read_pes_header(AVFormatContext
*s
,
230 int64_t *ppos
, int *pstart_code
,
231 int64_t *ppts
, int64_t *pdts
)
233 MpegDemuxContext
*m
= s
->priv_data
;
234 int len
, size
, startcode
, c
, flags
, header_len
;
235 int pes_ext
, ext2_len
, id_ext
, skip
;
237 int64_t last_sync
= url_ftell(s
->pb
);
240 url_fseek(s
->pb
, last_sync
, SEEK_SET
);
242 /* next start code (should be immediately after) */
243 m
->header_state
= 0xff;
244 size
= MAX_SYNC_SIZE
;
245 startcode
= find_next_start_code(s
->pb
, &size
, &m
->header_state
);
246 last_sync
= url_ftell(s
->pb
);
247 //printf("startcode=%x pos=0x%"PRIx64"\n", startcode, url_ftell(s->pb));
250 if (startcode
== PACK_START_CODE
)
252 if (startcode
== SYSTEM_HEADER_START_CODE
)
254 if (startcode
== PADDING_STREAM
) {
255 url_fskip(s
->pb
, get_be16(s
->pb
));
258 if (startcode
== PRIVATE_STREAM_2
) {
259 len
= get_be16(s
->pb
);
262 if (get_byte(s
->pb
) == 'S') {
264 get_buffer(s
->pb
, buf
, sizeof(buf
));
265 m
->sofdec
= !memcmp(buf
, "ofdec", 5);
270 m
->sofdec
-= !m
->sofdec
;
272 url_fskip(s
->pb
, len
);
275 if (startcode
== PROGRAM_STREAM_MAP
) {
276 mpegps_psm_parse(m
, s
->pb
);
280 /* find matching stream */
281 if (!((startcode
>= 0x1c0 && startcode
<= 0x1df) ||
282 (startcode
>= 0x1e0 && startcode
<= 0x1ef) ||
283 (startcode
== 0x1bd) || (startcode
== 0x1fd)))
286 *ppos
= url_ftell(s
->pb
) - 4;
288 len
= get_be16(s
->pb
);
290 dts
= AV_NOPTS_VALUE
;
297 /* XXX: for mpeg1, should test only bit 7 */
301 if ((c
& 0xc0) == 0x40) {
302 /* buffer scale & size */
307 if ((c
& 0xe0) == 0x20) {
308 dts
= pts
= get_pts(s
->pb
, c
);
311 dts
= get_pts(s
->pb
, -1);
314 } else if ((c
& 0xc0) == 0x80) {
316 #if 0 /* some streams have this field set for no apparent reason */
317 if ((c
& 0x30) != 0) {
318 /* Encrypted multiplex not handled */
322 flags
= get_byte(s
->pb
);
323 header_len
= get_byte(s
->pb
);
325 if (header_len
> len
)
329 dts
= pts
= get_pts(s
->pb
, -1);
332 dts
= get_pts(s
->pb
, -1);
336 if (flags
& 0x3f && header_len
== 0){
338 av_log(s
, AV_LOG_WARNING
, "Further flags set but no bytes left\n");
340 if (flags
& 0x01) { /* PES extension */
341 pes_ext
= get_byte(s
->pb
);
343 /* Skip PES private data, program packet sequence counter and P-STD buffer */
344 skip
= (pes_ext
>> 4) & 0xb;
346 if (pes_ext
& 0x40 || skip
> header_len
){
347 av_log(s
, AV_LOG_WARNING
, "pes_ext %X is invalid\n", pes_ext
);
350 url_fskip(s
->pb
, skip
);
353 if (pes_ext
& 0x01) { /* PES extension 2 */
354 ext2_len
= get_byte(s
->pb
);
356 if ((ext2_len
& 0x7f) > 0) {
357 id_ext
= get_byte(s
->pb
);
358 if ((id_ext
& 0x80) == 0)
359 startcode
= ((startcode
& 0xff) << 8) | id_ext
;
366 url_fskip(s
->pb
, header_len
);
371 if (startcode
== PRIVATE_STREAM_1
&& !m
->psm_es_type
[startcode
& 0xff]) {
372 startcode
= get_byte(s
->pb
);
374 if (startcode
>= 0x80 && startcode
<= 0xcf) {
375 /* audio: skip header */
380 if (startcode
>= 0xb0 && startcode
<= 0xbf) {
381 /* MLP/TrueHD audio has a 4-byte header */
389 if(dts
!= AV_NOPTS_VALUE
&& ppos
){
391 for(i
=0; i
<s
->nb_streams
; i
++){
392 if(startcode
== s
->streams
[i
]->id
&&
393 !url_is_streamed(s
->pb
) /* index useless on streams anyway */) {
394 ff_reduce_index(s
, i
);
395 av_add_index_entry(s
->streams
[i
], *ppos
, dts
, 0, 0, AVINDEX_KEYFRAME
/* FIXME keyframe? */);
400 *pstart_code
= startcode
;
406 static int mpegps_read_packet(AVFormatContext
*s
,
409 MpegDemuxContext
*m
= s
->priv_data
;
411 int len
, startcode
, i
, es_type
;
412 enum CodecID codec_id
= CODEC_ID_NONE
;
414 int64_t pts
, dts
, dummy_pos
; //dummy_pos is needed for the index building to work
415 uint8_t av_uninit(dvdaudio_substream_type
);
418 len
= mpegps_read_pes_header(s
, &dummy_pos
, &startcode
, &pts
, &dts
);
422 if(startcode
== 0x1bd) {
423 dvdaudio_substream_type
= get_byte(s
->pb
);
428 /* now find stream */
429 for(i
=0;i
<s
->nb_streams
;i
++) {
431 if (st
->id
== startcode
)
435 es_type
= m
->psm_es_type
[startcode
& 0xff];
436 if(es_type
> 0 && es_type
!= STREAM_TYPE_PRIVATE_DATA
){
437 if(es_type
== STREAM_TYPE_VIDEO_MPEG1
){
438 codec_id
= CODEC_ID_MPEG2VIDEO
;
439 type
= CODEC_TYPE_VIDEO
;
440 } else if(es_type
== STREAM_TYPE_VIDEO_MPEG2
){
441 codec_id
= CODEC_ID_MPEG2VIDEO
;
442 type
= CODEC_TYPE_VIDEO
;
443 } else if(es_type
== STREAM_TYPE_AUDIO_MPEG1
||
444 es_type
== STREAM_TYPE_AUDIO_MPEG2
){
445 codec_id
= CODEC_ID_MP3
;
446 type
= CODEC_TYPE_AUDIO
;
447 } else if(es_type
== STREAM_TYPE_AUDIO_AAC
){
448 codec_id
= CODEC_ID_AAC
;
449 type
= CODEC_TYPE_AUDIO
;
450 } else if(es_type
== STREAM_TYPE_VIDEO_MPEG4
){
451 codec_id
= CODEC_ID_MPEG4
;
452 type
= CODEC_TYPE_VIDEO
;
453 } else if(es_type
== STREAM_TYPE_VIDEO_H264
){
454 codec_id
= CODEC_ID_H264
;
455 type
= CODEC_TYPE_VIDEO
;
456 } else if(es_type
== STREAM_TYPE_AUDIO_AC3
){
457 codec_id
= CODEC_ID_AC3
;
458 type
= CODEC_TYPE_AUDIO
;
462 } else if (startcode
>= 0x1e0 && startcode
<= 0x1ef) {
463 static const unsigned char avs_seqh
[4] = { 0, 0, 1, 0xb0 };
464 unsigned char buf
[8];
465 get_buffer(s
->pb
, buf
, 8);
466 url_fseek(s
->pb
, -8, SEEK_CUR
);
467 if(!memcmp(buf
, avs_seqh
, 4) && (buf
[6] != 0 || buf
[7] != 1))
468 codec_id
= CODEC_ID_CAVS
;
470 codec_id
= CODEC_ID_PROBE
;
471 type
= CODEC_TYPE_VIDEO
;
472 } else if (startcode
>= 0x1c0 && startcode
<= 0x1df) {
473 type
= CODEC_TYPE_AUDIO
;
474 codec_id
= m
->sofdec
> 0 ? CODEC_ID_ADPCM_ADX
: CODEC_ID_MP2
;
475 } else if (startcode
>= 0x80 && startcode
<= 0x87) {
476 type
= CODEC_TYPE_AUDIO
;
477 codec_id
= CODEC_ID_AC3
;
478 } else if ( ( startcode
>= 0x88 && startcode
<= 0x8f)
479 ||( startcode
>= 0x98 && startcode
<= 0x9f)) {
480 /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
481 type
= CODEC_TYPE_AUDIO
;
482 codec_id
= CODEC_ID_DTS
;
483 } else if (startcode
>= 0xa0 && startcode
<= 0xaf) {
484 type
= CODEC_TYPE_AUDIO
;
485 /* 16 bit form will be handled as CODEC_ID_PCM_S16BE */
486 codec_id
= CODEC_ID_PCM_DVD
;
487 } else if (startcode
>= 0xb0 && startcode
<= 0xbf) {
488 type
= CODEC_TYPE_AUDIO
;
489 codec_id
= CODEC_ID_TRUEHD
;
490 } else if (startcode
>= 0xc0 && startcode
<= 0xcf) {
491 /* Used for both AC-3 and E-AC-3 in EVOB files */
492 type
= CODEC_TYPE_AUDIO
;
493 codec_id
= CODEC_ID_AC3
;
494 } else if (startcode
>= 0x20 && startcode
<= 0x3f) {
495 type
= CODEC_TYPE_SUBTITLE
;
496 codec_id
= CODEC_ID_DVD_SUBTITLE
;
497 } else if (startcode
>= 0xfd55 && startcode
<= 0xfd5f) {
498 type
= CODEC_TYPE_VIDEO
;
499 codec_id
= CODEC_ID_VC1
;
500 } else if (startcode
== 0x1bd) {
501 // check dvd audio substream type
502 type
= CODEC_TYPE_AUDIO
;
503 switch(dvdaudio_substream_type
& 0xe0) {
504 case 0xa0: codec_id
= CODEC_ID_PCM_DVD
;
506 case 0x80: if((dvdaudio_substream_type
& 0xf8) == 0x88)
507 codec_id
= CODEC_ID_DTS
;
508 else codec_id
= CODEC_ID_AC3
;
510 default: av_log(s
, AV_LOG_ERROR
, "Unknown 0x1bd sub-stream\n");
516 url_fskip(s
->pb
, len
);
519 /* no stream found: add a new stream */
520 st
= av_new_stream(s
, startcode
);
523 st
->codec
->codec_type
= type
;
524 st
->codec
->codec_id
= codec_id
;
525 if (codec_id
!= CODEC_ID_PCM_S16BE
)
526 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
528 if(st
->discard
>= AVDISCARD_ALL
)
530 if ((startcode
>= 0xa0 && startcode
<= 0xaf) ||
531 (startcode
== 0x1bd && ((dvdaudio_substream_type
& 0xe0) == 0xa0))) {
534 /* for LPCM, we just skip the header and consider it is raw
538 get_byte(s
->pb
); /* emphasis (1), muse(1), reserved(1), frame number(5) */
539 b1
= get_byte(s
->pb
); /* quant (2), freq(2), reserved(1), channels(3) */
540 get_byte(s
->pb
); /* dynamic range control (0x80 = off) */
542 freq
= (b1
>> 4) & 3;
543 st
->codec
->sample_rate
= lpcm_freq_tab
[freq
];
544 st
->codec
->channels
= 1 + (b1
& 7);
545 st
->codec
->bits_per_coded_sample
= 16 + ((b1
>> 6) & 3) * 4;
546 st
->codec
->bit_rate
= st
->codec
->channels
*
547 st
->codec
->sample_rate
*
548 st
->codec
->bits_per_coded_sample
;
549 if (st
->codec
->bits_per_coded_sample
== 16)
550 st
->codec
->codec_id
= CODEC_ID_PCM_S16BE
;
551 else if (st
->codec
->bits_per_coded_sample
== 28)
552 return AVERROR(EINVAL
);
554 av_new_packet(pkt
, len
);
555 get_buffer(s
->pb
, pkt
->data
, pkt
->size
);
558 pkt
->stream_index
= st
->index
;
560 av_log(s
, AV_LOG_DEBUG
, "%d: pts=%0.3f dts=%0.3f size=%d\n",
561 pkt
->stream_index
, pkt
->pts
/ 90000.0, pkt
->dts
/ 90000.0, pkt
->size
);
567 static int64_t mpegps_read_dts(AVFormatContext
*s
, int stream_index
,
568 int64_t *ppos
, int64_t pos_limit
)
571 int64_t pos
, pts
, dts
;
575 printf("read_dts: pos=0x%"PRIx64
" next=%d -> ", pos
, find_next
);
577 if (url_fseek(s
->pb
, pos
, SEEK_SET
) < 0)
578 return AV_NOPTS_VALUE
;
581 len
= mpegps_read_pes_header(s
, &pos
, &startcode
, &pts
, &dts
);
584 printf("none (ret=%d)\n", len
);
586 return AV_NOPTS_VALUE
;
588 if (startcode
== s
->streams
[stream_index
]->id
&&
589 dts
!= AV_NOPTS_VALUE
) {
592 url_fskip(s
->pb
, len
);
595 printf("pos=0x%"PRIx64
" dts=0x%"PRIx64
" %0.3f\n", pos
, dts
, dts
/ 90000.0);
601 AVInputFormat mpegps_demuxer
= {
603 NULL_IF_CONFIG_SMALL("MPEG-PS format"),
604 sizeof(MpegDemuxContext
),
609 NULL
, //mpegps_read_seek,
611 .flags
= AVFMT_SHOW_IDS
|AVFMT_TS_DISCONT
,