// 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 */
/* Audio */
hb_sync_audio_t sync_audio[8];
+ int64_t audio_passthru_slip;
/* Statistics */
uint64_t st_counts[4];
/* 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;
}
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 ) ) )
{
{
/* 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;
}
* 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;
}
* 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 )
{
*/
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
{
*/
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;
/* 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 */
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;
}
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 )
{
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 )
hb_buffer_close( &buf );
continue;
}
- sync->next_pts = buf->start;
+ sync->next_pts = start;
}
if ( sync->first_drop )
{
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;
/*
* 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;
}
OSDN Git Service
