X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fsync.c;h=0c359f1dda7c2f41b218a56f2533ea3d48c80900;hb=07cc0ebf6a7141a76fd9b6e2da6cf510def1ebc7;hp=9d6679d244787cd5a2fec1eaeb26aa6bb771e4ef;hpb=960d7f33e08f831d8a0aa17fd265b2193b82ed31;p=handbrake-jp%2Fhandbrake-jp-git.git
diff --git a/libhb/sync.c b/libhb/sync.c
index 9d6679d2..0c359f1d 100644
--- a/libhb/sync.c
+++ b/libhb/sync.c
@@ -1,13 +1,14 @@
/* $Id: sync.c,v 1.38 2005/04/14 21:57:58 titer Exp $
This file is part of the HandBrake source code.
- Homepage: .
+ Homepage: .
It may be used under the terms of the GNU General Public License. */
#include "hb.h"
+#include
#include "samplerate.h"
-#include "ffmpeg/avcodec.h"
+#include "libavcodec/avcodec.h"
#ifdef INT64_MIN
#undef INT64_MIN /* Because it isn't defined correctly in Zeta */
@@ -19,8 +20,12 @@
typedef struct
{
hb_audio_t * audio;
- int64_t count_frames;
-
+
+ int64_t next_start; /* start time of next output frame */
+ int64_t next_pts; /* start time of next input frame */
+ int64_t first_drop; /* PTS of first 'went backwards' frame dropped */
+ int drop_count; /* count of 'time went backwards' drops */
+
/* Raw */
SRC_STATE * state;
SRC_DATA data;
@@ -34,42 +39,42 @@ typedef struct
struct hb_work_private_s
{
hb_job_t * job;
- int done;
-
+ int busy; // bitmask with one bit for each active input
+ // (bit 0 = video; 1 = audio 0, 2 = audio 1, ...
+ // appropriate bit is cleared when input gets
+ // an eof buf. syncWork returns done when all
+ // bits are clear.
/* Video */
hb_subtitle_t * subtitle;
int64_t pts_offset;
- int64_t pts_offset_old;
- int64_t count_frames;
- int64_t count_frames_max;
- int64_t video_sequence;
+ int64_t next_start; /* start time of next output frame */
+ int64_t next_pts; /* start time of next input frame */
+ int64_t first_drop; /* PTS of first 'went backwards' frame dropped */
+ int drop_count; /* count of 'time went backwards' drops */
+ int drops; /* frames dropped to make a cbr video stream */
+ int dups; /* frames duplicated to make a cbr video stream */
+ int video_sequence;
+ int count_frames;
+ int count_frames_max;
+ int chap_mark; /* to propagate chapter mark across a drop */
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 int SyncVideo( hb_work_object_t * w );
+static void 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 * );
-static void InsertSilence( hb_work_object_t * w, int i );
+static void InsertSilence( hb_work_object_t * w, int i, int64_t d );
static void UpdateState( hb_work_object_t * w );
/***********************************************************************
@@ -90,14 +95,6 @@ int syncInit( hb_work_object_t * w, hb_job_t * job )
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;
@@ -105,24 +102,27 @@ int syncInit( hb_work_object_t * w, hb_job_t * job )
{
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;
- hb_log( "sync: expecting %lld video frames", pv->count_frames_max );
+ hb_log( "sync: expecting %d video frames", pv->count_frames_max );
+ pv->busy |= 1;
/* Initialize libsamplerate for every audio track we have */
- for( i = 0; i < hb_list_count( title->list_audio ); i++ )
+ if ( ! job->indepth_scan )
{
- InitAudio( w, i );
+ for( i = 0; i < hb_list_count( title->list_audio ); i++ )
+ {
+ pv->busy |= ( 1 << (i + 1) );
+ InitAudio( w, i );
+ }
}
/* Get subtitle info, if any */
pv->subtitle = hb_list_item( title->list_subtitle, 0 );
- pv->video_sequence = 0;
-
return 0;
}
@@ -136,14 +136,26 @@ 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;
-
+ hb_audio_t * audio = NULL;
int i;
- if( pv->cur ) hb_buffer_close( &pv->cur );
+ if( pv->cur )
+ {
+ hb_buffer_close( &pv->cur );
+ }
+
+ hb_log( "sync: got %d frames, %d expected",
+ pv->count_frames, pv->count_frames_max );
+
+ if (pv->drops || pv->dups )
+ {
+ hb_log( "sync: %d frames dropped, %d duplicated", pv->drops, pv->dups );
+ }
for( i = 0; i < hb_list_count( title->list_audio ); i++ )
{
- if( job->acodec & HB_ACODEC_AC3 )
+ audio = hb_list_item( title->list_audio, i );
+ if( audio->config.out.codec == HB_ACODEC_AC3 )
{
free( pv->sync_audio[i].ac3_buf );
}
@@ -152,7 +164,7 @@ void syncClose( hb_work_object_t * w )
src_delete( pv->sync_audio[i].state );
}
}
-
+
free( pv );
w->private_data = NULL;
}
@@ -173,17 +185,16 @@ int syncWork( hb_work_object_t * w, hb_buffer_t ** unused1,
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 )
+ if ( pv->busy & 1 )
+ SyncVideo( w );
+
+ for( i = 0; i < hb_list_count( pv->job->title->list_audio ); i++ )
{
- for( i = 0; i < hb_list_count( pv->job->title->list_audio ); i++ )
- {
+ if ( pv->busy & ( 1 << (i + 1) ) )
SyncAudio( w, i );
- }
}
- /* Handle video */
- return SyncVideo( w );
+ return ( pv->busy? HB_WORK_OK : HB_WORK_DONE );
}
hb_work_object_t hb_sync =
@@ -205,7 +216,7 @@ 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( sync->audio->config.out.codec == HB_ACODEC_AC3 )
{
/* Have a silent AC-3 frame ready in case we have to fill a
gap */
@@ -216,9 +227,9 @@ static void InitAudio( hb_work_object_t * w, int i )
codec = avcodec_find_encoder( CODEC_ID_AC3 );
c = avcodec_alloc_context();
- c->bit_rate = sync->audio->bitrate;
- c->sample_rate = sync->audio->rate;
- c->channels = 2;
+ c->bit_rate = sync->audio->config.in.bitrate;
+ c->sample_rate = sync->audio->config.in.samplerate;
+ c->channels = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT( sync->audio->config.in.channel_layout );
if( avcodec_open( c, codec ) < 0 )
{
@@ -228,8 +239,8 @@ static void InitAudio( hb_work_object_t * w, int i )
zeros = calloc( AC3_SAMPLES_PER_FRAME *
sizeof( short ) * c->channels, 1 );
- sync->ac3_size = sync->audio->bitrate * AC3_SAMPLES_PER_FRAME /
- sync->audio->rate / 8;
+ sync->ac3_size = sync->audio->config.in.bitrate * AC3_SAMPLES_PER_FRAME /
+ sync->audio->config.in.samplerate / 8;
sync->ac3_buf = malloc( sync->ac3_size );
if( avcodec_encode_audio( c, sync->ac3_buf, sync->ac3_size,
@@ -237,7 +248,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 );
@@ -246,134 +257,116 @@ static void InitAudio( hb_work_object_t * w, int i )
{
/* Initialize libsamplerate */
int error;
- sync->state = src_new( SRC_LINEAR, HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(sync->audio->amixdown), &error );
+ sync->state = src_new( SRC_SINC_MEDIUM_QUALITY, HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(sync->audio->config.out.mixdown), &error );
sync->data.end_of_input = 0;
}
}
-
-
-#define PTS_DISCONTINUITY_TOLERANCE 90000
-
/***********************************************************************
* SyncVideo
***********************************************************************
- *
+ *
**********************************************************************/
-static int SyncVideo( hb_work_object_t * w )
+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;
- int64_t pts_expected;
- int chap_break;
-
- if( pv->done )
- {
- return HB_WORK_DONE;
- }
-
- if( hb_thread_has_exited( job->reader ) &&
- !hb_fifo_size( job->fifo_mpeg2 ) &&
- !hb_fifo_size( job->fifo_raw ) )
- {
- /* All video data has been processed already, we won't get
- more */
- 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;
- }
if( !pv->cur && !( pv->cur = hb_fifo_get( job->fifo_raw ) ) )
{
/* We haven't even got a frame yet */
- return HB_WORK_OK;
+ return;
}
cur = pv->cur;
+ 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 ) );
+ pv->busy &=~ 1;
+ return;
+ }
/* At this point we have a frame to process. Let's check
1) if we will be able to push into the fifo ahead
2) if the next frame is there already, since we need it to
- know whether we'll have to repeat the current frame or not */
+ compute the duration of the current frame*/
while( !hb_fifo_is_full( job->fifo_sync ) &&
( next = hb_fifo_see( job->fifo_raw ) ) )
{
hb_buffer_t * buf_tmp;
+ if( next->size == 0 )
+ {
+ /* we got an end-of-stream. Feed it downstream & signal that
+ * we're done. Note that this means we drop the final frame of
+ * 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 ) );
+ pv->busy &=~ 1;
+ return;
+ }
if( pv->pts_offset == INT64_MIN )
{
/* This is our first frame */
- hb_log( "sync: first pts is %lld", cur->start );
- pv->pts_offset = cur->start;
+ pv->pts_offset = 0;
+ if ( cur->start != 0 )
+ {
+ /*
+ * The first pts from a dvd should always be zero but
+ * can be non-zero with a transport or program stream since
+ * we're not guaranteed to start on an IDR frame. If we get
+ * a non-zero initial PTS extend its duration so it behaves
+ * as if it started at zero so that our audio timing will
+ * be in sync.
+ */
+ hb_log( "sync: first pts is %lld", cur->start );
+ cur->start = 0;
+ }
}
/*
- * Track the video sequence number localy so that we can sync the audio
- * to it using the sequence number as well as the PTS.
+ * since the first frame is always 0 and the upstream reader code
+ * is taking care of adjusting for pts discontinuities, we just have
+ * to deal with the next frame's start being in the past. This can
+ * happen when the PTS is adjusted after data loss but video frame
+ * reordering causes some frames with the old clock to appear after
+ * the clock change. This creates frames that overlap in time which
+ * looks to us like time going backward. The downstream muxing code
+ * can deal with overlaps of up to a frame time but anything larger
+ * we handle by dropping frames here.
*/
- 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 )
+ if ( (int64_t)( next->start - cur->start ) <= 0 )
{
- 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 )
+ if ( pv->first_drop == 0 )
{
- while( ( sub = hb_fifo_see( pv->subtitle->fifo_raw ) ) )
- {
- 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;
- }
- }
+ pv->first_drop = next->start;
}
-
- /* Trash current picture */
- /* 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; // Don't stomp existing chapter breaks
-
- /* Calculate new offset */
- pv->pts_offset_old = pv->pts_offset;
- pv->pts_offset = cur->start -
- pv->count_frames * pv->job->vrate_base / 300;
-
- if( !pv->discontinuity )
+ ++pv->drop_count;
+ buf_tmp = hb_fifo_get( job->fifo_raw );
+ if ( buf_tmp->new_chap )
{
- pv->discontinuity = 1;
+ // don't drop a chapter mark when we drop the buffer
+ pv->chap_mark = buf_tmp->new_chap;
}
-
- pv->video_sequence = cur->sequence;
+ hb_buffer_close( &buf_tmp );
continue;
}
+ if ( pv->first_drop )
+ {
+ hb_log( "sync: video time didn't advance - dropped %d frames "
+ "(delta %d ms, current %lld, next %lld, 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;
+ pv->drop_count = 0;
+ }
+
+ /*
+ * 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;
/* Look for a subtitle for this frame */
if( pv->subtitle )
@@ -387,7 +380,7 @@ static int SyncVideo( hb_work_object_t * w )
if( sub2 && sub->stop > sub2->start )
sub->stop = sub2->start;
- // hb_log("0x%x: video seq: %lld subtitle sequence: %lld",
+ // hb_log("0x%x: video seq: %lld subtitle sequence: %lld",
// sub, cur->sequence, sub->sequence);
if( sub->sequence > cur->sequence )
@@ -409,27 +402,10 @@ static int SyncVideo( hb_work_object_t * w )
* 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 );
@@ -443,7 +419,7 @@ static int SyncVideo( hb_work_object_t * w )
if( sub->stop > sub->start)
{
/*
- * Normal subtitle which ends after it starts, check to
+ * 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 &&
@@ -455,7 +431,27 @@ static int SyncVideo( hb_work_object_t * w )
*
* 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
{
/*
@@ -485,8 +481,8 @@ static int SyncVideo( hb_work_object_t * w )
*
* fall through to display.
*/
- }
- else
+ }
+ else
{
/*
* Defer until the play point is within the subtitle
@@ -505,48 +501,98 @@ static int SyncVideo( hb_work_object_t * w )
}
}
- /* 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 )
+ int64_t duration;
+ if ( job->mux & HB_MUX_AVI || job->cfr )
{
- /* 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;
- }
+ /*
+ * 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.
+ */
- 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;
+ /* 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 ) )
+ {
+ /* 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;
+ }
+
+ 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
{
- /* The frame has the expected date and won't have to be
- duplicated, just put it through */
+ /*
+ * 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 );
+ }
+ }
+
+ buf_tmp->start = pv->next_start;
+ pv->next_start += duration;
+ buf_tmp->stop = pv->next_start;
+
+ if ( pv->chap_mark )
+ {
+ // we have a pending chapter mark from a recent drop - put it on this
+ // buffer (this may make it one frame late but we can't do any better).
+ buf_tmp->new_chap = pv->chap_mark;
+ pv->chap_mark = 0;
}
-
- /* 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 */
@@ -569,348 +615,220 @@ static int SyncVideo( hb_work_object_t * w )
/* 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 (%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;
+ 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;
}
}
+}
+
+static void OutputAudioFrame( hb_job_t *job, hb_audio_t *audio, hb_buffer_t *buf,
+ hb_sync_audio_t *sync, hb_fifo_t *fifo, int i )
+{
+ int64_t start = sync->next_start;
+ int64_t duration = buf->stop - buf->start;
- return HB_WORK_OK;
+ sync->next_pts += duration;
+
+ if( audio->config.in.samplerate == audio->config.out.samplerate ||
+ audio->config.out.codec == HB_ACODEC_AC3 ||
+ audio->config.out.codec == HB_ACODEC_DCA )
+ {
+ /*
+ * If we don't have to do sample rate conversion or this audio is
+ * pass-thru just send the input buffer downstream after adjusting
+ * its timestamps to make the output stream continuous.
+ */
+ }
+ else
+ {
+ /* Not pass-thru - do sample rate conversion */
+ int count_in, count_out;
+ hb_buffer_t * buf_raw = buf;
+ int channel_count = HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(audio->config.out.mixdown) *
+ sizeof( float );
+
+ count_in = buf_raw->size / channel_count;
+ /*
+ * When using stupid rates like 44.1 there will always be some
+ * truncation error. E.g., a 1536 sample AC3 frame will turn into a
+ * 1536*44.1/48.0 = 1411.2 sample frame. If we just truncate the .2
+ * the error will build up over time and eventually the audio will
+ * substantially lag the video. libsamplerate will keep track of the
+ * fractional sample & give it to us when appropriate if we give it
+ * an extra sample of space in the output buffer.
+ */
+ count_out = ( duration * audio->config.out.samplerate ) / 90000 + 1;
+
+ sync->data.input_frames = count_in;
+ sync->data.output_frames = count_out;
+ sync->data.src_ratio = (double)audio->config.out.samplerate /
+ (double)audio->config.in.samplerate;
+
+ buf = hb_buffer_init( count_out * channel_count );
+ sync->data.data_in = (float *) buf_raw->data;
+ sync->data.data_out = (float *) buf->data;
+ if( src_process( sync->state, &sync->data ) )
+ {
+ /* XXX If this happens, we're screwed */
+ hb_log( "sync: audio %d src_process failed", i );
+ }
+ hb_buffer_close( &buf_raw );
+
+ buf->size = sync->data.output_frames_gen * channel_count;
+ duration = ( sync->data.output_frames_gen * 90000 ) /
+ audio->config.out.samplerate;
+ }
+ buf->frametype = HB_FRAME_AUDIO;
+ buf->start = start;
+ buf->stop = start + duration;
+ sync->next_start = start + duration;
+ hb_fifo_push( fifo, buf );
}
/***********************************************************************
* SyncAudio
***********************************************************************
- *
+ *
**********************************************************************/
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_job_t * job = pv->job;
+ hb_sync_audio_t * sync = &pv->sync_audio[i];
+ hb_audio_t * audio = sync->audio;
hb_buffer_t * buf;
- hb_sync_audio_t * sync;
-
hb_fifo_t * fifo;
- int rate;
-
- int64_t pts_expected;
- int64_t start;
- job = pv->job;
- sync = &pv->sync_audio[i];
- audio = sync->audio;
-
- if( job->acodec & HB_ACODEC_AC3 )
+ if( audio->config.out.codec == HB_ACODEC_AC3 )
{
- fifo = audio->fifo_out;
- rate = audio->rate;
+ fifo = audio->priv.fifo_out;
}
else
{
- fifo = audio->fifo_sync;
- rate = job->arate;
+ fifo = audio->priv.fifo_sync;
}
- while( !hb_fifo_is_full( fifo ) &&
- ( buf = hb_fifo_see( audio->fifo_raw ) ) )
+ while( !hb_fifo_is_full( fifo ) && ( buf = hb_fifo_see( audio->priv.fifo_raw ) ) )
{
- /* The PTS of the samples we are expecting now */
- pts_expected = pv->pts_offset + sync->count_frames * 90000 / rate;
-
- // 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*/
-
- 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 )
- {
- /*
- * 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
+ /* if the next buffer is an eof send it downstream */
+ if ( buf->size <= 0 )
{
- 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 )
- {
- 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;
+ buf = hb_fifo_get( audio->priv.fifo_raw );
+ hb_fifo_push( fifo, buf );
+ pv->busy &=~ (1 << (i + 1) );
+ return;
}
- else if( buf->start > pts_expected + 9000 )
- {
- /* 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 ( (int64_t)( buf->start - sync->next_pts ) < 0 )
{
- 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 )
+ // 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 )
{
- hb_log( "Sync: Audio no longer way out of sync at PTS %lld",
- buf->start );
- pv->way_out_of_sync = 0;
+ // Discard data that's in the past.
+ if ( sync->first_drop == 0 )
+ {
+ sync->first_drop = sync->next_pts;
+ }
+ ++sync->drop_count;
+ buf = hb_fifo_get( audio->priv.fifo_raw );
+ hb_buffer_close( &buf );
+ continue;
}
+ sync->next_pts = buf->start;
}
-
- if( job->acodec & HB_ACODEC_AC3 )
+ if ( sync->first_drop )
{
- buf = hb_fifo_get( audio->fifo_raw );
- buf->start = start;
- buf->stop = start + 90000 * AC3_SAMPLES_PER_FRAME / rate;
-
- sync->count_frames += AC3_SAMPLES_PER_FRAME;
+ // 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,
+ (int)( sync->next_pts - sync->first_drop ) / 90,
+ sync->drop_count, sync->first_drop, sync->next_pts );
+ sync->first_drop = 0;
+ sync->drop_count = 0;
+ sync->next_pts = buf->start;
}
- else
+ if ( buf->start - sync->next_pts >= (90 * 70) )
{
- hb_buffer_t * buf_raw = hb_fifo_get( audio->fifo_raw );
-
- int count_in, count_out;
-
- 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--;
- else if( buf->start > pts_expected + 1500 )
- count_out++;
-
- sync->data.data_in = (float *) buf_raw->data;
- sync->data.input_frames = count_in;
- sync->data.output_frames = count_out;
-
- sync->data.src_ratio = (double) sync->data.output_frames /
- (double) sync->data.input_frames;
-
- 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 ) )
+ if ( buf->start - sync->next_pts > (90000LL * 60) )
{
- /* XXX If this happens, we're screwed */
- hb_log( "sync: src_process failed" );
+ // 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 );
+ buf = hb_fifo_get( audio->priv.fifo_raw );
+ hb_buffer_close( &buf );
+ continue;
}
- hb_buffer_close( &buf_raw );
-
- 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;
- buf->stop = start + sync->data.output_frames_gen *
- 90000 / job->arate;
-
- sync->count_frames += sync->data.output_frames_gen;
+ /*
+ * there's a gap of at least 70ms between the last
+ * frame we processed & the next. Fill it with silence.
+ */
+ 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 );
+ return;
}
- 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.
+ * When we get here we've taken care of all the dups and gaps in the
+ * audio stream and are ready to inject the next input frame into
+ * the output stream.
*/
- 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_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 ) ||
- hb_fifo_size( audio->fifo_sync ) ||
- hb_fifo_size( audio->fifo_out ) )
- {
- /* We have some audio, we are fine */
- return 0;
- }
-
- /* No audio left in fifos */
-
- if( hb_thread_has_exited( job->reader ) )
- {
- /* We might miss some audio to complete encoding and muxing
- the video track */
- hb_log("Reader has exited early, inserting silence.");
- return 1;
+ buf = hb_fifo_get( audio->priv.fifo_raw );
+ OutputAudioFrame( job, audio, buf, sync, fifo, i );
}
-
- if( hb_fifo_is_full( job->fifo_mpeg2 ) &&
- hb_fifo_is_full( job->fifo_raw ) &&
- hb_fifo_is_full( job->fifo_sync ) &&
- hb_fifo_is_full( job->fifo_render ) &&
- 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;
- }
-
- return 0;
}
-static void InsertSilence( hb_work_object_t * w, int i )
+static void InsertSilence( hb_work_object_t * w, int i, int64_t duration )
{
hb_work_private_t * pv = w->private_data;
- hb_job_t * job;
- hb_sync_audio_t * sync;
- hb_buffer_t * buf;
-
- job = pv->job;
- sync = &pv->sync_audio[i];
-
- if( job->acodec & HB_ACODEC_AC3 )
- {
- buf = hb_buffer_init( sync->ac3_size );
- buf->start = sync->count_frames * 90000 / sync->audio->rate;
- buf->stop = buf->start + 90000 * AC3_SAMPLES_PER_FRAME /
- sync->audio->rate;
- memcpy( buf->data, sync->ac3_buf, buf->size );
-
- hb_log( "sync: adding a silent AC-3 frame for track %x",
- sync->audio->id );
- hb_fifo_push( sync->audio->fifo_out, buf );
-
- sync->count_frames += AC3_SAMPLES_PER_FRAME;
-
- }
- else
+ hb_job_t *job = pv->job;
+ hb_sync_audio_t *sync = &pv->sync_audio[i];
+ hb_buffer_t *buf;
+ hb_fifo_t *fifo;
+
+ // to keep pass-thru and regular audio in sync we generate silence in
+ // AC3 frame-sized units. If the silence duration isn't an integer multiple
+ // of the AC3 frame duration we will truncate or round up depending on
+ // which minimizes the timing error.
+ const int frame_dur = ( 90000 * AC3_SAMPLES_PER_FRAME ) /
+ sync->audio->config.in.samplerate;
+ int frame_count = ( duration + (frame_dur >> 1) ) / frame_dur;
+
+ while ( --frame_count >= 0 )
{
- 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_fifo_push( sync->audio->fifo_sync, buf );
-
- sync->count_frames += job->arate / 20;
+ if( sync->audio->config.out.codec == HB_ACODEC_AC3 )
+ {
+ buf = hb_buffer_init( sync->ac3_size );
+ buf->start = sync->next_pts;
+ buf->stop = buf->start + frame_dur;
+ memcpy( buf->data, sync->ac3_buf, buf->size );
+ fifo = sync->audio->priv.fifo_out;
+ }
+ else
+ {
+ buf = hb_buffer_init( AC3_SAMPLES_PER_FRAME * sizeof( float ) *
+ HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(
+ sync->audio->config.out.mixdown) );
+ buf->start = sync->next_pts;
+ buf->stop = buf->start + frame_dur;
+ memset( buf->data, 0, buf->size );
+ fifo = sync->audio->priv.fifo_sync;
+ }
+ OutputAudioFrame( job, sync->audio, buf, sync, fifo, i );
}
}
@@ -933,14 +851,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] ) /