X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fsync.c;h=c391945b0483176230f6db565de9a1d7ad1a172c;hb=f9341345b37e0738a140423297c222a7e40eddab;hp=d943e62a33eb0b77db30cfb98260837f2a5bd6a3;hpb=04259fcace87d860b0024667e789aceb8e3271f3;p=handbrake-jp%2Fhandbrake-jp-git.git

diff --git a/libhb/sync.c b/libhb/sync.c
index d943e62a..c391945b 100644
--- a/libhb/sync.c
+++ b/libhb/sync.c
@@ -1,14 +1,13 @@
 /* $Id: sync.c,v 1.38 2005/04/14 21:57:58 titer Exp $
 
    This file is part of the HandBrake source code.
-   Homepage: <http://handbrake.m0k.org/>.
+   Homepage: <http://handbrake.fr/>.
    It may be used under the terms of the GNU General Public License. */
 
 #include "hb.h"
+#include "hbffmpeg.h"
 #include <stdio.h>
-
 #include "samplerate.h"
-#include "ffmpeg/avcodec.h"
 
 #ifdef INT64_MIN
 #undef INT64_MIN /* Because it isn't defined correctly in Zeta */
@@ -23,10 +22,8 @@ typedef struct
 
     int64_t      next_start;    /* start time of next output frame */
     int64_t      next_pts;      /* start time of next input frame */
-    int64_t      start_silence; /* if we're inserting silence, the time we started */
     int64_t      first_drop;    /* PTS of first 'went backwards' frame dropped */
     int          drop_count;    /* count of 'time went backwards' drops */
-    int          inserting_silence;
 
     /* Raw */
     SRC_STATE  * state;
@@ -41,8 +38,11 @@ typedef struct
 struct hb_work_private_s
 {
     hb_job_t * job;
-    int        done;
-
+    int        busy;            // bitmask with one bit for each active input
+                                // (bit 0 = video; 1 = audio 0, 2 = audio 1, ...
+                                // appropriate bit is cleared when input gets
+                                // an eof buf. syncWork returns done when all
+                                // bits are clear.
     /* Video */
     hb_subtitle_t * subtitle;
     int64_t pts_offset;
@@ -71,9 +71,8 @@ struct hb_work_private_s
  * Local prototypes
  **********************************************************************/
 static void InitAudio( hb_work_object_t * w, int i );
-static int  SyncVideo( hb_work_object_t * w );
+static void SyncVideo( hb_work_object_t * w );
 static void SyncAudio( hb_work_object_t * w, int i );
-static int  NeedSilence( hb_work_object_t * w, hb_audio_t *, int i );
 static void InsertSilence( hb_work_object_t * w, int i, int64_t d );
 static void UpdateState( hb_work_object_t * w );
 
@@ -95,32 +94,41 @@ int syncInit( hb_work_object_t * w, hb_job_t * job )
 
     pv->job            = job;
     pv->pts_offset     = INT64_MIN;
-    pv->count_frames   = 0;
 
     /* Calculate how many video frames we are expecting */
-    duration = 0;
-    for( i = job->chapter_start; i <= job->chapter_end; i++ )
+    if (job->pts_to_stop)
     {
-        chapter   = hb_list_item( title->list_chapter, i - 1 );
-        duration += chapter->duration;
+        duration = job->pts_to_stop + 90000;
     }
-    duration += 90000;
+    else
+    {
+        duration = 0;
+        for( i = job->chapter_start; i <= job->chapter_end; i++ )
+        {
+            chapter   = hb_list_item( title->list_chapter, i - 1 );
+            duration += chapter->duration;
+        }
+        duration += 90000;
         /* 1 second safety so we're sure we won't miss anything */
+    }
     pv->count_frames_max = duration * job->vrate / job->vrate_base / 90000;
 
     hb_log( "sync: expecting %d video frames", pv->count_frames_max );
+    pv->busy |= 1;
 
     /* Initialize libsamplerate for every audio track we have */
-    for( i = 0; i < hb_list_count( title->list_audio ); i++ )
+    if ( ! job->indepth_scan )
     {
-        InitAudio( w, i );
+        for( i = 0; i < hb_list_count( title->list_audio ); i++ )
+        {
+            pv->busy |= ( 1 << (i + 1) );
+            InitAudio( w, i );
+        }
     }
 
     /* Get subtitle info, if any */
     pv->subtitle = hb_list_item( title->list_subtitle, 0 );
 
-    pv->video_sequence = 0;
-
     return 0;
 }
 
@@ -152,13 +160,6 @@ void syncClose( hb_work_object_t * w )
 
     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
     {
-        if ( pv->sync_audio[i].start_silence )
-        {
-            hb_log( "sync: added %d ms of silence to audio %d",
-                    (int)((pv->sync_audio[i].next_pts -
-                              pv->sync_audio[i].start_silence) / 90), i );
-        }
-
         audio = hb_list_item( title->list_audio, i );
         if( audio->config.out.codec == HB_ACODEC_AC3 )
         {
@@ -190,17 +191,16 @@ int syncWork( hb_work_object_t * w, hb_buffer_t ** unused1,
     hb_work_private_t * pv = w->private_data;
     int i;
 
-    /* If we ever got a video frame, handle audio now */
-    if( pv->pts_offset != INT64_MIN )
+    if ( pv->busy & 1 )
+        SyncVideo( w );
+
+    for( i = 0; i < hb_list_count( pv->job->title->list_audio ); i++ )
     {
-        for( i = 0; i < hb_list_count( pv->job->title->list_audio ); i++ )
-        {
+        if ( pv->busy & ( 1 << (i + 1) ) )
             SyncAudio( w, i );
-        }
     }
 
-    /* Handle video */
-    return SyncVideo( w );
+    return ( pv->busy? HB_WORK_OK : HB_WORK_DONE );
 }
 
 hb_work_object_t hb_sync =
@@ -237,7 +237,7 @@ static void InitAudio( hb_work_object_t * w, int i )
         c->sample_rate = sync->audio->config.in.samplerate;
         c->channels    = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT( sync->audio->config.in.channel_layout );
 
-        if( avcodec_open( c, codec ) < 0 )
+        if( hb_avcodec_open( c, codec ) < 0 )
         {
             hb_log( "sync: avcodec_open failed" );
             return;
@@ -256,14 +256,14 @@ static void InitAudio( hb_work_object_t * w, int i )
         }
 
         free( zeros );
-        avcodec_close( c );
+        hb_avcodec_close( c );
         av_free( c );
     }
     else
     {
         /* Initialize libsamplerate */
         int error;
-        sync->state             = src_new( SRC_LINEAR, HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(sync->audio->config.out.mixdown), &error );
+        sync->state             = src_new( SRC_SINC_MEDIUM_QUALITY, HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(sync->audio->config.out.mixdown), &error );
         sync->data.end_of_input = 0;
     }
 }
@@ -273,39 +273,25 @@ static void InitAudio( hb_work_object_t * w, int i )
  ***********************************************************************
  *
  **********************************************************************/
-static int SyncVideo( hb_work_object_t * w )
+static void SyncVideo( hb_work_object_t * w )
 {
     hb_work_private_t * pv = w->private_data;
     hb_buffer_t * cur, * next, * sub = NULL;
     hb_job_t * job = pv->job;
 
-    if( pv->done )
-    {
-        return HB_WORK_DONE;
-    }
-
-    if( hb_thread_has_exited( job->reader ) &&
-        !hb_fifo_size( job->fifo_mpeg2 ) &&
-        !hb_fifo_size( job->fifo_raw ) )
-    {
-        pv->done = 1;
-
-        hb_buffer_t * buf_tmp;
-
-       // Drop an empty buffer into our output to ensure that things
-       // get flushed all the way out.
-        buf_tmp = hb_buffer_init(0); // Empty end buffer
-        hb_fifo_push( job->fifo_sync, buf_tmp );
-
-        return HB_WORK_DONE;
-    }
-
     if( !pv->cur && !( pv->cur = hb_fifo_get( job->fifo_raw ) ) )
     {
         /* We haven't even got a frame yet */
-        return HB_WORK_OK;
+        return;
     }
     cur = pv->cur;
+    if( cur->size == 0 )
+    {
+        /* we got an end-of-stream. Feed it downstream & signal that we're done. */
+        hb_fifo_push( job->fifo_sync, hb_buffer_init( 0 ) );
+        pv->busy &=~ 1;
+        return;
+    }
 
     /* At this point we have a frame to process. Let's check
         1) if we will be able to push into the fifo ahead
@@ -316,6 +302,16 @@ static int SyncVideo( hb_work_object_t * w )
     {
         hb_buffer_t * buf_tmp;
 
+        if( next->size == 0 )
+        {
+            /* we got an end-of-stream. Feed it downstream & signal that
+             * we're done. Note that this means we drop the final frame of
+             * video (we don't know its duration). On DVDs the final frame
+             * is often strange and dropping it seems to be a good idea. */
+            hb_fifo_push( job->fifo_sync, hb_buffer_init( 0 ) );
+            pv->busy &=~ 1;
+            return;
+        }
         if( pv->pts_offset == INT64_MIN )
         {
             /* This is our first frame */
@@ -335,6 +331,10 @@ static int SyncVideo( hb_work_object_t * w )
             }
         }
 
+        if( cur->new_chap ) {
+            hb_log("sync got new chapter %d", cur->new_chap );
+        }
+
         /*
          * since the first frame is always 0 and the upstream reader code
          * is taking care of adjusting for pts discontinuities, we just have
@@ -346,7 +346,7 @@ static int SyncVideo( hb_work_object_t * w )
          * can deal with overlaps of up to a frame time but anything larger
          * we handle by dropping frames here.
          */
-        if ( (int64_t)( next->start - pv->next_pts ) <= 0 )
+        if ( (int64_t)( next->start - cur->start ) <= 0 )
         {
             if ( pv->first_drop == 0 )
             {
@@ -365,9 +365,9 @@ static int SyncVideo( hb_work_object_t * w )
         if ( pv->first_drop )
         {
             hb_log( "sync: video time didn't advance - dropped %d frames "
-                    "(delta %d ms, current %lld, next %lld)",
-                    pv->drop_count, (int)( pv->next_pts - pv->first_drop ) / 90,
-                    pv->next_pts, pv->first_drop );
+                    "(delta %d ms, current %lld, next %lld, dur %d)",
+                    pv->drop_count, (int)( cur->start - pv->first_drop ) / 90,
+                    cur->start, next->start, (int)( next->start - cur->start ) );
             pv->first_drop = 0;
             pv->drop_count = 0;
         }
@@ -512,7 +512,7 @@ static int SyncVideo( hb_work_object_t * w )
         }
 
         int64_t duration;
-        if ( job->mux & HB_MUX_AVI )
+        if ( job->mux & HB_MUX_AVI || job->cfr )
         {
             /*
              * The concept of variable frame rate video was a bit too advanced
@@ -583,8 +583,8 @@ static int SyncVideo( hb_work_object_t * w )
              */
             buf_tmp = cur;
             pv->cur = cur = hb_fifo_get( job->fifo_raw );
-            pv->next_pts = next->start;
-            duration = next->start - buf_tmp->start;
+            pv->next_pts = cur->start;
+            duration = cur->start - buf_tmp->start;
             if ( duration <= 0 )
             {
                 hb_log( "sync: invalid video duration %lld, start %lld, next %lld",
@@ -625,19 +625,16 @@ static int SyncVideo( hb_work_object_t * w )
         /* Make sure we won't get more frames then expected */
         if( pv->count_frames >= pv->count_frames_max * 2)
         {
-            hb_log( "sync: got too many frames (%d), exiting early", pv->count_frames );
-            pv->done = 1;
-
-           // Drop an empty buffer into our output to ensure that things
-           // get flushed all the way out.
-           buf_tmp = hb_buffer_init(0); // Empty end buffer
-           hb_fifo_push( job->fifo_sync, buf_tmp );
+            hb_log( "sync: got too many frames (%d), exiting early",
+                    pv->count_frames );
 
-            break;
+            // Drop an empty buffer into our output to ensure that things
+            // get flushed all the way out.
+            hb_fifo_push( job->fifo_sync, hb_buffer_init( 0 ) );
+            pv->busy &=~ 1;
+            return;
         }
     }
-
-    return HB_WORK_OK;
 }
 
 static void OutputAudioFrame( hb_job_t *job, hb_audio_t *audio, hb_buffer_t *buf,
@@ -701,16 +698,6 @@ static void OutputAudioFrame( hb_job_t *job, hb_audio_t *audio, hb_buffer_t *buf
     buf->start = start;
     buf->stop  = start + duration;
     sync->next_start = start + duration;
-    while( hb_fifo_is_full( fifo ) )
-    {
-        hb_snooze( 50 );
-        if ( job->done && hb_fifo_is_full( fifo ) )
-        {
-            /* don't block here if the job's finished */
-            hb_buffer_close( &buf );
-            return;
-        }
-    }
     hb_fifo_push( fifo, buf );
 }
 
@@ -739,66 +726,70 @@ static void SyncAudio( hb_work_object_t * w, int i )
 
     while( !hb_fifo_is_full( fifo ) && ( buf = hb_fifo_see( audio->priv.fifo_raw ) ) )
     {
+        /* if the next buffer is an eof send it downstream */
+        if ( buf->size <= 0 )
+        {
+            buf = hb_fifo_get( audio->priv.fifo_raw );
+            hb_fifo_push( fifo, buf );
+            pv->busy &=~ (1 << (i + 1) );
+            return;
+        }
         if ( (int64_t)( buf->start - sync->next_pts ) < 0 )
         {
-            /*
-             * audio time went backwards by more than a frame time (this can
-             * happen when we reset the PTS because of lost data).
-             * Discard data that's in the past.
-             */
-            if ( sync->first_drop == 0 )
+            // audio time went backwards.
+            // If our output clock is more than a half frame ahead of the
+            // input clock drop this frame to move closer to sync.
+            // Otherwise drop frames until the input clock matches the output clock.
+            if ( sync->first_drop || sync->next_start - buf->start > 90*15 )
             {
-                sync->first_drop = buf->start;
+                // Discard data that's in the past.
+                if ( sync->first_drop == 0 )
+                {
+                    sync->first_drop = sync->next_pts;
+                }
+                ++sync->drop_count;
+                buf = hb_fifo_get( audio->priv.fifo_raw );
+                hb_buffer_close( &buf );
+                continue;
             }
-            ++sync->drop_count;
-            buf = hb_fifo_get( audio->priv.fifo_raw );
-            hb_buffer_close( &buf );
-            continue;
+            sync->next_pts = buf->start;
         }
         if ( sync->first_drop )
         {
+            // we were dropping old data but input buf time is now current
             hb_log( "sync: audio %d time went backwards %d ms, dropped %d frames "
                     "(next %lld, current %lld)", i,
                     (int)( sync->next_pts - sync->first_drop ) / 90,
                     sync->drop_count, sync->first_drop, sync->next_pts );
             sync->first_drop = 0;
             sync->drop_count = 0;
+            sync->next_pts = buf->start;
         }
-
-        if ( sync->inserting_silence && (int64_t)(buf->start - sync->next_pts) > 0 )
+        if ( buf->start - sync->next_pts >= (90 * 70) )
         {
-            /*
-             * if we're within one frame time of the amount of silence
-             * we need, insert just what we need otherwise insert a frame time.
-             */
-            int64_t framedur = buf->stop - buf->start;
-            if ( buf->start - sync->next_pts <= framedur )
+            if ( buf->start - sync->next_pts > (90000LL * 60) )
             {
-                InsertSilence( w, i, buf->start - sync->next_pts );
-                sync->inserting_silence = 0;
-            }
-            else
-            {
-                InsertSilence( w, i, framedur );
+                // there's a gap of more than a minute between the last
+                // frame and this. assume we got a corrupted timestamp
+                // and just drop the next buf.
+                hb_log( "sync: %d minute time gap in audio %d - dropping buf"
+                        "  start %lld, next %lld",
+                        (int)((buf->start - sync->next_pts) / (90000*60)),
+                        i, buf->start, sync->next_pts );
+                buf = hb_fifo_get( audio->priv.fifo_raw );
+                hb_buffer_close( &buf );
+                continue;
             }
-            continue;
-        }
-        if ( buf->start - sync->next_pts >= (90 * 70) )
-        {
             /*
              * there's a gap of at least 70ms between the last
              * frame we processed & the next. Fill it with silence.
              */
-            if ( ! sync->inserting_silence )
-            {
-                hb_log( "sync: adding %d ms of silence to audio %d"
-                        "  start %lld, next %lld",
-                        (int)((buf->start - sync->next_pts) / 90),
-                        i, buf->start, sync->next_pts );
-                sync->inserting_silence = 1;
-            }
+            hb_log( "sync: adding %d ms of silence to audio %d"
+                    "  start %lld, next %lld",
+                    (int)((buf->start - sync->next_pts) / 90),
+                    i, buf->start, sync->next_pts );
             InsertSilence( w, i, buf->start - sync->next_pts );
-            continue;
+            return;
         }
 
         /*
@@ -809,43 +800,6 @@ static void SyncAudio( hb_work_object_t * w, int i )
         buf = hb_fifo_get( audio->priv.fifo_raw );
         OutputAudioFrame( job, audio, buf, sync, fifo, i );
     }
-
-    if( NeedSilence( w, audio, i ) )
-    {
-        InsertSilence( w, i, (90000 * AC3_SAMPLES_PER_FRAME) /
-                             sync->audio->config.in.samplerate );
-    }
-}
-
-static int NeedSilence( hb_work_object_t * w, hb_audio_t * audio, int i )
-{
-    hb_work_private_t * pv = w->private_data;
-    hb_job_t * job = pv->job;
-    hb_sync_audio_t * sync = &pv->sync_audio[i];
-
-    if( hb_fifo_size( audio->priv.fifo_in ) ||
-        hb_fifo_size( audio->priv.fifo_raw ) ||
-        hb_fifo_size( audio->priv.fifo_sync ) ||
-        hb_fifo_size( audio->priv.fifo_out ) )
-    {
-        /* We have some audio, we are fine */
-        return 0;
-    }
-
-    /* No audio left in fifos */
-
-    if( hb_thread_has_exited( job->reader ) )
-    {
-        /* We might miss some audio to complete encoding and muxing
-           the video track */
-        if ( sync->start_silence == 0 )
-        {
-            hb_log("sync: reader has exited, adding silence to audio %d", i);
-            sync->start_silence = sync->next_pts;
-        }
-        return 1;
-    }
-    return 0;
 }
 
 static void InsertSilence( hb_work_object_t * w, int i, int64_t duration )