X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fwork.c;h=c1891a6838b53908a0c93a444209da203215d4c2;hb=55b0015a8c50106e553bc2f48336cc2a1c495459;hp=6bd9700f751bc88755d439a2826d01c61463da6e;hpb=7dc534bc87accdf2d58a0a6e8e209fdf9c46f41a;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/work.c b/libhb/work.c index 6bd9700f..c1891a68 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. @@ -46,6 +49,24 @@ hb_thread_t * hb_work_init( hb_list_t * jobs, int cpu_count, return hb_thread_init( "work", work_func, work, HB_LOW_PRIORITY ); } +static void InitWorkState( hb_handle_t * h ) +{ + hb_state_t state; + + state.state = HB_STATE_WORKING; +#define p state.param.working + p.progress = 0.0; + p.rate_cur = 0.0; + p.rate_avg = 0.0; + p.hours = -1; + p.minutes = -1; + p.seconds = -1; +#undef p + + hb_set_state( h, &state ); + +} + /** * Iterates through job list and calls do_job for each job. * @param _work Handle work object. @@ -62,6 +83,7 @@ static void work_func( void * _work ) hb_list_rem( work->jobs, job ); job->die = work->die; *(work->current_job) = job; + InitWorkState( job->h ); do_job( job, work->cpu_count ); *(work->current_job) = NULL; } @@ -209,13 +231,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"); @@ -287,12 +305,27 @@ void hb_display_job_info( hb_job_t * job ) if( subtitle ) { - hb_log( " * subtitle track %i, %s (id %x) %s [%s] -> %s ", subtitle->track, subtitle->lang, subtitle->id, - subtitle->format == PICTURESUB ? "Picture" : "Text", - subtitle->source == VOBSUB ? "VOBSUB" : - ((subtitle->source == CC608SUB || - subtitle->source == CC708SUB) ? "CC" : "SRT"), - subtitle->config.dest == RENDERSUB ? "Render/Burn in" : "Pass-Through"); + if( subtitle->source == SRTSUB ) + { + /* For SRT, print offset and charset too */ + hb_log( " * subtitle track %i, %s (id %x) %s [%s] -> %s%s, offset: %"PRId64", charset: %s", + subtitle->track, subtitle->lang, subtitle->id, "Text", "SRT", "Pass-Through", + subtitle->config.default_track ? ", Default" : "", + subtitle->config.offset, subtitle->config.src_codeset ); + } + else + { + hb_log( " * subtitle track %i, %s (id %x) %s [%s] -> %s%s%s", subtitle->track, subtitle->lang, subtitle->id, + subtitle->format == PICTURESUB ? "Picture" : "Text", + subtitle->source == VOBSUB ? "VOBSUB" : + subtitle->source == CC608SUB || subtitle->source == CC708SUB ? "CC" : + subtitle->source == UTF8SUB ? "UTF-8" : + subtitle->source == TX3GSUB ? "TX3G" : + subtitle->source == SSASUB ? "SSA" : "Unknown", + subtitle->config.dest == RENDERSUB ? "Render/Burn in" : "Pass-Through", + subtitle->config.force ? ", Forced Only" : "", + subtitle->config.default_track ? ", Default" : "" ); + } } } @@ -366,7 +399,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 +415,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,16 +493,167 @@ 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 ); + 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 ); + + /* + * Audio fifos must be initialized before sync + */ + if( !job->indepth_scan ) + { + // if we are doing passthru, and the input codec is not the same as the output + // codec, then remove this audio from the job. If we're not doing passthru and + // the input codec is the 'internal' ffmpeg codec, make sure that only one + // audio references that audio stream since the codec context is specific to + // the audio id & multiple copies of the same stream will garble the audio + // or cause aborts. + uint8_t aud_id_uses[MAX_STREAMS]; + memset( aud_id_uses, 0, sizeof(aud_id_uses) ); + for( i = 0; i < hb_list_count( title->list_audio ); ) + { + audio = hb_list_item( title->list_audio, i ); + if( ( ( audio->config.out.codec == HB_ACODEC_AC3 ) && ( audio->config.in.codec != HB_ACODEC_AC3 ) ) || + ( ( audio->config.out.codec == HB_ACODEC_DCA ) && ( audio->config.in.codec != HB_ACODEC_DCA ) ) ) + { + hb_log( "Passthru requested and input codec is not the same as output codec for track %d", + audio->config.out.track ); + hb_list_rem( title->list_audio, audio ); + free( audio ); + continue; + } + if ( audio->config.in.codec == HB_ACODEC_FFMPEG ) + { + if ( aud_id_uses[audio->id] ) + { + hb_log( "Multiple decodes of audio id %d, removing track %d", + audio->id, audio->config.out.track ); + hb_list_rem( title->list_audio, audio ); + free( audio ); + continue; + } + ++aud_id_uses[audio->id]; + } + /* Adjust output track number, in case we removed one. + * Output tracks sadly still need to be in sequential order. + */ + audio->config.out.track = i++; + } + + int requested_mixdown = 0; + int requested_mixdown_index = 0; + + for( i = 0; i < hb_list_count( title->list_audio ); i++ ) + { + audio = hb_list_item( title->list_audio, i ); + + if( audio->config.out.codec != audio->config.in.codec ) + { + /* sense-check the current mixdown options */ + /* log the requested mixdown */ + for (j = 0; j < hb_audio_mixdowns_count; j++) { + if (hb_audio_mixdowns[j].amixdown == audio->config.out.mixdown) { + requested_mixdown = audio->config.out.mixdown; + requested_mixdown_index = j; + } + } + + /* sense-check the requested mixdown */ + + if( audio->config.out.mixdown == 0 && + audio->config.out.codec != HB_ACODEC_AC3 && + audio->config.out.codec != HB_ACODEC_DCA ) + { + /* + * Mixdown wasn't specified and this is not pass-through, + * set a default mixdown of stereo. + */ + audio->config.out.mixdown = HB_AMIXDOWN_STEREO; + } + + // Here we try to sanitize the audio input to output mapping. + // Constraints are: + // 1. only the AC3 & DCA decoder libraries currently support mixdown + // 2. the lame encoder library only supports stereo. + // 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. + switch (audio->config.in.channel_layout & HB_INPUT_CH_LAYOUT_DISCRETE_NO_LFE_MASK) + { + // stereo input or something not handled below + default: + case HB_INPUT_CH_LAYOUT_STEREO: + // mono gets mixed up to stereo & more than stereo gets mixed down + if ( audio->config.out.mixdown > HB_AMIXDOWN_STEREO ) + { + audio->config.out.mixdown = HB_AMIXDOWN_STEREO; + } + break; + + // mono input + case HB_INPUT_CH_LAYOUT_MONO: + // everything else passes through + audio->config.out.mixdown = HB_AMIXDOWN_MONO; + break; + + // dolby (DPL1 aka Dolby Surround = 4.0 matrix-encoded) input + // 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 ( audio->config.out.mixdown > HB_AMIXDOWN_DOLBY ) + { + audio->config.out.mixdown = HB_AMIXDOWN_DOLBY; + } + break; + + // 4 channel discrete + case HB_INPUT_CH_LAYOUT_2F2R: + case HB_INPUT_CH_LAYOUT_3F1R: + if ( audio->config.out.mixdown > HB_AMIXDOWN_DOLBY ) + { + audio->config.out.mixdown = HB_AMIXDOWN_DOLBY; + } + break; + + // 5 or 6 channel discrete + case HB_INPUT_CH_LAYOUT_3F2R: + if ( ! ( audio->config.in.channel_layout & + HB_INPUT_CH_LAYOUT_HAS_LFE ) ) + { + // we don't do 5 channel discrete so mixdown to DPLII + audio->config.out.mixdown = HB_AMIXDOWN_DOLBYPLII; + } + break; + } + + /* log the output mixdown */ + for (j = 0; j < hb_audio_mixdowns_count; j++) { + if (hb_audio_mixdowns[j].amixdown == audio->config.out.mixdown) { + if ( audio->config.out.mixdown != requested_mixdown ) + { + hb_log("work: sanitizing track %i mixdown %s to %s", i, hb_audio_mixdowns[requested_mixdown_index].human_readable_name, hb_audio_mixdowns[j].human_readable_name); + } + break; + } + } + } + + if (audio->config.out.codec == HB_ACODEC_VORBIS) + audio->priv.config.vorbis.language = audio->config.lang.simple; + + /* set up the audio work structures */ + 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 */ - hb_list_add( job->list_work, ( w = hb_get_work( WORK_SYNC ) ) ); - w->fifo_in = NULL; - w->fifo_out = NULL; + sync = hb_sync_init( job ); /* Video decoder */ int vcodec = title->video_codec? title->video_codec : WORK_DECMPEG2; @@ -480,7 +665,10 @@ static void do_job( hb_job_t * job, int cpu_count ) /* 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 ) + w->fifo_out = job->fifo_render; + else + w->fifo_out = NULL; if( !job->indepth_scan ) { @@ -539,6 +727,7 @@ static void do_job( hb_job_t * job, int cpu_count ) *subtitle = *(interjob->select_subtitle); free( interjob->select_subtitle ); interjob->select_subtitle = NULL; + break; } } } @@ -564,10 +753,10 @@ static void do_job( hb_job_t * job, int cpu_count ) 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 ); + 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 ) { @@ -598,6 +787,30 @@ static void do_job( hb_job_t * job, int cpu_count ) w->subtitle = subtitle; hb_list_add( job->list_work, w ); } + + if( !job->indepth_scan && subtitle->source == UTF8SUB ) + { + w = hb_get_work( WORK_DECUTF8SUB ); + 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 == TX3GSUB ) + { + w = hb_get_work( WORK_DECTX3GSUB ); + 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 == SSASUB ) + { + w = hb_get_work( WORK_DECSSASUB ); + w->fifo_in = subtitle->fifo_in; + w->fifo_out = subtitle->fifo_raw; + hb_list_add( job->list_work, w ); + } if( !job->indepth_scan && subtitle->format == PICTURESUB @@ -618,255 +831,57 @@ static void do_job( hb_job_t * job, int cpu_count ) if( !job->indepth_scan ) { - // if we are doing passthru, and the input codec is not the same as the output - // codec, then remove this audio from the job. If we're not doing passthru and - // the input codec is the 'internal' ffmpeg codec, make sure that only one - // audio references that audio stream since the codec context is specific to - // the audio id & multiple copies of the same stream will garble the audio - // or cause aborts. - uint8_t aud_id_uses[MAX_STREAMS]; - memset( aud_id_uses, 0, sizeof(aud_id_uses) ); - for( i = 0; i < hb_list_count( title->list_audio ); ) - { - audio = hb_list_item( title->list_audio, i ); - if( ( ( audio->config.out.codec == HB_ACODEC_AC3 ) && ( audio->config.in.codec != HB_ACODEC_AC3 ) ) || - ( ( audio->config.out.codec == HB_ACODEC_DCA ) && ( audio->config.in.codec != HB_ACODEC_DCA ) ) ) - { - hb_log( "Passthru requested and input codec is not the same as output codec for track %d", - audio->config.out.track ); - hb_list_rem( title->list_audio, audio ); - free( audio ); - continue; - } - if ( audio->config.in.codec == HB_ACODEC_FFMPEG ) - { - if ( aud_id_uses[audio->id] ) - { - hb_log( "Multiple decodes of audio id %d, removing track %d", - audio->id, audio->config.out.track ); - hb_list_rem( title->list_audio, audio ); - free( audio ); - continue; - } - ++aud_id_uses[audio->id]; - } - /* Adjust output track number, in case we removed one. - * Output tracks sadly still need to be in sequential order. - */ - audio->config.out.track = i++; - } - - int requested_mixdown = 0; - int requested_mixdown_index = 0; - - for( i = 0; i < hb_list_count( title->list_audio ); i++ ) - { - audio = hb_list_item( title->list_audio, i ); - - if( audio->config.out.codec != audio->config.in.codec ) - { - /* sense-check the current mixdown options */ - - /* log the requested mixdown */ - for (j = 0; j < hb_audio_mixdowns_count; j++) { - if (hb_audio_mixdowns[j].amixdown == audio->config.out.mixdown) { - requested_mixdown = audio->config.out.mixdown; - requested_mixdown_index = j; - } - } - - /* sense-check the requested mixdown */ - - if( audio->config.out.mixdown == 0 && - audio->config.out.codec != HB_ACODEC_AC3 && - audio->config.out.codec != HB_ACODEC_DCA ) - { - /* - * Mixdown wasn't specified and this is not pass-through, - * set a default mixdown of stereo. - */ - audio->config.out.mixdown = HB_AMIXDOWN_STEREO; - } - - // Here we try to sanitize the audio input to output mapping. - // Constraints are: - // 1. only the AC3 & DCA decoder libraries currently support mixdown - // 2. the lame encoder library only supports stereo. - // 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) - { - // stereo input or something not handled below - default: - case HB_INPUT_CH_LAYOUT_STEREO: - // mono gets mixed up to stereo & more than stereo gets mixed down - if ( STEREO_ONLY( audio ) || - audio->config.out.mixdown > HB_AMIXDOWN_STEREO) - { - audio->config.out.mixdown = HB_AMIXDOWN_STEREO; - } - break; - - // mono input - 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 - { - // everything else passes through - audio->config.out.mixdown = HB_AMIXDOWN_MONO; - } - break; - - // dolby (DPL1 aka Dolby Surround = 4.0 matrix-encoded) input - // 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 ) || - audio->config.out.mixdown > HB_AMIXDOWN_DOLBY ) - { - audio->config.out.mixdown = HB_AMIXDOWN_DOLBY; - } - break; - - // 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 - { - // 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 ); - } - break; - - // 5 or 6 channel discrete - case HB_INPUT_CH_LAYOUT_3F2R: - if ( CAN_MIXDOWN( audio ) ) - { - if ( STEREO_ONLY( audio ) ) - { - 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; - } - } - else if ( ! ( audio->config.in.channel_layout & - HB_INPUT_CH_LAYOUT_HAS_LFE ) ) - { - // 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 - { - // we can't mixdown so force 6 channel discrete - audio->config.out.mixdown = HB_AMIXDOWN_6CH; - } - break; - } - - /* log the output mixdown */ - for (j = 0; j < hb_audio_mixdowns_count; j++) { - if (hb_audio_mixdowns[j].amixdown == audio->config.out.mixdown) { - if ( audio->config.out.mixdown != requested_mixdown ) - { - hb_log("work: sanitizing track %i mixdown %s to %s", i, hb_audio_mixdowns[requested_mixdown_index].human_readable_name, hb_audio_mixdowns[j].human_readable_name); - } - break; - } - } - } - - if (audio->config.out.codec == HB_ACODEC_VORBIS) - 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 Decoder Thread - */ - if ( ( w = hb_codec_decoder( audio->config.in.codec ) ) == NULL ) + for( i = 0; i < hb_list_count( title->list_audio ); i++ ) { - hb_error("Invalid input codec: %d", audio->config.in.codec); - *job->die = 1; - goto cleanup; - } - 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 = hb_list_item( title->list_audio, i ); - /* - * 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 ) + * Audio Decoder Thread + */ + if ( ( w = hb_codec_decoder( audio->config.in.codec ) ) == NULL ) { - hb_error("Invalid audio codec: %#x", audio->config.out.codec); - w = 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 +894,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 +909,70 @@ 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; + } + } + } } - hb_list_rem( job->list_work, w ); - w->close( w ); - free( w ); hb_handle_t * h = job->h; hb_state_t state; @@ -919,11 +980,22 @@ static void do_job( hb_job_t * job, int cpu_count ) hb_log("work: average encoding speed for job is %f fps", state.param.working.rate_avg); + 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 ); + } + 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 +1157,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 +1181,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 +1189,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 ); + } }