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