X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Freader.c;h=6e7f0e63b1dfa4247a01a711b9a30ae689b18728;hb=4f0019f03c2e85e8634150ff0c9a31bee6d35ce5;hp=8c5ecdd2a6d862e45716ae39b34d64ba22d5543c;hpb=c593146bf3fab6290c71cbbb974e0a756e43f5e0;p=handbrake-jp%2Fhandbrake-jp-git.git

diff --git a/libhb/reader.c b/libhb/reader.c
index 8c5ecdd2..6e7f0e63 100644
--- a/libhb/reader.c
+++ b/libhb/reader.c
@@ -31,6 +31,9 @@ typedef struct
     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
+
+    int            start_found;     // found pts_to_start point
+    uint64_t       st_first;
 } hb_reader_t;
 
 /***********************************************************************
@@ -38,6 +41,7 @@ typedef struct
  **********************************************************************/
 static void        ReaderFunc( void * );
 static hb_fifo_t ** GetFifoForId( hb_job_t * job, int id );
+static void UpdateState( hb_reader_t  * r, int64_t start);
 
 /***********************************************************************
  * hb_reader_init
@@ -63,21 +67,23 @@ hb_thread_t * hb_reader_init( hb_job_t * job )
     r->stream_timing[0].last = -r->stream_timing[0].average;
     r->stream_timing[1].id = -1;
 
+    if ( !job->pts_to_start )
+        r->start_found = 1;
+
     return hb_thread_init( "reader", ReaderFunc, r,
                            HB_NORMAL_PRIORITY );
 }
 
 static void push_buf( const hb_reader_t *r, hb_fifo_t *fifo, hb_buffer_t *buf )
 {
-    while( !*r->die && !r->job->done && hb_fifo_is_full( fifo ) )
+    while ( !*r->die && !r->job->done )
     {
-        /*
-         * Loop until the incoming fifo is ready to receive
-         * this buffer.
-         */
-        hb_snooze( 50 );
+        if ( hb_fifo_full_wait( fifo ) )
+        {
+            hb_fifo_push( fifo, buf );
+            break;
+        }
     }
-    hb_fifo_push( fifo, buf );
 }
 
 static int is_audio( hb_reader_t *r, int id )
@@ -141,7 +147,10 @@ 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;
@@ -191,14 +200,23 @@ static void ReaderFunc( void * _r )
     int            chapter = -1;
     int            chapter_end = r->job->chapter_end;
 
-    if( !( r->dvd = hb_dvd_init( r->title->dvd ) ) )
+    if ( r->title->type == HB_DVD_TYPE )
     {
-        if ( !( r->stream = hb_stream_open( r->title->dvd, r->title ) ) )
-        {
-          return;
-        }
+        if ( !( r->dvd = hb_dvd_init( r->title->path ) ) )
+            return;
+    }
+    else if ( r->title->type == HB_STREAM_TYPE )
+    {
+        if ( !( r->stream = hb_stream_open( r->title->path, r->title ) ) )
+            return;
+    }
+    else
+    {
+        // Unknown type, should never happen
+        return;
     }
 
+    hb_buffer_t *ps = hb_buffer_init( HB_DVD_READ_BUFFER_SIZE );
     if (r->dvd)
     {
         /*
@@ -220,11 +238,16 @@ 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 );
+            hb_buffer_close( &ps );
             return;
         }
+        if (r->job->angle)
+        {
+            hb_dvd_set_angle( r->dvd, r->job->angle );
+        }
 
         if ( r->job->start_at_preview )
         {
@@ -241,6 +264,28 @@ static void ReaderFunc( void * _r )
                         ( r->job->seek_points ? ( r->job->seek_points + 1.0 ) : 11.0 ) );
 
     } 
+    else if ( r->stream && r->job->pts_to_start )
+    {
+        int64_t pts_to_start = r->job->pts_to_start;
+        
+        // Find out what the first timestamp of the stream is
+        // and then seek to the appropriate offset from it
+        if ( hb_stream_read( r->stream, ps ) )
+        {
+            if ( ps->start > 0 )
+                pts_to_start += ps->start;
+        }
+        
+        if ( hb_stream_seek_ts( r->stream, pts_to_start ) >= 0 )
+        {
+            // Seek takes us to the nearest I-frame before the timestamp
+            // that we want.  So we will retrieve the start time of the
+            // first packet we get, subtract that from pts_to_start, and
+            // inspect the reset of the frames in sync.
+            r->start_found = 2;
+            r->job->pts_to_start = pts_to_start;
+        }
+    } 
     else if( r->stream )
     {
         /*
@@ -264,7 +309,6 @@ static void ReaderFunc( void * _r )
     }
 
     list  = hb_list_init();
-    hb_buffer_t *ps = hb_buffer_init( HB_DVD_READ_BUFFER_SIZE );
 
     while( !*r->die && !r->job->done )
     {
@@ -298,6 +342,17 @@ static void ReaderFunc( void * _r )
           {
             break;
           }
+          if ( r->start_found == 2 )
+          {
+            // We will inspect the timestamps of each frame in sync
+            // to skip from this seek point to the timestamp we
+            // want to start at.
+            if ( ps->start > 0 && ps->start < r->job->pts_to_start )
+                r->job->pts_to_start -= ps->start;
+            else if ( ps->start >= r->job->pts_to_start )
+                r->job->pts_to_start = 0;
+            r->start_found = 1;
+          }
         }
 
         if( r->job->indepth_scan )
@@ -329,17 +384,22 @@ static void ReaderFunc( void * _r )
             hb_list_rem( list, buf );
             fifos = GetFifoForId( r->job, buf->id );
 
-            if ( ! r->saw_video )
+            if ( fifos && ! r->saw_video && !r->job->indepth_scan )
             {
-                /* 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
                 {
@@ -350,16 +410,7 @@ static void ReaderFunc( void * _r )
             {
                 if ( buf->renderOffset != -1 )
                 {
-                    if ( r->scr_changes == r->demux.scr_changes )
-                    {
-                        // This packet is referenced to the same SCR as the last.
-                        // Adjust timestamp to remove the System Clock Reference
-                        // offset then update the average inter-packet time
-                        // for this stream.
-                        buf->renderOffset -= r->scr_offset;
-                        update_ipt( r, buf );
-                    }
-                    else
+                    if ( r->scr_changes != r->demux.scr_changes )
                     {
                         // This is the first audio or video packet after an SCR
                         // change. Compute a new scr offset that would make this
@@ -404,6 +455,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;
                         }
@@ -411,15 +464,48 @@ static void ReaderFunc( void * _r )
                 }
                 if ( buf->start != -1 )
                 {
+                    int64_t start = buf->start - r->scr_offset;
+                    if ( !r->start_found )
+                        UpdateState( r, start );
+
+                    if ( !r->start_found &&
+                        r->job->pts_to_start && 
+                        buf->renderOffset != -1 &&
+                        start >= r->job->pts_to_start )
+                    {
+                        // pts_to_start point found
+                        // force a new scr offset computation
+                        stream_timing_t *st = find_st( r, buf );
+                        if ( st && 
+                            (st->is_audio ||
+                            ( st == r->stream_timing && !r->saw_audio ) ) )
+                        {
+                            // Re-zero our timestamps
+                            st->last = -st->average;
+                            new_scr_offset( r, buf );
+                            r->start_found = 1;
+                            r->job->pts_to_start = 0;
+                        }
+                    }
                     buf->start -= r->scr_offset;
-                    if ( r->job->pts_to_stop && buf->start > r->job->pts_to_stop )
+                }
+                if ( buf->renderOffset != -1 )
+                {
+                    if ( r->scr_changes == r->demux.scr_changes )
                     {
-                        // we're doing a subset of the input and we've hit the
-                        // stopping point.
-                        hb_buffer_close( &buf );
-                        goto done;
+                        // This packet is referenced to the same SCR as the last.
+                        // Adjust timestamp to remove the System Clock Reference
+                        // offset then update the average inter-packet time
+                        // for this stream.
+                        buf->renderOffset -= r->scr_offset;
+                        update_ipt( r, buf );
                     }
                 }
+                if ( !r->start_found )
+                {
+                    hb_buffer_close( &buf );
+                    continue;
+                }
 
                 buf->sequence = r->sequence++;
                 /* if there are mutiple output fifos, send a copy of the
@@ -442,15 +528,24 @@ static void ReaderFunc( void * _r )
         }
     }
 
-  done:
     // send empty buffers downstream to video & audio decoders to signal we're done.
-    push_buf( r, r->job->fifo_mpeg2, hb_buffer_init(0) );
-
-    hb_audio_t *audio;
-    for( n = 0; ( audio = hb_list_item( r->job->title->list_audio, n ) ); ++n )
+    if( !*r->die && !r->job->done )
     {
-        if ( audio->priv.fifo_in )
-            push_buf( r, audio->priv.fifo_in, hb_buffer_init(0) );
+        push_buf( r, r->job->fifo_mpeg2, hb_buffer_init(0) );
+
+        hb_audio_t *audio;
+        for( n = 0; (audio = hb_list_item( r->job->title->list_audio, n)); ++n )
+        {
+            if ( audio->priv.fifo_in )
+                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 );
@@ -480,6 +575,46 @@ static void ReaderFunc( void * _r )
     _r = NULL;
 }
 
+static void UpdateState( hb_reader_t  * r, int64_t start)
+{
+    hb_state_t state;
+    uint64_t now;
+    double avg;
+
+    now = hb_get_date();
+    if( !r->st_first )
+    {
+        r->st_first = now;
+    }
+
+#define p state.param.working
+    state.state = HB_STATE_SEARCHING;
+    p.progress  = (float) start / (float) r->job->pts_to_start;
+    if( p.progress > 1.0 )
+    {
+        p.progress = 1.0;
+    }
+    if (now > r->st_first)
+    {
+        int eta;
+
+        avg = 1000.0 * (double)start / (now - r->st_first);
+        eta = ( r->job->pts_to_start - start ) / avg;
+        p.hours   = eta / 3600;
+        p.minutes = ( eta % 3600 ) / 60;
+        p.seconds = eta % 60;
+    }
+    else
+    {
+        p.rate_avg = 0.0;
+        p.hours    = -1;
+        p.minutes  = -1;
+        p.seconds  = -1;
+    }
+#undef p
+
+    hb_set_state( r->job->h, &state );
+}
 /***********************************************************************
  * GetFifoForId
  ***********************************************************************
@@ -490,8 +625,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));
 
@@ -512,37 +647,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;