X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fstream.c;h=24093e62a74d7bd072e99782454323683c70b007;hb=4f0019f03c2e85e8634150ff0c9a31bee6d35ce5;hp=d1244f5ee3f4ae44ed6fcb50c621f9a3bba56fd8;hpb=30a49a00399e8564eaff214115e2de6ede2306f8;p=handbrake-jp%2Fhandbrake-jp-git.git

diff --git a/libhb/stream.c b/libhb/stream.c
index d1244f5e..24093e62 100644
--- a/libhb/stream.c
+++ b/libhb/stream.c
@@ -15,6 +15,11 @@
 #include "mp4v2/mp4v2.h"
 
 #define min(a, b) a < b ? a : b
+#define STR4_TO_UINT32(p) \
+    ((((const uint8_t*)(p))[0] << 24) | \
+     (((const uint8_t*)(p))[1] << 16) | \
+     (((const uint8_t*)(p))[2] <<  8) | \
+      ((const uint8_t*)(p))[3])
 
 /*
  * This table defines how ISO MPEG stream type codes map to HandBrake
@@ -25,8 +30,9 @@
  * Entries with a worker proc id of 0 or a kind of 'U' indicate that HB
  * doesn't handle the stream type.
  */
+typedef enum { N, U, A, V } kind_t;
 typedef struct {
-    enum { N, U, A, V } kind; /* not handled / unknown / audio / video */
+    kind_t kind; /* not handled / unknown / audio / video */
     int codec;          /* HB worker object id of codec */
     int codec_param;    /* param for codec (usually ffmpeg codec id) */
     const char* name;   /* description of type */
@@ -59,7 +65,7 @@ static const stream2codec_t st2codec[256] = {
 
     st(0x1b, V, WORK_DECAVCODECV,  CODEC_ID_H264,  "H.264"),
 
-    st(0x80, N, 0,                 0,              "DigiCipher II Video"),
+    st(0x80, N, HB_ACODEC_MPGA,    CODEC_ID_PCM_BLURAY, "DigiCipher II Video"),
     st(0x81, A, HB_ACODEC_AC3,     0,              "AC-3"),
     st(0x82, A, HB_ACODEC_DCA,     0,              "HDMV DTS"),
     st(0x83, A, HB_ACODEC_LPCM,    0,              "LPCM"),
@@ -177,8 +183,8 @@ struct hb_stream_s
         int section_length;
         int program_number;
         unsigned int PCR_PID;
+        uint32_t reg_desc;
         int program_info_length;
-        unsigned char *progam_info_descriptor_data;
         struct
         {
             unsigned char stream_type;
@@ -207,6 +213,7 @@ static void ffmpeg_close( hb_stream_t *d );
 static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream );
 static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf );
 static int ffmpeg_seek( hb_stream_t *stream, float frac );
+static int ffmpeg_seek_ts( hb_stream_t *stream, int64_t ts );
 
 /*
  * streams have a bunch of state that's learned during the scan. We don't
@@ -353,9 +360,16 @@ static int hb_stream_check_for_ts(const uint8_t *buf)
 
 static int hb_stream_check_for_ps(const uint8_t *buf)
 {
-    // program streams should start with a PACK then some other mpeg start
-    // code (usually a SYS but that might be missing if we only have a clip).
-    return check_ps_sync(buf) && check_ps_sc(buf);
+    // program streams should start with a PACK then some other mpeg start 
+    // code (usually a SYS but that might be missing if we only have a clip). 
+    int offset = 0;
+
+    for ( offset = 0; offset < 8*1024-24; ++offset )
+    {
+        if ( check_ps_sync( &buf[offset] ) && check_ps_sc( &buf[offset] ) )
+            return 1;
+    }
+    return 0;
 }
 
 static int hb_stream_check_for_dvd_ps(const uint8_t *buf)
@@ -369,6 +383,7 @@ static int hb_stream_check_for_dvd_ps(const uint8_t *buf)
 static int hb_stream_get_type(hb_stream_t *stream)
 {
     uint8_t buf[2048*4];
+    int i = 64;
 
     if ( fread(buf, 1, sizeof(buf), stream->file_handle) == sizeof(buf) )
     {
@@ -394,12 +409,17 @@ static int hb_stream_get_type(hb_stream_t *stream)
             stream->hb_stream_type = dvd_program;
             return 1;
         }
-        if ( hb_stream_check_for_ps(buf) != 0 )
+        do
         {
-            hb_log("file is MPEG Program Stream");
-            stream->hb_stream_type = program;
-            return 1;
-        }
+            if ( hb_stream_check_for_ps(buf) != 0 )
+            {
+                hb_log("file is MPEG Program Stream");
+                stream->hb_stream_type = program;
+                return 1;
+            }
+            // Seek back to handle start codes that run over end of last buffer
+            fseek( stream->file_handle, -28, SEEK_CUR );
+        } while ( --i && fread(buf, 1, sizeof(buf), stream->file_handle) == sizeof(buf) );
     }
     return 0;
 }
@@ -1191,6 +1211,37 @@ int hb_stream_read( hb_stream_t * src_stream, hb_buffer_t * b )
                 ep = b->data + b->alloc;
             }
             *cp++ = c;
+            // Non-video streams can emulate start codes, so we need
+            // to inspect PES packets and skip over their data
+            // sections to avoid mis-detection of the next pack header.
+            if ( ( strt_code >> 8 ) == 0x000001 &&
+                 ( strt_code & 0xff ) >= 0xbb )
+            {
+                int len = 0;
+                c = getc_unlocked( src_stream->file_handle );
+                if ( c == EOF )
+                    break;
+                len = c << 8;
+                c = getc_unlocked( src_stream->file_handle );
+                if ( c == EOF )
+                    break;
+                len |= c;
+                if ( cp+len+2 > ep )
+                {
+                    // need to expand the buffer
+                    int curSize = cp - b->data;
+                    if ( curSize * 2 > curSize+len+2 )
+                        hb_buffer_realloc( b, curSize * 2 );
+                    else
+                        hb_buffer_realloc( b, curSize + len + 2 );
+                    cp = b->data + curSize;
+                    ep = b->data + b->alloc;
+                }
+                *cp++ = len >> 8;
+                *cp++ = len & 0xff;
+                fread( cp, 1, len, src_stream->file_handle );
+                cp += len;
+            }
         }
         funlockfile( src_stream->file_handle );
 
@@ -1200,13 +1251,22 @@ int hb_stream_read( hb_stream_t * src_stream, hb_buffer_t * b )
         if ( c != EOF )
         {
             fseeko( src_stream->file_handle, -4, SEEK_CUR );
-            b->size -= 4;
+            // Only 3 of the 4 bytes read were added to the buffer.
+            b->size -= 3;
         }
         return 1;
     }
     return hb_ts_stream_decode( src_stream, b );
 }
 
+int64_t ffmpeg_initial_timestamp( hb_stream_t * stream )
+{
+    AVStream *s = stream->ffmpeg_ic->streams[stream->ffmpeg_video_id];
+    if ( s->nb_index_entries < 1 )
+        return 0;
+
+    return s->index_entries[0].timestamp;
+}
 int hb_stream_seek_chapter( hb_stream_t * stream, int chapter_num )
 {
 
@@ -1232,7 +1292,7 @@ int hb_stream_seek_chapter( hb_stream_t * stream, int chapter_num )
     stream->chapter = chapter_num - 1;
     stream->chapter_end = sum_dur;
 
-    int64_t pos = ( ( ( sum_dur - chapter->duration ) * AV_TIME_BASE ) / 90000 );
+    int64_t pos = ( ( ( sum_dur - chapter->duration ) * AV_TIME_BASE ) / 90000 ) + ffmpeg_initial_timestamp( stream );
 
     hb_deep_log( 2, "Seeking to chapter %d: starts %"PRId64", ends %"PRId64", AV pos %"PRId64,
                  chapter_num, sum_dur - chapter->duration, sum_dur, pos);
@@ -1241,6 +1301,17 @@ int hb_stream_seek_chapter( hb_stream_t * stream, int chapter_num )
     {
         av_seek_frame( stream->ffmpeg_ic, -1, pos, 0);
     }
+    else
+    {
+        // ffmpeg has a bug that causes the first PTS after
+        // av_find_stream_info() is called to be incorrect.
+        // av_find_stream_info is called whenever opening a file
+        // with ffmpeg.  av_seek_frame clears the condition
+        // that causes the problem. since hb_stream_seek_chapter
+        // is called before we start reading, make sure
+        // we do a seek here.
+        av_seek_frame( stream->ffmpeg_ic, -1, ffmpeg_initial_timestamp( stream ), AVSEEK_FLAG_BACKWARD );
+    }
     return 1;
 }
 
@@ -1309,6 +1380,15 @@ int hb_stream_seek( hb_stream_t * stream, float f )
     return 1;
 }
 
+int hb_stream_seek_ts( hb_stream_t * stream, int64_t ts )
+{
+	if ( stream->hb_stream_type == ffmpeg )
+    {
+        return ffmpeg_seek_ts( stream, ts );
+    }
+    return -1;
+}
+
 static const char* make_upper( const char* s )
 {
     static char name[8];
@@ -1363,6 +1443,18 @@ static void set_audio_description( hb_audio_t *audio, iso639_lang_t *lang )
               sizeof( audio->config.lang.description ), "%s (%s)",
               strlen(lang->native_name) ? lang->native_name : lang->eng_name,
               codec_name );
+
+    if (audio->config.in.codec == HB_ACODEC_FFMPEG)
+    {
+        int layout = audio->config.in.channel_layout;
+        char *desc = audio->config.lang.description +
+                        strlen( audio->config.lang.description );
+        sprintf( desc, " (%d.%d ch)",
+                 HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(layout) +
+                     HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(layout),
+                 HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(layout) );
+    }
+
     snprintf( audio->config.lang.simple, sizeof( audio->config.lang.simple ), "%s",
               strlen(lang->native_name) ? lang->native_name : lang->eng_name );
     snprintf( audio->config.lang.iso639_2, sizeof( audio->config.lang.iso639_2 ),
@@ -1382,9 +1474,12 @@ static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream,
 
     /* check that we found a PES header */
     uint8_t stype = 0;
+    kind_t kind;
+
     if (buf && buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0x01)
     {
         stype = stream->ts_stream_type[1 + aud_pid_index];
+        kind = st2codec[stype].kind;
 
         // 0xbd ("private stream 1") is the normal container for non-ISO
         // media - AC3/DCA/PCM/etc.
@@ -1397,6 +1492,15 @@ static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream,
                 // some other type of audio we'll end up ignoring them).
                 stype = 0x81;
                 stream->ts_stream_type[1 + aud_pid_index] = 0x81;
+                kind = st2codec[stype].kind;
+            }
+            if ( stype == 0x80 && 
+                 stream->pmt_info.reg_desc == STR4_TO_UINT32("HDMV") )
+            {
+                // LPCM audio in bluray have an stype of 0x80
+                // 0x80 is used for other DigiCipher normally
+                // To distinguish, Bluray streams have a reg_desc of HDMV
+                kind = A;
             }
         }
         else if ( buf[3] == 0xfd )
@@ -1416,6 +1520,7 @@ static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream,
                 stream->ts_multiplexed[1 + aud_pid_index] = 0x76;
                 stype = 0x81;
                 stream->ts_stream_type[1 + aud_pid_index] = 0x81;
+                kind = st2codec[stype].kind;
             }
             if ( st2codec[stype].kind == A && stype == 0x86 )
             {
@@ -1424,6 +1529,7 @@ static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream,
                 stream->ts_multiplexed[1 + aud_pid_index] = 0x71;
                 stype = 0x82;
                 stream->ts_stream_type[1 + aud_pid_index] = 0x82;
+                kind = st2codec[stype].kind;
             }
         }
         else if ((buf[3] & 0xe0) == 0xc0)
@@ -1435,21 +1541,23 @@ static hb_audio_t *hb_ts_stream_set_audio_id_and_codec(hb_stream_t *stream,
                 // XXX assume unknown stream types are MPEG audio
                 stype = 0x03;
                 stream->ts_stream_type[1 + aud_pid_index] = 0x03;
+                kind = st2codec[stype].kind;
             }
         }
         else
         {
             stype = 0;
+            kind = st2codec[stype].kind;
         }
     }
     // if we found an audio stream type & HB has a codec that can decode it
     // finish configuring the audio so we'll add it to the title's list.
-    if ( st2codec[stype].kind == A && st2codec[stype].codec )
+    if ( kind == A && st2codec[stype].codec )
     {
         audio->id = 1 + aud_pid_index;
         audio->config.in.codec = st2codec[stype].codec;
         audio->config.in.codec_param = st2codec[stype].codec_param;
-		set_audio_description( audio,
+        set_audio_description( audio,
                   lang_for_code( stream->a52_info[aud_pid_index].lang_code ) );
         hb_log("transport stream pid 0x%x (type 0x%x) may be %s audio (id 0x%x)",
                stream->ts_audio_pids[aud_pid_index],
@@ -1593,35 +1701,45 @@ static void hb_ts_stream_init(hb_stream_t *stream)
 static off_t align_to_next_packet(hb_stream_t *stream)
 {
     uint8_t buf[MAX_HOLE];
-	off_t pos = 0;
+    off_t pos = 0;
     off_t start = ftello(stream->file_handle);
+    off_t orig;
 
     if ( start >= stream->packetsize ) {
         start -= stream->packetsize;
         fseeko(stream->file_handle, start, SEEK_SET);
     }
+    orig = start;
 
-    if (fread(buf, sizeof(buf), 1, stream->file_handle) == 1)
-	{
-        const uint8_t *bp = buf;
-        int i;
-
-        for ( i = sizeof(buf); --i >= 0; ++bp )
+    while (1)
+    {
+        if (fread(buf, sizeof(buf), 1, stream->file_handle) == 1)
         {
-            if ( have_ts_sync( bp, stream->packetsize ) )
+            const uint8_t *bp = buf;
+            int i;
+
+            for ( i = sizeof(buf) - 8 * stream->packetsize; --i >= 0; ++bp )
+            {
+                if ( have_ts_sync( bp, stream->packetsize ) )
+                {
+                    break;
+                }
+            }
+            if ( i >= 0 )
             {
+                pos = ( bp - buf ) - stream->packetsize + 188;
                 break;
             }
+            fseeko(stream->file_handle, -8 * stream->packetsize, SEEK_CUR);
+            start = ftello(stream->file_handle);
         }
-        if ( i >= 0 )
+        else
         {
-            pos = ( bp - buf ) - stream->packetsize + 188;
-            if ( pos < 0 )
-                pos = 0;
+            return 0;
         }
-	}
+    }
     fseeko(stream->file_handle, start+pos, SEEK_SET);
-	return pos;
+    return start - orig + pos;
 }
 
 
@@ -1723,7 +1841,7 @@ static const char *stream_type_name (uint8_t stream_type)
 int decode_program_map(hb_stream_t* stream)
 {
     bitbuf_t bb;
-	set_buf(&bb, stream->pmt_info.tablebuf, stream->pmt_info.tablepos, 0);
+    set_buf(&bb, stream->pmt_info.tablebuf, stream->pmt_info.tablepos, 0);
 
     get_bits(&bb, 8);  // table_id
     get_bits(&bb, 4);
@@ -1738,22 +1856,44 @@ int decode_program_map(hb_stream_t* stream)
     get_bits(&bb, 8);  // section_number
     get_bits(&bb, 8);  // last_section_number
     get_bits(&bb, 3);
-    unsigned int PCR_PID = get_bits(&bb, 13);
-    stream->pmt_info.PCR_PID = PCR_PID;
+    stream->pmt_info.PCR_PID = get_bits(&bb, 13);
     get_bits(&bb, 4);
-    unsigned int program_info_length = get_bits(&bb, 12);
+    int program_info_length = get_bits(&bb, 12);
     stream->pmt_info.program_info_length = program_info_length;
 
-	int i=0;
-	unsigned char *descriptor_buf = (unsigned char *) malloc(program_info_length);
-	for (i = 0; i < program_info_length; i++)
-	{
-	  descriptor_buf[i] = get_bits(&bb, 8);
-	}
+    int i;
+    for (i = 0; i < program_info_length - 2; )
+    {
+        uint8_t tag, len;
+        tag = get_bits(&bb, 8);
+        len = get_bits(&bb, 8);
+        i += 2;
+        if ( i + len > program_info_length )
+        {
+            break;
+        }
+        if (tag == 0x05 && len >= 4)
+        {
+            // registration descriptor
+            stream->pmt_info.reg_desc = get_bits(&bb, 32);
+            i += 4;
+            len -= 4;
+        }
+        int j;
+        for ( j = 0; j < len; j++ )
+        {
+            get_bits(&bb, 8);
+        }
+        i += len;
+    }
+    for ( ; i < program_info_length; i++ )
+    {
+        get_bits(&bb, 8);
+    }
 
-	int cur_pos =  9 /* data after the section length field*/ + program_info_length;
-	int done_reading_stream_types = 0;
-	while (!done_reading_stream_types)
+    int cur_pos =  9 /* data after the section length field*/ + program_info_length;
+    int done_reading_stream_types = 0;
+    while (!done_reading_stream_types)
     {
         unsigned char stream_type = get_bits(&bb, 8);
         get_bits(&bb, 3);
@@ -1811,8 +1951,7 @@ int decode_program_map(hb_stream_t* stream)
             done_reading_stream_types = 1;
     }
 
-	free(descriptor_buf);
-	return 1;
+    return 1;
 }
 
 static int build_program_map(const uint8_t *buf, hb_stream_t *stream)
@@ -2652,24 +2791,19 @@ static void add_ffmpeg_audio( hb_title_t *title, hb_stream_t *stream, int id )
 {
     AVStream *st = stream->ffmpeg_ic->streams[id];
     AVCodecContext *codec = st->codec;
+    int layout;
 
     // scan will ignore any audio without a bitrate. Since we've already
     // typed the audio in order to determine its codec we set up the audio
     // paramters here.
+    layout = hb_ff_layout_xlat( codec->channel_layout, codec->channels );
+    if ( !layout )
+    {
+        // Unsupported layout
+        return;
+    }
     if ( codec->bit_rate || codec->sample_rate )
     {
-        static const int chan2layout[] = {
-            HB_INPUT_CH_LAYOUT_MONO,  // We should allow no audio really.
-            HB_INPUT_CH_LAYOUT_MONO,   
-            HB_INPUT_CH_LAYOUT_STEREO,
-            HB_INPUT_CH_LAYOUT_2F1R,   
-            HB_INPUT_CH_LAYOUT_2F2R,
-            HB_INPUT_CH_LAYOUT_3F2R,   
-            HB_INPUT_CH_LAYOUT_4F2R,
-            HB_INPUT_CH_LAYOUT_STEREO, 
-            HB_INPUT_CH_LAYOUT_STEREO,
-        };
-
         hb_audio_t *audio = calloc( 1, sizeof(*audio) );;
 
         audio->id = id;
@@ -2688,7 +2822,7 @@ static void add_ffmpeg_audio( hb_title_t *title, hb_stream_t *stream, int id )
 
             audio->config.in.bitrate = codec->bit_rate? codec->bit_rate : 1;
             audio->config.in.samplerate = codec->sample_rate;
-            audio->config.in.channel_layout = chan2layout[codec->channels & 7];
+            audio->config.in.channel_layout = layout;
         }
 
         set_audio_description( audio, lang_for_code2( st->language ) );
@@ -2697,6 +2831,175 @@ static void add_ffmpeg_audio( hb_title_t *title, hb_stream_t *stream, int id )
     }
 }
 
+/*
+ * Format:
+ *   MkvVobSubtitlePrivateData = ( Line )*
+ *   Line = FieldName ':' ' ' FieldValue '\n'
+ *   FieldName = [^:]+
+ *   FieldValue = [^\n]+
+ * 
+ * The line of interest is:
+ *   PaletteLine = "palette" ':' ' ' RRGGBB ( ',' ' ' RRGGBB )*
+ * 
+ * More information on the format at:
+ *   http://www.matroska.org/technical/specs/subtitles/images.html
+ */
+static int ffmpeg_parse_vobsub_extradata_mkv( AVCodecContext *codec, hb_subtitle_t *subtitle )
+{
+    // lines = (string) codec->extradata;
+    char *lines = malloc( codec->extradata_size + 1 );
+    if ( lines == NULL )
+        return 1;
+    memcpy( lines, codec->extradata, codec->extradata_size );
+    lines[codec->extradata_size] = '\0';
+    
+    uint32_t rgb[16];
+    int gotPalette = 0;
+    int gotDimensions = 0;
+    
+    char *curLine, *curLine_parserData;
+    for ( curLine = strtok_r( lines, "\n", &curLine_parserData );
+          curLine;
+          curLine = strtok_r( NULL, "\n", &curLine_parserData ) )
+    {
+        if (!gotPalette)
+        {
+            int numElementsRead = sscanf(curLine, "palette: "
+                "%06x, %06x, %06x, %06x, "
+                "%06x, %06x, %06x, %06x, "
+                "%06x, %06x, %06x, %06x, "
+                "%06x, %06x, %06x, %06x",
+                &rgb[0],  &rgb[1],  &rgb[2],  &rgb[3],
+                &rgb[4],  &rgb[5],  &rgb[6],  &rgb[7],
+                &rgb[8],  &rgb[9],  &rgb[10], &rgb[11],
+                &rgb[12], &rgb[13], &rgb[14], &rgb[15]);
+
+            if (numElementsRead == 16) {
+                gotPalette = 1;
+            }
+        }
+        if (!gotDimensions)
+        {
+            int numElementsRead = sscanf(curLine, "size: %dx%d",
+                &subtitle->width, &subtitle->height);
+
+            if (numElementsRead == 2) {
+                gotDimensions = 1;
+            }
+        }
+        if (gotPalette && gotDimensions)
+            break;
+    }
+
+    if (subtitle->width == 0 || subtitle->height == 0)
+    {
+        subtitle->width = 720;
+        subtitle->height = 480;
+    }
+    
+    free( lines );
+    
+    if ( gotPalette )
+    {
+        int i;
+        for (i=0; i<16; i++)
+            subtitle->palette[i] = hb_rgb2yuv(rgb[i]);
+        return 0;
+    }
+    else
+    {
+        return 1;
+    }
+}
+
+/*
+ * Format: 8-bit {0,Y,Cb,Cr} x 16
+ */
+static int ffmpeg_parse_vobsub_extradata_mp4( AVCodecContext *codec, hb_subtitle_t *subtitle )
+{
+    if ( codec->extradata_size != 4*16 )
+        return 1;
+    
+    int i, j;
+    for ( i=0, j=0; i<16; i++, j+=4 )
+    {
+        subtitle->palette[i] = 
+            codec->extradata[j+1] << 16 |   // Y
+            codec->extradata[j+2] << 8  |   // Cb
+            codec->extradata[j+3] << 0;     // Cr
+    }
+    if (codec->width <= 0 || codec->height <= 0)
+    {
+        subtitle->width = 720;
+        subtitle->height = 480;
+    }
+    else
+    {
+        subtitle->width = codec->width;
+        subtitle->height = codec->height;
+    }
+    return 0;
+}
+
+/*
+ * Parses the 'subtitle->palette' information from the specific VOB subtitle track's private data.
+ * Returns 0 if successful or 1 if parsing failed or was incomplete.
+ */
+static int ffmpeg_parse_vobsub_extradata( AVCodecContext *codec, hb_subtitle_t *subtitle )
+{
+    // XXX: Better if we actually chose the correct parser based on the input container
+    return
+        ffmpeg_parse_vobsub_extradata_mkv( codec, subtitle ) &&
+        ffmpeg_parse_vobsub_extradata_mp4( codec, subtitle );
+}
+
+static void add_ffmpeg_subtitle( hb_title_t *title, hb_stream_t *stream, int id )
+{
+    AVStream *st = stream->ffmpeg_ic->streams[id];
+    AVCodecContext *codec = st->codec;
+    
+    hb_subtitle_t *subtitle = calloc( 1, sizeof(*subtitle) );
+    
+    subtitle->id = id;
+    
+    switch ( codec->codec_id )
+    {
+        case CODEC_ID_DVD_SUBTITLE:
+            subtitle->format = PICTURESUB;
+            subtitle->source = VOBSUB;
+            subtitle->config.dest = RENDERSUB;  // By default render (burn-in) the VOBSUB.
+            if ( ffmpeg_parse_vobsub_extradata( codec, subtitle ) )
+                hb_log( "add_ffmpeg_subtitle: malformed extradata for VOB subtitle track; "
+                        "subtitle colors likely to be wrong" );
+            break;
+        case CODEC_ID_TEXT:
+            subtitle->format = TEXTSUB;
+            subtitle->source = UTF8SUB;
+            subtitle->config.dest = PASSTHRUSUB;
+            break;
+        case CODEC_ID_MOV_TEXT: // TX3G
+            subtitle->format = TEXTSUB;
+            subtitle->source = TX3GSUB;
+            subtitle->config.dest = PASSTHRUSUB;
+            break;
+        case CODEC_ID_SSA:
+            subtitle->format = TEXTSUB;
+            subtitle->source = SSASUB;
+            subtitle->config.dest = PASSTHRUSUB;
+            break;
+        default:
+            hb_log( "add_ffmpeg_subtitle: unknown subtitle stream type: 0x%x", (int) codec->codec_id );
+            free(subtitle);
+            return;
+    }
+    
+    iso639_lang_t *language = lang_for_code2( st->language );
+    strcpy( subtitle->lang, language->eng_name );
+    strncpy( subtitle->iso639_2, language->iso639_2, 4 );
+    
+    hb_list_add(title->list_subtitle, subtitle);
+}
+
 static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream )
 {
     AVFormatContext *ic = stream->ffmpeg_ic;
@@ -2731,6 +3034,13 @@ static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream )
              avcodec_find_decoder( ic->streams[i]->codec->codec_id ) &&
              title->video_codec == 0 )
         {
+            AVCodecContext *context = ic->streams[i]->codec;
+            if ( context->pix_fmt != PIX_FMT_YUV420P &&
+                 !sws_isSupportedInput( context->pix_fmt ) )
+            {
+                hb_log( "ffmpeg_title_scan: Unsupported color space" );
+                continue;
+            }
             title->video_id = i;
             stream->ffmpeg_video_id = i;
 
@@ -2746,6 +3056,10 @@ static hb_title_t *ffmpeg_title_scan( hb_stream_t *stream )
         {
             add_ffmpeg_audio( title, stream, i );
         }
+        else if ( ic->streams[i]->codec->codec_type == CODEC_TYPE_SUBTITLE )
+        {
+            add_ffmpeg_subtitle( title, stream, i );
+        }
     }
 
     title->container_name = strdup( ic->iformat->name );
@@ -2933,6 +3247,34 @@ static int ffmpeg_read( hb_stream_t *stream, hb_buffer_t *buf )
     {
         buf->renderOffset = buf->start;
     }
+    
+    /* 
+     * Fill out buf->stop for subtitle packets
+     * 
+     * libavcodec's MKV demuxer stores the duration of UTF-8 subtitles (CODEC_ID_TEXT)
+     * in the 'convergence_duration' field for some reason.
+     * 
+     * Other subtitles' durations are stored in the 'duration' field.
+     * 
+     * VOB subtitles (CODEC_ID_DVD_SUBTITLE) do not have their duration stored in
+     * either field. This is not a problem because the VOB decoder can extract this
+     * information from the packet payload itself.
+     * 
+     * SSA subtitles (CODEC_ID_SSA) do not have their duration stored in
+     * either field. This is not a problem because the SSA decoder can extract this
+     * information from the packet payload itself.
+     */
+    enum CodecID ffmpeg_pkt_codec = stream->ffmpeg_ic->streams[stream->ffmpeg_pkt->stream_index]->codec->codec_id;
+    if ( ffmpeg_pkt_codec == CODEC_ID_TEXT ) {
+        int64_t ffmpeg_pkt_duration = stream->ffmpeg_pkt->convergence_duration;
+        int64_t buf_duration = av_to_hb_pts( ffmpeg_pkt_duration, tsconv );
+        buf->stop = buf->start + buf_duration;
+    }
+    if ( ffmpeg_pkt_codec == CODEC_ID_MOV_TEXT ) {
+        int64_t ffmpeg_pkt_duration = stream->ffmpeg_pkt->duration;
+        int64_t buf_duration = av_to_hb_pts( ffmpeg_pkt_duration, tsconv );
+        buf->stop = buf->start + buf_duration;
+    }
 
     /*
      * Check to see whether this video buffer is on a chapter
@@ -2983,3 +3325,16 @@ static int ffmpeg_seek( hb_stream_t *stream, float frac )
     }
     return 1;
 }
+
+// Assumes that we are always seeking forward
+static int ffmpeg_seek_ts( hb_stream_t *stream, int64_t ts )
+{
+    AVFormatContext *ic = stream->ffmpeg_ic;
+    int64_t pos;
+
+    pos = ts * AV_TIME_BASE / 90000 + ffmpeg_initial_timestamp( stream );
+    stream->need_keyframe = 1;
+    // Seek to the nearest timestamp before that requested where
+    // there is an I-frame
+    return av_seek_frame( ic, -1, pos, AVSEEK_FLAG_BACKWARD );
+}