X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fwork.c;h=eea492b9c5a88060a443761c889af22d3faa2ccd;hb=e90d429b62c48a65174957cbe3bbac1a2f861ef3;hp=6bd9700f751bc88755d439a2826d01c61463da6e;hpb=7dc534bc87accdf2d58a0a6e8e209fdf9c46f41a;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/work.c b/libhb/work.c index 6bd9700f..eea492b9 100644 --- a/libhb/work.c +++ b/libhb/work.c @@ -23,7 +23,10 @@ static void work_func(); static void do_job( hb_job_t *, int cpu_count ); static void work_loop( void * ); -#define FIFO_CPU_MULT 8 +#define FIFO_LARGE 32 +#define FIFO_LARGE_WAKE 16 +#define FIFO_SMALL 16 +#define FIFO_SMALL_WAKE 15 /** * Allocates work object and launches work thread with work_func. @@ -209,13 +212,9 @@ void hb_display_job_info( hb_job_t * job ) { hb_log( " + keeping source display aspect ratio"); } - if( job->anamorphic.modulus != 16 ) - { - hb_log( " + modulus: %i", job->anamorphic.modulus ); - } - hb_log( " + storage dimensions: %d * %d -> %d * %d, crop %d/%d/%d/%d", + hb_log( " + storage dimensions: %d * %d -> %d * %d, crop %d/%d/%d/%d, mod %i", title->width, title->height, job->width, job->height, - job->crop[0], job->crop[1], job->crop[2], job->crop[3] ); + job->crop[0], job->crop[1], job->crop[2], job->crop[3], job->modulus ); if( job->anamorphic.itu_par ) { hb_log( " + using ITU pixel aspect ratio values"); @@ -366,7 +365,6 @@ void correct_framerate( hb_job_t * job ) job->vrate = job->vrate_base * ( (double)real_frames * 90000 / interjob->total_time ); } - /** * Job initialization rountine. * Initializes fifos. @@ -383,6 +381,8 @@ static void do_job( hb_job_t * job, int cpu_count ) hb_title_t * title; int i, j; hb_work_object_t * w; + hb_work_object_t * sync; + hb_work_object_t * muxer; hb_interjob_t * interjob; hb_audio_t * audio; @@ -459,163 +459,15 @@ static void do_job( hb_job_t * job, int cpu_count ) job->vrate_base = title->rate_base; } - job->fifo_mpeg2 = hb_fifo_init( 256 ); - job->fifo_raw = hb_fifo_init( FIFO_CPU_MULT * cpu_count ); - job->fifo_sync = hb_fifo_init( FIFO_CPU_MULT * cpu_count ); - job->fifo_render = hb_fifo_init( FIFO_CPU_MULT * cpu_count ); - job->fifo_mpeg4 = hb_fifo_init( FIFO_CPU_MULT * cpu_count ); - - /* Synchronization */ - hb_list_add( job->list_work, ( w = hb_get_work( WORK_SYNC ) ) ); - w->fifo_in = NULL; - w->fifo_out = NULL; - - /* Video decoder */ - int vcodec = title->video_codec? title->video_codec : WORK_DECMPEG2; - hb_list_add( job->list_work, ( w = hb_get_work( vcodec ) ) ); - w->codec_param = title->video_codec_param; - w->fifo_in = job->fifo_mpeg2; - w->fifo_out = job->fifo_raw; - - /* Video renderer */ - hb_list_add( job->list_work, ( w = hb_get_work( WORK_RENDER ) ) ); - w->fifo_in = job->fifo_sync; - w->fifo_out = job->fifo_render; - - if( !job->indepth_scan ) - { - - /* Video encoder */ - switch( job->vcodec ) - { - case HB_VCODEC_FFMPEG: - w = hb_get_work( WORK_ENCAVCODEC ); - break; - case HB_VCODEC_X264: - w = hb_get_work( WORK_ENCX264 ); - break; - case HB_VCODEC_THEORA: - w = hb_get_work( WORK_ENCTHEORA ); - break; - } - w->fifo_in = job->fifo_render; - w->fifo_out = job->fifo_mpeg4; - w->config = &job->config; - - hb_list_add( job->list_work, w ); - } + job->fifo_mpeg2 = hb_fifo_init( FIFO_LARGE, FIFO_LARGE_WAKE ); + job->fifo_raw = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE ); + job->fifo_sync = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE ); + job->fifo_render = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE ); + job->fifo_mpeg4 = hb_fifo_init( FIFO_LARGE, FIFO_LARGE_WAKE ); /* - * Look for the scanned subtitle in the existing subtitle list + * Audio fifos must be initialized before sync */ - if ( !job->indepth_scan && interjob->select_subtitle && - ( job->pass == 0 || job->pass == 2 ) ) - { - /* - * Disable forced subtitles if we didn't find any in the scan - * so that we display normal subtitles instead. - * - * select_subtitle implies that we did a scan. - */ - if( interjob->select_subtitle->config.force && - interjob->select_subtitle->forced_hits == 0 ) - { - interjob->select_subtitle->config.force = 0; - } - for( i=0; i < hb_list_count(title->list_subtitle); i++ ) - { - subtitle = hb_list_item( title->list_subtitle, i ); - - if( subtitle ) - { - /* - * Disable forced subtitles if we didn't find any in the scan - * so that we display normal subtitles instead. - * - * select_subtitle implies that we did a scan. - */ - if( interjob->select_subtitle->id == subtitle->id ) - { - *subtitle = *(interjob->select_subtitle); - free( interjob->select_subtitle ); - interjob->select_subtitle = NULL; - } - } - } - - if( interjob->select_subtitle ) - { - /* - * Its not in the existing list - * - * Must be second pass of a two pass with subtitle scan enabled, so - * add the subtitle that we found on the first pass for use in this - * pass. - */ - hb_list_add( title->list_subtitle, interjob->select_subtitle ); - interjob->select_subtitle = NULL; - } - } - - - for( i=0; i < hb_list_count(title->list_subtitle); i++ ) - { - subtitle = hb_list_item( title->list_subtitle, i ); - - if( subtitle ) - { - subtitle->fifo_in = hb_fifo_init( FIFO_CPU_MULT * cpu_count ); - subtitle->fifo_raw = hb_fifo_init( FIFO_CPU_MULT * cpu_count ); - subtitle->fifo_sync = hb_fifo_init( FIFO_CPU_MULT * cpu_count ); - subtitle->fifo_out = hb_fifo_init( FIFO_CPU_MULT * cpu_count ); - - if( (!job->indepth_scan || job->select_subtitle_config.force) && - subtitle->source == VOBSUB ) { - /* - * Don't add threads for subtitles when we are scanning, unless - * looking for forced subtitles. - */ - w = hb_get_work( WORK_DECVOBSUB ); - w->fifo_in = subtitle->fifo_in; - w->fifo_out = subtitle->fifo_raw; - w->subtitle = subtitle; - hb_list_add( job->list_work, w ); - } - - if( !job->indepth_scan && subtitle->source == CC608SUB ) - { - w = hb_get_work( WORK_DECCC608 ); - w->fifo_in = subtitle->fifo_in; - w->fifo_out = subtitle->fifo_raw; - hb_list_add( job->list_work, w ); - } - - if( !job->indepth_scan && subtitle->source == SRTSUB ) - { - w = hb_get_work( WORK_DECSRTSUB ); - w->fifo_in = subtitle->fifo_in; - w->fifo_out = subtitle->fifo_raw; - w->subtitle = subtitle; - hb_list_add( job->list_work, w ); - } - - if( !job->indepth_scan && - subtitle->format == PICTURESUB - && subtitle->config.dest == PASSTHRUSUB ) - { - /* - * Passing through a subtitle picture, this will have to - * be rle encoded before muxing. - */ - w = hb_get_work( WORK_ENCVOBSUB ); - w->fifo_in = subtitle->fifo_sync; - w->fifo_out = subtitle->fifo_out; - w->subtitle = subtitle; - hb_list_add( job->list_work, w ); - } - } - } - if( !job->indepth_scan ) { // if we are doing passthru, and the input codec is not the same as the output @@ -695,7 +547,6 @@ static void do_job( hb_job_t * job, int cpu_count ) // So if the encoder is lame we need the output to be stereo (or multichannel // matrixed into stereo like dpl). If the decoder is not AC3 or DCA the // encoder has to handle the input format since we can't do a mixdown. -#define CAN_MIXDOWN(a) ( a->config.in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA) ) #define STEREO_ONLY(a) ( a->config.out.codec & HB_ACODEC_LAME ) switch (audio->config.in.channel_layout & HB_INPUT_CH_LAYOUT_DISCRETE_NO_LFE_MASK) @@ -715,16 +566,6 @@ static void do_job( hb_job_t * job, int cpu_count ) case HB_INPUT_CH_LAYOUT_MONO: if ( STEREO_ONLY( audio ) ) { - if ( !CAN_MIXDOWN( audio ) ) - { - // XXX we're hosed - we can't mix up & lame can't handle - // the input format. The user shouldn't be able to make - // this choice. It's too late to do anything about it now - // so complain in the log & let things abort in lame. - hb_log( "ERROR - can't use lame mp3 audio output with " - "mono audio stream %x - output will be messed up", - audio->id ); - } audio->config.out.mixdown = HB_AMIXDOWN_STEREO; } else @@ -738,7 +579,7 @@ static void do_job( hb_job_t * job, int cpu_count ) // the A52 flags don't allow for a way to distinguish between DPL1 and // DPL2 on a DVD so we always assume a DPL1 source for A52_DOLBY. case HB_INPUT_CH_LAYOUT_DOLBY: - if ( STEREO_ONLY( audio ) || !CAN_MIXDOWN( audio ) || + if ( STEREO_ONLY( audio ) || audio->config.out.mixdown > HB_AMIXDOWN_DOLBY ) { audio->config.out.mixdown = HB_AMIXDOWN_DOLBY; @@ -748,57 +589,31 @@ static void do_job( hb_job_t * job, int cpu_count ) // 4 channel discrete case HB_INPUT_CH_LAYOUT_2F2R: case HB_INPUT_CH_LAYOUT_3F1R: - if ( CAN_MIXDOWN( audio ) ) - { - if ( STEREO_ONLY( audio ) || - audio->config.out.mixdown > HB_AMIXDOWN_DOLBY ) - { - audio->config.out.mixdown = HB_AMIXDOWN_DOLBY; - } - } - else + if ( STEREO_ONLY( audio ) || + audio->config.out.mixdown > HB_AMIXDOWN_DOLBY ) { - // XXX we can't mixdown & don't have any way to specify - // 4 channel discrete output so we're hosed. - hb_log( "ERROR - can't handle 4 channel discrete audio stream " - "%x - output will be messed up", audio->id ); + audio->config.out.mixdown = HB_AMIXDOWN_DOLBY; } break; // 5 or 6 channel discrete case HB_INPUT_CH_LAYOUT_3F2R: - if ( CAN_MIXDOWN( audio ) ) + if ( STEREO_ONLY( audio ) ) { - if ( STEREO_ONLY( audio ) ) + if ( audio->config.out.mixdown < HB_AMIXDOWN_STEREO ) { - if ( audio->config.out.mixdown < HB_AMIXDOWN_STEREO ) - { - audio->config.out.mixdown = HB_AMIXDOWN_STEREO; - } - else if ( audio->config.out.mixdown > HB_AMIXDOWN_DOLBYPLII ) - { - audio->config.out.mixdown = HB_AMIXDOWN_DOLBYPLII; - } + audio->config.out.mixdown = HB_AMIXDOWN_STEREO; } - else if ( ! ( audio->config.in.channel_layout & - HB_INPUT_CH_LAYOUT_HAS_LFE ) ) + else if ( audio->config.out.mixdown > HB_AMIXDOWN_DOLBYPLII ) { - // we don't do 5 channel discrete so mixdown to DPLII audio->config.out.mixdown = HB_AMIXDOWN_DOLBYPLII; } } else if ( ! ( audio->config.in.channel_layout & - HB_INPUT_CH_LAYOUT_HAS_LFE ) ) - { - // XXX we can't mixdown & don't have any way to specify - // 5 channel discrete output so we're hosed. - hb_log( "ERROR - can't handle 5 channel discrete audio stream " - "%x - output will be messed up", audio->id ); - } - else + HB_INPUT_CH_LAYOUT_HAS_LFE ) ) { - // we can't mixdown so force 6 channel discrete - audio->config.out.mixdown = HB_AMIXDOWN_6CH; + // we don't do 5 channel discrete so mixdown to DPLII + audio->config.out.mixdown = HB_AMIXDOWN_DOLBYPLII; } break; } @@ -819,54 +634,219 @@ static void do_job( hb_job_t * job, int cpu_count ) audio->priv.config.vorbis.language = audio->config.lang.simple; /* set up the audio work structures */ - audio->priv.fifo_in = hb_fifo_init( 32 ); - audio->priv.fifo_raw = hb_fifo_init( FIFO_CPU_MULT * cpu_count ); - audio->priv.fifo_sync = hb_fifo_init( 32 ); - audio->priv.fifo_out = hb_fifo_init( 8 * FIFO_CPU_MULT * cpu_count ); + audio->priv.fifo_in = hb_fifo_init( FIFO_LARGE, FIFO_LARGE_WAKE ); + audio->priv.fifo_raw = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE ); + audio->priv.fifo_sync = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE ); + audio->priv.fifo_out = hb_fifo_init( FIFO_LARGE, FIFO_LARGE_WAKE ); + } + } + /* Synchronization */ + sync = hb_sync_init( job ); - /* - * Audio Decoder Thread - */ - if ( ( w = hb_codec_decoder( audio->config.in.codec ) ) == NULL ) + /* Video decoder */ + int vcodec = title->video_codec? title->video_codec : WORK_DECMPEG2; + hb_list_add( job->list_work, ( w = hb_get_work( vcodec ) ) ); + w->codec_param = title->video_codec_param; + w->fifo_in = job->fifo_mpeg2; + w->fifo_out = job->fifo_raw; + + /* Video renderer */ + hb_list_add( job->list_work, ( w = hb_get_work( WORK_RENDER ) ) ); + w->fifo_in = job->fifo_sync; + if( !job->indepth_scan ) + w->fifo_out = job->fifo_render; + else + w->fifo_out = NULL; + + if( !job->indepth_scan ) + { + + /* Video encoder */ + switch( job->vcodec ) { - hb_error("Invalid input codec: %d", audio->config.in.codec); - *job->die = 1; - goto cleanup; + case HB_VCODEC_FFMPEG: + w = hb_get_work( WORK_ENCAVCODEC ); + break; + case HB_VCODEC_X264: + w = hb_get_work( WORK_ENCX264 ); + break; + case HB_VCODEC_THEORA: + w = hb_get_work( WORK_ENCTHEORA ); + break; } - w->fifo_in = audio->priv.fifo_in; - w->fifo_out = audio->priv.fifo_raw; - w->config = &audio->priv.config; - w->audio = audio; - w->codec_param = audio->config.in.codec_param; + w->fifo_in = job->fifo_render; + w->fifo_out = job->fifo_mpeg4; + w->config = &job->config; hb_list_add( job->list_work, w ); + } + /* + * Look for the scanned subtitle in the existing subtitle list + */ + if ( !job->indepth_scan && interjob->select_subtitle && + ( job->pass == 0 || job->pass == 2 ) ) + { /* - * Audio Encoder Thread + * Disable forced subtitles if we didn't find any in the scan + * so that we display normal subtitles instead. + * + * select_subtitle implies that we did a scan. */ - if( audio->config.out.codec != HB_ACODEC_AC3 && - audio->config.out.codec != HB_ACODEC_DCA ) + if( interjob->select_subtitle->config.force && + interjob->select_subtitle->forced_hits == 0 ) + { + interjob->select_subtitle->config.force = 0; + } + for( i=0; i < hb_list_count(title->list_subtitle); i++ ) + { + subtitle = hb_list_item( title->list_subtitle, i ); + + if( subtitle ) + { + /* + * Disable forced subtitles if we didn't find any in the scan + * so that we display normal subtitles instead. + * + * select_subtitle implies that we did a scan. + */ + if( interjob->select_subtitle->id == subtitle->id ) + { + *subtitle = *(interjob->select_subtitle); + free( interjob->select_subtitle ); + interjob->select_subtitle = NULL; + break; + } + } + } + + if( interjob->select_subtitle ) { /* - * Add the encoder thread if not doing AC-3 pass through + * Its not in the existing list + * + * Must be second pass of a two pass with subtitle scan enabled, so + * add the subtitle that we found on the first pass for use in this + * pass. */ - if ( ( w = hb_codec_encoder( audio->config.out.codec ) ) == NULL ) + hb_list_add( title->list_subtitle, interjob->select_subtitle ); + interjob->select_subtitle = NULL; + } + } + + + for( i=0; i < hb_list_count(title->list_subtitle); i++ ) + { + subtitle = hb_list_item( title->list_subtitle, i ); + + if( subtitle ) + { + subtitle->fifo_in = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE ); + subtitle->fifo_raw = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE ); + subtitle->fifo_sync = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE ); + subtitle->fifo_out = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE ); + + if( (!job->indepth_scan || job->select_subtitle_config.force) && + subtitle->source == VOBSUB ) { + /* + * Don't add threads for subtitles when we are scanning, unless + * looking for forced subtitles. + */ + w = hb_get_work( WORK_DECVOBSUB ); + w->fifo_in = subtitle->fifo_in; + w->fifo_out = subtitle->fifo_raw; + w->subtitle = subtitle; + hb_list_add( job->list_work, w ); + } + + if( !job->indepth_scan && subtitle->source == CC608SUB ) { - hb_error("Invalid audio codec: %#x", audio->config.out.codec); - w = NULL; + w = hb_get_work( WORK_DECCC608 ); + w->fifo_in = subtitle->fifo_in; + w->fifo_out = subtitle->fifo_raw; + hb_list_add( job->list_work, w ); + } + + if( !job->indepth_scan && subtitle->source == SRTSUB ) + { + w = hb_get_work( WORK_DECSRTSUB ); + w->fifo_in = subtitle->fifo_in; + w->fifo_out = subtitle->fifo_raw; + w->subtitle = subtitle; + hb_list_add( job->list_work, w ); + } + + if( !job->indepth_scan && + subtitle->format == PICTURESUB + && subtitle->config.dest == PASSTHRUSUB ) + { + /* + * Passing through a subtitle picture, this will have to + * be rle encoded before muxing. + */ + w = hb_get_work( WORK_ENCVOBSUB ); + w->fifo_in = subtitle->fifo_sync; + w->fifo_out = subtitle->fifo_out; + w->subtitle = subtitle; + hb_list_add( job->list_work, w ); + } + } + } + + if( !job->indepth_scan ) + { + for( i = 0; i < hb_list_count( title->list_audio ); i++ ) + { + audio = hb_list_item( title->list_audio, i ); + + /* + * Audio Decoder Thread + */ + if ( ( w = hb_codec_decoder( audio->config.in.codec ) ) == NULL ) + { + hb_error("Invalid input codec: %d", audio->config.in.codec); *job->die = 1; goto cleanup; } - w->fifo_in = audio->priv.fifo_sync; - w->fifo_out = audio->priv.fifo_out; + w->fifo_in = audio->priv.fifo_in; + w->fifo_out = audio->priv.fifo_raw; w->config = &audio->priv.config; w->audio = audio; + w->codec_param = audio->config.in.codec_param; hb_list_add( job->list_work, w ); + + /* + * Audio Encoder Thread + */ + if( audio->config.out.codec != HB_ACODEC_AC3 && + audio->config.out.codec != HB_ACODEC_DCA ) + { + /* + * Add the encoder thread if not doing AC-3 pass through + */ + if ( ( w = hb_codec_encoder( audio->config.out.codec ) ) == NULL ) + { + hb_error("Invalid audio codec: %#x", audio->config.out.codec); + w = NULL; + *job->die = 1; + goto cleanup; + } + w->fifo_in = audio->priv.fifo_sync; + w->fifo_out = audio->priv.fifo_out; + w->config = &audio->priv.config; + w->audio = audio; + + hb_list_add( job->list_work, w ); + } } } - + + if( job->chapter_markers && job->chapter_start == job->chapter_end ) + { + job->chapter_markers = 0; + hb_log("work: only 1 chapter, disabling chapter markers"); } /* Display settings */ @@ -879,7 +859,7 @@ static void do_job( hb_job_t * job, int cpu_count ) job->done = 0; /* Launch processing threads */ - for( i = 1; i < hb_list_count( job->list_work ); i++ ) + for( i = 0; i < hb_list_count( job->list_work ); i++ ) { w = hb_list_item( job->list_work, i ); w->done = &job->done; @@ -894,24 +874,84 @@ static void do_job( hb_job_t * job, int cpu_count ) HB_LOW_PRIORITY ); } - // The muxer requires track information that's set up by the encoder - // init routines so we have to init the muxer last. - job->muxer = job->indepth_scan? NULL : hb_muxer_init( job ); + if ( job->indepth_scan ) + { + muxer = NULL; + w = sync; + sync->done = &job->done; + } + else + { + sync->done = &job->done; + sync->thread_sleep_interval = 10; + if( sync->init( w, job ) ) + { + hb_error( "Failure to initialise thread '%s'", w->name ); + *job->die = 1; + goto cleanup; + } + sync->thread = hb_thread_init( sync->name, work_loop, sync, + HB_LOW_PRIORITY ); + + // The muxer requires track information that's set up by the encoder + // init routines so we have to init the muxer last. + muxer = hb_muxer_init( job ); + w = muxer; + } - w = hb_list_item( job->list_work, 0 ); - w->thread_sleep_interval = 10; - w->init( w, job ); - while( !*job->die ) + while ( !*job->die && !*w->done && w->status != HB_WORK_DONE ) { - if ( ( w->status = w->work( w, NULL, NULL ) ) == HB_WORK_DONE ) + hb_buffer_t * buf_in, * buf_out; + + buf_in = hb_fifo_get_wait( w->fifo_in ); + if ( buf_in == NULL ) + continue; + if ( *job->die ) { + if( buf_in ) + { + hb_buffer_close( &buf_in ); + } break; } - hb_snooze( w->thread_sleep_interval ); + + buf_out = NULL; + w->status = w->work( w, &buf_in, &buf_out ); + + if( buf_in ) + { + hb_buffer_close( &buf_in ); + } + if ( buf_out && w->fifo_out == NULL ) + { + hb_buffer_close( &buf_out ); + } + if( buf_out ) + { + while ( !*job->die ) + { + if ( hb_fifo_full_wait( w->fifo_out ) ) + { + hb_fifo_push( w->fifo_out, buf_out ); + break; + } + } + } + } + + job->done = 1; + if( muxer != NULL ) + { + muxer->close( muxer ); + free( muxer ); + + if( sync->thread != NULL ) + { + hb_thread_close( &sync->thread ); + sync->close( sync ); + } + free( sync ); } - hb_list_rem( job->list_work, w ); - w->close( w ); - free( w ); hb_handle_t * h = job->h; hb_state_t state; @@ -921,9 +961,6 @@ static void do_job( hb_job_t * job, int cpu_count ) cleanup: /* Stop the write thread (thread_close will block until the muxer finishes) */ - if( job->muxer != NULL ) - hb_thread_close( &job->muxer ); - job->done = 1; /* Close work objects */ @@ -1085,21 +1122,19 @@ static void work_loop( void * _w ) hb_work_object_t * w = _w; hb_buffer_t * buf_in, * buf_out; - while( !*w->done ) + while( !*w->done && w->status != HB_WORK_DONE ) { -#if 0 - hb_lock( job->pause ); - hb_unlock( job->pause ); -#endif - if( hb_fifo_is_full( w->fifo_out ) || -// if( (hb_fifo_percent_full( w->fifo_out ) > 0.8) || - !( buf_in = hb_fifo_get( w->fifo_in ) ) ) - { - hb_snooze( w->thread_sleep_interval ); -// w->thread_sleep_interval += 1; + buf_in = hb_fifo_get_wait( w->fifo_in ); + if ( buf_in == NULL ) continue; + if ( *w->done ) + { + if( buf_in ) + { + hb_buffer_close( &buf_in ); + } + break; } -// w->thread_sleep_interval = MAX(1, (w->thread_sleep_interval - 1)); w->status = w->work( w, &buf_in, &buf_out ); @@ -1111,7 +1146,7 @@ static void work_loop( void * _w ) if( buf_in && buf_out && buf_in->new_chap && buf_in->start == buf_out->start) { // restore log below to debug chapter mark propagation problems - //hb_log("work %s: Copying Chapter Break @ %lld", w->name, buf_in->start); + //hb_log("work %s: Copying Chapter Break @ %"PRId64, w->name, buf_in->start); buf_out->new_chap = buf_in->new_chap; } @@ -1119,9 +1154,28 @@ static void work_loop( void * _w ) { hb_buffer_close( &buf_in ); } + if ( buf_out && w->fifo_out == NULL ) + { + hb_buffer_close( &buf_out ); + } if( buf_out ) { - hb_fifo_push( w->fifo_out, buf_out ); + while ( !*w->done ) + { + if ( hb_fifo_full_wait( w->fifo_out ) ) + { + hb_fifo_push( w->fifo_out, buf_out ); + break; + } + } } } + // Consume data in incoming fifo till job complete so that + // residual data does not stall the pipeline + while( !*w->done ) + { + buf_in = hb_fifo_get_wait( w->fifo_in ); + if ( buf_in != NULL ) + hb_buffer_close( &buf_in ); + } }