X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fsync.c;h=0c359f1dda7c2f41b218a56f2533ea3d48c80900;hb=95dbfda7aa638010bf0d72ea220ecf847dbcee81;hp=90e7fc3453353f49a6b4f7e987cf03ea674052fb;hpb=2707a4c05f84b3846e4e77ca4e9850cc61ffca10;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/sync.c b/libhb/sync.c index 90e7fc34..0c359f1d 100644 --- a/libhb/sync.c +++ b/libhb/sync.c @@ -8,7 +8,7 @@ #include #include "samplerate.h" -#include "ffmpeg/avcodec.h" +#include "libavcodec/avcodec.h" #ifdef INT64_MIN #undef INT64_MIN /* Because it isn't defined correctly in Zeta */ @@ -23,7 +23,6 @@ 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 */ @@ -40,8 +39,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; @@ -70,9 +72,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 ); @@ -94,7 +95,6 @@ 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; @@ -108,18 +108,21 @@ int syncInit( hb_work_object_t * w, hb_job_t * job ) 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; } @@ -151,13 +154,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 ) { @@ -189,17 +185,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 = @@ -262,7 +257,7 @@ static void InitAudio( hb_work_object_t * w, int i ) { /* 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; } } @@ -272,30 +267,24 @@ 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( !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 && pv->pts_offset == INT64_MIN ) + if( cur->size == 0 ) { - /* we got an end-of-stream with no video frames (happens during - * an indepth_scan). Feed the eos downstream & signal that we're done. */ + /* 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->done = 1; - return HB_WORK_DONE; + pv->busy &=~ 1; + return; } /* At this point we have a frame to process. Let's check @@ -309,13 +298,14 @@ static int SyncVideo( hb_work_object_t * w ) if( next->size == 0 ) { - // we got the empty buffer that signals end-of-stream - // note that we're done but continue to the end of this - // loop so that the final frame gets processed. - pv->done = 1; - next->start = pv->next_pts + 90*30; + /* 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 */ @@ -346,7 +336,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 +355,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 +502,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 +573,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,21 +615,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; - } - - if ( pv->done ) - { - hb_buffer_close( &pv->cur ); + hb_log( "sync: got too many frames (%d), exiting early", + pv->count_frames ); // 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 ) ); - return HB_WORK_DONE; + pv->busy &=~ 1; + return; } } - return HB_WORK_OK; } static void OutputAudioFrame( hb_job_t *job, hb_audio_t *audio, hb_buffer_t *buf, @@ -731,33 +716,60 @@ 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 ( buf->start - sync->next_pts >= (90 * 70) ) { + if ( buf->start - sync->next_pts > (90000LL * 60) ) + { + // 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; + } /* * there's a gap of at least 70ms between the last * frame we processed & the next. Fill it with silence. @@ -778,43 +790,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 )