X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=libhb%2Fsync.c;h=eee4708f5dcb7607dca8e440639d37121b7bedc2;hb=2a0e71f41fbf6c5fcde8dc286b16ccfd23061236;hp=920a0e3889a7948acbeebe421d28755c8b8473df;hpb=193ed51e0fc2fd74d30a64bff11f2417981587a7;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/sync.c b/libhb/sync.c index 920a0e38..eee4708f 100644 --- a/libhb/sync.c +++ b/libhb/sync.c @@ -44,7 +44,6 @@ struct hb_work_private_s // an eof buf. syncWork returns done when all // bits are clear. /* Video */ - hb_subtitle_t * subtitle; int64_t pts_offset; int64_t next_start; /* start time of next output frame */ int64_t next_pts; /* start time of next input frame */ @@ -60,6 +59,7 @@ struct hb_work_private_s /* Audio */ hb_sync_audio_t sync_audio[8]; + int64_t audio_passthru_slip; /* Statistics */ uint64_t st_counts[4]; @@ -124,16 +124,13 @@ int syncInit( hb_work_object_t * w, hb_job_t * job ) /* Initialize libsamplerate for every audio track we have */ if ( ! job->indepth_scan ) { - for( i = 0; i < hb_list_count( title->list_audio ); i++ ) + for( i = 0; i < hb_list_count( title->list_audio ) && i < 8; i++ ) { pv->busy |= ( 1 << (i + 1) ); InitAudio( w, i ); } } - /* Get subtitle info, if any */ - pv->subtitle = hb_list_item( title->list_subtitle, 0 ); - return 0; } @@ -283,6 +280,8 @@ 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; + hb_subtitle_t *subtitle; + int i; if( !pv->cur && !( pv->cur = hb_fifo_get( job->fifo_raw ) ) ) { @@ -294,6 +293,19 @@ static void SyncVideo( hb_work_object_t * w ) { /* 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->dest == PASSTHRUSUB ) + { + hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) ); + } + } + pv->busy &=~ 1; return; } @@ -314,6 +326,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->dest == PASSTHRUSUB ) + { + hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) ); + } + } pv->busy &=~ 1; return; } @@ -351,7 +375,8 @@ 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 ) + if ( (int64_t)( next->start - cur->start ) <= 0 || + (int64_t)( (cur->start - pv->audio_passthru_slip ) - pv->next_pts ) < 0 ) { if ( pv->first_drop == 0 ) { @@ -383,119 +408,168 @@ static void SyncVideo( hb_work_object_t * w ) */ pv->video_sequence = cur->sequence; - /* Look for a subtitle for this frame */ - if( pv->subtitle ) + /* + * Look for a subtitle for this frame. + * + * If found then it will be tagged onto a video buffer of the correct time and + * sent in to the render pipeline. This only needs to be done for VOBSUBs which + * get rendered, other types of subtitles can just sit in their raw_queue until + * delt with at muxing. + */ + for( i = 0; i < hb_list_count( job->list_subtitle ); i++) { - hb_buffer_t * sub2; - while( ( sub = hb_fifo_see( pv->subtitle->fifo_raw ) ) ) - { - /* If two subtitles overlap, make the first one stop - when the second one starts */ - sub2 = hb_fifo_see2( pv->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); - - 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; - } - - /* - * The subtitle is older than this picture, trash it - */ - sub = hb_fifo_get( pv->subtitle->fifo_raw ); - hb_buffer_close( &sub ); - } + subtitle = hb_list_item( job->list_subtitle, i ); /* - * There is a valid subtitle, is it time to display it? + * Rewrite timestamps on subtitles that need it (on raw queue). */ - if( sub ) + if( subtitle->source == CC608SUB || + subtitle->source == CC708SUB ) { - if( sub->stop > sub->start) + /* + * Rewrite timestamps on subtitles that came from Closed Captions + * since they are using the MPEG2 timestamps. + */ + while( ( sub = hb_fifo_see( subtitle->fifo_raw ) ) ) { /* - * Normal subtitle which ends after it starts, check to - * see that the current video is between the start and end. + * Rewrite the timestamps as and when the video + * (cur->start) reaches the same timestamp as a + * closed caption (sub->start). + * + * What about discontinuity boundaries - not delt + * with here - Van? + * + * Bypass the sync fifo altogether. */ - if( cur->start > sub->start && - cur->start < sub->stop ) + if( sub->size <= 0 ) { + sub = hb_fifo_get( subtitle->fifo_raw ); + hb_fifo_push( subtitle->fifo_out, sub ); + sub = NULL; + break; + } else { /* - * We should be playing this, so leave the - * subtitle in place. + * 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. * - * fall through to display */ - if( ( sub->stop - sub->start ) < ( 3 * 90000 ) ) + if( sub->start < cur->start ) { - /* - * 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; - } + uint64_t duration; + duration = sub->stop - sub->start; + sub = hb_fifo_get( subtitle->fifo_raw ); + hb_fifo_push( subtitle->fifo_out, sub ); + } else { + sub = NULL; + break; } } - else + } + } + + if( subtitle->source == VOBSUB ) + { + hb_buffer_t * sub2; + while( ( sub = hb_fifo_see( subtitle->fifo_raw ) ) ) + { + if( sub->size == 0 ) + { + /* + * EOF, pass it through immediately. + */ + break; + } + + /* If two subtitles overlap, make the first one stop + 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); + + if( sub->sequence > cur->sequence ) { /* - * Defer until the play point is within the subtitle + * 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; } + + /* + * The subtitle is older than this picture, trash it + */ + sub = hb_fifo_get( subtitle->fifo_raw ); + hb_buffer_close( &sub ); } - else + + if( sub && sub->size == 0 ) { - /* - * The end of the subtitle is less than the start, this is a - * sign of a PTS discontinuity. + /* + * Continue immediately on subtitle EOF */ - if( sub->start > cur->start ) + break; + } + + /* + * There is a valid subtitle, is it time to display it? + */ + if( sub ) + { + if( sub->stop > sub->start) { /* - * we haven't reached the start time yet, or - * we have jumped backwards after having - * already started this subtitle. + * Normal subtitle which ends after it starts, check to + * see that the current video is between the start and end. */ - if( cur->start < sub->stop ) + if( cur->start > sub->start && + cur->start < sub->stop ) { /* - * We have jumped backwards and so should - * continue displaying this subtitle. + * We should be playing this, so leave the + * subtitle in place. * - * fall through to display. + * 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( subtitle->fifo_raw ); + + if( sub2 && sub->stop > sub2->start ) + { + sub->stop = sub2->start; + } + } } else { @@ -504,97 +578,77 @@ static void SyncVideo( hb_work_object_t * w ) */ sub = NULL; } - } else { + } + else + { /* - * Play this subtitle as the start is greater than our - * video point. - * - * fall through to display/ + * 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/ + */ + } } } } - } - - int64_t duration; - if ( job->mux & HB_MUX_AVI || job->cfr ) - { - /* - * The concept of variable frame rate video was a bit too advanced - * for Microsoft so AVI doesn't support it. Since almost all dvd - * video is VFR we have to convert it to constant frame rate to - * put it in an AVI container. So here we duplicate, drop and - * otherwise trash video frames to appease the gods of Redmond. - */ - - /* mpeg durations are exact when expressed in ticks of the - * 27MHz System clock but not in HB's 90KHz PTS clock. To avoid - * a truncation bias that will eventually cause the audio to desync - * we compute the duration of the next frame using 27MHz ticks - * then truncate it to 90KHz. */ - duration = ( (int64_t)(pv->count_frames + 1 ) * job->vrate_base ) / 300 - - pv->next_start; - - /* We don't want the input & output clocks to be exactly in phase - * otherwise small variations in the time will cause us to think - * we're a full frame off & there will be lots of drops and dups. - * We offset the input clock by half the duration so it's maximally - * out of phase with the output clock. */ - if( cur->start < pv->next_start - ( duration >> 1 ) ) + if( sub ) { - /* current frame too old - drop it */ - if ( cur->new_chap ) - { - pv->chap_mark = cur->new_chap; - } - hb_buffer_close( &cur ); - pv->cur = cur = hb_fifo_get( job->fifo_raw ); - pv->next_pts = next->start; - ++pv->drops; - continue; + /* + * Got a sub to display... + */ + break; } + } // end subtitles - if( next->start > pv->next_start + duration + ( duration >> 1 ) ) - { - /* next frame too far ahead - dup current frame */ - buf_tmp = hb_buffer_init( cur->size ); - hb_buffer_copy_settings( buf_tmp, cur ); - memcpy( buf_tmp->data, cur->data, cur->size ); - buf_tmp->sequence = cur->sequence; - ++pv->dups; - } - else - { - /* this frame in our time window & doesn't need to be duped */ - buf_tmp = cur; - pv->cur = cur = hb_fifo_get( job->fifo_raw ); - pv->next_pts = next->start; - } - } - else + /* + * Adjust the pts of the current frame so that it's contiguous + * with the previous frame. The start time of the current frame + * has to be the end time of the previous frame and the stop + * time has to be the start of the next frame. 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 ); + pv->next_pts = cur->start; + int64_t duration = cur->start - buf_tmp->start; + if ( duration <= 0 ) { - /* - * Adjust the pts of the current frame so that it's contiguous - * with the previous frame. The start time of the current frame - * has to be the end time of the previous frame and the stop - * time has to be the start of the next frame. 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 ); - 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", - duration, buf_tmp->start, next->start ); - } + hb_log( "sync: invalid video duration %lld, start %lld, next %lld", + duration, buf_tmp->start, next->start ); } buf_tmp->start = pv->next_start; @@ -611,14 +665,47 @@ static void SyncVideo( hb_work_object_t * w ) /* If we have a subtitle for this picture, copy it */ /* FIXME: we should avoid this memcpy */ - if( sub ) + if( sub && subtitle && + subtitle->format == PICTURESUB ) { - 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 ); + 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 */ @@ -730,8 +817,10 @@ static void SyncAudio( hb_work_object_t * w, int i ) hb_audio_t * audio = sync->audio; hb_buffer_t * buf; hb_fifo_t * fifo; + int64_t start; - if( audio->config.out.codec == HB_ACODEC_AC3 ) + if( audio->config.out.codec == HB_ACODEC_AC3 || + audio->config.out.codec == HB_ACODEC_DCA ) { fifo = audio->priv.fifo_out; } @@ -742,6 +831,7 @@ static void SyncAudio( hb_work_object_t * w, int i ) while( !hb_fifo_is_full( fifo ) && ( buf = hb_fifo_see( audio->priv.fifo_raw ) ) ) { + start = buf->start - pv->audio_passthru_slip; /* if the next buffer is an eof send it downstream */ if ( buf->size <= 0 ) { @@ -756,13 +846,13 @@ static void SyncAudio( hb_work_object_t * w, int i ) pv->busy &=~ (1 << (i + 1) ); return; } - if ( (int64_t)( buf->start - sync->next_pts ) < 0 ) + if ( (int64_t)( start - sync->next_pts ) < 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 ) + if ( sync->first_drop || sync->next_start - start > 90*15 ) { // Discard data that's in the past. if ( sync->first_drop == 0 ) @@ -774,7 +864,7 @@ static void SyncAudio( hb_work_object_t * w, int i ) hb_buffer_close( &buf ); continue; } - sync->next_pts = buf->start; + sync->next_pts = start; } if ( sync->first_drop ) { @@ -785,19 +875,19 @@ static void SyncAudio( hb_work_object_t * w, int i ) sync->drop_count, sync->first_drop, sync->next_pts ); sync->first_drop = 0; sync->drop_count = 0; - sync->next_pts = buf->start; + sync->next_pts = start; } - if ( buf->start - sync->next_pts >= (90 * 70) ) + if ( start - sync->next_pts >= (90 * 70) ) { - if ( buf->start - sync->next_pts > (90000LL * 60) ) + if ( 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 ); + (int)((start - sync->next_pts) / (90000*60)), + i, start, sync->next_pts ); buf = hb_fifo_get( audio->priv.fifo_raw ); hb_buffer_close( &buf ); continue; @@ -805,12 +895,23 @@ static void SyncAudio( hb_work_object_t * w, int i ) /* * there's a gap of at least 70ms between the last * frame we processed & the next. Fill it with silence. + * Or in the case of DCA, skip some frames from the + * other streams. */ + if( sync->audio->config.out.codec == HB_ACODEC_DCA ) + { + hb_log( "sync: audio gap %d ms. Skipping frames. Audio %d" + " start %lld, next %lld", + (int)((start - sync->next_pts) / 90), + i, start, sync->next_pts ); + pv->audio_passthru_slip += (start - sync->next_pts); + return; + } 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 ); + (int)((start - sync->next_pts) / 90), + i, start, sync->next_pts ); + InsertSilence( w, i, start - sync->next_pts ); return; }