/* $Id: sync.c,v 1.38 2005/04/14 21:57:58 titer Exp $
This file is part of the HandBrake source code.
- Homepage: <http://handbrake.m0k.org/>.
+ Homepage: <http://handbrake.fr/>.
It may be used under the terms of the GNU General Public License. */
#include "hb.h"
+#include "hbffmpeg.h"
#include <stdio.h>
-
#include "samplerate.h"
-#include "ffmpeg/avcodec.h"
#ifdef INT64_MIN
#undef INT64_MIN /* Because it isn't defined correctly in Zeta */
int64_t next_start; /* start time of next output frame */
int64_t next_pts; /* start time of next input frame */
- int64_t start_silence; /* if we're inserting silence, the time we started */
int64_t first_drop; /* PTS of first 'went backwards' frame dropped */
int drop_count; /* count of 'time went backwards' drops */
- int inserting_silence;
/* Raw */
SRC_STATE * state;
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;
* 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 *, int i );
static void InsertSilence( hb_work_object_t * w, int i, int64_t d );
static void UpdateState( hb_work_object_t * w );
pv->job = job;
pv->pts_offset = INT64_MIN;
- pv->count_frames = 0;
/* Calculate how many video frames we are expecting */
- duration = 0;
- for( i = job->chapter_start; i <= job->chapter_end; i++ )
+ if (job->pts_to_stop)
{
- chapter = hb_list_item( title->list_chapter, i - 1 );
- duration += chapter->duration;
+ duration = job->pts_to_stop + 90000;
}
- duration += 90000;
+ else
+ {
+ duration = 0;
+ for( i = job->chapter_start; i <= job->chapter_end; i++ )
+ {
+ chapter = hb_list_item( title->list_chapter, i - 1 );
+ duration += chapter->duration;
+ }
+ duration += 90000;
/* 1 second safety so we're sure we won't miss anything */
+ }
pv->count_frames_max = duration * job->vrate / job->vrate_base / 90000;
hb_log( "sync: expecting %d video frames", pv->count_frames_max );
+ pv->busy |= 1;
/* 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;
}
for( i = 0; i < hb_list_count( title->list_audio ); i++ )
{
- if ( pv->sync_audio[i].start_silence )
- {
- hb_log( "sync: added %d ms of silence to audio %d",
- (int)((pv->sync_audio[i].next_pts -
- pv->sync_audio[i].start_silence) / 90), i );
- }
-
audio = hb_list_item( title->list_audio, i );
if( audio->config.out.codec == HB_ACODEC_AC3 )
{
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 =
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 )
+ if( hb_avcodec_open( c, codec ) < 0 )
{
hb_log( "sync: avcodec_open failed" );
return;
}
free( zeros );
- avcodec_close( c );
+ hb_avcodec_close( c );
av_free( c );
}
else
{
/* Initialize libsamplerate */
int error;
- sync->state = src_new( SRC_LINEAR, HB_AMIXDOWN_GET_DISCRETE_CHANNEL_COUNT(sync->audio->config.out.mixdown), &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;
}
}
***********************************************************************
*
**********************************************************************/
-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;
- 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 ) )
- {
- 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
{
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 */
}
}
+ if( cur->new_chap ) {
+ hb_log("sync got new chapter %d", cur->new_chap );
+ }
+
/*
* since the first frame is always 0 and the upstream reader code
* is taking care of adjusting for pts discontinuities, we just have
* can deal with overlaps of up to a frame time but anything larger
* we handle by dropping frames here.
*/
- if ( (int64_t)( next->start - pv->next_pts ) <= 0 )
+ if ( (int64_t)( next->start - cur->start ) <= 0 )
{
if ( pv->first_drop == 0 )
{
if ( pv->first_drop )
{
hb_log( "sync: video time didn't advance - dropped %d frames "
- "(delta %d ms, current %lld, next %lld)",
- pv->drop_count, (int)( pv->next_pts - pv->first_drop ) / 90,
- pv->next_pts, pv->first_drop );
+ "(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;
}
}
int64_t duration;
- if ( job->mux & HB_MUX_AVI )
+ if ( job->mux & HB_MUX_AVI || job->cfr )
{
/*
- * The concept of variable bitrate video was a bit too advanced for
- * Microsoft so AVI doesn't support it. Since almost all dvd
- * video is VBR we have to convert it to constant bit rate to
+ * 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.
*/
*/
buf_tmp = cur;
pv->cur = cur = hb_fifo_get( job->fifo_raw );
- pv->next_pts = next->start;
- duration = next->start - buf_tmp->start;
+ 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",
/* Make sure we won't get more frames then expected */
if( pv->count_frames >= pv->count_frames_max * 2)
{
- hb_log( "sync: got too many frames (%d), exiting early", pv->count_frames );
- 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 );
+ hb_log( "sync: got too many frames (%d), exiting early",
+ pv->count_frames );
- break;
+ // 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;
}
}
-
- return HB_WORK_OK;
}
static void OutputAudioFrame( hb_job_t *job, hb_audio_t *audio, hb_buffer_t *buf,
buf->start = start;
buf->stop = start + duration;
sync->next_start = start + duration;
- while( hb_fifo_is_full( fifo ) )
- {
- hb_snooze( 50 );
- if ( job->done && hb_fifo_is_full( fifo ) )
- {
- /* don't block here if the job's finished */
- hb_buffer_close( &buf );
- return;
- }
- }
hb_fifo_push( fifo, buf );
}
while( !hb_fifo_is_full( fifo ) && ( buf = hb_fifo_see( audio->priv.fifo_raw ) ) )
{
+ /* if the next buffer is an eof send it downstream */
+ if ( buf->size <= 0 )
+ {
+ buf = hb_fifo_get( audio->priv.fifo_raw );
+ hb_fifo_push( fifo, buf );
+ pv->busy &=~ (1 << (i + 1) );
+ return;
+ }
if ( (int64_t)( buf->start - sync->next_pts ) < 0 )
{
- /*
- * audio time went backwards by more than a frame time (this can
- * happen when we reset the PTS because of lost data).
- * Discard data that's in the past.
- */
- if ( sync->first_drop == 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 )
{
- sync->first_drop = buf->start;
+ // 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->drop_count;
- buf = hb_fifo_get( audio->priv.fifo_raw );
- hb_buffer_close( &buf );
- continue;
+ sync->next_pts = buf->start;
}
if ( sync->first_drop )
{
+ // 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;
}
-
- if ( sync->inserting_silence && (int64_t)(buf->start - sync->next_pts) > 0 )
+ if ( buf->start - sync->next_pts >= (90 * 70) )
{
- /*
- * if we're within one frame time of the amount of silence
- * we need, insert just what we need otherwise insert a frame time.
- */
- int64_t framedur = buf->stop - buf->start;
- if ( buf->start - sync->next_pts <= framedur )
+ if ( buf->start - sync->next_pts > (90000LL * 60) )
{
- InsertSilence( w, i, buf->start - sync->next_pts );
- sync->inserting_silence = 0;
- }
- else
- {
- InsertSilence( w, i, framedur );
+ // 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;
}
- continue;
- }
- if ( buf->start - sync->next_pts >= (90 * 70) )
- {
/*
* there's a gap of at least 70ms between the last
* frame we processed & the next. Fill it with silence.
*/
- if ( ! sync->inserting_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 );
- sync->inserting_silence = 1;
- }
+ 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 );
- continue;
+ return;
}
/*
buf = hb_fifo_get( audio->priv.fifo_raw );
OutputAudioFrame( job, audio, buf, sync, fifo, i );
}
-
- if( NeedSilence( w, audio, i ) )
- {
- InsertSilence( w, i, (90000 * AC3_SAMPLES_PER_FRAME) /
- sync->audio->config.in.samplerate );
- }
-}
-
-static int NeedSilence( hb_work_object_t * w, hb_audio_t * audio, int i )
-{
- hb_work_private_t * pv = w->private_data;
- hb_job_t * job = pv->job;
- hb_sync_audio_t * sync = &pv->sync_audio[i];
-
- if( hb_fifo_size( audio->priv.fifo_in ) ||
- hb_fifo_size( audio->priv.fifo_raw ) ||
- hb_fifo_size( audio->priv.fifo_sync ) ||
- hb_fifo_size( audio->priv.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 */
- if ( sync->start_silence == 0 )
- {
- hb_log("sync: reader has exited, adding silence to audio %d", i);
- sync->start_silence = sync->next_pts;
- }
- return 1;
- }
- return 0;
}
static void InsertSilence( hb_work_object_t * w, int i, int64_t duration )
OSDN Git Service
