X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fsync.c;h=04bdf162f36dac69cb0365a451548a2ada917d3b;hb=2654f65485b009783b79a0feb5bbd67e794ab8e1;hp=6ebbf6e0d6425430196081a12bd5984a138f417c;hpb=c7d8a4c93c59999481f91333ebdebde830575dbf;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/sync.c b/libhb/sync.c index 6ebbf6e0..04bdf162 100644 --- a/libhb/sync.c +++ b/libhb/sync.c @@ -20,7 +20,7 @@ typedef struct { hb_audio_t * audio; int64_t count_frames; - + /* Raw */ SRC_STATE * state; SRC_DATA data; @@ -40,17 +40,27 @@ struct hb_work_private_s hb_subtitle_t * subtitle; int64_t pts_offset; int64_t pts_offset_old; + int64_t next_start; int64_t count_frames; int64_t count_frames_max; + int64_t video_sequence; hb_buffer_t * cur; /* The next picture to process */ /* Audio */ hb_sync_audio_t sync_audio[8]; + /* Flags */ + int discontinuity; + /* Statistics */ uint64_t st_counts[4]; uint64_t st_dates[4]; uint64_t st_first; + + /* Throttle message flags */ + int trashing_audio; + int inserting_silence; + int way_out_of_sync; }; /*********************************************************************** @@ -84,13 +94,19 @@ int syncInit( hb_work_object_t * w, hb_job_t * job ) pv->pts_offset_old = INT64_MIN; pv->count_frames = 0; + pv->discontinuity = 0; + + pv->trashing_audio = 0; + pv->inserting_silence = 0; + pv->way_out_of_sync = 0; + /* Calculate how many video frames we are expecting */ 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; @@ -106,6 +122,8 @@ int syncInit( hb_work_object_t * w, hb_job_t * job ) /* Get subtitle info, if any */ pv->subtitle = hb_list_item( title->list_subtitle, 0 ); + pv->video_sequence = 0; + return 0; } @@ -119,14 +137,15 @@ void syncClose( hb_work_object_t * w ) hb_work_private_t * pv = w->private_data; hb_job_t * job = pv->job; hb_title_t * title = job->title; - + int i; if( pv->cur ) hb_buffer_close( &pv->cur ); for( i = 0; i < hb_list_count( title->list_audio ); i++ ) { - if( job->acodec & HB_ACODEC_AC3 ) + if( job->acodec & HB_ACODEC_AC3 || + job->audio_mixdowns[i] == HB_AMIXDOWN_AC3 ) { free( pv->sync_audio[i].ac3_buf ); } @@ -135,7 +154,7 @@ void syncClose( hb_work_object_t * w ) src_delete( pv->sync_audio[i].state ); } } - + free( pv ); w->private_data = NULL; } @@ -144,9 +163,14 @@ void syncClose( hb_work_object_t * w ) * Work *********************************************************************** * The root routine of this work abject + * + * The way this works is that we are syncing the audio to the PTS of + * the last video that we processed. That's why we skip the audio sync + * if we haven't got a valid PTS from the video yet. + * **********************************************************************/ int syncWork( hb_work_object_t * w, hb_buffer_t ** unused1, - hb_buffer_t ** unused2 ) + hb_buffer_t ** unused2 ) { hb_work_private_t * pv = w->private_data; int i; @@ -183,7 +207,8 @@ static void InitAudio( hb_work_object_t * w, int i ) sync = &pv->sync_audio[i]; sync->audio = hb_list_item( title->list_audio, i ); - if( job->acodec & HB_ACODEC_AC3 ) + if( job->acodec & HB_ACODEC_AC3 || + job->audio_mixdowns[i] == HB_AMIXDOWN_AC3 ) { /* Have a silent AC-3 frame ready in case we have to fill a gap */ @@ -215,7 +240,7 @@ static void InitAudio( hb_work_object_t * w, int i ) { hb_log( "sync: avcodec_encode_audio failed" ); } - + free( zeros ); avcodec_close( c ); av_free( c ); @@ -236,7 +261,7 @@ static void InitAudio( hb_work_object_t * w, int i ) /*********************************************************************** * SyncVideo *********************************************************************** - * + * **********************************************************************/ static int SyncVideo( hb_work_object_t * w ) { @@ -260,14 +285,14 @@ static int SyncVideo( hb_work_object_t * w ) hb_log( "sync: got %lld frames, %lld expected", pv->count_frames, pv->count_frames_max ); 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; } @@ -294,19 +319,41 @@ static int SyncVideo( hb_work_object_t * w ) pv->pts_offset = cur->start; } + /* + * Track the video sequence number localy so that we can sync the audio + * to it using the sequence number as well as the PTS. + */ + pv->video_sequence = cur->sequence; + /* Check for PTS jumps over 0.5 second */ if( next->start < cur->start - PTS_DISCONTINUITY_TOLERANCE || next->start > cur->start + PTS_DISCONTINUITY_TOLERANCE ) { - hb_log( "PTS discontinuity (%lld, %lld)", - cur->start, next->start ); - - /* Trash all subtitles */ + hb_log( "Sync: Video PTS discontinuity %s (current buffer start=%lld, next buffer start=%lld)", + pv->discontinuity ? "second" : "first", cur->start, next->start ); + + /* + * Do we need to trash the subtitle, is it from the next->start period + * or is it from our old position. If the latter then trash it. + */ if( pv->subtitle ) { - while( ( sub = hb_fifo_get( pv->subtitle->fifo_raw ) ) ) + while( ( sub = hb_fifo_see( pv->subtitle->fifo_raw ) ) ) { - hb_buffer_close( &sub ); + if( ( sub->start > ( cur->start - PTS_DISCONTINUITY_TOLERANCE ) ) && + ( sub->start < ( cur->start + PTS_DISCONTINUITY_TOLERANCE ) ) ) + { + /* + * The subtitle is from our current time region which we are + * jumping from. So trash it as we are about to jump backwards + * or forwards and don't want it blocking the subtitle fifo. + */ + hb_log("Trashing subtitle 0x%x due to PTS discontinuity", sub); + sub = hb_fifo_get( pv->subtitle->fifo_raw ); + hb_buffer_close( &sub ); + } else { + break; + } } } @@ -319,8 +366,20 @@ static int SyncVideo( hb_work_object_t * w ) /* Calculate new offset */ pv->pts_offset_old = pv->pts_offset; - pv->pts_offset = cur->start - - pv->count_frames * pv->job->vrate_base / 300; + if ( job->vfr ) + { + pv->pts_offset = cur->start - pv->next_start; + } else { + pv->pts_offset = cur->start - + pv->count_frames * pv->job->vrate_base / 300; + } + + if( !pv->discontinuity ) + { + pv->discontinuity = 1; + } + + pv->video_sequence = cur->sequence; continue; } @@ -336,61 +395,210 @@ static int SyncVideo( hb_work_object_t * w ) if( sub2 && sub->stop > sub2->start ) sub->stop = sub2->start; - if( sub->stop > cur->start ) + // hb_log("0x%x: video seq: %lld subtitle sequence: %lld", + // sub, cur->sequence, sub->sequence); + + if( sub->sequence > cur->sequence ) + { + /* + * The video is behind where we are, so wait until + * it catches up to the same reader point on the + * DVD. Then our PTS should be in the same region + * as the video. + */ + sub = NULL; + break; + } + + if( sub->stop > cur->start ) { + /* + * The stop time is in the future, so fall through + * and we'll deal with it in the next block of + * code. + */ break; + } + else + { + /* + * The stop time is in the past. But is it due to + * it having been played already, or has the PTS + * been reset to 0? + */ + if( ( cur->start - sub->stop ) > PTS_DISCONTINUITY_TOLERANCE ) { + /* + * There is a lot of time between our current + * video and where this subtitle is ending, + * assume that we are about to reset the PTS + * and do not throw away this subtitle. + */ + break; + } + } - /* The subtitle is older than this picture, trash it */ + /* + * The subtitle is older than this picture, trash it + */ sub = hb_fifo_get( pv->subtitle->fifo_raw ); hb_buffer_close( &sub ); } - /* If we have subtitles left in the fifo, check if we should - apply the first one to the current frame or if we should - keep it for later */ - if( sub && sub->start > cur->start ) + /* + * There is a valid subtitle, is it time to display it? + */ + if( sub ) { - sub = NULL; + if( sub->stop > sub->start) + { + /* + * Normal subtitle which ends after it starts, check to + * see that the current video is between the start and end. + */ + if( cur->start > sub->start && + cur->start < sub->stop ) + { + /* + * We should be playing this, so leave the + * subtitle in place. + * + * fall through to display + */ + if( ( sub->stop - sub->start ) < ( 3 * 90000 ) ) + { + /* + * Subtitle is on for less than three seconds, extend + * the time that it is displayed to make it easier + * to read. Make it 3 seconds or until the next + * subtitle is displayed. + * + * This is in response to Indochine which only + * displays subs for 1 second - too fast to read. + */ + sub->stop = sub->start + ( 3 * 90000 ); + + sub2 = hb_fifo_see2( pv->subtitle->fifo_raw ); + + if( sub2 && sub->stop > sub2->start ) + { + sub->stop = sub2->start; + } + } + } + else + { + /* + * Defer until the play point is within the subtitle + */ + sub = NULL; + } + } + else + { + /* + * The end of the subtitle is less than the start, this is a + * sign of a PTS discontinuity. + */ + if( sub->start > cur->start ) + { + /* + * we haven't reached the start time yet, or + * we have jumped backwards after having + * already started this subtitle. + */ + if( cur->start < sub->stop ) + { + /* + * We have jumped backwards and so should + * continue displaying this subtitle. + * + * fall through to display. + */ + } + else + { + /* + * Defer until the play point is within the subtitle + */ + sub = NULL; + } + } else { + /* + * Play this subtitle as the start is greater than our + * video point. + * + * fall through to display/ + */ + } + } } } - /* The PTS of the frame we are expecting now */ - pts_expected = pv->pts_offset + - pv->count_frames * pv->job->vrate_base / 300; - - if( cur->start < pts_expected - pv->job->vrate_base / 300 / 2 && - next->start < pts_expected + pv->job->vrate_base / 300 / 2 ) + if ( job->vfr ) { - /* The current frame is too old but the next one matches, - let's trash */ - /* Also, make sure we don't trash a chapter break */ - chap_break = cur->new_chap; - hb_buffer_close( &cur ); + /* + * adjust the pts of the current frame so that it's contiguous + * with the previous frame. pts_offset tracks the time difference + * between the pts values in the input content (which start at some + * random time) and our timestamps (which start at zero). We don't + * make any adjustments to the source timestamps other than removing + * the clock offsets (which also removes pts discontinuities). + * This means we automatically encode at the source's frame rate. + * MP2 uses an implicit duration (frames end when the next frame + * starts) but more advanced containers like MP4 use an explicit + * duration. Since we're looking ahead one frame we set the + * explicit stop time from the start time of the next frame. + */ + buf_tmp = cur; pv->cur = cur = hb_fifo_get( job->fifo_raw ); - cur->new_chap |= chap_break; // Make sure we don't stomp the existing one. - - continue; - } - - if( next->start > pts_expected + 3 * pv->job->vrate_base / 300 / 2 ) - { - /* We'll need the current frame more than one time. Make a - copy of it and keep it */ - buf_tmp = hb_buffer_init( cur->size ); - memcpy( buf_tmp->data, cur->data, cur->size ); + buf_tmp->start = pv->next_start; + pv->next_start = next->start - pv->pts_offset; + buf_tmp->stop = pv->next_start; } else { - /* The frame has the expected date and won't have to be - duplicated, just put it through */ - buf_tmp = cur; - pv->cur = cur = hb_fifo_get( job->fifo_raw ); + /* The PTS of the frame we are expecting now */ + pts_expected = pv->pts_offset + + pv->count_frames * pv->job->vrate_base / 300; + + //hb_log("Video expecting PTS %lld, current frame: %lld, next frame: %lld, cf: %lld", + // pts_expected, cur->start, next->start, pv->count_frames * pv->job->vrate_base / 300 ); + + if( cur->start < pts_expected - pv->job->vrate_base / 300 / 2 && + next->start < pts_expected + pv->job->vrate_base / 300 / 2 ) + { + /* The current frame is too old but the next one matches, + let's trash */ + /* Also, make sure we don't trash a chapter break */ + chap_break = cur->new_chap; + hb_buffer_close( &cur ); + pv->cur = cur = hb_fifo_get( job->fifo_raw ); + cur->new_chap |= chap_break; // Make sure we don't stomp the existing one. + + continue; + } + + if( next->start > pts_expected + 3 * pv->job->vrate_base / 300 / 2 ) + { + /* We'll need the current frame more than one time. Make a + copy of it and keep it */ + buf_tmp = hb_buffer_init( cur->size ); + memcpy( buf_tmp->data, cur->data, cur->size ); + buf_tmp->sequence = cur->sequence; + } + else + { + /* The frame has the expected date and won't have to be + duplicated, just put it through */ + buf_tmp = cur; + pv->cur = cur = hb_fifo_get( job->fifo_raw ); + } + + /* Replace those MPEG-2 dates with our dates */ + buf_tmp->start = (uint64_t) pv->count_frames * + pv->job->vrate_base / 300; + buf_tmp->stop = (uint64_t) ( pv->count_frames + 1 ) * + pv->job->vrate_base / 300; } - - /* Replace those MPEG-2 dates with our dates */ - buf_tmp->start = (uint64_t) pv->count_frames * - pv->job->vrate_base / 300; - buf_tmp->stop = (uint64_t) ( pv->count_frames + 1 ) * - pv->job->vrate_base / 300; /* If we have a subtitle for this picture, copy it */ /* FIXME: we should avoid this memcpy */ @@ -411,16 +619,16 @@ static int SyncVideo( hb_work_object_t * w ) UpdateState( w ); /* Make sure we won't get more frames then expected */ - if( pv->count_frames >= pv->count_frames_max ) + if( pv->count_frames >= pv->count_frames_max * 2) { - hb_log( "sync: got %lld frames", pv->count_frames ); + hb_log( "sync: got too many frames (%lld), 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 ); - + break; } } @@ -431,7 +639,7 @@ static int SyncVideo( hb_work_object_t * w ) /*********************************************************************** * SyncAudio *********************************************************************** - * + * **********************************************************************/ static void SyncAudio( hb_work_object_t * w, int i ) { @@ -451,7 +659,8 @@ static void SyncAudio( hb_work_object_t * w, int i ) sync = &pv->sync_audio[i]; audio = sync->audio; - if( job->acodec & HB_ACODEC_AC3 ) + if( job->acodec & HB_ACODEC_AC3 || + job->audio_mixdowns[i] == HB_AMIXDOWN_AC3 ) { fifo = audio->fifo_out; rate = audio->rate; @@ -468,49 +677,153 @@ static void SyncAudio( hb_work_object_t * w, int i ) /* The PTS of the samples we are expecting now */ pts_expected = pv->pts_offset + sync->count_frames * 90000 / rate; - if( ( buf->start > pts_expected + PTS_DISCONTINUITY_TOLERANCE || - buf->start < pts_expected - PTS_DISCONTINUITY_TOLERANCE ) && - pv->pts_offset_old > INT64_MIN ) + // hb_log("Video Sequence: %lld, Audio Sequence: %lld", pv->video_sequence, buf->sequence); + + /* + * Using the same logic as the Video have we crossed a VOB + * boundary as detected by the expected PTS and the PTS of our + * audio being out by more than the tolerance value. + */ + if( buf->start > pts_expected + PTS_DISCONTINUITY_TOLERANCE || + buf->start < pts_expected - PTS_DISCONTINUITY_TOLERANCE ) { /* There has been a PTS discontinuity, and this frame might - be from before the discontinuity */ - pts_expected = pv->pts_offset_old + sync->count_frames * - 90000 / rate; + be from before the discontinuity*/ + if( pv->discontinuity ) + { + /* + * There is an outstanding discontinuity, so use the offset from + * that discontinuity. + */ + pts_expected = pv->pts_offset_old + sync->count_frames * + 90000 / rate; + } + else + { + /* + * No outstanding discontinuity, so the audio must be leading the + * video (or the PTS values are really stuffed). So lets mark this + * as a discontinuity ourselves for the audio to use until + * the video also crosses the discontinuity. + * + * pts_offset is used when we are in the same time space as the video + * pts_offset_old when in a discontinuity. + * + * Therefore set the pts_offset_old given the new pts_offset for this + * current buffer. + */ + pv->discontinuity = 1; + pv->pts_offset_old = buf->start - sync->count_frames * + 90000 / rate; + pts_expected = pv->pts_offset_old + sync->count_frames * + 90000 / rate; + + hb_log("Sync: Audio discontinuity (sequence: vid %lld aud %lld) (pts %lld < %lld < %lld)", + pv->video_sequence, buf->sequence, + pts_expected - PTS_DISCONTINUITY_TOLERANCE, buf->start, + pts_expected + PTS_DISCONTINUITY_TOLERANCE ); + } + + /* + * Is the audio from a valid period given the previous + * Video PTS. I.e. has there just been a video PTS + * discontinuity and this audio belongs to the vdeo from + * before? + */ if( buf->start > pts_expected + PTS_DISCONTINUITY_TOLERANCE || buf->start < pts_expected - PTS_DISCONTINUITY_TOLERANCE ) { - /* There is really nothing we can do with it */ - buf = hb_fifo_get( audio->fifo_raw ); - hb_buffer_close( &buf ); - continue; - } + /* + * It's outside of our tolerance for where the video + * is now, and it's outside of the tolerance for + * where we have been in the case of a VOB change. + * Try and reconverge regardless. so continue on to + * our convergence code below which will kick in as + * it will be more than 100ms out. + * + * Note that trashing the Audio could make things + * worse if the Audio is in front because we will end + * up diverging even more. We need to hold on to the + * audio until the video catches up. + */ + if( !pv->way_out_of_sync ) + { + hb_log("Sync: Audio is way out of sync, attempt to reconverge from current video PTS"); + pv->way_out_of_sync = 1; + } - /* Use the older offset */ - start = pts_expected - pv->pts_offset_old; + /* + * It wasn't from the old place, so we must be from + * the new, but just too far out. So attempt to + * reconverge by resetting the point we want to be to + * where we are currently wanting to be. + */ + pts_expected = pv->pts_offset + sync->count_frames * 90000 / rate; + start = pts_expected - pv->pts_offset; + } else { + /* Use the older offset */ + start = pts_expected - pv->pts_offset_old; + } } else { start = pts_expected - pv->pts_offset; + + if( pv->discontinuity ) + { + /* + * The Audio is tracking the Video again using the normal pts_offset, so the + * discontinuity is over. + */ + hb_log( "Sync: Audio joined Video after discontinuity at PTS %lld", buf->start ); + pv->discontinuity = 0; + } } /* Tolerance: 100 ms */ if( buf->start < pts_expected - 9000 ) { - /* Late audio, trash it */ - hb_log( "sync: trashing late audio" ); + if( !pv->trashing_audio ) + { + /* Audio is behind the Video, trash it, can't use it now. */ + hb_log( "Sync: Audio PTS (%lld) < Video PTS (%lld) by greater than 100ms, trashing audio to reconverge", + buf->start, pts_expected); + pv->trashing_audio = 1; + } buf = hb_fifo_get( audio->fifo_raw ); hb_buffer_close( &buf ); continue; } else if( buf->start > pts_expected + 9000 ) { - /* Missing audio, send a frame of silence */ + /* Audio is ahead of the Video, insert silence until we catch up*/ + if( !pv->inserting_silence ) + { + hb_log("Sync: Audio PTS (%lld) > Video PTS (%lld) by greater than 100ms insert silence until reconverged", buf->start, pts_expected); + pv->inserting_silence = 1; + } InsertSilence( w, i ); continue; } + else + { + if( pv->trashing_audio || pv->inserting_silence ) + { + hb_log( "Sync: Audio back in Sync at PTS %lld", buf->start ); + pv->trashing_audio = 0; + pv->inserting_silence = 0; + } + if( pv->way_out_of_sync ) + { + hb_log( "Sync: Audio no longer way out of sync at PTS %lld", + buf->start ); + pv->way_out_of_sync = 0; + } + } - if( job->acodec & HB_ACODEC_AC3 ) + if( job->acodec & HB_ACODEC_AC3 || + job->audio_mixdowns[i] == HB_AMIXDOWN_AC3 ) { buf = hb_fifo_get( audio->fifo_raw ); buf->start = start; @@ -558,10 +871,20 @@ static void SyncAudio( hb_work_object_t * w, int i ) sync->count_frames += sync->data.output_frames_gen; } - buf->key = 1; + buf->frametype = HB_FRAME_AUDIO; hb_fifo_push( fifo, buf ); } + if( hb_fifo_is_full( fifo ) && + pv->way_out_of_sync ) + { + /* + * Trash the top audio packet to avoid dead lock as we reconverge. + */ + if ( (buf = hb_fifo_get( audio->fifo_raw ) ) != NULL) + hb_buffer_close( &buf ); + } + if( NeedSilence( w, audio ) ) { InsertSilence( w, i ); @@ -588,6 +911,7 @@ static int NeedSilence( hb_work_object_t * w, hb_audio_t * audio ) { /* We might miss some audio to complete encoding and muxing the video track */ + hb_log("Reader has exited early, inserting silence."); return 1; } @@ -598,6 +922,7 @@ static int NeedSilence( hb_work_object_t * w, hb_audio_t * audio ) hb_fifo_is_full( job->fifo_mpeg4 ) ) { /* Too much video and no audio, oh-oh */ + hb_log("Still got some video - and nothing in the audio fifo, insert silence"); return 1; } @@ -614,7 +939,8 @@ static void InsertSilence( hb_work_object_t * w, int i ) job = pv->job; sync = &pv->sync_audio[i]; - if( job->acodec & HB_ACODEC_AC3 ) + if( job->acodec & HB_ACODEC_AC3 || + job->audio_mixdowns[i] == HB_AMIXDOWN_AC3 ) { buf = hb_buffer_init( sync->ac3_size ); buf->start = sync->count_frames * 90000 / sync->audio->rate; @@ -637,8 +963,6 @@ static void InsertSilence( hb_work_object_t * w, int i ) buf->stop = buf->start + 90000 / 20; memset( buf->data, 0, buf->size ); - hb_log( "sync: adding 50 ms of silence for track %x", - sync->audio->id ); hb_fifo_push( sync->audio->fifo_sync, buf ); sync->count_frames += job->arate / 20; @@ -664,14 +988,14 @@ static void UpdateState( hb_work_object_t * w ) 3 * sizeof( uint64_t ) ); pv->st_dates[3] = hb_get_date(); pv->st_counts[3] = pv->count_frames; - } + } #define p state.param.working state.state = HB_STATE_WORKING; p.progress = (float) pv->count_frames / (float) pv->count_frames_max; if( p.progress > 1.0 ) { - p.progress = 1.0; + p.progress = 1.0; } p.rate_cur = 1000.0 * (float) ( pv->st_counts[3] - pv->st_counts[0] ) /