} hb_sync_audio_t;
-struct hb_work_object_s
+struct hb_work_private_s
{
- HB_WORK_COMMON;
-
hb_job_t * job;
int done;
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;
};
/***********************************************************************
* Local prototypes
**********************************************************************/
static void InitAudio( hb_work_object_t * w, int i );
-static void Close( hb_work_object_t ** _w );
-static int Work( hb_work_object_t * w, hb_buffer_t ** unused1,
- hb_buffer_t ** unused2 );
static int 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 * );
***********************************************************************
* Initialize the work object
**********************************************************************/
-hb_work_object_t * hb_work_sync_init( hb_job_t * job )
+int syncInit( hb_work_object_t * w, hb_job_t * job )
{
- hb_work_object_t * w;
hb_title_t * title = job->title;
hb_chapter_t * chapter;
int i;
uint64_t duration;
+ hb_work_private_t * pv;
- w = calloc( sizeof( hb_work_object_t ), 1 );
- w->name = strdup( "Synchronization" );
- w->work = Work;
- w->close = Close;
+ pv = calloc( 1, sizeof( hb_work_private_t ) );
+ w->private_data = pv;
- w->job = job;
- w->pts_offset = INT64_MIN;
- w->pts_offset_old = INT64_MIN;
- w->count_frames = 0;
+ pv->job = job;
+ pv->pts_offset = INT64_MIN;
+ 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;
}
duration += 90000;
/* 1 second safety so we're sure we won't miss anything */
- w->count_frames_max = duration * job->vrate / job->vrate_base / 90000;
+ pv->count_frames_max = duration * job->vrate / job->vrate_base / 90000;
- hb_log( "sync: expecting %lld video frames", w->count_frames_max );
+ hb_log( "sync: expecting %lld video frames", pv->count_frames_max );
/* Initialize libsamplerate for every audio track we have */
for( i = 0; i < hb_list_count( title->list_audio ); i++ )
}
/* Get subtitle info, if any */
- w->subtitle = hb_list_item( title->list_subtitle, 0 );
+ pv->subtitle = hb_list_item( title->list_subtitle, 0 );
+
+ pv->video_sequence = 0;
+
+ return 0;
+}
+
+/***********************************************************************
+ * Close
+ ***********************************************************************
+ *
+ **********************************************************************/
+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 ||
+ job->audio_mixdowns[i] == HB_AMIXDOWN_AC3 )
+ {
+ free( pv->sync_audio[i].ac3_buf );
+ }
+ else
+ {
+ src_delete( pv->sync_audio[i].state );
+ }
+ }
+
+ free( pv );
+ w->private_data = NULL;
+}
+
+/***********************************************************************
+ * 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_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 )
+ {
+ for( i = 0; i < hb_list_count( pv->job->title->list_audio ); i++ )
+ {
+ SyncAudio( w, i );
+ }
+ }
- return w;
+ /* Handle video */
+ return SyncVideo( w );
}
+hb_work_object_t hb_sync =
+{
+ WORK_SYNC,
+ "Synchronization",
+ syncInit,
+ syncWork,
+ syncClose
+};
+
static void InitAudio( hb_work_object_t * w, int i )
{
- hb_job_t * job = w->job;
+ hb_work_private_t * pv = w->private_data;
+ hb_job_t * job = pv->job;
hb_title_t * title = job->title;
hb_sync_audio_t * sync;
- sync = &w->sync_audio[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 */
c->bit_rate = sync->audio->bitrate;
c->sample_rate = sync->audio->rate;
- c->channels = sync->audio->channels;
+ c->channels = 2;
if( avcodec_open( c, codec ) < 0 )
{
{
/* Initialize libsamplerate */
int error;
- sync->state = src_new( SRC_LINEAR, 2, &error );
+ sync->state = src_new( SRC_LINEAR, HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(sync->audio->amixdown), &error );
sync->data.end_of_input = 0;
}
}
-/***********************************************************************
- * Close
- ***********************************************************************
- *
- **********************************************************************/
-static void Close( hb_work_object_t ** _w )
-{
- hb_work_object_t * w = *_w;
- hb_job_t * job = w->job;
- hb_title_t * title = job->title;
-
- int i;
-
- if( w->cur ) hb_buffer_close( &w->cur );
-
- for( i = 0; i < hb_list_count( title->list_audio ); i++ )
- {
- if( job->acodec & HB_ACODEC_AC3 )
- {
- free( w->sync_audio[i].ac3_buf );
- }
- else
- {
- src_delete( w->sync_audio[i].state );
- }
- }
-
- free( w->name );
- free( w );
- *_w = NULL;
-}
-
-/***********************************************************************
- * Work
- ***********************************************************************
- * The root routine of this work abject
- **********************************************************************/
-static int Work( hb_work_object_t * w, hb_buffer_t ** unused1,
- hb_buffer_t ** unused2 )
-{
- int i;
-
- /* If we ever got a video frame, handle audio now */
- if( w->pts_offset != INT64_MIN )
- {
- for( i = 0; i < hb_list_count( w->job->title->list_audio ); i++ )
- {
- SyncAudio( w, i );
- }
- }
- /* Handle video */
- return SyncVideo( w );
-}
#define PTS_DISCONTINUITY_TOLERANCE 90000
**********************************************************************/
static int 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 = w->job;
+ hb_job_t * job = pv->job;
int64_t pts_expected;
+ int chap_break;
- if( w->done )
+ if( pv->done )
{
return HB_WORK_DONE;
}
/* All video data has been processed already, we won't get
more */
hb_log( "sync: got %lld frames, %lld expected",
- w->count_frames, w->count_frames_max );
- w->done = 1;
+ 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;
}
- if( !w->cur && !( w->cur = hb_fifo_get( job->fifo_raw ) ) )
+ if( !pv->cur && !( pv->cur = hb_fifo_get( job->fifo_raw ) ) )
{
/* We haven't even got a frame yet */
return HB_WORK_OK;
}
- cur = w->cur;
+ cur = pv->cur;
/* At this point we have a frame to process. Let's check
1) if we will be able to push into the fifo ahead
{
hb_buffer_t * buf_tmp;
- if( w->pts_offset == INT64_MIN )
+ if( pv->pts_offset == INT64_MIN )
{
/* This is our first frame */
hb_log( "sync: first pts is %lld", cur->start );
- w->pts_offset = cur->start;
+ 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 );
+ hb_log( "Sync: Video PTS discontinuity %s (current buffer start=%lld, next buffer start=%lld)",
+ pv->discontinuity ? "second" : "first", cur->start, next->start );
- /* Trash all subtitles */
- if( w->subtitle )
+ /*
+ * 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( w->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;
+ }
}
}
/* Trash current picture */
+ /* Also, make sure we don't trash a chapter break */
+ chap_break = cur->new_chap;
hb_buffer_close( &cur );
- w->cur = cur = hb_fifo_get( job->fifo_raw );
+ pv->cur = cur = hb_fifo_get( job->fifo_raw );
+ cur->new_chap |= chap_break; // Don't stomp existing chapter breaks
/* Calculate new offset */
- w->pts_offset_old = w->pts_offset;
- w->pts_offset = cur->start -
- w->count_frames * w->job->vrate_base / 300;
+ pv->pts_offset_old = pv->pts_offset;
+ 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;
}
/* Look for a subtitle for this frame */
- if( w->subtitle )
+ if( pv->subtitle )
{
hb_buffer_t * sub2;
- while( ( sub = hb_fifo_see( w->subtitle->fifo_raw ) ) )
+ 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( w->subtitle->fifo_raw );
+ sub2 = hb_fifo_see2( pv->subtitle->fifo_raw );
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 */
- sub = hb_fifo_get( w->subtitle->fifo_raw );
+ /*
+ * 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
+ */
+ }
+ 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 = w->pts_offset +
- w->count_frames * w->job->vrate_base / 300;
-
- if( cur->start < pts_expected - w->job->vrate_base / 300 / 2 &&
- next->start < pts_expected + w->job->vrate_base / 300 / 2 )
- {
- /* The current frame is too old but the next one matches,
- let's trash */
- hb_buffer_close( &cur );
- w->cur = cur = hb_fifo_get( job->fifo_raw );
- continue;
- }
-
- if( next->start > pts_expected + 3 * w->job->vrate_base / 300 / 2 )
+ if ( job->vfr )
{
- /* 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 );
+ /*
+ * 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 );
+ 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;
- w->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;
- /* Replace those MPEG-2 dates with our dates */
- buf_tmp->start = (uint64_t) w->count_frames *
- w->job->vrate_base / 300;
- buf_tmp->stop = (uint64_t) ( w->count_frames + 1 ) *
- w->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;
+ }
/* If we have a subtitle for this picture, copy it */
/* FIXME: we should avoid this memcpy */
UpdateState( w );
/* Make sure we won't get more frames then expected */
- if( w->count_frames >= w->count_frames_max )
+ if( pv->count_frames >= pv->count_frames_max * 2)
{
- hb_log( "sync: got %lld frames", w->count_frames );
- w->done = 1;
+ 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;
}
}
**********************************************************************/
static void SyncAudio( hb_work_object_t * w, int i )
{
+ hb_work_private_t * pv = w->private_data;
hb_job_t * job;
hb_audio_t * audio;
hb_buffer_t * buf;
int64_t pts_expected;
int64_t start;
- job = w->job;
- sync = &w->sync_audio[i];
+ job = pv->job;
+ 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;
( buf = hb_fifo_see( audio->fifo_raw ) ) )
{
/* The PTS of the samples we are expecting now */
- pts_expected = w->pts_offset + sync->count_frames * 90000 / rate;
+ pts_expected = pv->pts_offset + sync->count_frames * 90000 / rate;
+
+ // hb_log("Video Sequence: %lld, Audio Sequence: %lld", pv->video_sequence, buf->sequence);
- if( ( buf->start > pts_expected + PTS_DISCONTINUITY_TOLERANCE ||
- buf->start < pts_expected - PTS_DISCONTINUITY_TOLERANCE ) &&
- w->pts_offset_old > INT64_MIN )
+ /*
+ * 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 = w->pts_offset_old + sync->count_frames *
- 90000 / rate;
+ be from before the discontinuity*/
- if( buf->start > pts_expected + PTS_DISCONTINUITY_TOLERANCE ||
- buf->start < pts_expected - PTS_DISCONTINUITY_TOLERANCE )
+ if( pv->discontinuity )
{
- /* There is really nothing we can do with it */
- buf = hb_fifo_get( audio->fifo_raw );
- hb_buffer_close( &buf );
- continue;
+ /*
+ * 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 );
}
- /* Use the older offset */
- start = pts_expected - w->pts_offset_old;
+ /*
+ * 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 )
+ {
+ /*
+ * 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;
+ }
+
+ /*
+ * 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 - w->pts_offset;
+ 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;
int count_in, count_out;
- count_in = buf_raw->size / 2 / sizeof( float );
+ count_in = buf_raw->size / HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->amixdown) / sizeof( float );
count_out = ( buf_raw->stop - buf_raw->start ) * job->arate / 90000;
if( buf->start < pts_expected - 1500 )
count_out--;
sync->data.src_ratio = (double) sync->data.output_frames /
(double) sync->data.input_frames;
- buf = hb_buffer_init( sync->data.output_frames * 2 *
+ buf = hb_buffer_init( sync->data.output_frames * HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->amixdown) *
sizeof( float ) );
sync->data.data_out = (float *) buf->data;
if( src_process( sync->state, &sync->data ) )
}
hb_buffer_close( &buf_raw );
- buf->size = sync->data.output_frames_gen * 2 * sizeof( float );
+ buf->size = sync->data.output_frames_gen * HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->amixdown) * sizeof( float );
/* Set dates for resampled data */
buf->start = start;
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 );
static int NeedSilence( hb_work_object_t * w, hb_audio_t * audio )
{
- hb_job_t * job = w->job;
+ hb_work_private_t * pv = w->private_data;
+ hb_job_t * job = pv->job;
if( hb_fifo_size( audio->fifo_in ) ||
hb_fifo_size( audio->fifo_raw ) ||
{
/* We might miss some audio to complete encoding and muxing
the video track */
+ hb_log("Reader has exited early, inserting silence.");
return 1;
}
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;
}
static void InsertSilence( hb_work_object_t * w, int i )
{
+ hb_work_private_t * pv = w->private_data;
hb_job_t * job;
hb_sync_audio_t * sync;
hb_buffer_t * buf;
- job = w->job;
- sync = &w->sync_audio[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;
}
else
{
- buf = hb_buffer_init( 2 * job->arate / 20 *
+ buf = hb_buffer_init( HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(sync->audio->amixdown) * job->arate / 20 *
sizeof( float ) );
buf->start = sync->count_frames * 90000 / job->arate;
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;
static void UpdateState( hb_work_object_t * w )
{
+ hb_work_private_t * pv = w->private_data;
hb_state_t state;
- if( !w->count_frames )
+ if( !pv->count_frames )
{
- w->st_first = hb_get_date();
+ pv->st_first = hb_get_date();
}
- w->count_frames++;
+ pv->count_frames++;
- if( hb_get_date() > w->st_dates[3] + 1000 )
+ if( hb_get_date() > pv->st_dates[3] + 1000 )
{
- memmove( &w->st_dates[0], &w->st_dates[1],
+ memmove( &pv->st_dates[0], &pv->st_dates[1],
3 * sizeof( uint64_t ) );
- memmove( &w->st_counts[0], &w->st_counts[1],
+ memmove( &pv->st_counts[0], &pv->st_counts[1],
3 * sizeof( uint64_t ) );
- w->st_dates[3] = hb_get_date();
- w->st_counts[3] = w->count_frames;
+ 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) w->count_frames / (float) w->count_frames_max;
+ p.progress = (float) pv->count_frames / (float) pv->count_frames_max;
if( p.progress > 1.0 )
{
p.progress = 1.0;
}
p.rate_cur = 1000.0 *
- (float) ( w->st_counts[3] - w->st_counts[0] ) /
- (float) ( w->st_dates[3] - w->st_dates[0] );
- if( hb_get_date() > w->st_first + 4000 )
+ (float) ( pv->st_counts[3] - pv->st_counts[0] ) /
+ (float) ( pv->st_dates[3] - pv->st_dates[0] );
+ if( hb_get_date() > pv->st_first + 4000 )
{
int eta;
- p.rate_avg = 1000.0 * (float) w->st_counts[3] /
- (float) ( w->st_dates[3] - w->st_first );
- eta = (float) ( w->count_frames_max - w->st_counts[3] ) /
+ p.rate_avg = 1000.0 * (float) pv->st_counts[3] /
+ (float) ( pv->st_dates[3] - pv->st_first );
+ eta = (float) ( pv->count_frames_max - pv->st_counts[3] ) /
p.rate_avg;
p.hours = eta / 3600;
p.minutes = ( eta % 3600 ) / 60;
}
#undef p
- hb_set_state( w->job->h, &state );
+ hb_set_state( pv->job->h, &state );
}
OSDN Git Service
