X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fwork.c;h=c1891a6838b53908a0c93a444209da203215d4c2;hb=55b0015a8c50106e553bc2f48336cc2a1c495459;hp=53d9e27c74a2feaf565e1fa6726a724b50d9a9c1;hpb=b47564182dd9c4a6b505342c71465e0a35b1c54d;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/work.c b/libhb/work.c index 53d9e27c..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; } @@ -125,7 +147,7 @@ void hb_display_job_info( hb_job_t * job ) hb_log("job configuration:"); hb_log( " * source"); - hb_log( " + %s", title->dvd ); + hb_log( " + %s", title->path ); hb_log( " + title %d, chapter(s) %d to %d", title->index, job->chapter_start, job->chapter_end ); @@ -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"); @@ -273,7 +291,7 @@ void hb_display_job_info( hb_job_t * job ) } else if( job->vquality > 1 ) { - hb_log( " + quality: %.2f %s", job->vquality, job->crf && job->vcodec == HB_VCODEC_X264 ? "(RF)" : "(QP)" ); + hb_log( " + quality: %.2f %s", job->vquality, job->vcodec == HB_VCODEC_X264 ? "(RF)" : "(QP)" ); } else { @@ -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" : "" ); + } } } @@ -354,7 +387,7 @@ void correct_framerate( hb_job_t * job ) hb_interjob_t * interjob = hb_interjob_get( job->h ); - if( ( job->sequence_id & 0xFFFFFF ) != ( interjob->last_job ) ) + if( ( job->sequence_id & 0xFFFFFF ) != ( interjob->last_job & 0xFFFFFF) ) return; // Interjob information is for a different encode. /* Cache the original framerate before altering it. */ @@ -362,9 +395,9 @@ void correct_framerate( hb_job_t * job ) interjob->vrate_base = job->vrate_base; real_frames = interjob->frame_count - interjob->render_dropped; - job->vrate = job->vrate_base * ( real_frames / ( interjob->total_time / 90000 ) ); -} + job->vrate = job->vrate_base * ( (double)real_frames * 90000 / interjob->total_time ); +} /** * Job initialization rountine. @@ -382,6 +415,9 @@ 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; hb_subtitle_t * subtitle; @@ -393,6 +429,7 @@ static void do_job( hb_job_t * job, int cpu_count ) unsigned int subtitle_hit = 0; title = job->title; + interjob = hb_interjob_get( job->h ); if( job->pass == 2 && !job->cfr ) { @@ -456,160 +493,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 && job->select_subtitle && *(job->select_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( (*job->select_subtitle)->config.force && - (*job->select_subtitle)->forced_hits == 0 ) - { - (*job->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( (*job->select_subtitle)->id == subtitle->id ) - { - *subtitle = *(*job->select_subtitle); - free( *job->select_subtitle ); - free( job->select_subtitle ); - job->select_subtitle = NULL; - } - } - } - - if( job->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, *job->select_subtitle ); - free( job->select_subtitle ); - job->select_subtitle = NULL; - } - } - else if ( !job->indepth_scan && job->select_subtitle ) - { - free( job->select_subtitle ); - job->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 || 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->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 @@ -689,17 +581,13 @@ 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) { // 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) + if ( audio->config.out.mixdown > HB_AMIXDOWN_STEREO ) { audio->config.out.mixdown = HB_AMIXDOWN_STEREO; } @@ -707,33 +595,15 @@ static void do_job( hb_job_t * job, int cpu_count ) // 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; - } + // 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 ) + if ( audio->config.out.mixdown > HB_AMIXDOWN_DOLBY ) { audio->config.out.mixdown = HB_AMIXDOWN_DOLBY; } @@ -742,57 +612,19 @@ 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 ( 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 ( 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 + if ( ! ( audio->config.in.channel_layout & + 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; } @@ -813,54 +645,243 @@ 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 ) + { + 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->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 + && 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 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 */ @@ -873,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; @@ -888,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 ); - w = hb_list_item( job->list_work, 0 ); - w->thread_sleep_interval = 10; - w->init( w, job ); - while( !*job->die ) + // 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; + } + + 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; @@ -913,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 */ @@ -1006,59 +1084,47 @@ cleanup: } } - if( job->native_language ) { + + if( subtitle_forced_id ) + { /* - * We still have a native_language, so the audio and subtitles are - * different, so in this case it is a foreign film and we want to - * select the subtitle with the highest hits in our language. + * If there are any subtitle streams with forced subtitles + * then select it in preference to the lowest. */ - subtitle_hit = subtitle_highest_id; - hb_log( "Found a native-language subtitle id 0x%x", subtitle_hit); - } else { - if( subtitle_forced_id ) - { - /* - * If there are any subtitle streams with forced subtitles - * then select it in preference to the lowest. - */ - subtitle_hit = subtitle_forced_id; - hb_log("Found a subtitle candidate id 0x%x (contains forced subs)", - subtitle_hit); - } else if( subtitle_lowest < subtitle_highest ) + subtitle_hit = subtitle_forced_id; + hb_log("Found a subtitle candidate id 0x%x (contains forced subs)", + subtitle_hit); + } else if( subtitle_lowest < subtitle_highest ) + { + /* + * OK we have more than one, and the lowest is lower, + * but how much lower to qualify for turning it on by + * default? + * + * Let's say 10% as a default. + */ + if( subtitle_lowest < ( subtitle_highest * 0.1 ) ) { - /* - * OK we have more than one, and the lowest is lower, - * but how much lower to qualify for turning it on by - * default? - * - * Let's say 10% as a default. - */ - if( subtitle_lowest < ( subtitle_highest * 0.1 ) ) - { - subtitle_hit = subtitle_lowest_id; - hb_log( "Found a subtitle candidate id 0x%x", - subtitle_hit ); - } else { - hb_log( "No candidate subtitle detected during subtitle-scan"); - } + subtitle_hit = subtitle_lowest_id; + hb_log( "Found a subtitle candidate id 0x%x", + subtitle_hit ); + } else { + hb_log( "No candidate subtitle detected during subtitle-scan"); } } } - if( job->select_subtitle ) + if( job->indepth_scan ) { - if( job->indepth_scan ) + for( i=0; i < hb_list_count( title->list_subtitle ); i++ ) { - for( i=0; i < hb_list_count( title->list_subtitle ); i++ ) + subtitle = hb_list_item( title->list_subtitle, i ); + if( subtitle->id == subtitle_hit ) { - subtitle = hb_list_item( title->list_subtitle, i ); - if( subtitle->id == subtitle_hit ) - { - subtitle->config = job->select_subtitle_config; - hb_list_rem( title->list_subtitle, subtitle ); - *job->select_subtitle = subtitle; - break; - } + subtitle->config = job->select_subtitle_config; + hb_list_rem( title->list_subtitle, subtitle ); + interjob->select_subtitle = subtitle; + break; } } } @@ -1091,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 ); @@ -1117,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; } @@ -1125,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 ); + } }