X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=libhb%2Freader.c;fp=libhb%2Freader.c;h=1dda826d0e2ac34f8937e6c98b1b04b92616cb81;hb=ee932fa7c59d811e53dcab64bcaf0fce2527052d;hp=9dfd915e465f63665bd29a5c9c24e9dea31e7cfe;hpb=03abe4fee6e608fd5c20cda70c0eb4763a56ad4f;p=handbrake-jp%2Fhandbrake-jp.git

diff --git a/libhb/reader.c b/libhb/reader.c
index 9dfd915..1dda826 100644
--- a/libhb/reader.c
+++ b/libhb/reader.c
@@ -11,6 +11,7 @@ typedef struct
     double average; // average time between packets
     int64_t last;   // last timestamp seen on this stream
     int id;         // stream id
+    int is_audio;   // != 0 if this is an audio stream
 } stream_timing_t;
 
 typedef struct
@@ -26,9 +27,10 @@ typedef struct
     int64_t        scr_offset;
     hb_psdemux_t   demux;
     int            scr_changes;
-    uint           sequence;
-    int            saw_video;
-    int            st_slots;            // size (in slots) of stream_timing array
+    uint32_t       sequence;
+    uint8_t        st_slots;        // size (in slots) of stream_timing array
+    uint8_t        saw_video;       // != 0 if we've seen video
+    uint8_t        saw_audio;       // != 0 if we've seen audio
 } hb_reader_t;
 
 /***********************************************************************
@@ -78,6 +80,21 @@ static void push_buf( const hb_reader_t *r, hb_fifo_t *fifo, hb_buffer_t *buf )
     hb_fifo_push( fifo, buf );
 }
 
+static int is_audio( hb_reader_t *r, int id )
+{
+    int i;
+    hb_audio_t *audio;
+
+    for( i = 0; ( audio = hb_list_item( r->title->list_audio, i ) ); ++i )
+    {
+        if ( audio->id == id )
+        {
+            return 1;
+        }
+    }
+    return 0;
+}
+
 // The MPEG STD (Standard Target Decoder) essentially requires that we keep
 // per-stream timing so that when there's a timing discontinuity we can
 // seemlessly join packets on either side of the discontinuity. This join
@@ -124,8 +141,14 @@ static stream_timing_t *id_to_st( hb_reader_t *r, const hb_buffer_t *buf )
         }
         st->id = buf->id;
         st->average = 30.*90.;
-        st->last = buf->renderOffset - st->average;
-
+        if ( r->saw_video )
+            st->last = buf->renderOffset - st->average;
+        else
+            st->last = -st->average;
+        if ( ( st->is_audio = is_audio( r, buf->id ) ) != 0 )
+        {
+            r->saw_audio = 1;
+        }
         st[1].id = -1;
     }
     return st;
@@ -200,34 +223,62 @@ static void ReaderFunc( void * _r )
         }
         /* end chapter mapping XXX */
 
-        if( !hb_dvd_start( r->dvd, r->title->index, start ) )
+        if( !hb_dvd_start( r->dvd, r->title, start ) )
         {
             hb_dvd_close( &r->dvd );
             return;
         }
+        if (r->job->angle)
+        {
+            hb_dvd_set_angle( r->dvd, r->job->angle );
+        }
 
         if ( r->job->start_at_preview )
         {
             // XXX code from DecodePreviews - should go into its own routine
-            hb_dvd_seek( r->dvd, (float)r->job->start_at_preview / 11. );
+            hb_dvd_seek( r->dvd, (float)r->job->start_at_preview /
+                         ( r->job->seek_points ? ( r->job->seek_points + 1.0 ) : 11.0 ) );
         }
     }
     else if ( r->stream && r->job->start_at_preview )
     {
+        
         // XXX code from DecodePreviews - should go into its own routine
-        hb_stream_seek( r->stream, (float)( r->job->start_at_preview - 1 ) / 11. );
+        hb_stream_seek( r->stream, (float)( r->job->start_at_preview - 1 ) /
+                        ( r->job->seek_points ? ( r->job->seek_points + 1.0 ) : 11.0 ) );
+
+    } 
+    else if( r->stream )
+    {
+        /*
+         * Standard stream, seek to the starting chapter, if set, and track the
+         * end chapter so that we end at the right time.
+         */
+        int start = r->job->chapter_start;
+        hb_chapter_t *chap = hb_list_item( r->title->list_chapter, chapter_end - 1 );
+        
+        chapter_end = chap->index;
+        if (start > 1)
+        {
+            chap = hb_list_item( r->title->list_chapter, start - 1 );
+            start = chap->index;
+        }
+        
+        /*
+         * Seek to the start chapter.
+         */
+        hb_stream_seek_chapter( r->stream, start );
     }
 
     list  = hb_list_init();
     hb_buffer_t *ps = hb_buffer_init( HB_DVD_READ_BUFFER_SIZE );
-    r->demux.flaky_clock = r->title->flaky_clock;
 
     while( !*r->die && !r->job->done )
     {
         if (r->dvd)
-          chapter = hb_dvd_chapter( r->dvd );
+            chapter = hb_dvd_chapter( r->dvd );
         else if (r->stream)
-          chapter = 1;
+            chapter = hb_stream_chapter( r->stream );
 
         if( chapter < 0 )
         {
@@ -278,31 +329,29 @@ static void ReaderFunc( void * _r )
             hb_set_state( r->job->h, &state );
         }
 
-        if ( r->title->demuxer == HB_NULL_DEMUXER )
-        {
-            hb_demux_null( ps, list, &r->demux );
-        }
-        else
-        {
-            hb_demux_ps( ps, list, &r->demux );
-        }
+        (hb_demux[r->title->demuxer])( ps, list, &r->demux );
 
         while( ( buf = hb_list_item( list, 0 ) ) )
         {
             hb_list_rem( list, buf );
             fifos = GetFifoForId( r->job, buf->id );
 
-            if ( ! r->saw_video )
+            if ( fifos && ! r->saw_video )
             {
-                /* The first video packet defines 'time zero' so discard
-                   data until we get a video packet with a PTS & DTS */
-                if ( buf->id == r->title->video_id && buf->start != -1 &&
-                     buf->renderOffset != -1 )
+                // The first data packet with a PTS from an audio or video stream
+                // that we're decoding defines 'time zero'. Discard packets until
+                // we get one.
+                if ( buf->start != -1 && buf->renderOffset != -1 &&
+                     ( buf->id == r->title->video_id || is_audio( r, buf->id ) ) )
                 {
                     // force a new scr offset computation
                     r->scr_changes = r->demux.scr_changes - 1;
+                    // create a stream state if we don't have one so the
+                    // offset will get computed correctly.
+                    id_to_st( r, buf );
                     r->saw_video = 1;
-                    hb_log( "reader: first SCR %lld", r->demux.last_scr );
+                    hb_log( "reader: first SCR %"PRId64" id %d DTS %"PRId64,
+                            r->demux.last_scr, buf->id, buf->renderOffset );
                 }
                 else
                 {
@@ -332,10 +381,11 @@ static void ReaderFunc( void * _r )
 
                         if ( st )
                         {
-                            // if this isn't the video stream or we don't
-                            // have audio yet then generate a new scr
-                            if ( st != r->stream_timing ||
-                                 r->stream_timing[1].id == -1 )
+                            // if this is the video stream and we don't have
+                            // audio yet or this is an audio stream
+                            // generate a new scr
+                            if ( st->is_audio ||
+                                 ( st == r->stream_timing && !r->saw_audio ) )
                             {
                                 new_scr_offset( r, buf );
                             }
@@ -343,11 +393,21 @@ static void ReaderFunc( void * _r )
                             {
                                 // defer the scr change until we get some
                                 // audio since audio has a timestamp per
-                                // frame but video doesn't. Clear the timestamps
-                                // so the decoder will regenerate them from
-                                // the frame durations.
-                                buf->start = -1;
-                                buf->renderOffset = -1;
+                                // frame but video & subtitles don't. Clear
+                                // the timestamps so the decoder will generate
+                                // them from the frame durations.
+                                if ( st != r->stream_timing )
+                                {
+                                    // not a video stream so it's probably
+                                    // subtitles - the best we can do is to
+                                    // line it up with the last video packet.
+                                    buf->start = r->stream_timing->last;
+                                }
+                                else
+                                {
+                                    buf->start = -1;
+                                    buf->renderOffset = -1;
+                                }
                             }
                         }
                         else
@@ -356,6 +416,8 @@ static void ReaderFunc( void * _r )
                             // packet of a stream we've never seen before. We
                             // have no idea what the timing should be so toss
                             // this buffer & wait for a stream we've already seen.
+                            // add stream to list of streams we have seen
+                            id_to_st( r, buf );
                             hb_buffer_close( &buf );
                             continue;
                         }
@@ -405,6 +467,13 @@ static void ReaderFunc( void * _r )
             push_buf( r, audio->priv.fifo_in, hb_buffer_init(0) );
     }
 
+    hb_subtitle_t *subtitle;
+    for( n = 0; ( subtitle = hb_list_item( r->job->title->list_subtitle, n ) ); ++n )
+    {
+        if ( subtitle->fifo_in && subtitle->source == VOBSUB)
+            push_buf( r, subtitle->fifo_in, hb_buffer_init(0) );
+    }
+
     hb_list_empty( &list );
     hb_buffer_close( &ps );
     if (r->dvd)
@@ -442,8 +511,8 @@ static hb_fifo_t ** GetFifoForId( hb_job_t * job, int id )
     hb_title_t    * title = job->title;
     hb_audio_t    * audio;
     hb_subtitle_t * subtitle;
-    int             i, n;
-    static hb_fifo_t * fifos[8];
+    int             i, n, count;
+    static hb_fifo_t * fifos[100];
 
     memset(fifos, 0, sizeof(fifos));
 
@@ -464,37 +533,29 @@ static hb_fifo_t ** GetFifoForId( hb_job_t * job, int id )
         }
     }
 
-    if( job->indepth_scan ) {
-        /*
-         * Count the occurances of the subtitles, don't actually
-         * return any to encode unless we are looking fro forced
-         * subtitles in which case we need to look in the sub picture
-         * to see if it has the forced flag enabled.
-         */
-        for (i=0; i < hb_list_count(title->list_subtitle); i++) {
-            subtitle =  hb_list_item( title->list_subtitle, i);
-            if (id == subtitle->id) {
+    n = 0;
+    count = hb_list_count( title->list_subtitle );
+    count = count > 99 ? 99 : count;
+    for( i=0; i < count; i++ ) {
+        subtitle =  hb_list_item( title->list_subtitle, i );
+        if (id == subtitle->id) {
+            subtitle->hits++;
+            if( !job->indepth_scan || job->select_subtitle_config.force )
+            {
                 /*
-                 * A hit, count it.
+                 * Pass the subtitles to be processed if we are not scanning, or if
+                 * we are scanning and looking for forced subs, then pass them up
+                 * to decode whether the sub is a forced one.
                  */
-                subtitle->hits++;
-                if( job->subtitle_force )
-                {
-
-                    fifos[0] = subtitle->fifo_in;
-                    return fifos;
-                }
-                break;
+                fifos[n++] = subtitle->fifo_in;
             }
         }
-    } else {
-        if( ( subtitle = hb_list_item( title->list_subtitle, 0 ) ) &&
-            id == subtitle->id )
-        {
-            fifos[0] = subtitle->fifo_in;
-            return fifos;
-        }
     }
+    if ( n != 0 )
+    {
+        return fifos;
+    }
+    
     if( !job->indepth_scan )
     {
         n = 0;