libavformat/mpeg.c

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