Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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 "internal.h"
  24. #include "mpeg.h"
  25.  
  26. #if CONFIG_VOBSUB_DEMUXER
  27. # include "subtitles.h"
  28. # include "libavutil/bprint.h"
  29. #endif
  30.  
  31. #undef NDEBUG
  32. #include <assert.h>
  33. #include "libavutil/avassert.h"
  34.  
  35. /*********************************************/
  36. /* demux code */
  37.  
  38. #define MAX_SYNC_SIZE 100000
  39.  
  40. static int check_pes(const uint8_t *p, const uint8_t *end){
  41.     int pes1;
  42.     int pes2=      (p[3] & 0xC0) == 0x80
  43.                 && (p[4] & 0xC0) != 0x40
  44.                 &&((p[4] & 0xC0) == 0x00 || (p[4]&0xC0)>>2 == (p[6]&0xF0));
  45.  
  46.     for(p+=3; p<end && *p == 0xFF; p++);
  47.     if((*p&0xC0) == 0x40) p+=2;
  48.     if((*p&0xF0) == 0x20){
  49.         pes1= p[0]&p[2]&p[4]&1;
  50.     }else if((*p&0xF0) == 0x30){
  51.         pes1= p[0]&p[2]&p[4]&p[5]&p[7]&p[9]&1;
  52.     }else
  53.         pes1 = *p == 0x0F;
  54.  
  55.     return pes1||pes2;
  56. }
  57.  
  58. static int check_pack_header(const uint8_t *buf) {
  59.     return (buf[1] & 0xC0) == 0x40 || (buf[1] & 0xF0) == 0x20;
  60. }
  61.  
  62. static int mpegps_probe(AVProbeData *p)
  63. {
  64.     uint32_t code= -1;
  65.     int sys=0, pspack=0, priv1=0, vid=0, audio=0, invalid=0;
  66.     int i;
  67.     int score=0;
  68.  
  69.     for(i=0; i<p->buf_size; i++){
  70.         code = (code<<8) + p->buf[i];
  71.         if ((code & 0xffffff00) == 0x100) {
  72.             int len= p->buf[i+1] << 8 | p->buf[i+2];
  73.             int pes= check_pes(p->buf+i, p->buf+p->buf_size);
  74.             int pack = check_pack_header(p->buf+i);
  75.  
  76.             if(code == SYSTEM_HEADER_START_CODE) sys++;
  77.             else if(code == PACK_START_CODE && pack) pspack++;
  78.             else if((code & 0xf0) == VIDEO_ID &&  pes) vid++;
  79.             // skip pes payload to avoid start code emulation for private
  80.             // and audio streams
  81.             else if((code & 0xe0) == AUDIO_ID &&  pes) {audio++; i+=len;}
  82.             else if(code == PRIVATE_STREAM_1  &&  pes) {priv1++; i+=len;}
  83.             else if(code == 0x1fd             &&  pes) vid++; //VC1
  84.  
  85.             else if((code & 0xf0) == VIDEO_ID && !pes) invalid++;
  86.             else if((code & 0xe0) == AUDIO_ID && !pes) invalid++;
  87.             else if(code == PRIVATE_STREAM_1  && !pes) invalid++;
  88.         }
  89.     }
  90.  
  91.     if(vid+audio > invalid+1)     /* invalid VDR files nd short PES streams */
  92.         score = AVPROBE_SCORE_EXTENSION / 2;
  93.  
  94.     if(sys>invalid && sys*9 <= pspack*10)
  95.         return (audio > 12 || vid > 3 || pspack > 2) ? AVPROBE_SCORE_EXTENSION + 2 : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg
  96.     if(pspack > invalid && (priv1+vid+audio)*10 >= pspack*9)
  97.         return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2 : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg
  98.     if((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys && !pspack && p->buf_size>2048 && vid + audio > invalid) /* PES stream */
  99.         return (audio > 12 || vid > 3 + 2*invalid) ? AVPROBE_SCORE_EXTENSION + 2 : AVPROBE_SCORE_EXTENSION / 2;
  100.  
  101.     //02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
  102.     //mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6
  103.     //Have\ Yourself\ a\ Merry\ Little\ Christmas.mp3 0 0 0 5 0 1 len:21618
  104.     return score;
  105. }
  106.  
  107.  
  108. typedef struct MpegDemuxContext {
  109.     int32_t header_state;
  110.     unsigned char psm_es_type[256];
  111.     int sofdec;
  112.     int dvd;
  113.     int imkh_cctv;
  114. #if CONFIG_VOBSUB_DEMUXER
  115.     AVFormatContext *sub_ctx;
  116.     FFDemuxSubtitlesQueue q[32];
  117. #endif
  118. } MpegDemuxContext;
  119.  
  120. static int mpegps_read_header(AVFormatContext *s)
  121. {
  122.     MpegDemuxContext *m = s->priv_data;
  123.     char buffer[7];
  124.     int64_t last_pos = avio_tell(s->pb);
  125.  
  126.     m->header_state = 0xff;
  127.     s->ctx_flags |= AVFMTCTX_NOHEADER;
  128.  
  129.     avio_get_str(s->pb, 6, buffer, sizeof(buffer));
  130.     if (!memcmp("IMKH", buffer, 4)) {
  131.         m->imkh_cctv = 1;
  132.     } else if (!memcmp("Sofdec", buffer, 6)) {
  133.         m->sofdec = 1;
  134.     } else
  135.        avio_seek(s->pb, last_pos, SEEK_SET);
  136.  
  137.     /* no need to do more */
  138.     return 0;
  139. }
  140.  
  141. static int64_t get_pts(AVIOContext *pb, int c)
  142. {
  143.     uint8_t buf[5];
  144.  
  145.     buf[0] = c<0 ? avio_r8(pb) : c;
  146.     avio_read(pb, buf+1, 4);
  147.  
  148.     return ff_parse_pes_pts(buf);
  149. }
  150.  
  151. static int find_next_start_code(AVIOContext *pb, int *size_ptr,
  152.                                 int32_t *header_state)
  153. {
  154.     unsigned int state, v;
  155.     int val, n;
  156.  
  157.     state = *header_state;
  158.     n = *size_ptr;
  159.     while (n > 0) {
  160.         if (url_feof(pb))
  161.             break;
  162.         v = avio_r8(pb);
  163.         n--;
  164.         if (state == 0x000001) {
  165.             state = ((state << 8) | v) & 0xffffff;
  166.             val = state;
  167.             goto found;
  168.         }
  169.         state = ((state << 8) | v) & 0xffffff;
  170.     }
  171.     val = -1;
  172.  found:
  173.     *header_state = state;
  174.     *size_ptr = n;
  175.     return val;
  176. }
  177.  
  178. /**
  179.  * Extract stream types from a program stream map
  180.  * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
  181.  *
  182.  * @return number of bytes occupied by PSM in the bitstream
  183.  */
  184. static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb)
  185. {
  186.     int psm_length, ps_info_length, es_map_length;
  187.  
  188.     psm_length = avio_rb16(pb);
  189.     avio_r8(pb);
  190.     avio_r8(pb);
  191.     ps_info_length = avio_rb16(pb);
  192.  
  193.     /* skip program_stream_info */
  194.     avio_skip(pb, ps_info_length);
  195.     es_map_length = avio_rb16(pb);
  196.  
  197.     /* at least one es available? */
  198.     while (es_map_length >= 4){
  199.         unsigned char type      = avio_r8(pb);
  200.         unsigned char es_id     = avio_r8(pb);
  201.         uint16_t es_info_length = avio_rb16(pb);
  202.         /* remember mapping from stream id to stream type */
  203.         m->psm_es_type[es_id] = type;
  204.         /* skip program_stream_info */
  205.         avio_skip(pb, es_info_length);
  206.         es_map_length -= 4 + es_info_length;
  207.     }
  208.     avio_rb32(pb); /* crc32 */
  209.     return 2 + psm_length;
  210. }
  211.  
  212. /* read the next PES header. Return its position in ppos
  213.    (if not NULL), and its start code, pts and dts.
  214.  */
  215. static int mpegps_read_pes_header(AVFormatContext *s,
  216.                                   int64_t *ppos, int *pstart_code,
  217.                                   int64_t *ppts, int64_t *pdts)
  218. {
  219.     MpegDemuxContext *m = s->priv_data;
  220.     int len, size, startcode, c, flags, header_len;
  221.     int pes_ext, ext2_len, id_ext, skip;
  222.     int64_t pts, dts;
  223.     int64_t last_sync= avio_tell(s->pb);
  224.  
  225.  error_redo:
  226.         avio_seek(s->pb, last_sync, SEEK_SET);
  227.  redo:
  228.         /* next start code (should be immediately after) */
  229.         m->header_state = 0xff;
  230.         size = MAX_SYNC_SIZE;
  231.         startcode = find_next_start_code(s->pb, &size, &m->header_state);
  232.         last_sync = avio_tell(s->pb);
  233.     if (startcode < 0){
  234.         if(url_feof(s->pb))
  235.             return AVERROR_EOF;
  236.         //FIXME we should remember header_state
  237.         return AVERROR(EAGAIN);
  238.     }
  239.  
  240.     if (startcode == PACK_START_CODE)
  241.         goto redo;
  242.     if (startcode == SYSTEM_HEADER_START_CODE)
  243.         goto redo;
  244.     if (startcode == PADDING_STREAM) {
  245.         avio_skip(s->pb, avio_rb16(s->pb));
  246.         goto redo;
  247.     }
  248.     if (startcode == PRIVATE_STREAM_2) {
  249.         if (!m->sofdec) {
  250.             /* Need to detect whether this from a DVD or a 'Sofdec' stream */
  251.             int len = avio_rb16(s->pb);
  252.             int bytesread = 0;
  253.             uint8_t *ps2buf = av_malloc(len);
  254.  
  255.             if (ps2buf) {
  256.                 bytesread = avio_read(s->pb, ps2buf, len);
  257.  
  258.                 if (bytesread != len) {
  259.                     avio_skip(s->pb, len - bytesread);
  260.                 } else {
  261.                     uint8_t *p = 0;
  262.                     if (len >= 6)
  263.                         p = memchr(ps2buf, 'S', len - 5);
  264.  
  265.                     if (p)
  266.                         m->sofdec = !memcmp(p+1, "ofdec", 5);
  267.  
  268.                     m->sofdec -= !m->sofdec;
  269.  
  270.                     if (m->sofdec < 0) {
  271.                         if (len == 980  && ps2buf[0] == 0) {
  272.                             /* PCI structure? */
  273.                             uint32_t startpts = AV_RB32(ps2buf + 0x0d);
  274.                             uint32_t endpts = AV_RB32(ps2buf + 0x11);
  275.                             uint8_t hours = ((ps2buf[0x19] >> 4) * 10) + (ps2buf[0x19] & 0x0f);
  276.                             uint8_t mins  = ((ps2buf[0x1a] >> 4) * 10) + (ps2buf[0x1a] & 0x0f);
  277.                             uint8_t secs  = ((ps2buf[0x1b] >> 4) * 10) + (ps2buf[0x1b] & 0x0f);
  278.  
  279.                             m->dvd = (hours <= 23 &&
  280.                                       mins  <= 59 &&
  281.                                       secs  <= 59 &&
  282.                                       (ps2buf[0x19] & 0x0f) < 10 &&
  283.                                       (ps2buf[0x1a] & 0x0f) < 10 &&
  284.                                       (ps2buf[0x1b] & 0x0f) < 10 &&
  285.                                       endpts >= startpts);
  286.                         } else if (len == 1018 && ps2buf[0] == 1) {
  287.                             /* DSI structure? */
  288.                             uint8_t hours = ((ps2buf[0x1d] >> 4) * 10) + (ps2buf[0x1d] & 0x0f);
  289.                             uint8_t mins  = ((ps2buf[0x1e] >> 4) * 10) + (ps2buf[0x1e] & 0x0f);
  290.                             uint8_t secs  = ((ps2buf[0x1f] >> 4) * 10) + (ps2buf[0x1f] & 0x0f);
  291.  
  292.                             m->dvd = (hours <= 23 &&
  293.                                       mins  <= 59 &&
  294.                                       secs  <= 59 &&
  295.                                       (ps2buf[0x1d] & 0x0f) < 10 &&
  296.                                       (ps2buf[0x1e] & 0x0f) < 10 &&
  297.                                       (ps2buf[0x1f] & 0x0f) < 10);
  298.                         }
  299.                     }
  300.                 }
  301.  
  302.                 av_free(ps2buf);
  303.  
  304.                 /* If this isn't a DVD packet or no memory
  305.                  * could be allocated, just ignore it.
  306.                  * If we did, move back to the start of the
  307.                  * packet (plus 'length' field) */
  308.                 if (!m->dvd || avio_skip(s->pb, -(len + 2)) < 0) {
  309.                     /* Skip back failed.
  310.                      * This packet will be lost but that can't be helped
  311.                      * if we can't skip back
  312.                      */
  313.                     goto redo;
  314.                 }
  315.             } else {
  316.                 /* No memory */
  317.                 avio_skip(s->pb, len);
  318.                 goto redo;
  319.             }
  320.         } else if (!m->dvd) {
  321.             int len = avio_rb16(s->pb);
  322.             avio_skip(s->pb, len);
  323.             goto redo;
  324.         }
  325.     }
  326.     if (startcode == PROGRAM_STREAM_MAP) {
  327.         mpegps_psm_parse(m, s->pb);
  328.         goto redo;
  329.     }
  330.  
  331.     /* find matching stream */
  332.     if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
  333.           (startcode >= 0x1e0 && startcode <= 0x1ef) ||
  334.           (startcode == 0x1bd) ||
  335.           (startcode == PRIVATE_STREAM_2) ||
  336.           (startcode == 0x1fd)))
  337.         goto redo;
  338.     if (ppos) {
  339.         *ppos = avio_tell(s->pb) - 4;
  340.     }
  341.     len = avio_rb16(s->pb);
  342.     pts =
  343.     dts = AV_NOPTS_VALUE;
  344.     if (startcode != PRIVATE_STREAM_2)
  345.     {
  346.     /* stuffing */
  347.     for(;;) {
  348.         if (len < 1)
  349.             goto error_redo;
  350.         c = avio_r8(s->pb);
  351.         len--;
  352.         /* XXX: for mpeg1, should test only bit 7 */
  353.         if (c != 0xff)
  354.             break;
  355.     }
  356.     if ((c & 0xc0) == 0x40) {
  357.         /* buffer scale & size */
  358.         avio_r8(s->pb);
  359.         c = avio_r8(s->pb);
  360.         len -= 2;
  361.     }
  362.     if ((c & 0xe0) == 0x20) {
  363.         dts = pts = get_pts(s->pb, c);
  364.         len -= 4;
  365.         if (c & 0x10){
  366.             dts = get_pts(s->pb, -1);
  367.             len -= 5;
  368.         }
  369.     } else if ((c & 0xc0) == 0x80) {
  370.         /* mpeg 2 PES */
  371.         flags = avio_r8(s->pb);
  372.         header_len = avio_r8(s->pb);
  373.         len -= 2;
  374.         if (header_len > len)
  375.             goto error_redo;
  376.         len -= header_len;
  377.         if (flags & 0x80) {
  378.             dts = pts = get_pts(s->pb, -1);
  379.             header_len -= 5;
  380.             if (flags & 0x40) {
  381.                 dts = get_pts(s->pb, -1);
  382.                 header_len -= 5;
  383.             }
  384.         }
  385.         if (flags & 0x3f && header_len == 0){
  386.             flags &= 0xC0;
  387.             av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");
  388.         }
  389.         if (flags & 0x01) { /* PES extension */
  390.             pes_ext = avio_r8(s->pb);
  391.             header_len--;
  392.             /* Skip PES private data, program packet sequence counter and P-STD buffer */
  393.             skip = (pes_ext >> 4) & 0xb;
  394.             skip += skip & 0x9;
  395.             if (pes_ext & 0x40 || skip > header_len){
  396.                 av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext);
  397.                 pes_ext=skip=0;
  398.             }
  399.             avio_skip(s->pb, skip);
  400.             header_len -= skip;
  401.  
  402.             if (pes_ext & 0x01) { /* PES extension 2 */
  403.                 ext2_len = avio_r8(s->pb);
  404.                 header_len--;
  405.                 if ((ext2_len & 0x7f) > 0) {
  406.                     id_ext = avio_r8(s->pb);
  407.                     if ((id_ext & 0x80) == 0)
  408.                         startcode = ((startcode & 0xff) << 8) | id_ext;
  409.                     header_len--;
  410.                 }
  411.             }
  412.         }
  413.         if(header_len < 0)
  414.             goto error_redo;
  415.         avio_skip(s->pb, header_len);
  416.     }
  417.     else if( c!= 0xf )
  418.         goto redo;
  419.     }
  420.  
  421.     if (startcode == PRIVATE_STREAM_1) {
  422.         startcode = avio_r8(s->pb);
  423.         len--;
  424.     }
  425.     if(len<0)
  426.         goto error_redo;
  427.     if(dts != AV_NOPTS_VALUE && ppos){
  428.         int i;
  429.         for(i=0; i<s->nb_streams; i++){
  430.             if(startcode == s->streams[i]->id &&
  431.                s->pb->seekable /* index useless on streams anyway */) {
  432.                 ff_reduce_index(s, i);
  433.                 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);
  434.             }
  435.         }
  436.     }
  437.  
  438.     *pstart_code = startcode;
  439.     *ppts = pts;
  440.     *pdts = dts;
  441.     return len;
  442. }
  443.  
  444. static int mpegps_read_packet(AVFormatContext *s,
  445.                               AVPacket *pkt)
  446. {
  447.     MpegDemuxContext *m = s->priv_data;
  448.     AVStream *st;
  449.     int len, startcode, i, es_type, ret;
  450.     int lpcm_header_len = -1; //Init to supress warning
  451.     int request_probe= 0;
  452.     enum AVCodecID codec_id = AV_CODEC_ID_NONE;
  453.     enum AVMediaType type;
  454.     int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
  455.  
  456.  redo:
  457.     len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
  458.     if (len < 0)
  459.         return len;
  460.  
  461.     if (startcode >= 0x80 && startcode <= 0xcf) {
  462.         if(len < 4)
  463.             goto skip;
  464.  
  465.         /* audio: skip header */
  466.         avio_r8(s->pb);
  467.         lpcm_header_len = avio_rb16(s->pb);
  468.         len -= 3;
  469.         if (startcode >= 0xb0 && startcode <= 0xbf) {
  470.             /* MLP/TrueHD audio has a 4-byte header */
  471.             avio_r8(s->pb);
  472.             len--;
  473.         }
  474.     }
  475.  
  476.     /* now find stream */
  477.     for(i=0;i<s->nb_streams;i++) {
  478.         st = s->streams[i];
  479.         if (st->id == startcode)
  480.             goto found;
  481.     }
  482.  
  483.     es_type = m->psm_es_type[startcode & 0xff];
  484.         if(es_type == STREAM_TYPE_VIDEO_MPEG1){
  485.             codec_id = AV_CODEC_ID_MPEG2VIDEO;
  486.             type = AVMEDIA_TYPE_VIDEO;
  487.         } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){
  488.             codec_id = AV_CODEC_ID_MPEG2VIDEO;
  489.             type = AVMEDIA_TYPE_VIDEO;
  490.         } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||
  491.                   es_type == STREAM_TYPE_AUDIO_MPEG2){
  492.             codec_id = AV_CODEC_ID_MP3;
  493.             type = AVMEDIA_TYPE_AUDIO;
  494.         } else if(es_type == STREAM_TYPE_AUDIO_AAC){
  495.             codec_id = AV_CODEC_ID_AAC;
  496.             type = AVMEDIA_TYPE_AUDIO;
  497.         } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){
  498.             codec_id = AV_CODEC_ID_MPEG4;
  499.             type = AVMEDIA_TYPE_VIDEO;
  500.         } else if(es_type == STREAM_TYPE_VIDEO_H264){
  501.             codec_id = AV_CODEC_ID_H264;
  502.             type = AVMEDIA_TYPE_VIDEO;
  503.         } else if(es_type == STREAM_TYPE_AUDIO_AC3){
  504.             codec_id = AV_CODEC_ID_AC3;
  505.             type = AVMEDIA_TYPE_AUDIO;
  506.         } else if(m->imkh_cctv && es_type == 0x91){
  507.             codec_id = AV_CODEC_ID_PCM_MULAW;
  508.             type = AVMEDIA_TYPE_AUDIO;
  509.     } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
  510.         static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
  511.         unsigned char buf[8];
  512.         avio_read(s->pb, buf, 8);
  513.         avio_seek(s->pb, -8, SEEK_CUR);
  514.         if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
  515.             codec_id = AV_CODEC_ID_CAVS;
  516.         else
  517.             request_probe= 1;
  518.         type = AVMEDIA_TYPE_VIDEO;
  519.     } else if (startcode == PRIVATE_STREAM_2) {
  520.         type = AVMEDIA_TYPE_DATA;
  521.         codec_id = AV_CODEC_ID_DVD_NAV;
  522.     } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
  523.         type = AVMEDIA_TYPE_AUDIO;
  524.         codec_id = m->sofdec > 0 ? AV_CODEC_ID_ADPCM_ADX : AV_CODEC_ID_MP2;
  525.     } else if (startcode >= 0x80 && startcode <= 0x87) {
  526.         type = AVMEDIA_TYPE_AUDIO;
  527.         codec_id = AV_CODEC_ID_AC3;
  528.     } else if (  ( startcode >= 0x88 && startcode <= 0x8f)
  529.                ||( startcode >= 0x98 && startcode <= 0x9f)) {
  530.         /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
  531.         type = AVMEDIA_TYPE_AUDIO;
  532.         codec_id = AV_CODEC_ID_DTS;
  533.     } else if (startcode >= 0xa0 && startcode <= 0xaf) {
  534.         type = AVMEDIA_TYPE_AUDIO;
  535.         if(lpcm_header_len == 6) {
  536.             codec_id = AV_CODEC_ID_MLP;
  537.         } else {
  538.             codec_id = AV_CODEC_ID_PCM_DVD;
  539.         }
  540.     } else if (startcode >= 0xb0 && startcode <= 0xbf) {
  541.         type = AVMEDIA_TYPE_AUDIO;
  542.         codec_id = AV_CODEC_ID_TRUEHD;
  543.     } else if (startcode >= 0xc0 && startcode <= 0xcf) {
  544.         /* Used for both AC-3 and E-AC-3 in EVOB files */
  545.         type = AVMEDIA_TYPE_AUDIO;
  546.         codec_id = AV_CODEC_ID_AC3;
  547.     } else if (startcode >= 0x20 && startcode <= 0x3f) {
  548.         type = AVMEDIA_TYPE_SUBTITLE;
  549.         codec_id = AV_CODEC_ID_DVD_SUBTITLE;
  550.     } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
  551.         type = AVMEDIA_TYPE_VIDEO;
  552.         codec_id = AV_CODEC_ID_VC1;
  553.     } else {
  554.     skip:
  555.         /* skip packet */
  556.         avio_skip(s->pb, len);
  557.         goto redo;
  558.     }
  559.     /* no stream found: add a new stream */
  560.     st = avformat_new_stream(s, NULL);
  561.     if (!st)
  562.         goto skip;
  563.     st->id = startcode;
  564.     st->codec->codec_type = type;
  565.     st->codec->codec_id = codec_id;
  566.     if (st->codec->codec_id == AV_CODEC_ID_PCM_MULAW) {
  567.         st->codec->channels = 1;
  568.         st->codec->channel_layout = AV_CH_LAYOUT_MONO;
  569.         st->codec->sample_rate = 8000;
  570.     }
  571.     st->request_probe     = request_probe;
  572.     st->need_parsing = AVSTREAM_PARSE_FULL;
  573.  found:
  574.     if(st->discard >= AVDISCARD_ALL)
  575.         goto skip;
  576.     if (startcode >= 0xa0 && startcode <= 0xaf) {
  577.       if (lpcm_header_len == 6 && st->codec->codec_id == AV_CODEC_ID_MLP) {
  578.             if (len < 6)
  579.                 goto skip;
  580.             avio_skip(s->pb, 6);
  581.             len -=6;
  582.       }
  583.     }
  584.     ret = av_get_packet(s->pb, pkt, len);
  585.     pkt->pts = pts;
  586.     pkt->dts = dts;
  587.     pkt->pos = dummy_pos;
  588.     pkt->stream_index = st->index;
  589.     av_dlog(s, "%d: pts=%0.3f dts=%0.3f size=%d\n",
  590.             pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
  591.             pkt->size);
  592.  
  593.     return (ret < 0) ? ret : 0;
  594. }
  595.  
  596. static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
  597.                                int64_t *ppos, int64_t pos_limit)
  598. {
  599.     int len, startcode;
  600.     int64_t pos, pts, dts;
  601.  
  602.     pos = *ppos;
  603.     if (avio_seek(s->pb, pos, SEEK_SET) < 0)
  604.         return AV_NOPTS_VALUE;
  605.  
  606.     for(;;) {
  607.         len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
  608.         if (len < 0) {
  609.             av_dlog(s, "none (ret=%d)\n", len);
  610.             return AV_NOPTS_VALUE;
  611.         }
  612.         if (startcode == s->streams[stream_index]->id &&
  613.             dts != AV_NOPTS_VALUE) {
  614.             break;
  615.         }
  616.         avio_skip(s->pb, len);
  617.     }
  618.     av_dlog(s, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
  619.             pos, dts, dts / 90000.0);
  620.     *ppos = pos;
  621.     return dts;
  622. }
  623.  
  624. AVInputFormat ff_mpegps_demuxer = {
  625.     .name           = "mpeg",
  626.     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),
  627.     .priv_data_size = sizeof(MpegDemuxContext),
  628.     .read_probe     = mpegps_probe,
  629.     .read_header    = mpegps_read_header,
  630.     .read_packet    = mpegps_read_packet,
  631.     .read_timestamp = mpegps_read_dts,
  632.     .flags          = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,
  633. };
  634.  
  635. #if CONFIG_VOBSUB_DEMUXER
  636.  
  637. #define REF_STRING "# VobSub index file,"
  638.  
  639. static int vobsub_probe(AVProbeData *p)
  640. {
  641.     if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))
  642.         return AVPROBE_SCORE_MAX;
  643.     return 0;
  644. }
  645.  
  646. static int vobsub_read_header(AVFormatContext *s)
  647. {
  648.     int i, ret = 0, header_parsed = 0, langidx = 0;
  649.     MpegDemuxContext *vobsub = s->priv_data;
  650.     char *sub_name = NULL;
  651.     size_t fname_len;
  652.     char *ext, *header_str;
  653.     AVBPrint header;
  654.     int64_t delay = 0;
  655.     AVStream *st = NULL;
  656.  
  657.     sub_name = av_strdup(s->filename);
  658.     fname_len = strlen(sub_name);
  659.     ext = sub_name - 3 + fname_len;
  660.     if (fname_len < 4 || *(ext - 1) != '.') {
  661.         av_log(s, AV_LOG_ERROR, "The input index filename is too short "
  662.                "to guess the associated .SUB file\n");
  663.         ret = AVERROR_INVALIDDATA;
  664.         goto end;
  665.     }
  666.     memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3);
  667.     av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->filename, sub_name);
  668.     ret = avformat_open_input(&vobsub->sub_ctx, sub_name, &ff_mpegps_demuxer, NULL);
  669.     if (ret < 0) {
  670.         av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", sub_name);
  671.         goto end;
  672.     }
  673.  
  674.     av_bprint_init(&header, 0, AV_BPRINT_SIZE_UNLIMITED);
  675.     while (!url_feof(s->pb)) {
  676.         char line[2048];
  677.         int len = ff_get_line(s->pb, line, sizeof(line));
  678.  
  679.         if (!len)
  680.             break;
  681.  
  682.         line[strcspn(line, "\r\n")] = 0;
  683.  
  684.         if (!strncmp(line, "id:", 3)) {
  685.             int n, stream_id = 0;
  686.             char id[64] = {0};
  687.  
  688.             n = sscanf(line, "id: %63[^,], index: %u", id, &stream_id);
  689.             if (n != 2) {
  690.                 av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', "
  691.                        "assuming 'id: und, index: 0'\n", line);
  692.                 strcpy(id, "und");
  693.                 stream_id = 0;
  694.             }
  695.  
  696.             if (stream_id >= FF_ARRAY_ELEMS(vobsub->q)) {
  697.                 av_log(s, AV_LOG_ERROR, "Maximum number of subtitles streams reached\n");
  698.                 ret = AVERROR(EINVAL);
  699.                 goto end;
  700.             }
  701.  
  702.             st = avformat_new_stream(s, NULL);
  703.             if (!st) {
  704.                 ret = AVERROR(ENOMEM);
  705.                 goto end;
  706.             }
  707.             st->id = stream_id;
  708.             st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
  709.             st->codec->codec_id   = AV_CODEC_ID_DVD_SUBTITLE;
  710.             avpriv_set_pts_info(st, 64, 1, 1000);
  711.             av_dict_set(&st->metadata, "language", id, 0);
  712.             av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);
  713.             header_parsed = 1;
  714.  
  715.         } else if (st && !strncmp(line, "timestamp:", 10)) {
  716.             AVPacket *sub;
  717.             int hh, mm, ss, ms;
  718.             int64_t pos, timestamp;
  719.             const char *p = line + 10;
  720.  
  721.             if (!s->nb_streams) {
  722.                 av_log(s, AV_LOG_ERROR, "Timestamp declared before any stream\n");
  723.                 ret = AVERROR_INVALIDDATA;
  724.                 goto end;
  725.             }
  726.  
  727.             if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"SCNx64,
  728.                        &hh, &mm, &ss, &ms, &pos) != 5) {
  729.                 av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "
  730.                        "abort parsing\n", line);
  731.                 break;
  732.             }
  733.             timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay;
  734.             timestamp = av_rescale_q(timestamp, (AVRational){1,1000}, st->time_base);
  735.  
  736.             sub = ff_subtitles_queue_insert(&vobsub->q[s->nb_streams - 1], "", 0, 0);
  737.             if (!sub) {
  738.                 ret = AVERROR(ENOMEM);
  739.                 goto end;
  740.             }
  741.             sub->pos = pos;
  742.             sub->pts = timestamp;
  743.             sub->stream_index = s->nb_streams - 1;
  744.  
  745.         } else if (st && !strncmp(line, "alt:", 4)) {
  746.             const char *p = line + 4;
  747.  
  748.             while (*p == ' ')
  749.                 p++;
  750.             av_dict_set(&st->metadata, "title", p, 0);
  751.             av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", st->id, p);
  752.             header_parsed = 1;
  753.  
  754.         } else if (!strncmp(line, "delay:", 6)) {
  755.             int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0;
  756.             const char *p = line + 6;
  757.  
  758.             while (*p == ' ')
  759.                 p++;
  760.             if (*p == '-' || *p == '+') {
  761.                 sign = *p == '-' ? -1 : 1;
  762.                 p++;
  763.             }
  764.             sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms);
  765.             delay = ((hh*3600LL + mm*60LL + ss) * 1000LL + ms) * sign;
  766.  
  767.         } else if (!strncmp(line, "langidx:", 8)) {
  768.             const char *p = line + 8;
  769.  
  770.             if (sscanf(p, "%d", &langidx) != 1)
  771.                 av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n");
  772.  
  773.         } else if (!header_parsed) {
  774.             if (line[0] && line[0] != '#')
  775.                 av_bprintf(&header, "%s\n", line);
  776.         }
  777.     }
  778.  
  779.     if (langidx < s->nb_streams)
  780.         s->streams[langidx]->disposition |= AV_DISPOSITION_DEFAULT;
  781.  
  782.     for (i = 0; i < s->nb_streams; i++) {
  783.         vobsub->q[i].sort = SUB_SORT_POS_TS;
  784.         ff_subtitles_queue_finalize(&vobsub->q[i]);
  785.     }
  786.  
  787.     if (!av_bprint_is_complete(&header)) {
  788.         av_bprint_finalize(&header, NULL);
  789.         ret = AVERROR(ENOMEM);
  790.         goto end;
  791.     }
  792.     av_bprint_finalize(&header, &header_str);
  793.     for (i = 0; i < s->nb_streams; i++) {
  794.         AVStream *sub_st = s->streams[i];
  795.         sub_st->codec->extradata      = av_strdup(header_str);
  796.         sub_st->codec->extradata_size = header.len;
  797.     }
  798.     av_free(header_str);
  799.  
  800. end:
  801.     av_free(sub_name);
  802.     return ret;
  803. }
  804.  
  805. #define FAIL(r) do { ret = r; goto fail; } while (0)
  806.  
  807. static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt)
  808. {
  809.     MpegDemuxContext *vobsub = s->priv_data;
  810.     FFDemuxSubtitlesQueue *q;
  811.     AVIOContext *pb = vobsub->sub_ctx->pb;
  812.     int ret, psize, total_read = 0, i;
  813.     AVPacket idx_pkt;
  814.  
  815.     int64_t min_ts = INT64_MAX;
  816.     int sid = 0;
  817.     for (i = 0; i < s->nb_streams; i++) {
  818.         FFDemuxSubtitlesQueue *tmpq = &vobsub->q[i];
  819.         int64_t ts = tmpq->subs[tmpq->current_sub_idx].pts;
  820.         if (ts < min_ts) {
  821.             min_ts = ts;
  822.             sid = i;
  823.         }
  824.     }
  825.     q = &vobsub->q[sid];
  826.     ret = ff_subtitles_queue_read_packet(q, &idx_pkt);
  827.     if (ret < 0)
  828.         return ret;
  829.  
  830.     /* compute maximum packet size using the next packet position. This is
  831.      * useful when the len in the header is non-sense */
  832.     if (q->current_sub_idx < q->nb_subs) {
  833.         psize = q->subs[q->current_sub_idx].pos - idx_pkt.pos;
  834.     } else {
  835.         int64_t fsize = avio_size(pb);
  836.         psize = fsize < 0 ? 0xffff : fsize - idx_pkt.pos;
  837.     }
  838.  
  839.     avio_seek(pb, idx_pkt.pos, SEEK_SET);
  840.  
  841.     av_init_packet(pkt);
  842.     pkt->size = 0;
  843.     pkt->data = NULL;
  844.  
  845.     do {
  846.         int n, to_read, startcode;
  847.         int64_t pts, dts;
  848.         int64_t old_pos = avio_tell(pb), new_pos;
  849.         int pkt_size;
  850.  
  851.         ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);
  852.         if (ret < 0) {
  853.             if (pkt->size) // raise packet even if incomplete
  854.                 break;
  855.             FAIL(ret);
  856.         }
  857.         to_read = ret & 0xffff;
  858.         new_pos = avio_tell(pb);
  859.         pkt_size = ret + (new_pos - old_pos);
  860.  
  861.         /* this prevents reads above the current packet */
  862.         if (total_read + pkt_size > psize)
  863.             break;
  864.         total_read += pkt_size;
  865.  
  866.         /* the current chunk doesn't match the stream index (unlikely) */
  867.         if ((startcode & 0x1f) != idx_pkt.stream_index)
  868.             break;
  869.  
  870.         ret = av_grow_packet(pkt, to_read);
  871.         if (ret < 0)
  872.             FAIL(ret);
  873.  
  874.         n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);
  875.         if (n < to_read)
  876.             pkt->size -= to_read - n;
  877.     } while (total_read < psize);
  878.  
  879.     pkt->pts = pkt->dts = idx_pkt.pts;
  880.     pkt->pos = idx_pkt.pos;
  881.     pkt->stream_index = idx_pkt.stream_index;
  882.  
  883.     av_free_packet(&idx_pkt);
  884.     return 0;
  885.  
  886. fail:
  887.     av_free_packet(pkt);
  888.     av_free_packet(&idx_pkt);
  889.     return ret;
  890. }
  891.  
  892. static int vobsub_read_seek(AVFormatContext *s, int stream_index,
  893.                             int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
  894. {
  895.     MpegDemuxContext *vobsub = s->priv_data;
  896.  
  897.     /* Rescale requested timestamps based on the first stream (timebase is the
  898.      * same for all subtitles stream within a .idx/.sub). Rescaling is done just
  899.      * like in avformat_seek_file(). */
  900.     if (stream_index == -1 && s->nb_streams != 1) {
  901.         int i, ret = 0;
  902.         AVRational time_base = s->streams[0]->time_base;
  903.         ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
  904.         min_ts = av_rescale_rnd(min_ts, time_base.den,
  905.                                 time_base.num * (int64_t)AV_TIME_BASE,
  906.                                 AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
  907.         max_ts = av_rescale_rnd(max_ts, time_base.den,
  908.                                 time_base.num * (int64_t)AV_TIME_BASE,
  909.                                 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
  910.         for (i = 0; i < s->nb_streams; i++) {
  911.             int r = ff_subtitles_queue_seek(&vobsub->q[i], s, stream_index,
  912.                                             min_ts, ts, max_ts, flags);
  913.             if (r < 0)
  914.                 ret = r;
  915.         }
  916.         return ret;
  917.     }
  918.  
  919.     if (stream_index == -1) // only 1 stream
  920.         stream_index = 0;
  921.     return ff_subtitles_queue_seek(&vobsub->q[stream_index], s, stream_index,
  922.                                    min_ts, ts, max_ts, flags);
  923. }
  924.  
  925. static int vobsub_read_close(AVFormatContext *s)
  926. {
  927.     int i;
  928.     MpegDemuxContext *vobsub = s->priv_data;
  929.  
  930.     for (i = 0; i < s->nb_streams; i++)
  931.         ff_subtitles_queue_clean(&vobsub->q[i]);
  932.     if (vobsub->sub_ctx)
  933.         avformat_close_input(&vobsub->sub_ctx);
  934.     return 0;
  935. }
  936.  
  937. AVInputFormat ff_vobsub_demuxer = {
  938.     .name           = "vobsub",
  939.     .long_name      = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),
  940.     .priv_data_size = sizeof(MpegDemuxContext),
  941.     .read_probe     = vobsub_probe,
  942.     .read_header    = vobsub_read_header,
  943.     .read_packet    = vobsub_read_packet,
  944.     .read_seek2     = vobsub_read_seek,
  945.     .read_close     = vobsub_read_close,
  946.     .flags          = AVFMT_SHOW_IDS,
  947.     .extensions     = "idx",
  948. };
  949. #endif
  950.