1/* 2 * MPEG1/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 "mpeg.h" 24 25//#define DEBUG_SEEK 26 27#undef NDEBUG 28#include <assert.h> 29 30/*********************************************/ 31/* demux code */ 32 33#define MAX_SYNC_SIZE 100000 34 35static int check_pes(uint8_t *p, uint8_t *end){ 36 int pes1; 37 int pes2= (p[3] & 0xC0) == 0x80 38 && (p[4] & 0xC0) != 0x40 39 &&((p[4] & 0xC0) == 0x00 || (p[4]&0xC0)>>2 == (p[6]&0xF0)); 40 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; 47 }else 48 pes1 = *p == 0x0F; 49 50 return pes1||pes2; 51} 52 53static int mpegps_probe(AVProbeData *p) 54{ 55 uint32_t code= -1; 56 int sys=0, pspack=0, priv1=0, vid=0, audio=0, invalid=0; 57 int i; 58 int score=0; 59 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); 64 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++; 70 71 else if((code & 0xf0) == VIDEO_ID && !pes) invalid++; 72 else if((code & 0xe0) == AUDIO_ID && !pes) invalid++; 73 } 74 } 75 76 if(vid+audio > invalid) /* invalid VDR files nd short PES streams */ 77 score= AVPROBE_SCORE_MAX/4; 78 79//av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d %d len:%d\n", sys, priv1, pspack,vid, audio, invalid, 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(pspack > invalid && (priv1+vid+audio)*10 >= pspack*9) 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; 86 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 89 return score; 90} 91 92 93typedef struct MpegDemuxContext { 94 int32_t header_state; 95 unsigned char psm_es_type[256]; 96 int sofdec; 97} MpegDemuxContext; 98 99static int mpegps_read_header(AVFormatContext *s, 100 AVFormatParameters *ap) 101{ 102 MpegDemuxContext *m = s->priv_data; 103 const char *sofdec = "Sofdec"; 104 int v, i = 0; 105 106 m->header_state = 0xff; 107 s->ctx_flags |= AVFMTCTX_NOHEADER; 108 109 m->sofdec = -1; 110 do { 111 v = get_byte(s->pb); 112 m->header_state = m->header_state << 8 | v; 113 m->sofdec++; 114 } while (v == sofdec[i] && i++ < 6); 115 116 m->sofdec = (m->sofdec == 6) ? 1 : 0; 117 118 /* no need to do more */ 119 return 0; 120} 121 122static int64_t get_pts(ByteIOContext *pb, int c) 123{ 124 uint8_t buf[5]; 125 126 buf[0] = c<0 ? get_byte(pb) : c; 127 get_buffer(pb, buf+1, 4); 128 129 return ff_parse_pes_pts(buf); 130} 131 132static int find_next_start_code(ByteIOContext *pb, int *size_ptr, 133 int32_t *header_state) 134{ 135 unsigned int state, v; 136 int val, n; 137 138 state = *header_state; 139 n = *size_ptr; 140 while (n > 0) { 141 if (url_feof(pb)) 142 break; 143 v = get_byte(pb); 144 n--; 145 if (state == 0x000001) { 146 state = ((state << 8) | v) & 0xffffff; 147 val = state; 148 goto found; 149 } 150 state = ((state << 8) | v) & 0xffffff; 151 } 152 val = -1; 153 found: 154 *header_state = state; 155 *size_ptr = n; 156 return val; 157} 158 159#if 0 /* unused, remove? */ 160/* XXX: optimize */ 161static int find_prev_start_code(ByteIOContext *pb, int *size_ptr) 162{ 163 int64_t pos, pos_start; 164 int max_size, start_code; 165 166 max_size = *size_ptr; 167 pos_start = url_ftell(pb); 168 169 /* in order to go faster, we fill the buffer */ 170 pos = pos_start - 16386; 171 if (pos < 0) 172 pos = 0; 173 url_fseek(pb, pos, SEEK_SET); 174 get_byte(pb); 175 176 pos = pos_start; 177 for(;;) { 178 pos--; 179 if (pos < 0 || (pos_start - pos) >= max_size) { 180 start_code = -1; 181 goto the_end; 182 } 183 url_fseek(pb, pos, SEEK_SET); 184 start_code = get_be32(pb); 185 if ((start_code & 0xffffff00) == 0x100) 186 break; 187 } 188 the_end: 189 *size_ptr = pos_start - pos; 190 return start_code; 191} 192#endif 193 194/** 195 * Extracts stream types from a program stream map 196 * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35 197 * 198 * @return number of bytes occupied by PSM in the bitstream 199 */ 200static long mpegps_psm_parse(MpegDemuxContext *m, ByteIOContext *pb) 201{ 202 int psm_length, ps_info_length, es_map_length; 203 204 psm_length = get_be16(pb); 205 get_byte(pb); 206 get_byte(pb); 207 ps_info_length = get_be16(pb); 208 209 /* skip program_stream_info */ 210 url_fskip(pb, ps_info_length); 211 es_map_length = get_be16(pb); 212 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; 223 } 224 get_be32(pb); /* crc32 */ 225 return 2 + psm_length; 226} 227 228/* read the next PES header. Return its position in ppos 229 (if not NULL), and its start code, pts and dts. 230 */ 231static int mpegps_read_pes_header(AVFormatContext *s, 232 int64_t *ppos, int *pstart_code, 233 int64_t *ppts, int64_t *pdts) 234{ 235 MpegDemuxContext *m = s->priv_data; 236 int len, size, startcode, c, flags, header_len; 237 int pes_ext, ext2_len, id_ext, skip; 238 int64_t pts, dts; 239 int64_t last_sync= url_ftell(s->pb); 240 241 error_redo: 242 url_fseek(s->pb, last_sync, SEEK_SET); 243 redo: 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)); 250 if (startcode < 0){ 251 if(url_feof(s->pb)) 252 return AVERROR_EOF; 253 //FIXME we should remember header_state 254 return AVERROR(EAGAIN); 255 } 256 257 if (startcode == PACK_START_CODE) 258 goto redo; 259 if (startcode == SYSTEM_HEADER_START_CODE) 260 goto redo; 261 if (startcode == PADDING_STREAM) { 262 url_fskip(s->pb, get_be16(s->pb)); 263 goto redo; 264 } 265 if (startcode == PRIVATE_STREAM_2) { 266 len = get_be16(s->pb); 267 if (!m->sofdec) { 268 while (len-- >= 6) { 269 if (get_byte(s->pb) == 'S') { 270 uint8_t buf[5]; 271 get_buffer(s->pb, buf, sizeof(buf)); 272 m->sofdec = !memcmp(buf, "ofdec", 5); 273 len -= sizeof(buf); 274 break; 275 } 276 } 277 m->sofdec -= !m->sofdec; 278 } 279 url_fskip(s->pb, len); 280 goto redo; 281 } 282 if (startcode == PROGRAM_STREAM_MAP) { 283 mpegps_psm_parse(m, s->pb); 284 goto redo; 285 } 286 287 /* find matching stream */ 288 if (!((startcode >= 0x1c0 && startcode <= 0x1df) || 289 (startcode >= 0x1e0 && startcode <= 0x1ef) || 290 (startcode == 0x1bd) || (startcode == 0x1fd))) 291 goto redo; 292 if (ppos) { 293 *ppos = url_ftell(s->pb) - 4; 294 } 295 len = get_be16(s->pb); 296 pts = 297 dts = AV_NOPTS_VALUE; 298 /* stuffing */ 299 for(;;) { 300 if (len < 1) 301 goto error_redo; 302 c = get_byte(s->pb); 303 len--; 304 /* XXX: for mpeg1, should test only bit 7 */ 305 if (c != 0xff) 306 break; 307 } 308 if ((c & 0xc0) == 0x40) { 309 /* buffer scale & size */ 310 get_byte(s->pb); 311 c = get_byte(s->pb); 312 len -= 2; 313 } 314 if ((c & 0xe0) == 0x20) { 315 dts = pts = get_pts(s->pb, c); 316 len -= 4; 317 if (c & 0x10){ 318 dts = get_pts(s->pb, -1); 319 len -= 5; 320 } 321 } else if ((c & 0xc0) == 0x80) { 322 /* mpeg 2 PES */ 323#if 0 /* some streams have this field set for no apparent reason */ 324 if ((c & 0x30) != 0) { 325 /* Encrypted multiplex not handled */ 326 goto redo; 327 } 328#endif 329 flags = get_byte(s->pb); 330 header_len = get_byte(s->pb); 331 len -= 2; 332 if (header_len > len) 333 goto error_redo; 334 len -= header_len; 335 if (flags & 0x80) { 336 dts = pts = get_pts(s->pb, -1); 337 header_len -= 5; 338 if (flags & 0x40) { 339 dts = get_pts(s->pb, -1); 340 header_len -= 5; 341 } 342 } 343 if (flags & 0x3f && header_len == 0){ 344 flags &= 0xC0; 345 av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n"); 346 } 347 if (flags & 0x01) { /* PES extension */ 348 pes_ext = get_byte(s->pb); 349 header_len--; 350 /* Skip PES private data, program packet sequence counter and P-STD buffer */ 351 skip = (pes_ext >> 4) & 0xb; 352 skip += skip & 0x9; 353 if (pes_ext & 0x40 || skip > header_len){ 354 av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext); 355 pes_ext=skip=0; 356 } 357 url_fskip(s->pb, skip); 358 header_len -= skip; 359 360 if (pes_ext & 0x01) { /* PES extension 2 */ 361 ext2_len = get_byte(s->pb); 362 header_len--; 363 if ((ext2_len & 0x7f) > 0) { 364 id_ext = get_byte(s->pb); 365 if ((id_ext & 0x80) == 0) 366 startcode = ((startcode & 0xff) << 8) | id_ext; 367 header_len--; 368 } 369 } 370 } 371 if(header_len < 0) 372 goto error_redo; 373 url_fskip(s->pb, header_len); 374 } 375 else if( c!= 0xf ) 376 goto redo; 377 378 if (startcode == PRIVATE_STREAM_1 && !m->psm_es_type[startcode & 0xff]) { 379 startcode = get_byte(s->pb); 380 len--; 381 if (startcode >= 0x80 && startcode <= 0xcf) { 382 /* audio: skip header */ 383 get_byte(s->pb); 384 get_byte(s->pb); 385 get_byte(s->pb); 386 len -= 3; 387 if (startcode >= 0xb0 && startcode <= 0xbf) { 388 /* MLP/TrueHD audio has a 4-byte header */ 389 get_byte(s->pb); 390 len--; 391 } 392 } 393 } 394 if(len<0) 395 goto error_redo; 396 if(dts != AV_NOPTS_VALUE && ppos){ 397 int i; 398 for(i=0; i<s->nb_streams; i++){ 399 if(startcode == s->streams[i]->id && 400 !url_is_streamed(s->pb) /* index useless on streams anyway */) { 401 ff_reduce_index(s, i); 402 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */); 403 } 404 } 405 } 406 407 *pstart_code = startcode; 408 *ppts = pts; 409 *pdts = dts; 410 return len; 411} 412 413static int mpegps_read_packet(AVFormatContext *s, 414 AVPacket *pkt) 415{ 416 MpegDemuxContext *m = s->priv_data; 417 AVStream *st; 418 int len, startcode, i, es_type; 419 enum CodecID codec_id = CODEC_ID_NONE; 420 enum AVMediaType type; 421 int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work 422 uint8_t av_uninit(dvdaudio_substream_type); 423 424 redo: 425 len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts); 426 if (len < 0) 427 return len; 428 429 if(startcode == 0x1bd) { 430 dvdaudio_substream_type = get_byte(s->pb); 431 url_fskip(s->pb, 3); 432 len -= 4; 433 } 434 435 /* now find stream */ 436 for(i=0;i<s->nb_streams;i++) { 437 st = s->streams[i]; 438 if (st->id == startcode) 439 goto found; 440 } 441 442 es_type = m->psm_es_type[startcode & 0xff]; 443 if(es_type > 0 && es_type != STREAM_TYPE_PRIVATE_DATA){ 444 if(es_type == STREAM_TYPE_VIDEO_MPEG1){ 445 codec_id = CODEC_ID_MPEG2VIDEO; 446 type = AVMEDIA_TYPE_VIDEO; 447 } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){ 448 codec_id = CODEC_ID_MPEG2VIDEO; 449 type = AVMEDIA_TYPE_VIDEO; 450 } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 || 451 es_type == STREAM_TYPE_AUDIO_MPEG2){ 452 codec_id = CODEC_ID_MP3; 453 type = AVMEDIA_TYPE_AUDIO; 454 } else if(es_type == STREAM_TYPE_AUDIO_AAC){ 455 codec_id = CODEC_ID_AAC; 456 type = AVMEDIA_TYPE_AUDIO; 457 } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){ 458 codec_id = CODEC_ID_MPEG4; 459 type = AVMEDIA_TYPE_VIDEO; 460 } else if(es_type == STREAM_TYPE_VIDEO_H264){ 461 codec_id = CODEC_ID_H264; 462 type = AVMEDIA_TYPE_VIDEO; 463 } else if(es_type == STREAM_TYPE_AUDIO_AC3){ 464 codec_id = CODEC_ID_AC3; 465 type = AVMEDIA_TYPE_AUDIO; 466 } else { 467 goto skip; 468 } 469 } else if (startcode >= 0x1e0 && startcode <= 0x1ef) { 470 static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 }; 471 unsigned char buf[8]; 472 get_buffer(s->pb, buf, 8); 473 url_fseek(s->pb, -8, SEEK_CUR); 474 if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1)) 475 codec_id = CODEC_ID_CAVS; 476 else 477 codec_id = CODEC_ID_PROBE; 478 type = AVMEDIA_TYPE_VIDEO; 479 } else if (startcode >= 0x1c0 && startcode <= 0x1df) { 480 type = AVMEDIA_TYPE_AUDIO; 481 codec_id = m->sofdec > 0 ? CODEC_ID_ADPCM_ADX : CODEC_ID_MP2; 482 } else if (startcode >= 0x80 && startcode <= 0x87) { 483 type = AVMEDIA_TYPE_AUDIO; 484 codec_id = CODEC_ID_AC3; 485 } else if ( ( startcode >= 0x88 && startcode <= 0x8f) 486 ||( startcode >= 0x98 && startcode <= 0x9f)) { 487 /* 0x90 - 0x97 is reserved for SDDS in DVD specs */ 488 type = AVMEDIA_TYPE_AUDIO; 489 codec_id = CODEC_ID_DTS; 490 } else if (startcode >= 0xa0 && startcode <= 0xaf) { 491 type = AVMEDIA_TYPE_AUDIO; 492 /* 16 bit form will be handled as CODEC_ID_PCM_S16BE */ 493 codec_id = CODEC_ID_PCM_DVD; 494 } else if (startcode >= 0xb0 && startcode <= 0xbf) { 495 type = AVMEDIA_TYPE_AUDIO; 496 codec_id = CODEC_ID_TRUEHD; 497 } else if (startcode >= 0xc0 && startcode <= 0xcf) { 498 /* Used for both AC-3 and E-AC-3 in EVOB files */ 499 type = AVMEDIA_TYPE_AUDIO; 500 codec_id = CODEC_ID_AC3; 501 } else if (startcode >= 0x20 && startcode <= 0x3f) { 502 type = AVMEDIA_TYPE_SUBTITLE; 503 codec_id = CODEC_ID_DVD_SUBTITLE; 504 } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) { 505 type = AVMEDIA_TYPE_VIDEO; 506 codec_id = CODEC_ID_VC1; 507 } else if (startcode == 0x1bd) { 508 // check dvd audio substream type 509 type = AVMEDIA_TYPE_AUDIO; 510 switch(dvdaudio_substream_type & 0xe0) { 511 case 0xa0: codec_id = CODEC_ID_PCM_DVD; 512 break; 513 case 0x80: if((dvdaudio_substream_type & 0xf8) == 0x88) 514 codec_id = CODEC_ID_DTS; 515 else codec_id = CODEC_ID_AC3; 516 break; 517 default: av_log(s, AV_LOG_ERROR, "Unknown 0x1bd sub-stream\n"); 518 goto skip; 519 } 520 } else { 521 skip: 522 /* skip packet */ 523 url_fskip(s->pb, len); 524 goto redo; 525 } 526 /* no stream found: add a new stream */ 527 st = av_new_stream(s, startcode); 528 if (!st) 529 goto skip; 530 st->codec->codec_type = type; 531 st->codec->codec_id = codec_id; 532 if (codec_id != CODEC_ID_PCM_S16BE) 533 st->need_parsing = AVSTREAM_PARSE_FULL; 534 found: 535 if(st->discard >= AVDISCARD_ALL) 536 goto skip; 537 if ((startcode >= 0xa0 && startcode <= 0xaf) || 538 (startcode == 0x1bd && ((dvdaudio_substream_type & 0xe0) == 0xa0))) { 539 int b1, freq; 540 541 /* for LPCM, we just skip the header and consider it is raw 542 audio data */ 543 if (len <= 3) 544 goto skip; 545 get_byte(s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */ 546 b1 = get_byte(s->pb); /* quant (2), freq(2), reserved(1), channels(3) */ 547 get_byte(s->pb); /* dynamic range control (0x80 = off) */ 548 len -= 3; 549 freq = (b1 >> 4) & 3; 550 st->codec->sample_rate = lpcm_freq_tab[freq]; 551 st->codec->channels = 1 + (b1 & 7); 552 st->codec->bits_per_coded_sample = 16 + ((b1 >> 6) & 3) * 4; 553 st->codec->bit_rate = st->codec->channels * 554 st->codec->sample_rate * 555 st->codec->bits_per_coded_sample; 556 if (st->codec->bits_per_coded_sample == 16) 557 st->codec->codec_id = CODEC_ID_PCM_S16BE; 558 else if (st->codec->bits_per_coded_sample == 28) 559 return AVERROR(EINVAL); 560 } 561 av_new_packet(pkt, len); 562 get_buffer(s->pb, pkt->data, pkt->size); 563 pkt->pts = pts; 564 pkt->dts = dts; 565 pkt->pos = dummy_pos; 566 pkt->stream_index = st->index; 567#if 0 568 av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n", 569 pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0, pkt->size); 570#endif 571 572 return 0; 573} 574 575static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, 576 int64_t *ppos, int64_t pos_limit) 577{ 578 int len, startcode; 579 int64_t pos, pts, dts; 580 581 pos = *ppos; 582#ifdef DEBUG_SEEK 583 printf("read_dts: pos=0x%"PRIx64" next=%d -> ", pos, find_next); 584#endif 585 if (url_fseek(s->pb, pos, SEEK_SET) < 0) 586 return AV_NOPTS_VALUE; 587 588 for(;;) { 589 len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts); 590 if (len < 0) { 591#ifdef DEBUG_SEEK 592 printf("none (ret=%d)\n", len); 593#endif 594 return AV_NOPTS_VALUE; 595 } 596 if (startcode == s->streams[stream_index]->id && 597 dts != AV_NOPTS_VALUE) { 598 break; 599 } 600 url_fskip(s->pb, len); 601 } 602#ifdef DEBUG_SEEK 603 printf("pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n", pos, dts, dts / 90000.0); 604#endif 605 *ppos = pos; 606 return dts; 607} 608 609AVInputFormat mpegps_demuxer = { 610 "mpeg", 611 NULL_IF_CONFIG_SMALL("MPEG-PS format"), 612 sizeof(MpegDemuxContext), 613 mpegps_probe, 614 mpegps_read_header, 615 mpegps_read_packet, 616 NULL, 617 NULL, //mpegps_read_seek, 618 mpegps_read_dts, 619 .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT, 620}; 621