falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
49485 Commits
32 Branches
283MB
Tree: 7e0fc1a24f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7e0fc1a24f'
${ noResults }
FFmpeg/libavformat/mpeg.c

835 lines
26KB
Raw Blame History 

  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. 

  34. /*********************************************/

  35. /* demux code */

  36. 

  37. #define MAX_SYNC_SIZE 100000

  38. 

  39. static int check_pes(const uint8_t *p, const uint8_t *end){

  40.     int pes1;

  41.     int pes2=      (p[3] & 0xC0) == 0x80

  42.                 && (p[4] & 0xC0) != 0x40

  43.                 &&((p[4] & 0xC0) == 0x00 || (p[4]&0xC0)>>2 == (p[6]&0xF0));

  44. 

  45.     for(p+=3; p<end && *p == 0xFF; p++);

  46.     if((*p&0xC0) == 0x40) p+=2;

  47.     if((*p&0xF0) == 0x20){

  48.         pes1= p[0]&p[2]&p[4]&1;

  49.     }else if((*p&0xF0) == 0x30){

  50.         pes1= p[0]&p[2]&p[4]&p[5]&p[7]&p[9]&1;

  51.     }else

  52.         pes1 = *p == 0x0F;

  53. 

  54.     return pes1||pes2;

  55. }

  56. 

  57. static int check_pack_header(const uint8_t *buf) {

  58.     return (buf[1] & 0xC0) == 0x40 || (buf[1] & 0xF0) == 0x20;

  59. }

  60. 

  61. static int mpegps_probe(AVProbeData *p)

  62. {

  63.     uint32_t code= -1;

  64.     int sys=0, pspack=0, priv1=0, vid=0, audio=0, invalid=0;

  65.     int i;

  66.     int score=0;

  67. 

  68.     for(i=0; i<p->buf_size; i++){

  69.         code = (code<<8) + p->buf[i];

  70.         if ((code & 0xffffff00) == 0x100) {

  71.             int len= p->buf[i+1] << 8 | p->buf[i+2];

  72.             int pes= check_pes(p->buf+i, p->buf+p->buf_size);

  73.             int pack = check_pack_header(p->buf+i);

  74. 

  75.             if(code == SYSTEM_HEADER_START_CODE) sys++;

  76.             else if(code == PACK_START_CODE && pack) pspack++;

  77.             else if((code & 0xf0) == VIDEO_ID &&  pes) vid++;

  78.             // skip pes payload to avoid start code emulation for private

  79.             // and audio streams

  80.             else if((code & 0xe0) == AUDIO_ID &&  pes) {audio++; i+=len;}

  81.             else if(code == PRIVATE_STREAM_1  &&  pes) {priv1++; i+=len;}

  82.             else if(code == 0x1fd             &&  pes) vid++; //VC1

  83. 

  84.             else if((code & 0xf0) == VIDEO_ID && !pes) invalid++;

  85.             else if((code & 0xe0) == AUDIO_ID && !pes) invalid++;

  86.             else if(code == PRIVATE_STREAM_1  && !pes) invalid++;

  87.         }

  88.     }

  89. 

  90.     if(vid+audio > invalid+1)     /* invalid VDR files nd short PES streams */

  91.         score= AVPROBE_SCORE_MAX/4;

  92. 

  93.     if(sys>invalid && sys*9 <= pspack*10)

  94.         return (audio > 12 || vid > 3 || pspack > 2) ? AVPROBE_SCORE_MAX/2+2 : AVPROBE_SCORE_MAX/4; // +1 for .mpg

  95.     if(pspack > invalid && (priv1+vid+audio)*10 >= pspack*9)

  96.         return pspack > 2 ? AVPROBE_SCORE_MAX/2+2 : AVPROBE_SCORE_MAX/4; // +1 for .mpg

  97.     if((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys && !pspack && p->buf_size>2048 && vid + audio > invalid) /* PES stream */

  98.         return (audio > 12 || vid > 3 + 2*invalid) ? AVPROBE_SCORE_MAX/2+2 : AVPROBE_SCORE_MAX/4;

  99. 

  100.     //02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1

  101.     //mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6

  102.     //Have\ Yourself\ a\ Merry\ Little\ Christmas.mp3 0 0 0 5 0 1 len:21618

  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. #if CONFIG_VOBSUB_DEMUXER

  112.     AVFormatContext *sub_ctx;

  113.     FFDemuxSubtitlesQueue q;

  114. #endif

  115. } MpegDemuxContext;

  116. 

  117. static int mpegps_read_header(AVFormatContext *s)

  118. {

  119.     MpegDemuxContext *m = s->priv_data;

  120.     const char *sofdec = "Sofdec";

  121.     int v, i = 0;

  122.     int64_t last_pos = avio_tell(s->pb);

  123. 

  124.     m->header_state = 0xff;

  125.     s->ctx_flags |= AVFMTCTX_NOHEADER;

  126. 

  127.     m->sofdec = -1;

  128.     do {

  129.         v = avio_r8(s->pb);

  130.         m->sofdec++;

  131.     } while (v == sofdec[i] && i++ < 6);

  132. 

  133.     m->sofdec = (m->sofdec == 6) ? 1 : 0;

  134. 

  135.     if (!m->sofdec)

  136.        avio_seek(s->pb, last_pos, SEEK_SET);

  137. 

  138.     /* no need to do more */

  139.     return 0;

  140. }

  141. 

  142. static int64_t get_pts(AVIOContext *pb, int c)

  143. {

  144.     uint8_t buf[5];

  145. 

  146.     buf[0] = c<0 ? avio_r8(pb) : c;

  147.     avio_read(pb, buf+1, 4);

  148. 

  149.     return ff_parse_pes_pts(buf);

  150. }

  151. 

  152. static int find_next_start_code(AVIOContext *pb, int *size_ptr,

  153.                                 int32_t *header_state)

  154. {

  155.     unsigned int state, v;

  156.     int val, n;

  157. 

  158.     state = *header_state;

  159.     n = *size_ptr;

  160.     while (n > 0) {

  161.         if (url_feof(pb))

  162.             break;

  163.         v = avio_r8(pb);

  164.         n--;

  165.         if (state == 0x000001) {

  166.             state = ((state << 8) | v) & 0xffffff;

  167.             val = state;

  168.             goto found;

  169.         }

  170.         state = ((state << 8) | v) & 0xffffff;

  171.     }

  172.     val = -1;

  173.  found:

  174.     *header_state = state;

  175.     *size_ptr = n;

  176.     return val;

  177. }

  178. 

  179. /**

  180.  * Extract stream types from a program stream map

  181.  * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35

  182.  *

  183.  * @return number of bytes occupied by PSM in the bitstream

  184.  */

  185. static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb)

  186. {

  187.     int psm_length, ps_info_length, es_map_length;

  188. 

  189.     psm_length = avio_rb16(pb);

  190.     avio_r8(pb);

  191.     avio_r8(pb);

  192.     ps_info_length = avio_rb16(pb);

  193. 

  194.     /* skip program_stream_info */

  195.     avio_skip(pb, ps_info_length);

  196.     es_map_length = avio_rb16(pb);

  197. 

  198.     /* at least one es available? */

  199.     while (es_map_length >= 4){

  200.         unsigned char type      = avio_r8(pb);

  201.         unsigned char es_id     = avio_r8(pb);

  202.         uint16_t es_info_length = avio_rb16(pb);

  203.         /* remember mapping from stream id to stream type */

  204.         m->psm_es_type[es_id] = type;

  205.         /* skip program_stream_info */

  206.         avio_skip(pb, es_info_length);

  207.         es_map_length -= 4 + es_info_length;

  208.     }

  209.     avio_rb32(pb); /* crc32 */

  210.     return 2 + psm_length;

  211. }

  212. 

  213. /* read the next PES header. Return its position in ppos

  214.    (if not NULL), and its start code, pts and dts.

  215.  */

  216. static int mpegps_read_pes_header(AVFormatContext *s,

  217.                                   int64_t *ppos, int *pstart_code,

  218.                                   int64_t *ppts, int64_t *pdts)

  219. {

  220.     MpegDemuxContext *m = s->priv_data;

  221.     int len, size, startcode, c, flags, header_len;

  222.     int pes_ext, ext2_len, id_ext, skip;

  223.     int64_t pts, dts;

  224.     int64_t last_sync= avio_tell(s->pb);

  225. 

  226.  error_redo:

  227.         avio_seek(s->pb, last_sync, SEEK_SET);

  228.  redo:

  229.         /* next start code (should be immediately after) */

  230.         m->header_state = 0xff;

  231.         size = MAX_SYNC_SIZE;

  232.         startcode = find_next_start_code(s->pb, &size, &m->header_state);

  233.         last_sync = avio_tell(s->pb);

  234.     if (startcode < 0){

  235.         if(url_feof(s->pb))

  236.             return AVERROR_EOF;

  237.         //FIXME we should remember header_state

  238.         return AVERROR(EAGAIN);

  239.     }

  240. 

  241.     if (startcode == PACK_START_CODE)

  242.         goto redo;

  243.     if (startcode == SYSTEM_HEADER_START_CODE)

  244.         goto redo;

  245.     if (startcode == PADDING_STREAM) {

  246.         avio_skip(s->pb, avio_rb16(s->pb));

  247.         goto redo;

  248.     }

  249.     if (startcode == PRIVATE_STREAM_2) {

  250.         len = avio_rb16(s->pb);

  251.         if (!m->sofdec) {

  252.             while (len-- >= 6) {

  253.                 if (avio_r8(s->pb) == 'S') {

  254.                     uint8_t buf[5];

  255.                     avio_read(s->pb, buf, sizeof(buf));

  256.                     m->sofdec = !memcmp(buf, "ofdec", 5);

  257.                     len -= sizeof(buf);

  258.                     break;

  259.                 }

  260.             }

  261.             m->sofdec -= !m->sofdec;

  262.         }

  263.         avio_skip(s->pb, len);

  264.         goto redo;

  265.     }

  266.     if (startcode == PROGRAM_STREAM_MAP) {

  267.         mpegps_psm_parse(m, s->pb);

  268.         goto redo;

  269.     }

  270. 

  271.     /* find matching stream */

  272.     if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||

  273.           (startcode >= 0x1e0 && startcode <= 0x1ef) ||

  274.           (startcode == 0x1bd) || (startcode == 0x1fd)))

  275.         goto redo;

  276.     if (ppos) {

  277.         *ppos = avio_tell(s->pb) - 4;

  278.     }

  279.     len = avio_rb16(s->pb);

  280.     pts =

  281.     dts = AV_NOPTS_VALUE;

  282.     /* stuffing */

  283.     for(;;) {

  284.         if (len < 1)

  285.             goto error_redo;

  286.         c = avio_r8(s->pb);

  287.         len--;

  288.         /* XXX: for mpeg1, should test only bit 7 */

  289.         if (c != 0xff)

  290.             break;

  291.     }

  292.     if ((c & 0xc0) == 0x40) {

  293.         /* buffer scale & size */

  294.         avio_r8(s->pb);

  295.         c = avio_r8(s->pb);

  296.         len -= 2;

  297.     }

  298.     if ((c & 0xe0) == 0x20) {

  299.         dts = pts = get_pts(s->pb, c);

  300.         len -= 4;

  301.         if (c & 0x10){

  302.             dts = get_pts(s->pb, -1);

  303.             len -= 5;

  304.         }

  305.     } else if ((c & 0xc0) == 0x80) {

  306.         /* mpeg 2 PES */

  307.         flags = avio_r8(s->pb);

  308.         header_len = avio_r8(s->pb);

  309.         len -= 2;

  310.         if (header_len > len)

  311.             goto error_redo;

  312.         len -= header_len;

  313.         if (flags & 0x80) {

  314.             dts = pts = get_pts(s->pb, -1);

  315.             header_len -= 5;

  316.             if (flags & 0x40) {

  317.                 dts = get_pts(s->pb, -1);

  318.                 header_len -= 5;

  319.             }

  320.         }

  321.         if (flags & 0x3f && header_len == 0){

  322.             flags &= 0xC0;

  323.             av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");

  324.         }

  325.         if (flags & 0x01) { /* PES extension */

  326.             pes_ext = avio_r8(s->pb);

  327.             header_len--;

  328.             /* Skip PES private data, program packet sequence counter and P-STD buffer */

  329.             skip = (pes_ext >> 4) & 0xb;

  330.             skip += skip & 0x9;

  331.             if (pes_ext & 0x40 || skip > header_len){

  332.                 av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext);

  333.                 pes_ext=skip=0;

  334.             }

  335.             avio_skip(s->pb, skip);

  336.             header_len -= skip;

  337. 

  338.             if (pes_ext & 0x01) { /* PES extension 2 */

  339.                 ext2_len = avio_r8(s->pb);

  340.                 header_len--;

  341.                 if ((ext2_len & 0x7f) > 0) {

  342.                     id_ext = avio_r8(s->pb);

  343.                     if ((id_ext & 0x80) == 0)

  344.                         startcode = ((startcode & 0xff) << 8) | id_ext;

  345.                     header_len--;

  346.                 }

  347.             }

  348.         }

  349.         if(header_len < 0)

  350.             goto error_redo;

  351.         avio_skip(s->pb, header_len);

  352.     }

  353.     else if( c!= 0xf )

  354.         goto redo;

  355. 

  356.     if (startcode == PRIVATE_STREAM_1) {

  357.         startcode = avio_r8(s->pb);

  358.         len--;

  359.     }

  360.     if(len<0)

  361.         goto error_redo;

  362.     if(dts != AV_NOPTS_VALUE && ppos){

  363.         int i;

  364.         for(i=0; i<s->nb_streams; i++){

  365.             if(startcode == s->streams[i]->id &&

  366.                s->pb->seekable /* index useless on streams anyway */) {

  367.                 ff_reduce_index(s, i);

  368.                 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0, AVINDEX_KEYFRAME /* FIXME keyframe? */);

  369.             }

  370.         }

  371.     }

  372. 

  373.     *pstart_code = startcode;

  374.     *ppts = pts;

  375.     *pdts = dts;

  376.     return len;

  377. }

  378. 

  379. static int mpegps_read_packet(AVFormatContext *s,

  380.                               AVPacket *pkt)

  381. {

  382.     MpegDemuxContext *m = s->priv_data;

  383.     AVStream *st;

  384.     int len, startcode, i, es_type, ret;

  385.     int lpcm_header_len = -1; //Init to supress warning

  386.     int request_probe= 0;

  387.     enum AVCodecID codec_id = AV_CODEC_ID_NONE;

  388.     enum AVMediaType type;

  389.     int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work

  390. 

  391.  redo:

  392.     len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);

  393.     if (len < 0)

  394.         return len;

  395. 

  396.     if (startcode >= 0x80 && startcode <= 0xcf) {

  397.         if(len < 4)

  398.             goto skip;

  399. 

  400.         /* audio: skip header */

  401.         avio_r8(s->pb);

  402.         lpcm_header_len = avio_rb16(s->pb);

  403.         len -= 3;

  404.         if (startcode >= 0xb0 && startcode <= 0xbf) {

  405.             /* MLP/TrueHD audio has a 4-byte header */

  406.             avio_r8(s->pb);

  407.             len--;

  408.         }

  409.     }

  410. 

  411.     /* now find stream */

  412.     for(i=0;i<s->nb_streams;i++) {

  413.         st = s->streams[i];

  414.         if (st->id == startcode)

  415.             goto found;

  416.     }

  417. 

  418.     es_type = m->psm_es_type[startcode & 0xff];

  419.         if(es_type == STREAM_TYPE_VIDEO_MPEG1){

  420.             codec_id = AV_CODEC_ID_MPEG2VIDEO;

  421.             type = AVMEDIA_TYPE_VIDEO;

  422.         } else if(es_type == STREAM_TYPE_VIDEO_MPEG2){

  423.             codec_id = AV_CODEC_ID_MPEG2VIDEO;

  424.             type = AVMEDIA_TYPE_VIDEO;

  425.         } else if(es_type == STREAM_TYPE_AUDIO_MPEG1 ||

  426.                   es_type == STREAM_TYPE_AUDIO_MPEG2){

  427.             codec_id = AV_CODEC_ID_MP3;

  428.             type = AVMEDIA_TYPE_AUDIO;

  429.         } else if(es_type == STREAM_TYPE_AUDIO_AAC){

  430.             codec_id = AV_CODEC_ID_AAC;

  431.             type = AVMEDIA_TYPE_AUDIO;

  432.         } else if(es_type == STREAM_TYPE_VIDEO_MPEG4){

  433.             codec_id = AV_CODEC_ID_MPEG4;

  434.             type = AVMEDIA_TYPE_VIDEO;

  435.         } else if(es_type == STREAM_TYPE_VIDEO_H264){

  436.             codec_id = AV_CODEC_ID_H264;

  437.             type = AVMEDIA_TYPE_VIDEO;

  438.         } else if(es_type == STREAM_TYPE_AUDIO_AC3){

  439.             codec_id = AV_CODEC_ID_AC3;

  440.             type = AVMEDIA_TYPE_AUDIO;

  441.     } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {

  442.         static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };

  443.         unsigned char buf[8];

  444.         avio_read(s->pb, buf, 8);

  445.         avio_seek(s->pb, -8, SEEK_CUR);

  446.         if(!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))

  447.             codec_id = AV_CODEC_ID_CAVS;

  448.         else

  449.             request_probe= 1;

  450.         type = AVMEDIA_TYPE_VIDEO;

  451.     } else if (startcode >= 0x1c0 && startcode <= 0x1df) {

  452.         type = AVMEDIA_TYPE_AUDIO;

  453.         codec_id = m->sofdec > 0 ? AV_CODEC_ID_ADPCM_ADX : AV_CODEC_ID_MP2;

  454.     } else if (startcode >= 0x80 && startcode <= 0x87) {

  455.         type = AVMEDIA_TYPE_AUDIO;

  456.         codec_id = AV_CODEC_ID_AC3;

  457.     } else if (  ( startcode >= 0x88 && startcode <= 0x8f)

  458.                ||( startcode >= 0x98 && startcode <= 0x9f)) {

  459.         /* 0x90 - 0x97 is reserved for SDDS in DVD specs */

  460.         type = AVMEDIA_TYPE_AUDIO;

  461.         codec_id = AV_CODEC_ID_DTS;

  462.     } else if (startcode >= 0xa0 && startcode <= 0xaf) {

  463.         type = AVMEDIA_TYPE_AUDIO;

  464.         if(lpcm_header_len == 6) {

  465.             codec_id = AV_CODEC_ID_MLP;

  466.         } else {

  467.             /* 16 bit form will be handled as AV_CODEC_ID_PCM_S16BE */

  468.             codec_id = AV_CODEC_ID_PCM_DVD;

  469.         }

  470.     } else if (startcode >= 0xb0 && startcode <= 0xbf) {

  471.         type = AVMEDIA_TYPE_AUDIO;

  472.         codec_id = AV_CODEC_ID_TRUEHD;

  473.     } else if (startcode >= 0xc0 && startcode <= 0xcf) {

  474.         /* Used for both AC-3 and E-AC-3 in EVOB files */

  475.         type = AVMEDIA_TYPE_AUDIO;

  476.         codec_id = AV_CODEC_ID_AC3;

  477.     } else if (startcode >= 0x20 && startcode <= 0x3f) {

  478.         type = AVMEDIA_TYPE_SUBTITLE;

  479.         codec_id = AV_CODEC_ID_DVD_SUBTITLE;

  480.     } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {

  481.         type = AVMEDIA_TYPE_VIDEO;

  482.         codec_id = AV_CODEC_ID_VC1;

  483.     } else {

  484.     skip:

  485.         /* skip packet */

  486.         avio_skip(s->pb, len);

  487.         goto redo;

  488.     }

  489.     /* no stream found: add a new stream */

  490.     st = avformat_new_stream(s, NULL);

  491.     if (!st)

  492.         goto skip;

  493.     st->id = startcode;

  494.     st->codec->codec_type = type;

  495.     st->codec->codec_id = codec_id;

  496.     st->request_probe     = request_probe;

  497.     if (codec_id != AV_CODEC_ID_PCM_S16BE)

  498.         st->need_parsing = AVSTREAM_PARSE_FULL;

  499.  found:

  500.     if(st->discard >= AVDISCARD_ALL)

  501.         goto skip;

  502.     if (startcode >= 0xa0 && startcode <= 0xaf) {

  503.       if (lpcm_header_len == 6 && st->codec->codec_id == AV_CODEC_ID_MLP) {

  504.             if (len < 6)

  505.                 goto skip;

  506.             avio_skip(s->pb, 6);

  507.             len -=6;

  508.       } else {

  509.         int b1, freq;

  510. 

  511.         /* for LPCM, we just skip the header and consider it is raw

  512.            audio data */

  513.         if (len <= 3)

  514.             goto skip;

  515.         avio_r8(s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */

  516.         b1 = avio_r8(s->pb); /* quant (2), freq(2), reserved(1), channels(3) */

  517.         avio_r8(s->pb); /* dynamic range control (0x80 = off) */

  518.         len -= 3;

  519.         freq = (b1 >> 4) & 3;

  520.         st->codec->sample_rate = lpcm_freq_tab[freq];

  521.         st->codec->channels = 1 + (b1 & 7);

  522.         st->codec->bits_per_coded_sample = 16 + ((b1 >> 6) & 3) * 4;

  523.         st->codec->bit_rate = st->codec->channels *

  524.                               st->codec->sample_rate *

  525.                               st->codec->bits_per_coded_sample;

  526.         if (st->codec->bits_per_coded_sample == 16)

  527.             st->codec->codec_id = AV_CODEC_ID_PCM_S16BE;

  528.         else if (st->codec->bits_per_coded_sample == 28)

  529.             return AVERROR(EINVAL);

  530.       }

  531.     }

  532.     ret = av_get_packet(s->pb, pkt, len);

  533.     pkt->pts = pts;

  534.     pkt->dts = dts;

  535.     pkt->pos = dummy_pos;

  536.     pkt->stream_index = st->index;

  537.     av_dlog(s, "%d: pts=%0.3f dts=%0.3f size=%d\n",

  538.             pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,

  539.             pkt->size);

  540. 

  541.     return (ret < 0) ? ret : 0;

  542. }

  543. 

  544. static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,

  545.                                int64_t *ppos, int64_t pos_limit)

  546. {

  547.     int len, startcode;

  548.     int64_t pos, pts, dts;

  549. 

  550.     pos = *ppos;

  551.     if (avio_seek(s->pb, pos, SEEK_SET) < 0)

  552.         return AV_NOPTS_VALUE;

  553. 

  554.     for(;;) {

  555.         len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);

  556.         if (len < 0) {

  557.             av_dlog(s, "none (ret=%d)\n", len);

  558.             return AV_NOPTS_VALUE;

  559.         }

  560.         if (startcode == s->streams[stream_index]->id &&

  561.             dts != AV_NOPTS_VALUE) {

  562.             break;

  563.         }

  564.         avio_skip(s->pb, len);

  565.     }

  566.     av_dlog(s, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",

  567.             pos, dts, dts / 90000.0);

  568.     *ppos = pos;

  569.     return dts;

  570. }

  571. 

  572. AVInputFormat ff_mpegps_demuxer = {

  573.     .name           = "mpeg",

  574.     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),

  575.     .priv_data_size = sizeof(MpegDemuxContext),

  576.     .read_probe     = mpegps_probe,

  577.     .read_header    = mpegps_read_header,

  578.     .read_packet    = mpegps_read_packet,

  579.     .read_timestamp = mpegps_read_dts,

  580.     .flags          = AVFMT_SHOW_IDS | AVFMT_TS_DISCONT,

  581. };

  582. 

  583. #if CONFIG_VOBSUB_DEMUXER

  584. 

  585. #define REF_STRING "# VobSub index file,"

  586. 

  587. static int vobsub_probe(AVProbeData *p)

  588. {

  589.     if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))

  590.         return AVPROBE_SCORE_MAX;

  591.     return 0;

  592. }

  593. 

  594. static int vobsub_read_header(AVFormatContext *s)

  595. {

  596.     int i, ret = 0, header_parsed = 0, langidx = 0;

  597.     MpegDemuxContext *vobsub = s->priv_data;

  598.     char *sub_name = NULL;

  599.     size_t fname_len;

  600.     char *ext, *header_str;

  601.     AVBPrint header;

  602.     int64_t delay = 0;

  603.     AVStream *st = NULL;

  604. 

  605.     sub_name = av_strdup(s->filename);

  606.     fname_len = strlen(sub_name);

  607.     ext = sub_name - 3 + fname_len;

  608.     if (fname_len < 4 || *(ext - 1) != '.') {

  609.         av_log(s, AV_LOG_ERROR, "The input index filename is too short "

  610.                "to guess the associated .SUB file\n");

  611.         ret = AVERROR_INVALIDDATA;

  612.         goto end;

  613.     }

  614.     memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3);

  615.     av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->filename, sub_name);

  616.     ret = avformat_open_input(&vobsub->sub_ctx, sub_name, &ff_mpegps_demuxer, NULL);

  617.     if (ret < 0) {

  618.         av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", sub_name);

  619.         goto end;

  620.     }

  621. 

  622.     av_bprint_init(&header, 0, AV_BPRINT_SIZE_UNLIMITED);

  623.     while (!url_feof(s->pb)) {

  624.         char line[2048];

  625.         int len = ff_get_line(s->pb, line, sizeof(line));

  626. 

  627.         if (!len)

  628.             break;

  629. 

  630.         line[strcspn(line, "\r\n")] = 0;

  631. 

  632.         if (!strncmp(line, "id:", 3)) {

  633.             int n, stream_id = 0;

  634.             char id[64] = {0};

  635. 

  636.             n = sscanf(line, "id: %63[^,], index: %u", id, &stream_id);

  637.             if (n != 2) {

  638.                 av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', "

  639.                        "assuming 'id: und, index: 0'\n", line);

  640.                 strcpy(id, "und");

  641.                 stream_id = 0;

  642.             }

  643. 

  644.             st = avformat_new_stream(s, NULL);

  645.             if (!st) {

  646.                 ret = AVERROR(ENOMEM);

  647.                 goto end;

  648.             }

  649.             st->id = stream_id;

  650.             st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;

  651.             st->codec->codec_id   = AV_CODEC_ID_DVD_SUBTITLE;

  652.             av_dict_set(&st->metadata, "language", id, 0);

  653.             av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);

  654.             header_parsed = 1;

  655. 

  656.         } else if (st && !strncmp(line, "timestamp:", 10)) {

  657.             AVPacket *sub;

  658.             int hh, mm, ss, ms;

  659.             int64_t pos, timestamp;

  660.             const char *p = line + 10;

  661. 

  662.             if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"PRIx64,

  663.                        &hh, &mm, &ss, &ms, &pos) != 5) {

  664.                 av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "

  665.                        "abort parsing\n", line);

  666.                 break;

  667.             }

  668.             timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay;

  669.             timestamp = av_rescale_q(timestamp, (AVRational){1,1000}, st->time_base);

  670. 

  671.             sub = ff_subtitles_queue_insert(&vobsub->q, "", 0, 0);

  672.             if (!sub) {

  673.                 ret = AVERROR(ENOMEM);

  674.                 goto end;

  675.             }

  676.             sub->pos = pos;

  677.             sub->pts = timestamp;

  678.             sub->stream_index = s->nb_streams - 1;

  679. 

  680.         } else if (st && !strncmp(line, "alt:", 4)) {

  681.             const char *p = line + 4;

  682. 

  683.             while (*p == ' ')

  684.                 p++;

  685.             av_dict_set(&st->metadata, "title", p, 0);

  686.             av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", st->id, p);

  687.             header_parsed = 1;

  688. 

  689.         } else if (!strncmp(line, "delay:", 6)) {

  690.             int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0;

  691.             const char *p = line + 6;

  692. 

  693.             while (*p == ' ')

  694.                 p++;

  695.             if (*p == '-' || *p == '+') {

  696.                 sign = *p == '-' ? -1 : 1;

  697.                 p++;

  698.             }

  699.             sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms);

  700.             delay = ((hh*3600LL + mm*60LL + ss) * 1000LL + ms) * sign;

  701. 

  702.         } else if (!strncmp(line, "langidx:", 8)) {

  703.             const char *p = line + 8;

  704. 

  705.             if (sscanf(p, "%d", &langidx) != 1)

  706.                 av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n");

  707. 

  708.         } else if (!header_parsed) {

  709.             if (line[0] && line[0] != '#')

  710.                 av_bprintf(&header, "%s\n", line);

  711.         }

  712.     }

  713. 

  714.     if (langidx < s->nb_streams)

  715.         s->streams[langidx]->disposition |= AV_DISPOSITION_DEFAULT;

  716. 

  717.     ff_subtitles_queue_finalize(&vobsub->q);

  718. 

  719.     if (!av_bprint_is_complete(&header)) {

  720.         av_bprint_finalize(&header, NULL);

  721.         ret = AVERROR(ENOMEM);

  722.         goto end;

  723.     }

  724.     av_bprint_finalize(&header, &header_str);

  725.     for (i = 0; i < s->nb_streams; i++) {

  726.         AVStream *sub_st = s->streams[i];

  727.         sub_st->codec->extradata      = av_strdup(header_str);

  728.         sub_st->codec->extradata_size = header.len;

  729.     }

  730.     av_free(header_str);

  731. 

  732. end:

  733.     av_free(sub_name);

  734.     return ret;

  735. }

  736. 

  737. static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt)

  738. {

  739.     MpegDemuxContext *vobsub = s->priv_data;

  740.     FFDemuxSubtitlesQueue *q = &vobsub->q;

  741.     AVIOContext *pb = vobsub->sub_ctx->pb;

  742.     int ret, psize, len16 = -1;

  743.     AVPacket idx_pkt;

  744. 

  745.     ret = ff_subtitles_queue_read_packet(q, &idx_pkt);

  746.     if (ret < 0)

  747.         return ret;

  748. 

  749.     /* compute maximum packet size using the next packet position. This is

  750.      * useful when the len in the header is non-sense */

  751.     if (q->current_sub_idx < q->nb_subs) {

  752.         psize = q->subs[q->current_sub_idx].pos - idx_pkt.pos;

  753.     } else {

  754.         int64_t fsize = avio_size(pb);

  755.         psize = fsize < 0 ? 0xffff : fsize - idx_pkt.pos;

  756.     }

  757. 

  758.     avio_seek(pb, idx_pkt.pos, SEEK_SET);

  759. 

  760.     av_init_packet(pkt);

  761.     pkt->size = 0;

  762.     pkt->data = NULL;

  763. 

  764.     do {

  765.         int n, to_read, startcode;

  766.         int64_t pts, dts;

  767. 

  768.         ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);

  769.         if (ret < 0)

  770.             return ret;

  771.         to_read = ret & 0xffff;

  772. 

  773.         /* this prevents reads above the current packet */

  774.         if (pkt->size + to_read > psize)

  775.             break;

  776. 

  777.         /* if the len is computed, we check for overread */

  778.         if (len16 != -1 && pkt->size + to_read > len16)

  779.             break;

  780. 

  781.         /* the current chunk doesn't match the stream index (unlikely) */

  782.         if ((startcode & 0x1f) != idx_pkt.stream_index)

  783.             break;

  784. 

  785.         ret = av_grow_packet(pkt, to_read);

  786.         if (ret < 0)

  787.             return ret;

  788. 

  789.         n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);

  790.         if (n < to_read)

  791.             pkt->size -= to_read - n;

  792. 

  793.         /* first chunk contains the total len of the packet to raise */

  794.         if (len16 == -1 && n > 2)

  795.             len16 = AV_RB16(pkt->data);

  796.     } while (len16 != -1 && pkt->size != len16);

  797. 

  798.     pkt->pts = pkt->dts = idx_pkt.pts;

  799.     pkt->pos = idx_pkt.pos;

  800.     pkt->stream_index = idx_pkt.stream_index;

  801. 

  802.     return 0;

  803. }

  804. 

  805. static int vobsub_read_seek(AVFormatContext *s, int stream_index,

  806.                             int64_t min_ts, int64_t ts, int64_t max_ts, int flags)

  807. {

  808.     MpegDemuxContext *vobsub = s->priv_data;

  809.     return ff_subtitles_queue_seek(&vobsub->q, s, stream_index,

  810.                                    min_ts, ts, max_ts, flags);

  811. }

  812. 

  813. static int vobsub_read_close(AVFormatContext *s)

  814. {

  815.     MpegDemuxContext *vobsub = s->priv_data;

  816.     ff_subtitles_queue_clean(&vobsub->q);

  817.     if (vobsub->sub_ctx)

  818.         avformat_close_input(&vobsub->sub_ctx);

  819.     return 0;

  820. }

  821. 

  822. AVInputFormat ff_vobsub_demuxer = {

  823.     .name           = "vobsub",

  824.     .long_name      = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),

  825.     .priv_data_size = sizeof(MpegDemuxContext),

  826.     .read_probe     = vobsub_probe,

  827.     .read_header    = vobsub_read_header,

  828.     .read_packet    = vobsub_read_packet,

  829.     .read_seek2     = vobsub_read_seek,

  830.     .read_close     = vobsub_read_close,

  831.     .flags          = AVFMT_SHOW_IDS,

  832.     .extensions     = "idx",

  833. };

  834. #endif