X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fsync.c;h=94b8411b491ca8309d9d1011c4399cbee003e7cc;hb=033e32de9c380f54c7d1362a3979da205ebc3a29;hp=67093d1e6f4fb12ee0c08a7c1e0c6c61f23919ad;hpb=558af2c66356ed24ff3e49264f19228bb8f0cbd5;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/sync.c b/libhb/sync.c index 67093d1e..94b8411b 100644 --- a/libhb/sync.c +++ b/libhb/sync.c @@ -60,6 +60,7 @@ struct hb_work_private_s /* Audio */ hb_sync_audio_t sync_audio[8]; int64_t audio_passthru_slip; + int64_t video_pts_slip; /* Statistics */ uint64_t st_counts[4]; @@ -95,28 +96,37 @@ int syncInit( hb_work_object_t * w, hb_job_t * job ) pv->job = job; pv->pts_offset = INT64_MIN; - /* Calculate how many video frames we are expecting */ - if (job->pts_to_stop) + if( job->pass == 2 ) { - duration = job->pts_to_stop + 90000; - } - else if( job->frame_to_stop ) - { - /* Set the duration to a rough estimate */ - duration = ( job->frame_to_stop / ( job->vrate / job->vrate_base ) ) * 90000; + /* We already have an accurate frame count from pass 1 */ + hb_interjob_t * interjob = hb_interjob_get( job->h ); + pv->count_frames_max = interjob->frame_count; } else { - duration = 0; - for( i = job->chapter_start; i <= job->chapter_end; i++ ) + /* Calculate how many video frames we are expecting */ + if ( job->pts_to_stop ) + { + duration = job->pts_to_stop + 90000; + } + else if( job->frame_to_stop ) { - chapter = hb_list_item( title->list_chapter, i - 1 ); - duration += chapter->duration; + /* Set the duration to a rough estimate */ + duration = ( job->frame_to_stop / ( title->rate / title->rate_base ) ) * 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 */ } - duration += 90000; - /* 1 second safety so we're sure we won't miss anything */ + pv->count_frames_max = duration * title->rate / title->rate_base / 90000; } - 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; @@ -155,6 +165,16 @@ void syncClose( hb_work_object_t * w ) hb_log( "sync: got %d frames, %d expected", pv->count_frames, pv->count_frames_max ); + /* save data for second pass */ + if( job->pass == 1 ) + { + /* Preserve frame count for better accuracy in pass 2 */ + hb_interjob_t * interjob = hb_interjob_get( job->h ); + interjob->frame_count = pv->count_frames; + interjob->last_job = job->sequence_id; + interjob->total_time = pv->next_start; + } + if (pv->drops || pv->dups ) { hb_log( "sync: %d frames dropped, %d duplicated", pv->drops, pv->dups ); @@ -282,6 +302,7 @@ static void SyncVideo( hb_work_object_t * w ) hb_job_t * job = pv->job; hb_subtitle_t *subtitle; int i; + int64_t pts_skip; if( !pv->cur && !( pv->cur = hb_fifo_get( job->fifo_raw ) ) ) { @@ -289,10 +310,24 @@ static void SyncVideo( hb_work_object_t * w ) return; } cur = pv->cur; + pts_skip = 0; 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 ) ); + + /* + * Push through any subtitle EOFs in case they were not synced through. + */ + for( i = 0; i < hb_list_count( job->list_subtitle ); i++) + { + subtitle = hb_list_item( job->list_subtitle, i ); + if( subtitle->config.dest == PASSTHRUSUB ) + { + hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) ); + } + } + pv->busy &=~ 1; return; } @@ -313,6 +348,18 @@ static void SyncVideo( hb_work_object_t * w ) * 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 ) ); + + /* + * Push through any subtitle EOFs in case they were not synced through. + */ + for( i = 0; i < hb_list_count( job->list_subtitle ); i++) + { + subtitle = hb_list_item( job->list_subtitle, i ); + if( subtitle->config.dest == PASSTHRUSUB ) + { + hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) ); + } + } pv->busy &=~ 1; return; } @@ -330,15 +377,11 @@ static void SyncVideo( hb_work_object_t * w ) * as if it started at zero so that our audio timing will * be in sync. */ - hb_log( "sync: first pts is %lld", cur->start ); + hb_log( "sync: first pts is %"PRId64, cur->start ); cur->start = 0; } } - 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 @@ -350,14 +393,18 @@ static void 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 - cur->start ) <= 0 || - (int64_t)( (cur->start - pv->audio_passthru_slip ) - pv->next_pts ) < 0 ) + if ( (int64_t)( next->start - pv->video_pts_slip - cur->start ) <= 0 ) { if ( pv->first_drop == 0 ) { pv->first_drop = next->start; } ++pv->drop_count; + if (next->start - cur->start > 0) + { + pts_skip += next->start - cur->start; + pv->video_pts_slip -= next->start - cur->start; + } buf_tmp = hb_fifo_get( job->fifo_raw ); if ( buf_tmp->new_chap ) { @@ -370,7 +417,7 @@ static void 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, dur %d)", + "(delta %d ms, current %"PRId64", next %"PRId64", 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; @@ -398,7 +445,9 @@ static void SyncVideo( hb_work_object_t * w ) /* * Rewrite timestamps on subtitles that need it (on raw queue). */ - if( subtitle->source == CCSUB ) + if( subtitle->source == CC608SUB || + subtitle->source == CC708SUB || + subtitle->source == SRTSUB ) { /* * Rewrite timestamps on subtitles that came from Closed Captions @@ -416,20 +465,25 @@ static void SyncVideo( hb_work_object_t * w ) * * Bypass the sync fifo altogether. */ - if( sub->size == 0 ) + if( sub->size <= 0 ) { sub = hb_fifo_get( subtitle->fifo_raw ); hb_fifo_push( subtitle->fifo_out, sub ); sub = NULL; break; } else { + /* + * Sync the subtitles to the incoming video, and use + * the matching converted video timestamp. + * + * Note that it doesn't appear that we need to convert + * timestamps, I guess that they were already correct, + * so just push them through for rendering. + * + */ if( sub->start < cur->start ) { - uint64_t duration; - duration = sub->stop - sub->start; sub = hb_fifo_get( subtitle->fifo_raw ); - sub->start = pv->next_start; - sub->stop = sub->start + duration; hb_fifo_push( subtitle->fifo_out, sub ); } else { sub = NULL; @@ -456,7 +510,9 @@ static void SyncVideo( hb_work_object_t * w ) when the second one starts */ sub2 = hb_fifo_see2( subtitle->fifo_raw ); if( sub2 && sub->stop > sub2->start ) + { sub->stop = sub2->start; + } // hb_log("0x%x: video seq: %lld subtitle sequence: %lld", // sub, cur->sequence, sub->sequence); @@ -479,120 +535,152 @@ static void SyncVideo( hb_work_object_t * w ) * and we'll deal with it in the next block of * code. */ - break; - } - - /* - * The subtitle is older than this picture, trash it - */ - sub = hb_fifo_get( subtitle->fifo_raw ); - hb_buffer_close( &sub ); - } - - if( sub && sub->size == 0 ) - { - /* - * Continue immediately on subtitle EOF - */ - break; - } - /* - * There is a valid subtitle, is it time to display it? - */ - if( sub ) - { - 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. + * There is a valid subtitle, is it time to display it? */ - if( cur->start > sub->start && - cur->start < sub->stop ) + if( sub->stop > sub->start) { /* - * We should be playing this, so leave the - * subtitle in place. - * - * fall through to display + * Normal subtitle which ends after it starts, + * check to see that the current video is between + * the start and end. */ - if( ( sub->stop - sub->start ) < ( 3 * 90000 ) ) + if( cur->start > sub->start && + cur->start < sub->stop ) { /* - * 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 ); + * We should be playing this, so leave the + * subtitle in place. + * + * fall through to display + */ + if( ( sub->stop - sub->start ) < ( 2 * 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 + ( 2 * 90000 ); - sub2 = hb_fifo_see2( subtitle->fifo_raw ); + sub2 = hb_fifo_see2( subtitle->fifo_raw ); - if( sub2 && sub->stop > sub2->start ) - { - sub->stop = sub2->start; + if( sub2 && sub->stop > sub2->start ) + { + sub->stop = sub2->start; + } } } + else + { + /* + * Defer until the play point is within + * the subtitle + */ + sub = NULL; + } } else { /* - * Defer until the play point is within the subtitle + * The end of the subtitle is less than the start, + * this is a sign of a PTS discontinuity. */ - sub = NULL; + 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/ + */ + } } + break; } else { + /* - * The end of the subtitle is less than the start, this is a - * sign of a PTS discontinuity. + * The subtitle is older than this picture, trash it */ - if( sub->start > cur->start ) + sub = hb_fifo_get( subtitle->fifo_raw ); + hb_buffer_close( &sub ); + } + } + + /* If we have a subtitle for this picture, copy it */ + /* FIXME: we should avoid this memcpy */ + if( sub ) + { + if( sub->size > 0 ) + { + if( subtitle->config.dest == RENDERSUB ) { - /* - * we haven't reached the start time yet, or - * we have jumped backwards after having - * already started this subtitle. - */ - if( cur->start < sub->stop ) + if ( cur->sub == NULL ) { /* - * We have jumped backwards and so should - * continue displaying this subtitle. - * - * fall through to display. + * Tack onto the video buffer for rendering */ - } - else - { - /* - * Defer until the play point is within the subtitle - */ - sub = NULL; + cur->sub = hb_buffer_init( sub->size ); + cur->sub->x = sub->x; + cur->sub->y = sub->y; + cur->sub->width = sub->width; + cur->sub->height = sub->height; + memcpy( cur->sub->data, sub->data, sub->size ); } } else { /* - * Play this subtitle as the start is greater than our - * video point. - * - * fall through to display/ + * Pass-Through, pop it off of the raw queue, */ + sub = hb_fifo_get( subtitle->fifo_raw ); + hb_fifo_push( subtitle->fifo_sync, sub ); + } + } else { + /* + * EOF - consume for rendered, else pass through + */ + if( subtitle->config.dest == RENDERSUB ) + { + sub = hb_fifo_get( subtitle->fifo_raw ); + hb_buffer_close( &sub ); + } else { + sub = hb_fifo_get( subtitle->fifo_raw ); + hb_fifo_push( subtitle->fifo_out, sub ); } } } } - if( sub ) - { - /* - * Got a sub to display... - */ - break; - } } // end subtitles /* @@ -610,11 +698,13 @@ static void SyncVideo( hb_work_object_t * w ) */ buf_tmp = cur; pv->cur = cur = hb_fifo_get( job->fifo_raw ); + cur->sub = NULL; pv->next_pts = cur->start; - int64_t duration = cur->start - buf_tmp->start; + int64_t duration = cur->start - pts_skip - buf_tmp->start; + pts_skip = 0; if ( duration <= 0 ) { - hb_log( "sync: invalid video duration %lld, start %lld, next %lld", + hb_log( "sync: invalid video duration %"PRId64", start %"PRId64", next %"PRId64"", duration, buf_tmp->start, next->start ); } @@ -630,51 +720,6 @@ static void SyncVideo( hb_work_object_t * w ) pv->chap_mark = 0; } - /* If we have a subtitle for this picture, copy it */ - /* FIXME: we should avoid this memcpy */ - if( sub && subtitle && - subtitle->format == PICTURESUB ) - { - if( sub->size > 0 ) - { - if( subtitle->dest == RENDERSUB ) - { - /* - * Tack onto the video buffer for rendering - */ - buf_tmp->sub = hb_buffer_init( sub->size ); - buf_tmp->sub->x = sub->x; - buf_tmp->sub->y = sub->y; - buf_tmp->sub->width = sub->width; - buf_tmp->sub->height = sub->height; - memcpy( buf_tmp->sub->data, sub->data, sub->size ); - } else { - /* - * Pass-Through, pop it off of the raw queue, rewrite times and - * make it available to be reencoded. - */ - uint64_t sub_duration; - sub = hb_fifo_get( subtitle->fifo_raw ); - sub_duration = sub->stop - sub->start; - sub->start = buf_tmp->start; - sub->stop = sub->start + duration; - hb_fifo_push( subtitle->fifo_sync, sub ); - } - } else { - /* - * EOF - consume for rendered, else pass through - */ - if( subtitle->dest == RENDERSUB ) - { - sub = hb_fifo_get( subtitle->fifo_raw ); - hb_buffer_close( &sub ); - } else { - sub = hb_fifo_get( subtitle->fifo_raw ); - hb_fifo_push( subtitle->fifo_out, sub ); - } - } - } - /* Push the frame to the renderer */ hb_fifo_push( job->fifo_sync, buf_tmp ); @@ -691,19 +736,6 @@ static void SyncVideo( hb_work_object_t * w ) pv->count_frames, pv->busy ); return; } - - /* 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 ); - - // 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; - } } } @@ -837,7 +869,7 @@ static void SyncAudio( hb_work_object_t * w, int i ) { // 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, + "(next %"PRId64", current %"PRId64")", i, (int)( sync->next_pts - sync->first_drop ) / 90, sync->drop_count, sync->first_drop, sync->next_pts ); sync->first_drop = 0; @@ -852,7 +884,7 @@ static void SyncAudio( hb_work_object_t * w, int i ) // 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", + " start %"PRId64", next %"PRId64, (int)((start - sync->next_pts) / (90000*60)), i, start, sync->next_pts ); buf = hb_fifo_get( audio->priv.fifo_raw ); @@ -868,14 +900,15 @@ static void SyncAudio( hb_work_object_t * w, int i ) if( sync->audio->config.out.codec == HB_ACODEC_DCA ) { hb_log( "sync: audio gap %d ms. Skipping frames. Audio %d" - " start %lld, next %lld", + " start %"PRId64", next %"PRId64, (int)((start - sync->next_pts) / 90), i, start, sync->next_pts ); pv->audio_passthru_slip += (start - sync->next_pts); + pv->video_pts_slip += (start - sync->next_pts); return; } hb_log( "sync: adding %d ms of silence to audio %d" - " start %lld, next %lld", + " start %"PRId64", next %"PRId64, (int)((start - sync->next_pts) / 90), i, start, sync->next_pts ); InsertSilence( w, i, start - sync->next_pts ); @@ -940,6 +973,8 @@ static void UpdateState( hb_work_object_t * w ) if( !pv->count_frames ) { pv->st_first = hb_get_date(); + pv->job->st_pause_date = -1; + pv->job->st_paused = 0; } pv->count_frames++; @@ -967,7 +1002,7 @@ static void UpdateState( hb_work_object_t * w ) { int eta; p.rate_avg = 1000.0 * (float) pv->st_counts[3] / - (float) ( pv->st_dates[3] - pv->st_first ); + (float) ( pv->st_dates[3] - pv->st_first - pv->job->st_paused); eta = (float) ( pv->count_frames_max - pv->st_counts[3] ) / p.rate_avg; p.hours = eta / 3600;