// Pulls the first packet out of this FIFO, blocking until such a packet is available.
// Returns NULL if this FIFO has been closed or flushed.
hb_buffer_t * hb_fifo_get_wait( hb_fifo_t * f )
{
hb_buffer_t * b;
hb_lock( f->lock );
if( f->size < 1 )
{
f->wait_empty = 1;
hb_cond_timedwait( f->cond_empty, f->lock, FIFO_TIMEOUT );
if( f->size < 1 )
{
hb_unlock( f->lock );
return NULL;
}
}
b = f->first;
f->first = b->next;
b->next = NULL;
f->size -= 1;
if( f->wait_full && f->size == f->capacity - f->thresh )
{
f->wait_full = 0;
hb_cond_signal( f->cond_full );
}
hb_unlock( f->lock );
return b;
}
// Appends the specified packet list to the end of the specified FIFO.
void hb_fifo_push( hb_fifo_t * f, hb_buffer_t * b )
{
if( !b )
{
return;
}
hb_lock( f->lock );
if( f->size > 0 )
{
f->last->next = b;
}
else
{
f->first = b;
}
f->last = b;
f->size += 1;
while( f->last->next )
{
f->size += 1;
f->last = f->last->next;
}
if( f->wait_empty && f->size >= 1 )
{
f->wait_empty = 0;
hb_cond_signal( f->cond_empty );
}
hb_unlock( f->lock );
}
/************************************************************************
* hb_thread_func()
************************************************************************
* We use it as the root routine for any thread, for two reasons:
* + To set the thread priority on OS X (pthread_setschedparam() could
* be called from hb_thread_init(), but it's nicer to do it as we
* are sure it is done before the real routine starts)
* + Get informed when the thread exits, so we know whether
* hb_thread_close() will block or not.
***********************************************************************/
static void attribute_align_thread hb_thread_func( void * _t )
{
hb_thread_t * t = (hb_thread_t *) _t;
#if defined( SYS_DARWIN )
/* Set the thread priority */
struct sched_param param;
memset( ¶m, 0, sizeof( struct sched_param ) );
param.sched_priority = t->priority;
pthread_setschedparam( pthread_self(), SCHED_OTHER, ¶m );
#endif
#if defined( SYS_BEOS )
signal( SIGINT, SIG_IGN );
#endif
/* Start the actual routine */
t->function( t->arg );
/* Inform that the thread can be joined now */
hb_deep_log( 2, "thread %"PRIx64" exited (\"%s\")", hb_thread_to_integer( t ), t->name );
hb_lock( t->lock );
t->exited = 1;
hb_unlock( t->lock );
}
// Frees the specified buffer list.
void hb_buffer_close( hb_buffer_t ** _b )
{
hb_buffer_t * b = *_b;
while( b )
{
hb_buffer_t * next = b->next;
hb_fifo_t *buffer_pool = size_to_pool( b->alloc );
b->next = NULL;
if( buffer_pool && b->data && !hb_fifo_is_full( buffer_pool ) )
{
hb_fifo_push_head( buffer_pool, b );
b = next;
continue;
}
// either the pool is full or this size doesn't use a pool
// free the buf
if( b->data )
{
free( b->data );
hb_lock(buffers.lock);
buffers.allocated -= b->alloc;
hb_unlock(buffers.lock);
}
free( b );
b = next;
}
*_b = NULL;
}
/***********************************************************************
* Close Audio
***********************************************************************
*
**********************************************************************/
void syncAudioClose( hb_work_object_t * w )
{
hb_work_private_t * pv = w->private_data;
hb_sync_audio_t * sync = &pv->type.audio;
if( sync->silence_buf )
{
free( sync->silence_buf );
}
if ( sync->state )
{
src_delete( sync->state );
}
hb_lock( pv->common->mutex );
if ( --pv->common->ref == 0 )
{
hb_unlock( pv->common->mutex );
hb_cond_close( &pv->common->next_frame );
hb_lock_close( &pv->common->mutex );
free( pv->common->first_pts );
free( pv->common );
}
else
{
hb_unlock( pv->common->mutex );
}
free( pv );
w->private_data = NULL;
}
void hb_buffer_pool_free( void )
{
int i;
int count;
int64_t freed = 0;
hb_buffer_t *b;
hb_lock(buffers.lock);
for( i = 10; i < 26; ++i)
{
count = 0;
while( ( b = hb_fifo_get(buffers.pool[i]) ) )
{
freed += b->alloc;
if( b->data )
{
free( b->data );
}
free( b );
count++;
}
if ( count )
{
hb_deep_log( 2, "Freed %d buffers of size %d", count,
buffers.pool[i]->buffer_size);
}
}
hb_deep_log( 2, "Allocated %"PRId64" bytes of buffers on this pass and Freed %"PRId64" bytes, "
"%"PRId64" bytes leaked", buffers.allocated, freed, buffers.allocated - freed);
buffers.allocated = 0;
hb_unlock(buffers.lock);
}
void
taskset_cycle( taskset_t *ts )
{
hb_lock( ts->task_cond_lock );
/*
* Signal all threads that their work is available.
*/
bit_nset( ts->task_begin_bitmap, 0, ts->thread_count - 1 );
hb_cond_broadcast( ts->task_begin );
/*
* Wait until all threads have completed. Note that we must
* loop here as hb_cond_wait() on some platforms (e.g pthead_cond_wait)
* may unblock prematurely.
*/
do
{
hb_cond_wait( ts->task_complete, ts->task_cond_lock );
} while ( !allbits_set( ts->task_complete_bitmap, ts->bitmap_elements ) );
/*
* Clear completion indications for next time.
*/
bit_nclear( ts->task_complete_bitmap, 0, ts->thread_count - 1 );
hb_unlock( ts->task_cond_lock );
}
// Pushes the specified buffer onto the specified FIFO,
// blocking until the FIFO has space available.
void hb_fifo_push_wait( hb_fifo_t * f, hb_buffer_t * b )
{
if( !b )
{
return;
}
hb_lock( f->lock );
if( f->size >= f->capacity )
{
f->wait_full = 1;
hb_cond_timedwait( f->cond_full, f->lock, FIFO_TIMEOUT );
}
if( f->size > 0 )
{
f->last->next = b;
}
else
{
f->first = b;
}
f->last = b;
f->size += 1;
while( f->last->next )
{
f->size += 1;
f->last = f->last->next;
}
if( f->wait_empty && f->size >= 1 )
{
f->wait_empty = 0;
hb_cond_signal( f->cond_empty );
}
hb_unlock( f->lock );
}
int hb_fifo_is_full( hb_fifo_t * f )
{
int ret;
hb_lock( f->lock );
ret = ( f->size >= f->capacity );
hb_unlock( f->lock );
return ret;
}
float hb_fifo_percent_full( hb_fifo_t * f )
{
float ret;
hb_lock( f->lock );
ret = f->size / f->capacity;
hb_unlock( f->lock );
return ret;
}
int hb_fifo_size( hb_fifo_t * f )
{
int ret;
hb_lock( f->lock );
ret = f->size;
hb_unlock( f->lock );
return ret;
}
/************************************************************************
* hb_thread_has_exited()
************************************************************************
* Returns 1 if the thread can be joined right away, 0 otherwise.
***********************************************************************/
int hb_thread_has_exited( hb_thread_t * t )
{
int exited;
hb_lock( t->lock );
exited = t->exited;
hb_unlock( t->lock );
return exited;
}
/*
* Current thread has completed its work. Indicate completion,
* and if all threads in this task set have completed, wakeup
* anyone waiting for this condition.
*/
void
taskset_thread_complete( taskset_t *ts, int thr_idx )
{
hb_lock( ts->task_cond_lock );
bit_set( ts->task_complete_bitmap, thr_idx );
if( allbits_set( ts->task_complete_bitmap, ts->bitmap_elements ) )
{
hb_cond_signal( ts->task_complete );
}
hb_unlock( ts->task_cond_lock );
}
/*
* threaded rotate - each thread rptates a single segment of all
* three planes. Where a segment is defined as the frame divided by
* the number of CPUs.
*
* This function blocks until the frame is rotated.
*/
static void rotate_filter( uint8_t ** dst,
hb_filter_private_t * pv )
{
int segment;
for( segment = 0; segment < pv->cpu_count; segment++ )
{
/*
* Setup the work for this plane.
*/
pv->rotate_arguments[segment].dst = dst;
/*
* Let the thread for this plane know that we've setup work
* for it by releasing the begin lock (ensuring that the
* complete lock is already locked so that we block when
* we try to lock it again below).
*/
hb_lock( pv->rotate_complete_lock[segment] );
hb_unlock( pv->rotate_begin_lock[segment] );
}
/*
* Wait until all three threads have completed by trying to get
* the complete lock that we locked earlier for each thread, which
* will block until that thread has completed the work on that
* plane.
*/
for( segment = 0; segment < pv->cpu_count; segment++ )
{
hb_lock( pv->rotate_complete_lock[segment] );
hb_unlock( pv->rotate_complete_lock[segment] );
}
/*
* Entire frame is now rotated.
*/
}
/***********************************************************************
* Close Video
***********************************************************************
*
**********************************************************************/
void syncVideoClose( hb_work_object_t * w )
{
hb_work_private_t * pv = w->private_data;
hb_job_t * job = pv->job;
hb_sync_video_t * sync = &pv->type.video;
// Wake up audio sync if it's still waiting on condition.
pv->common->pts_offset = 0;
pv->common->start_found = 1;
hb_cond_broadcast( pv->common->next_frame );
if( sync->cur )
{
hb_buffer_close( &sync->cur );
}
hb_log( "sync: got %d frames, %d expected",
pv->common->count_frames, sync->count_frames_max );
/* save data for second pass */
if( job->pass == 1 )
{
/* Preserve frame count for better accuracy in pass 2 */
hb_interjob_t * interjob = hb_interjob_get( job->h );
interjob->frame_count = pv->common->count_frames;
interjob->last_job = job->sequence_id;
}
if (sync->drops || sync->dups )
{
hb_log( "sync: %d frames dropped, %d duplicated",
sync->drops, sync->dups );
}
hb_lock( pv->common->mutex );
if ( --pv->common->ref == 0 )
{
hb_unlock( pv->common->mutex );
hb_cond_close( &pv->common->next_frame );
hb_lock_close( &pv->common->mutex );
free( pv->common->first_pts );
free( pv->common );
}
else
{
hb_unlock( pv->common->mutex );
}
free( pv );
w->private_data = NULL;
}
/*
* Block current thread until work is available for it.
*/
void
taskset_thread_wait4start( taskset_t *ts, int thr_idx )
{
hb_lock( ts->task_cond_lock );
while ( bit_is_clear( ts->task_begin_bitmap, thr_idx ) )
hb_cond_wait( ts->task_begin, ts->task_cond_lock );
/*
* We've been released for one run. Insure we block the next
* time through the loop.
*/
bit_clear( ts->task_begin_bitmap, thr_idx );
hb_unlock( ts->task_cond_lock );
}
void hb_buffer_realloc( hb_buffer_t * b, int size )
{
if ( size > b->alloc || b->data == NULL )
{
uint32_t orig = b->alloc;
size = size_to_pool( size )->buffer_size;
b->data = realloc( b->data, size );
b->alloc = size;
hb_lock(buffers.lock);
buffers.allocated += size - orig;
hb_unlock(buffers.lock);
}
}
// Waits until the specified FIFO is no longer full or until FIFO_TIMEOUT milliseconds have elapsed.
// Returns whether the FIFO is non-full upon return.
int hb_fifo_full_wait( hb_fifo_t * f )
{
int result;
hb_lock( f->lock );
if( f->size >= f->capacity )
{
f->wait_full = 1;
hb_cond_timedwait( f->cond_full, f->lock, FIFO_TIMEOUT );
}
result = ( f->size < f->capacity );
hb_unlock( f->lock );
return result;
}
void hb_fifo_flush( hb_fifo_t * f )
{
hb_buffer_t * b;
while( ( b = hb_fifo_get( f ) ) )
{
hb_buffer_close( &b );
}
hb_lock( f->lock );
hb_cond_signal( f->cond_empty );
hb_cond_signal( f->cond_full );
hb_unlock( f->lock );
}
hb_buffer_t * hb_fifo_see2( hb_fifo_t * f )
{
hb_buffer_t * b;
hb_lock( f->lock );
if( f->size < 2 )
{
hb_unlock( f->lock );
return NULL;
}
b = f->first->next;
hb_unlock( f->lock );
return b;
}
int hb_fifo_size_bytes( hb_fifo_t * f )
{
int ret = 0;
hb_buffer_t * link;
hb_lock( f->lock );
link = f->first;
while ( link )
{
ret += link->size;
link = link->next;
}
hb_unlock( f->lock );
return ret;
}
mfxStatus MFX_CDECL qsv_FreeResources(mfxHDL pthis, mfxThreadTask task, mfxStatus sts){
qsv_filter_t *plugin = pthis;
qsv_filter_task_t *current_task = (qsv_filter_task_t *)task;
plugin->core->DecreaseReference(plugin->core->pthis, &(current_task->in->Data));
plugin->core->DecreaseReference(plugin->core->pthis, &(current_task->out->Data));
current_task->busy = 0;
hb_lock(plugin->pv->pre_busy.frame_completed_lock);
plugin->pv->pre_busy.frame_go = 1;
hb_cond_broadcast(plugin->pv->pre_busy.frame_completed);
hb_unlock(plugin->pv->pre_busy.frame_completed_lock);
return MFX_ERR_NONE;
}
hb_buffer_t * hb_fifo_see_wait( hb_fifo_t * f )
{
hb_buffer_t * b;
hb_lock( f->lock );
if( f->size < 1 )
{
f->wait_empty = 1;
hb_cond_timedwait( f->cond_empty, f->lock, FIFO_TIMEOUT );
if( f->size < 1 )
{
hb_unlock( f->lock );
return NULL;
}
}
b = f->first;
hb_unlock( f->lock );
return b;
}
// Pulls a packet out of this FIFO, or returns NULL if no packet is available.
hb_buffer_t * hb_fifo_get( hb_fifo_t * f )
{
hb_buffer_t * b;
hb_lock( f->lock );
if( f->size < 1 )
{
hb_unlock( f->lock );
return NULL;
}
b = f->first;
f->first = b->next;
b->next = NULL;
f->size -= 1;
if( f->wait_full && f->size == f->capacity - f->thresh )
{
f->wait_full = 0;
hb_cond_signal( f->cond_full );
}
hb_unlock( f->lock );
return b;
}
void
taskset_fini( taskset_t *ts )
{
int i;
hb_lock( ts->task_cond_lock );
/*
* Tell each thread to stop, and then cleanup.
*/
bit_nset( ts->task_stop_bitmap, 0, ts->thread_count - 1 );
bit_nset( ts->task_begin_bitmap, 0, ts->thread_count - 1 );
hb_cond_broadcast( ts->task_begin );
/*
* Wait for all threads to exit.
*/
hb_cond_wait( ts->task_complete, ts->task_cond_lock );
hb_unlock( ts->task_cond_lock );
/*
* Clean up taskset memory.
*/
for( i = 0; i < ts->thread_count; i++)
{
hb_thread_close( &ts->task_threads[i] );
}
hb_lock_close( &ts->task_cond_lock );
hb_cond_close( &ts->task_begin );
hb_cond_close( &ts->task_complete );
free( ts->task_threads );
if( ts->task_threads_args != NULL )
free( ts->task_threads_args );
free( ts->task_begin_bitmap );
free( ts->task_complete_bitmap );
free( ts->task_stop_bitmap );
}
// Prepends the specified packet list to the start of the specified FIFO.
void hb_fifo_push_head( hb_fifo_t * f, hb_buffer_t * b )
{
hb_buffer_t * tmp;
uint32_t size = 0;
if( !b )
{
return;
}
hb_lock( f->lock );
/*
* If there are a chain of buffers prepend the lot
*/
tmp = b;
while( tmp->next )
{
tmp = tmp->next;
size += 1;
}
if( f->size > 0 )
{
tmp->next = f->first;
}
else
{
f->last = tmp;
}
f->first = b;
f->size += ( size + 1 );
hb_unlock( f->lock );
}
/***********************************************************************
* SyncAudio
***********************************************************************
*
**********************************************************************/
static int syncAudioWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
hb_buffer_t ** buf_out )
{
hb_work_private_t * pv = w->private_data;
hb_job_t * job = pv->job;
hb_sync_audio_t * sync = &pv->type.audio;
hb_buffer_t * buf;
int64_t start;
*buf_out = NULL;
buf = *buf_in;
*buf_in = NULL;
/* if the next buffer is an eof send it downstream */
if ( buf->size <= 0 )
{
hb_buffer_close( &buf );
*buf_out = hb_buffer_init( 0 );
pv->common->first_pts[sync->index+1] = INT64_MAX - 1;
return HB_WORK_DONE;
}
/* Wait till we can determine the initial pts of all streams */
if( pv->common->pts_offset == INT64_MIN )
{
pv->common->first_pts[sync->index+1] = buf->s.start;
hb_lock( pv->common->mutex );
while( pv->common->pts_offset == INT64_MIN )
{
// Full fifos will make us wait forever, so get the
// pts offset from the available streams if full
if (hb_fifo_is_full(w->fifo_in))
{
getPtsOffset( w );
hb_cond_broadcast( pv->common->next_frame );
}
else if ( checkPtsOffset( w ) )
hb_cond_broadcast( pv->common->next_frame );
else
hb_cond_timedwait( pv->common->next_frame, pv->common->mutex, 200 );
}
hb_unlock( pv->common->mutex );
}
/* Wait for start frame if doing point-to-point */
hb_lock( pv->common->mutex );
start = buf->s.start - pv->common->audio_pts_slip;
while ( !pv->common->start_found )
{
if ( pv->common->audio_pts_thresh < 0 )
{
// I would initialize this in hb_sync_init, but
// job->pts_to_start can be modified by reader
// after hb_sync_init is called.
pv->common->audio_pts_thresh = job->pts_to_start;
}
if ( buf->s.start < pv->common->audio_pts_thresh )
{
hb_buffer_close( &buf );
hb_unlock( pv->common->mutex );
return HB_WORK_OK;
}
while ( !pv->common->start_found &&
buf->s.start >= pv->common->audio_pts_thresh )
{
hb_cond_timedwait( pv->common->next_frame, pv->common->mutex, 10 );
// There is an unfortunate unavoidable deadlock that can occur.
// Since we need to wait for a specific frame in syncVideoWork,
// syncAudioWork can be stalled indefinitely. The video decoder
// often drops multiple of the initial frames after starting
// because they require references that have not been decoded yet.
// This allows a lot of audio to be queued in the fifo and the
// audio fifo fills before we get a single video frame. So we
// must drop some audio to unplug the pipeline and allow the first
// video frame to be decoded.
if ( hb_fifo_is_full(w->fifo_in) )
{
hb_buffer_t *tmp;
tmp = buf = hb_fifo_get( w->fifo_in );
while ( tmp )
{
tmp = hb_fifo_get( w->fifo_in );
if ( tmp )
{
hb_buffer_close( &buf );
buf = tmp;
}
}
}
}
start = buf->s.start - pv->common->audio_pts_slip;
}
if ( start < 0 )
{
hb_buffer_close( &buf );
hb_unlock( pv->common->mutex );
return HB_WORK_OK;
}
hb_unlock( pv->common->mutex );
if( job->frame_to_stop && pv->common->count_frames >= job->frame_to_stop )
{
hb_buffer_close( &buf );
*buf_out = hb_buffer_init( 0 );
return HB_WORK_DONE;
}
if( job->pts_to_stop && sync->next_start >= job->pts_to_stop )
{
hb_buffer_close( &buf );
*buf_out = hb_buffer_init( 0 );
return HB_WORK_DONE;
}
// 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->next_start - start > 90*15 )
{
// Discard data that's in the past.
if ( sync->first_drop == 0 )
{
sync->first_drop = start;
}
++sync->drop_count;
hb_buffer_close( &buf );
return HB_WORK_OK;
}
if ( sync->first_drop )
{
// we were dropping old data but input buf time is now current
hb_log( "sync: audio 0x%x time went backwards %d ms, dropped %d frames "
"(start %"PRId64", next %"PRId64")", w->audio->id,
(int)( sync->next_start - sync->first_drop ) / 90,
sync->drop_count, sync->first_drop, (int64_t)sync->next_start );
sync->first_drop = 0;
sync->drop_count = 0;
}
if ( start - sync->next_start >= (90 * 70) )
{
if ( start - sync->next_start > (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 0x%x - dropping buf"
" start %"PRId64", next %"PRId64,
(int)((start - sync->next_start) / (90000*60)),
w->audio->id, start, (int64_t)sync->next_start );
hb_buffer_close( &buf );
return HB_WORK_OK;
}
/*
* 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->drop_video_to_sync )
{
hb_log( "sync: audio gap %d ms. Skipping frames. Audio 0x%x"
" start %"PRId64", next %"PRId64,
(int)((start - sync->next_start) / 90),
w->audio->id, start, (int64_t)sync->next_start );
hb_lock( pv->common->mutex );
pv->common->audio_pts_slip += (start - sync->next_start);
pv->common->video_pts_slip += (start - sync->next_start);
hb_unlock( pv->common->mutex );
*buf_out = OutputAudioFrame( w->audio, buf, sync );
return HB_WORK_OK;
}
hb_log( "sync: adding %d ms of silence to audio 0x%x"
" start %"PRId64", next %"PRId64,
(int)((start - sync->next_start) / 90),
w->audio->id, start, (int64_t)sync->next_start );
InsertSilence( w, start - sync->next_start );
}
/*
* 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.
*/
*buf_out = OutputAudioFrame( w->audio, buf, sync );
return HB_WORK_OK;
}
/***********************************************************************
* syncVideoWork
***********************************************************************
*
**********************************************************************/
int syncVideoWork( hb_work_object_t * w, hb_buffer_t ** buf_in,
hb_buffer_t ** buf_out )
{
hb_buffer_t * cur, * next, * sub = NULL;
hb_work_private_t * pv = w->private_data;
hb_job_t * job = pv->job;
hb_subtitle_t * subtitle;
hb_sync_video_t * sync = &pv->type.video;
int i;
int64_t next_start;
*buf_out = NULL;
next = *buf_in;
*buf_in = NULL;
/* Wait till we can determine the initial pts of all streams */
if( next->size != 0 && pv->common->pts_offset == INT64_MIN )
{
pv->common->first_pts[0] = next->s.start;
hb_lock( pv->common->mutex );
while( pv->common->pts_offset == INT64_MIN )
{
// Full fifos will make us wait forever, so get the
// pts offset from the available streams if full
if ( hb_fifo_is_full( job->fifo_raw ) )
{
getPtsOffset( w );
hb_cond_broadcast( pv->common->next_frame );
}
else if ( checkPtsOffset( w ) )
hb_cond_broadcast( pv->common->next_frame );
else
hb_cond_timedwait( pv->common->next_frame, pv->common->mutex, 200 );
}
hb_unlock( pv->common->mutex );
}
hb_lock( pv->common->mutex );
next_start = next->s.start - pv->common->video_pts_slip;
hb_unlock( pv->common->mutex );
/* Wait for start of point-to-point encoding */
if( !pv->common->start_found )
{
hb_sync_video_t * sync = &pv->type.video;
if( next->size == 0 )
{
*buf_out = next;
pv->common->start_found = 1;
pv->common->first_pts[0] = INT64_MAX - 1;
hb_cond_broadcast( pv->common->next_frame );
/*
* 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->config.dest == PASSTHRUSUB )
{
hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) );
}
}
return HB_WORK_DONE;
}
if ( pv->common->count_frames < job->frame_to_start ||
next->s.start < job->pts_to_start )
{
// Flush any subtitles that have pts prior to the
// current frame
for( i = 0; i < hb_list_count( job->list_subtitle ); i++)
{
subtitle = hb_list_item( job->list_subtitle, i );
while( ( sub = hb_fifo_see( subtitle->fifo_raw ) ) )
{
if ( sub->s.start > next->s.start )
break;
sub = hb_fifo_get( subtitle->fifo_raw );
hb_buffer_close( &sub );
}
}
hb_lock( pv->common->mutex );
// Tell the audio threads what must be dropped
pv->common->audio_pts_thresh = next_start + pv->common->video_pts_slip;
hb_cond_broadcast( pv->common->next_frame );
hb_unlock( pv->common->mutex );
UpdateSearchState( w, next_start );
hb_buffer_close( &next );
return HB_WORK_OK;
}
hb_lock( pv->common->mutex );
pv->common->audio_pts_thresh = 0;
pv->common->audio_pts_slip += next_start;
pv->common->video_pts_slip += next_start;
next_start = 0;
pv->common->start_found = 1;
pv->common->count_frames = 0;
hb_cond_broadcast( pv->common->next_frame );
hb_unlock( pv->common->mutex );
sync->st_first = 0;
}
if( !sync->cur )
{
sync->cur = next;
if (next->size == 0)
{
/* we got an end-of-stream as our first video packet?
* Feed it downstream & signal that we're done.
*/
*buf_out = next;
pv->common->start_found = 1;
pv->common->first_pts[0] = INT64_MAX - 1;
hb_cond_broadcast( pv->common->next_frame );
/*
* 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->config.dest == PASSTHRUSUB )
{
hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) );
}
}
return HB_WORK_DONE;
}
return HB_WORK_OK;
}
cur = sync->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
2) if the next frame is there already, since we need it to
compute the duration of the current frame*/
if( next->size == 0 )
{
hb_buffer_close( &next );
pv->common->first_pts[0] = INT64_MAX - 1;
cur->s.start = sync->next_start;
cur->s.stop = cur->s.start + 90000. / ((double)job->vrate / (double)job->vrate_base);
sync->next_start += cur->s.stop - cur->s.start;;
/* Make sure last frame is reflected in frame count */
pv->common->count_frames++;
/* Push the frame to the renderer */
*buf_out = cur;
sync->cur = NULL;
/* 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. */
(*buf_out)->next = 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->config.dest == PASSTHRUSUB )
{
hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) );
}
}
pv->common->start_found = 1;
hb_cond_broadcast( pv->common->next_frame );
return HB_WORK_DONE;
}
/* Check for end of point-to-point frame encoding */
if( job->frame_to_stop && pv->common->count_frames > job->frame_to_stop )
{
// Drop an empty buffer into our output to ensure that things
// get flushed all the way out.
hb_buffer_close( &sync->cur );
hb_buffer_close( &next );
*buf_out = hb_buffer_init( 0 );
hb_log( "sync: reached %d frames, exiting early",
pv->common->count_frames );
/*
* 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->config.dest == PASSTHRUSUB )
{
hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) );
}
}
return HB_WORK_DONE;
}
/* Check for end of point-to-point pts encoding */
if( job->pts_to_stop && sync->next_start >= job->pts_to_stop )
{
// Drop an empty buffer into our output to ensure that things
// get flushed all the way out.
hb_log( "sync: reached pts %"PRId64", exiting early", cur->s.start );
hb_buffer_close( &sync->cur );
hb_buffer_close( &next );
*buf_out = 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->config.dest == PASSTHRUSUB )
{
hb_fifo_push( subtitle->fifo_out, hb_buffer_init( 0 ) );
}
}
return HB_WORK_DONE;
}
if( sync->first_frame )
{
/* This is our first frame */
if ( cur->s.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 %"PRId64, cur->s.start );
cur->s.start = 0;
}
sync->first_frame = 0;
}
/*
* 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.
*/
if ( next_start - cur->s.start <= 0 )
{
if ( sync->first_drop == 0 )
{
sync->first_drop = next_start;
}
++sync->drop_count;
if ( next->s.new_chap )
{
// don't drop a chapter mark when we drop the buffer
sync->chap_mark = next->s.new_chap;
}
hb_buffer_close( &next );
return HB_WORK_OK;
}
if ( sync->first_drop )
{
hb_log( "sync: video time didn't advance - dropped %d frames "
"(delta %d ms, current %"PRId64", next %"PRId64", dur %d)",
sync->drop_count, (int)( cur->s.start - sync->first_drop ) / 90,
cur->s.start, next_start, (int)( next_start - cur->s.start ) );
sync->first_drop = 0;
sync->drop_count = 0;
}
/*
* Track the video sequence number locally so that we can sync the audio
* to it using the sequence number as well as the PTS.
*/
sync->video_sequence = cur->sequence;
/* Process subtitles that apply to this video frame */
// NOTE: There is no logic in either subtitle-sync algorithm that waits
// for the subtitle-decoder if it is lagging behind the video-decoder.
//
// Therefore there is the implicit assumption that the subtitle-decoder
// is always faster than the video-decoder. This assumption is definitely
// incorrect in some cases where the SSA subtitle decoder is used.
for( i = 0; i < hb_list_count( job->list_subtitle ); i++)
{
int64_t sub_start, sub_stop, duration;
subtitle = hb_list_item( job->list_subtitle, i );
// Sanitize subtitle start and stop times, then pass to
// muxer or renderer filter.
while ( ( sub = hb_fifo_see( subtitle->fifo_raw ) ) != NULL )
{
hb_lock( pv->common->mutex );
sub_start = sub->s.start - pv->common->video_pts_slip;
hb_unlock( pv->common->mutex );
if (sub->s.stop == -1)
{
if (subtitle->config.dest != RENDERSUB &&
hb_fifo_size( subtitle->fifo_raw ) < 2)
{
// For passthru subs, we want to wait for the
// next subtitle so that we can fill in the stop time.
// This way the muxer can compute the duration of
// the subtitle.
//
// For render subs, we need to ensure that they
// get to the renderer before the associated video
// that they are to be applied to. It is the
// responsibility of the renderer to handle
// stop == -1.
break;
}
}
sub = hb_fifo_get( subtitle->fifo_raw );
if ( sub->s.stop == -1 )
{
hb_buffer_t *next;
next = hb_fifo_see( subtitle->fifo_raw );
if (next != NULL)
sub->s.stop = next->s.start;
}
// Need to re-write subtitle timestamps to account
// for any slippage.
sub_stop = -1;
if ( sub->s.stop != -1 )
{
duration = sub->s.stop - sub->s.start;
sub_stop = sub_start + duration;
}
sub->s.start = sub_start;
sub->s.stop = sub_stop;
hb_fifo_push( subtitle->fifo_out, sub );
}
}
/*
* 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_out = cur;
int64_t duration = next_start - cur->s.start;
sync->cur = cur = next;
cur->sub = NULL;
cur->s.start -= pv->common->video_pts_slip;
cur->s.stop -= pv->common->video_pts_slip;
sync->pts_skip = 0;
if ( duration <= 0 )
{
hb_log( "sync: invalid video duration %"PRId64", start %"PRId64", next %"PRId64"",
duration, cur->s.start, next_start );
}
(*buf_out)->s.start = sync->next_start;
sync->next_start += duration;
(*buf_out)->s.stop = sync->next_start;
if ( sync->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_out)->s.new_chap = sync->chap_mark;
sync->chap_mark = 0;
}
/* Update UI */
UpdateState( w );
return HB_WORK_OK;
}
int process_filter(qsv_filter_task_t* task, void* params){
mfxStatus sts = MFX_ERR_NONE;
if (MFX_ERR_NONE != (sts = lock_frame(task->processor.alloc,task->in)))return sts;
if (MFX_ERR_NONE != (sts = lock_frame(task->processor.alloc,task->out)))
{
unlock_frame(task->processor.alloc,task->in);
return sts;
}
qsv_nv12_to_yuv420(task->pv->sws_context_from_nv12,task->pv->pre.out, task->in, task->processor.core);
// signal: input is prepared, converted from pipeline into internal buffer
hb_lock(task->pv->pre.frame_completed_lock);
task->pv->pre.frame_go = 1;
hb_cond_broadcast(task->pv->pre.frame_completed);
hb_unlock(task->pv->pre.frame_completed_lock);
// wait: input is prepared, converted from pipeline into internal buffer
hb_lock(task->pv->post.frame_completed_lock);
while(!task->pv->post.frame_go){
hb_cond_timedwait(task->pv->post.frame_completed,task->pv->post.frame_completed_lock,1000);
if(*task->pv->job->die)
break;
}
task->pv->post.frame_go = 0;
hb_unlock(task->pv->post.frame_completed_lock);
// this is just a simple fun/test case
#if 0
{
int i = 0;
char *cur_line;
char* luma = task->pv->post.in->plane[0].data;
int pitch = task->pv->post.in->plane[0].stride;
int h = task->pv->post.in->plane[0].height;
int w = task->pv->post.in->plane[0].width;
for (i = 0; i < h; i++){
cur_line = luma + i * pitch;
if(i>h/4 && i < 3*h/4 && i % 5 == 0 )
memset(cur_line, 0 , w );
}
}
#endif
if(task->pv->post.in)
{
qsv_yuv420_to_nv12(task->pv->sws_context_to_nv12, task->out, task->pv->post.in);
}
// signal: output is prepared, converted from internal buffer into pipeline
hb_lock(task->pv->post_busy.frame_completed_lock);
task->pv->post_busy.frame_go = 1;
hb_cond_broadcast(task->pv->post_busy.frame_completed);
hb_unlock(task->pv->post_busy.frame_completed_lock);
unlock_frame(task->processor.alloc,task->in);
unlock_frame(task->processor.alloc,task->out);
return sts;
}
static int hb_qsv_filter_post_work( hb_filter_object_t * filter,
hb_buffer_t ** buf_in,
hb_buffer_t ** buf_out ){
hb_filter_private_t * pv = filter->private_data;
hb_buffer_t * in = *buf_in;
hb_buffer_t * out = *buf_out;
if ( in->size <= 0 )
{
*buf_out = in;
*buf_in = NULL;
return HB_FILTER_DONE;
}
av_qsv_context* qsv = pv->job->qsv;
pv = in->qsv_details.filter_details;
if (!pv)
{
*buf_out = NULL;
*buf_in = NULL;
return HB_FILTER_OK;
}
while(1){
int ret = filter_pre_init(qsv,pv);
if(ret >= 2)
av_qsv_sleep(1);
else
break;
}
pv->post.in = in;
pv->post.out = out;
// signal: input is prepared, can start inserting data back into pipeline
hb_lock(pv->post.frame_completed_lock);
pv->post.frame_go = 1;
hb_cond_broadcast(pv->post.frame_completed);
hb_unlock(pv->post.frame_completed_lock);
// wait: on signal that data is ready
hb_lock(pv->post_busy.frame_completed_lock);
while(!pv->post_busy.frame_go){
hb_cond_timedwait(pv->post_busy.frame_completed,pv->post_busy.frame_completed_lock,1000);
if(*pv->job->die)
break;
}
pv->post_busy.frame_go = 0;
hb_unlock(pv->post_busy.frame_completed_lock);
if (pv->post.status == HB_FILTER_OK || pv->post.status == HB_FILTER_DONE)
{
*buf_out = in;
}
else
{
*buf_out = NULL;
pv->post.status = HB_FILTER_OK;
}
*buf_in = NULL;
return HB_FILTER_OK;
}
