X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fhb.c;h=390e566d2494a25381a5ac556502da40f5c4eac7;hb=cdaae4f3b1390847b750ca69d605645b7b54074f;hp=bdd2353d94267b08acbf839442571840adc0f068;hpb=25cdc7534f4c28481dc3f4f0c77022a457cdede3;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/hb.c b/libhb/hb.c index bdd2353d..390e566d 100644 --- a/libhb/hb.c +++ b/libhb/hb.c @@ -1,12 +1,8 @@ -/* $Id: hb.c,v 1.43 2005/04/27 21:05:24 titer Exp $ - - This file is part of the HandBrake source code. - Homepage: . - It may be used under the terms of the GNU General Public License. */ - #include "hb.h" -#include "ffmpeg/avcodec.h" +#include "libavcodec/avcodec.h" +#include "libavformat/avformat.h" +#include "libswscale/swscale.h" struct hb_handle_s { @@ -28,7 +24,9 @@ struct hb_handle_s /* The thread which processes the jobs. Others threads are launched from this one (see work.c) */ hb_list_t * jobs; + hb_job_t * current_job; int job_count; + int job_count_permanent; volatile int work_die; int work_error; hb_thread_t * work_thread; @@ -40,6 +38,10 @@ struct hb_handle_s int paused; hb_lock_t * pause_lock; + /* For MacGui active queue + increments each time the scan thread completes*/ + int scanCount; + }; hb_work_object_t * hb_objects = NULL; @@ -102,6 +104,11 @@ hb_handle_t * hb_init_real( int verbose, int update_check ) } } + /* + * Initialise buffer pool + */ + hb_buffer_pool_init(); + /* CPU count detection */ hb_log( "hb_init: checking cpu count" ); h->cpu_count = hb_get_cpu_count(); @@ -115,10 +122,7 @@ hb_handle_t * hb_init_real( int verbose, int update_check ) h->pause_lock = hb_lock_init(); /* libavcodec */ - avcodec_init(); - register_avcodec( &mpeg4_encoder ); - register_avcodec( &mp2_decoder ); - register_avcodec( &ac3_encoder ); + av_register_all(); /* Start library thread */ hb_log( "hb_init: starting libhb thread" ); @@ -127,9 +131,105 @@ hb_handle_t * hb_init_real( int verbose, int update_check ) HB_NORMAL_PRIORITY ); return h; + + /* Set the scan count to start at 0 */ + //scan_count = 0; } /** + * libhb initialization routine. + * This version is to use when calling the dylib, the macro hb_init isn't available from a dylib call! + * @param verbose HB_DEBUG_NONE or HB_DEBUG_ALL. + * @param update_check signals libhb to check for updated version from HandBrake website. + * @return Handle to hb_handle_t for use on all subsequent calls to libhb. + */ +hb_handle_t * hb_init_dl( int verbose, int update_check ) +{ + hb_handle_t * h = calloc( sizeof( hb_handle_t ), 1 ); + uint64_t date; + + /* See hb_log() in common.c */ + if( verbose > HB_DEBUG_NONE ) + { + putenv( "HB_DEBUG=1" ); + } + + /* Check for an update on the website if asked to */ + h->build = -1; + + if( update_check ) + { + hb_log( "hb_init: checking for updates" ); + date = hb_get_date(); + h->update_thread = hb_update_init( &h->build, h->version ); + + for( ;; ) + { + if( hb_thread_has_exited( h->update_thread ) ) + { + /* Immediate success or failure */ + hb_thread_close( &h->update_thread ); + break; + } + if( hb_get_date() > date + 1000 ) + { + /* Still nothing after one second. Connection problem, + let the thread die */ + hb_log( "hb_init: connection problem, not waiting for " + "update_thread" ); + break; + } + hb_snooze( 500 ); + } + } + + /* CPU count detection */ + hb_log( "hb_init: checking cpu count" ); + h->cpu_count = hb_get_cpu_count(); + + h->list_title = hb_list_init(); + h->jobs = hb_list_init(); + h->current_job = NULL; + + h->state_lock = hb_lock_init(); + h->state.state = HB_STATE_IDLE; + + h->pause_lock = hb_lock_init(); + + /* libavcodec */ + avcodec_init(); + avcodec_register_all(); + + /* Start library thread */ + hb_log( "hb_init: starting libhb thread" ); + h->die = 0; + h->main_thread = hb_thread_init( "libhb", thread_func, h, + HB_NORMAL_PRIORITY ); + + hb_register( &hb_sync ); + hb_register( &hb_decmpeg2 ); + hb_register( &hb_decsub ); + hb_register( &hb_render ); + hb_register( &hb_encavcodec ); + hb_register( &hb_encxvid ); + hb_register( &hb_encx264 ); + hb_register( &hb_enctheora ); + hb_register( &hb_deca52 ); + hb_register( &hb_decdca ); + hb_register( &hb_decavcodec ); + hb_register( &hb_decavcodecv ); + hb_register( &hb_decavcodecvi ); + hb_register( &hb_decavcodecai ); + hb_register( &hb_declpcm ); + hb_register( &hb_encfaac ); + hb_register( &hb_enclame ); + hb_register( &hb_encvorbis ); + + return h; +} + + +/** * Returns current version of libhb. * @param h Handle to hb_handle_t. * @return character array of version number. @@ -189,7 +289,7 @@ void hb_scan( hb_handle_t * h, const char * path, int title_index ) hb_list_rem( h->list_title, title ); hb_title_close( &title ); } - + hb_log( "hb_scan: path=%s, title_index=%d", path, title_index ); h->scan_thread = hb_scan_init( h, path, title_index, h->list_title ); } @@ -218,28 +318,35 @@ void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture, char filename[1024]; FILE * file; uint8_t * buf1, * buf2, * buf3, * buf4, * pen; - uint32_t * p32; - AVPicture pic1, pic2, pic3, pic4; - ImgReSampleContext * context; + uint32_t * p32, swsflags; + AVPicture pic_in, pic_preview, pic_deint, pic_crop, pic_scale; + struct SwsContext * context; int i; + swsflags = SWS_LANCZOS; +#ifndef __x86_64__ + swsflags |= SWS_ACCURATE_RND; +#endif /* __x86_64__ */ + buf1 = malloc( title->width * title->height * 3 / 2 ); buf2 = malloc( title->width * title->height * 3 / 2 ); buf3 = malloc( title->width * title->height * 3 / 2 ); buf4 = malloc( title->width * title->height * 4 ); - avpicture_fill( &pic1, buf1, PIX_FMT_YUV420P, + avpicture_fill( &pic_in, buf1, PIX_FMT_YUV420P, title->width, title->height ); - avpicture_fill( &pic2, buf2, PIX_FMT_YUV420P, + avpicture_fill( &pic_deint, buf2, PIX_FMT_YUV420P, title->width, title->height ); - avpicture_fill( &pic3, buf3, PIX_FMT_YUV420P, + avpicture_fill( &pic_scale, buf3, PIX_FMT_YUV420P, job->width, job->height ); - avpicture_fill( &pic4, buf4, PIX_FMT_RGBA32, + avpicture_fill( &pic_preview, buf4, PIX_FMT_RGBA32, job->width, job->height ); - + + // Allocate the AVPicture frames and fill in + memset( filename, 0, 1024 ); hb_get_tempory_filename( h, filename, "%x%d", - (int) title, picture ); + (intptr_t) title, picture ); file = fopen( filename, "r" ); if( !file ) @@ -251,23 +358,47 @@ void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture, fread( buf1, title->width * title->height * 3 / 2, 1, file ); fclose( file ); - context = img_resample_full_init( - job->width, job->height, title->width, title->height, - job->crop[0], job->crop[1], job->crop[2], job->crop[3], - 0, 0, 0, 0 ); - if( job->deinterlace ) { - avpicture_deinterlace( &pic2, &pic1, PIX_FMT_YUV420P, - title->width, title->height ); - img_resample( context, &pic3, &pic2 ); + // Deinterlace and crop + avpicture_deinterlace( &pic_deint, &pic_in, PIX_FMT_YUV420P, title->width, title->height ); + av_picture_crop( &pic_crop, &pic_deint, PIX_FMT_YUV420P, job->crop[0], job->crop[2] ); } else { - img_resample( context, &pic3, &pic1 ); + // Crop + av_picture_crop( &pic_crop, &pic_in, PIX_FMT_YUV420P, job->crop[0], job->crop[2] ); } - img_convert( &pic4, PIX_FMT_RGBA32, &pic3, PIX_FMT_YUV420P, - job->width, job->height ); + + // Get scaling context + context = sws_getContext(title->width - (job->crop[2] + job->crop[3]), + title->height - (job->crop[0] + job->crop[1]), + PIX_FMT_YUV420P, + job->width, job->height, PIX_FMT_YUV420P, + swsflags, NULL, NULL, NULL); + + // Scale + sws_scale(context, + pic_crop.data, pic_crop.linesize, + 0, title->height - (job->crop[0] + job->crop[1]), + pic_scale.data, pic_scale.linesize); + + // Free context + sws_freeContext( context ); + + // Get preview context + context = sws_getContext(job->width, job->height, PIX_FMT_YUV420P, + job->width, job->height, PIX_FMT_RGBA32, + swsflags, NULL, NULL, NULL); + + // Create preview + sws_scale(context, + pic_scale.data, pic_scale.linesize, + 0, job->height, + pic_preview.data, pic_preview.linesize); + + // Free context + sws_freeContext( context ); /* Gray background */ p32 = (uint32_t *) buffer; @@ -294,10 +425,299 @@ void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture, } memset( pen, 0xFF, 4 * ( job->width + 2 ) ); - free( buf1 ); - free( buf2 ); - free( buf3 ); - free( buf4 ); + // Clean up + avpicture_free( &pic_preview ); + avpicture_free( &pic_scale ); + avpicture_free( &pic_deint ); + avpicture_free( &pic_in ); +} + + /** + * Analyzes a frame to detect interlacing artifacts + * and returns true if interlacing (combing) is found. + * + * Code taken from Thomas Oestreich's 32detect filter + * in the Transcode project, with minor formatting changes. + * + * @param buf An hb_buffer structure holding valid frame data + * @param width The frame's width in pixels + * @param height The frame's height in pixels + * @param color_equal Sensitivity for detecting similar colors + * @param color_diff Sensitivity for detecting different colors + * @param threshold Sensitivity for flagging planes as combed + * @param prog_equal Sensitivity for detecting similar colors on progressive frames + * @param prog_diff Sensitivity for detecting different colors on progressive frames + * @param prog_threshold Sensitivity for flagging progressive frames as combed + */ +int hb_detect_comb( hb_buffer_t * buf, int width, int height, int color_equal, int color_diff, int threshold, int prog_equal, int prog_diff, int prog_threshold ) +{ + int j, k, n, off, cc_1, cc_2, cc[3], flag[3] ; + uint16_t s1, s2, s3, s4; + cc_1 = 0; cc_2 = 0; + + int offset = 0; + + if ( buf->flags & 16 ) + { + /* Frame is progressive, be more discerning. */ + color_diff = prog_diff; + color_equal = prog_equal; + threshold = prog_threshold; + } + + /* One pas for Y, one pass for Cb, one pass for Cr */ + for( k = 0; k < 3; k++ ) + { + if( k == 1 ) + { + /* Y has already been checked, now offset by Y's dimensions + and divide all the other values by 2, since Cr and Cb + are half-size compared to Y. */ + offset = width * height; + width >>= 1; + height >>= 1; + } + else if ( k == 2 ) + { + /* Y and Cb are done, so the offset needs to be bumped + so it's width*height + (width / 2) * (height / 2) */ + offset *= 5/4; + } + + for( j = 0; j < width; ++j ) + { + off = 0; + + for( n = 0; n < ( height - 4 ); n = n + 2 ) + { + /* Look at groups of 4 sequential horizontal lines */ + s1 = ( ( buf->data + offset )[ off + j ] & 0xff ); + s2 = ( ( buf->data + offset )[ off + j + width ] & 0xff ); + s3 = ( ( buf->data + offset )[ off + j + 2 * width ] & 0xff ); + s4 = ( ( buf->data + offset )[ off + j + 3 * width ] & 0xff ); + + /* Note if the 1st and 2nd lines are more different in + color than the 1st and 3rd lines are similar in color.*/ + if ( ( abs( s1 - s3 ) < color_equal ) && + ( abs( s1 - s2 ) > color_diff ) ) + ++cc_1; + + /* Note if the 2nd and 3rd lines are more different in + color than the 2nd and 4th lines are similar in color.*/ + if ( ( abs( s2 - s4 ) < color_equal ) && + ( abs( s2 - s3 ) > color_diff) ) + ++cc_2; + + /* Now move down 2 horizontal lines before starting over.*/ + off += 2 * width; + } + } + + // compare results + /* The final cc score for a plane is the percentage of combed pixels it contains. + Because sensitivity goes down to hundreths of a percent, multiply by 1000 + so it will be easy to compare against the threhold value which is an integer. */ + cc[k] = (int)( ( cc_1 + cc_2 ) * 1000.0 / ( width * height ) ); + } + + + /* HandBrake is all yuv420, so weight the average percentage of all 3 planes accordingly.*/ + int average_cc = ( 2 * cc[0] + ( cc[1] / 2 ) + ( cc[2] / 2 ) ) / 3; + + /* Now see if that average percentage of combed pixels surpasses the threshold percentage given by the user.*/ + if( average_cc > threshold ) + { +#if 0 + hb_log("Average %i combed (Threshold %i) %i/%i/%i | PTS: %lld (%fs) %s", average_cc, threshold, cc[0], cc[1], cc[2], buf->start, (float)buf->start / 90000, (buf->flags & 16) ? "Film" : "Video" ); +#endif + return 1; + } + +#if 0 + hb_log("SKIPPED Average %i combed (Threshold %i) %i/%i/%i | PTS: %lld (%fs) %s", average_cc, threshold, cc[0], cc[1], cc[2], buf->start, (float)buf->start / 90000, (buf->flags & 16) ? "Film" : "Video" ); +#endif + + /* Reaching this point means no combing detected. */ + return 0; + +} + +/** + * Calculates job width and height for anamorphic content, + * + * @param job Handle to hb_job_t + * @param output_width Pointer to returned storage width + * @param output_height Pointer to returned storage height + * @param output_par_width Pointer to returned pixel width + @ param output_par_height Pointer to returned pixel height + */ +void hb_set_anamorphic_size( hb_job_t * job, + int *output_width, int *output_height, + int *output_par_width, int *output_par_height ) +{ + /* "Loose" anamorphic. + - Uses mod16-compliant dimensions, + - Allows users to set the width + - Handles ITU pixel aspects + */ + + /* Set up some variables to make the math easier to follow. */ + hb_title_t * title = job->title; + int cropped_width = title->width - job->crop[2] - job->crop[3] ; + int cropped_height = title->height - job->crop[0] - job->crop[1] ; + double storage_aspect = (double)cropped_width / (double)cropped_height; + int width = job->width; + int height; // Gets set later, ignore user value + int mod = job->modulus; + double aspect = title->aspect; + + /* Gotta handle bounding dimensions differently + than for non-anamorphic encodes: + If the width is too big, just reset it with no rescaling. + Instead of using the aspect-scaled job height, + we need to see if the job width divided by the storage aspect + is bigger than the max. If so, set it to the max (this is sloppy). + If not, set job height to job width divided by storage aspect. + */ + + if ( job->maxWidth && (job->maxWidth < job->width) ) + width = job->maxWidth; + + height = (double)width / storage_aspect; + if ( job->maxHeight && (job->maxHeight < height) ) + { + height = job->maxHeight; + } + else + { + height = (double)width / storage_aspect; + } + + + /* Time to get picture dimensions that divide cleanly. + These variables will store temporary dimensions as we iterate. */ + int i, w, h; + + /* In case the user specified a modulus, use it */ + if (job->modulus) + mod = job->modulus; + else + mod = 16; + + /* Iterate through multiples of mod to find one close to job->width. */ + for( i = 1;; i++ ) + { + w = mod * i; + + if (w < width) + { + if ( ( width - w ) <= ( mod / 2 ) ) + /* We'll take a width that's + smaller, but close enough. */ + break; + } + if (w == width) + /* Mod 16 dimensions, how nice! */ + break; + if( w > width ) + { + if ( ( w - width ) < (mod/2) ) + /* We'll take a width that's bigger, if we have to. */ + break; + } + } + width = mod * (i); + + /* Now do the same for a mod-friendly value near job->height. */ + for( i = 1;; i++) + { + h = i * mod; + + if (h < height) + { + if ( ( height - h ) <= ( mod / 2 )) + /* Go with a smaller height, + if it's close enough. */ + break; + } + if (h == height) + /* Mod 16 dimensions, how nice! */ + break; + + if ( h > height) + { + if ( ( h - height ) < ( mod / 2 )) + /* Use a taller height if necessary */ + break; + } + } + height = mod * (i); + + int pixel_aspect_width = job->pixel_aspect_width; + int pixel_aspect_height = job->pixel_aspect_height; + + /* If a source was really 704*480 and hard matted with cropping + to 720*480, replace the PAR values with the ITU broadcast ones. */ + if (title->width == 720 && cropped_width <= 706) + { + // convert aspect to a scaled integer so we can test for 16:9 & 4:3 + // aspect ratios ignoring insignificant differences in the LSBs of + // the floating point representation. + int iaspect = aspect * 9.; + + /* Handle ITU PARs */ + if (title->height == 480) + { + /* It's NTSC */ + if (iaspect == 16) + { + /* It's widescreen */ + pixel_aspect_width = 40; + pixel_aspect_height = 33; + } + else if (iaspect == 12) + { + /* It's 4:3 */ + pixel_aspect_width = 10; + pixel_aspect_height = 11; + } + } + else if (title->height == 576) + { + /* It's PAL */ + if(iaspect == 16) + { + /* It's widescreen */ + pixel_aspect_width = 16; + pixel_aspect_height = 11; + } + else if (iaspect == 12) + { + /* It's 4:3 */ + pixel_aspect_width = 12; + pixel_aspect_height = 11; + } + } + } + + /* Figure out what dimensions the source would display at. */ + int source_display_width = cropped_width * (double)pixel_aspect_width / + (double)pixel_aspect_height ; + + /* The film AR is the source's display width / cropped source height. + The output display width is the output height * film AR. + The output PAR is the output display width / output storage width. */ + pixel_aspect_width = height * source_display_width / cropped_height; + pixel_aspect_height = width; + + /* Pass the results back to the caller */ + *output_width = width; + *output_height = height; + + /* While x264 is smart enough to reduce fractions on its own, libavcodec + needs some help with the math, so lose superfluous factors. */ + hb_reduce( output_par_width, output_par_height, + pixel_aspect_width, pixel_aspect_height ); } /** @@ -306,14 +726,14 @@ void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture, * @param aspect Desired aspect ratio. Value of -1 uses title aspect. * @param pixels Maximum desired pixel count. */ -void hb_set_size( hb_job_t * job, int aspect, int pixels ) +void hb_set_size( hb_job_t * job, double aspect, int pixels ) { hb_title_t * title = job->title; int croppedWidth = title->width - title->crop[2] - title->crop[3]; int croppedHeight = title->height - title->crop[0] - title->crop[1]; - int croppedAspect = title->aspect * title->height * croppedWidth / - croppedHeight / title->width; + double croppedAspect = title->aspect * title->height * croppedWidth / + croppedHeight / title->width; int addCrop; int i, w, h; @@ -378,7 +798,7 @@ void hb_set_size( hb_job_t * job, int aspect, int pixels ) for( i = 0;; i++ ) { w = 16 * i; - h = MULTIPLE_16( w * HB_ASPECT_BASE / aspect ); + h = MULTIPLE_16( (int)( (double)w / aspect ) ); if( w * h > pixels ) { break; @@ -386,7 +806,7 @@ void hb_set_size( hb_job_t * job, int aspect, int pixels ) } i--; job->width = 16 * i; - job->height = MULTIPLE_16( 16 * i * HB_ASPECT_BASE / aspect ); + job->height = MULTIPLE_16( (int)( (double)job->width / aspect ) ); } /** @@ -410,6 +830,11 @@ hb_job_t * hb_job( hb_handle_t * h, int i ) return hb_list_item( h->jobs, i ); } +hb_job_t * hb_current_job( hb_handle_t * h ) +{ + return( h->current_job ); +} + /** * Adds a job to the job list. * @param h Handle to hb_handle_t. @@ -420,9 +845,10 @@ void hb_add( hb_handle_t * h, hb_job_t * job ) hb_job_t * job_copy; hb_title_t * title, * title_copy; hb_chapter_t * chapter, * chapter_copy; - hb_audio_t * audio, * audio_copy; + hb_audio_t * audio; hb_subtitle_t * subtitle, * subtitle_copy; int i; + char audio_lang[4]; /* Copy the title */ title = job->title; @@ -441,43 +867,207 @@ void hb_add( hb_handle_t * h, hb_job_t * job ) /* Copy the audio track(s) we want */ title_copy->list_audio = hb_list_init(); - /* Do nothing about audio during first pass */ - if( job->pass != 1 ) + for( i = 0; i < hb_list_count(job->list_audio); i++ ) { - for( i = 0; i < 8; i++ ) + if( ( audio = hb_list_item( job->list_audio, i ) ) ) + { + hb_list_add( title_copy->list_audio, hb_audio_copy(audio) ); + } + } + + title_copy->list_subtitle = hb_list_init(); + + /* + * The following code is confusing, there are three ways in which + * we select subtitles and it depends on whether this is single or + * two pass mode. + * + * subtitle_scan may be enabled, in which case the first pass + * scans all subtitles of that language. The second pass does not + * select any because they are set at the end of the first pass. + * + * native_language may have a preferred language, in which case we + * may be switching the language we want for the subtitles in the + * first pass of a single pass, or the second pass of a two pass. + * + * We may have manually selected a subtitle, in which case that is + * selected in the first pass of a single pass, or the second of a + * two pass. + */ + memset( audio_lang, 0, sizeof( audio_lang ) ); + + if ( job->indepth_scan || job->native_language ) { + + /* + * Find the first audio language that is being encoded + */ + for( i = 0; i < hb_list_count(job->list_audio); i++ ) { - if( job->audios[i] < 0 ) + if( ( audio = hb_list_item( job->list_audio, i ) ) ) { + strncpy(audio_lang, audio->config.lang.iso639_2, sizeof(audio_lang)); break; } - if( ( audio = hb_list_item( title->list_audio, job->audios[i] ) ) ) + } + + /* + * In all cases switch the language if we need to to our native + * language. + */ + if( job->native_language ) + { + if( strncasecmp( job->native_language, audio_lang, + sizeof( audio_lang ) ) != 0 ) { - audio_copy = malloc( sizeof( hb_audio_t ) ); - memcpy( audio_copy, audio, sizeof( hb_audio_t ) ); - hb_list_add( title_copy->list_audio, audio_copy ); + + if( job->pass != 2 ) + { + hb_log( "Enabled subtitles in native language '%s', audio is in '%s'", + job->native_language, audio_lang); + } + /* + * The main audio track is not in our native language, so switch + * the subtitles to use our native language instead. + */ + strncpy( audio_lang, job->native_language, sizeof( audio_lang ) ); + } else { + /* + * native language is irrelevent, free it. + */ + free( job->native_language ); + job->native_language = NULL; } } } - /* Copy the subtitle we want (or not) */ - title_copy->list_subtitle = hb_list_init(); - if( ( subtitle = hb_list_item( title->list_subtitle, job->subtitle ) ) ) + /* + * If doing a subtitle scan then add all the matching subtitles for this + * language. + */ + if ( job->indepth_scan ) { - subtitle_copy = malloc( sizeof( hb_subtitle_t ) ); - memcpy( subtitle_copy, subtitle, sizeof( hb_subtitle_t ) ); - hb_list_add( title_copy->list_subtitle, subtitle_copy ); + for( i=0; i < hb_list_count( title->list_subtitle ); i++ ) + { + subtitle = hb_list_item( title->list_subtitle, i ); + if( strcmp( subtitle->iso639_2, audio_lang ) == 0 ) + { + /* + * Matched subtitle language with audio language, so + * add this to our list to scan. + * + * We will update the subtitle list on the second pass + * later after the first pass has completed. + */ + subtitle_copy = malloc( sizeof( hb_subtitle_t ) ); + memcpy( subtitle_copy, subtitle, sizeof( hb_subtitle_t ) ); + hb_list_add( title_copy->list_subtitle, subtitle_copy ); + if ( job->native_language ) { + /* + * With native language just select the + * first match in our langiage, not all of + * them. Subsequent ones are likely to be commentary + */ + break; + } + } + } + } else { + /* + * Not doing a subtitle scan in this pass, but maybe we are in the + * first pass? + */ + if( job->select_subtitle ) + { + /* + * Don't add subtitles here, we'll add them via select_subtitle + * at the end of the subtitle_scan. + */ + } else { + /* + * Definitely not doing a subtitle scan. + */ + if( job->pass != 1 && job->native_language ) + { + /* + * We are not doing a subtitle scan but do want the + * native langauge subtitle selected, so select it + * for pass 0 or pass 2 of a two pass. + */ + for( i=0; i < hb_list_count( title->list_subtitle ); i++ ) + { + subtitle = hb_list_item( title->list_subtitle, i ); + if( strcmp( subtitle->iso639_2, audio_lang ) == 0 ) + { + /* + * Matched subtitle language with audio language, so + * add this to our list to scan. + */ + subtitle_copy = malloc( sizeof( hb_subtitle_t ) ); + memcpy( subtitle_copy, subtitle, sizeof( hb_subtitle_t ) ); + hb_list_add( title_copy->list_subtitle, subtitle_copy ); + break; + } + } + } else { + /* + * Manually selected subtitle, in which case only + * bother adding them for pass 0 or pass 2 of a two + * pass. + */ + if( job->pass != 1 ) + { + if( ( subtitle = hb_list_item( title->list_subtitle, job->subtitle ) ) ) + { + subtitle_copy = malloc( sizeof( hb_subtitle_t ) ); + memcpy( subtitle_copy, subtitle, sizeof( hb_subtitle_t ) ); + hb_list_add( title_copy->list_subtitle, subtitle_copy ); + } + } + } + } } /* Copy the job */ job_copy = calloc( sizeof( hb_job_t ), 1 ); memcpy( job_copy, job, sizeof( hb_job_t ) ); + title_copy->job = job_copy; job_copy->title = title_copy; + job_copy->list_audio = title_copy->list_audio; job_copy->file = strdup( job->file ); job_copy->h = h; job_copy->pause = h->pause_lock; + /* Copy the job filter list */ + if( job->filters ) + { + int i; + int filter_count = hb_list_count( job->filters ); + job_copy->filters = hb_list_init(); + for( i = 0; i < filter_count; i++ ) + { + /* + * Copy the filters, since the MacGui reuses the global filter objects + * meaning that queued up jobs overwrite the previous filter settings. + * In reality, settings is probably the only field that needs duplicating + * since it's the only value that is ever changed. But name is duplicated + * as well for completeness. Not copying private_data since it gets + * created for each job in renderInit. + */ + hb_filter_object_t * filter = hb_list_item( job->filters, i ); + hb_filter_object_t * filter_copy = malloc( sizeof( hb_filter_object_t ) ); + memcpy( filter_copy, filter, sizeof( hb_filter_object_t ) ); + if( filter->name ) + filter_copy->name = strdup( filter->name ); + if( filter->settings ) + filter_copy->settings = strdup( filter->settings ); + hb_list_add( job_copy->filters, filter_copy ); + } + } + /* Add the job to the list */ hb_list_add( h->jobs, job_copy ); + h->job_count = hb_count(h); + h->job_count_permanent++; } /** @@ -489,6 +1079,10 @@ void hb_rem( hb_handle_t * h, hb_job_t * job ) { hb_list_rem( h->jobs, job ); + h->job_count = hb_count(h); + if (h->job_count_permanent) + h->job_count_permanent--; + /* XXX free everything XXX */ } @@ -502,6 +1096,7 @@ void hb_start( hb_handle_t * h ) { /* XXX Hack */ h->job_count = hb_list_count( h->jobs ); + h->job_count_permanent = h->job_count; hb_lock( h->state_lock ); h->state.state = HB_STATE_WORKING; @@ -514,6 +1109,7 @@ void hb_start( hb_handle_t * h ) p.hours = -1; p.minutes = -1; p.seconds = -1; + p.sequence_id = 0; #undef p hb_unlock( h->state_lock ); @@ -521,7 +1117,7 @@ void hb_start( hb_handle_t * h ) h->work_die = 0; h->work_thread = hb_work_init( h->jobs, h->cpu_count, - &h->work_die, &h->work_error ); + &h->work_die, &h->work_error, &h->current_job ); } /** @@ -562,6 +1158,9 @@ void hb_stop( hb_handle_t * h ) { h->work_die = 1; + h->job_count = hb_count(h); + h->job_count_permanent = 0; + hb_resume( h ); } @@ -575,12 +1174,31 @@ void hb_get_state( hb_handle_t * h, hb_state_t * s ) hb_lock( h->state_lock ); memcpy( s, &h->state, sizeof( hb_state_t ) ); - h->state.state = HB_STATE_IDLE; + if ( h->state.state == HB_STATE_SCANDONE || h->state.state == HB_STATE_WORKDONE ) + h->state.state = HB_STATE_IDLE; + + hb_unlock( h->state_lock ); +} + +void hb_get_state2( hb_handle_t * h, hb_state_t * s ) +{ + hb_lock( h->state_lock ); + + memcpy( s, &h->state, sizeof( hb_state_t ) ); hb_unlock( h->state_lock ); } /** + * Called in MacGui in UpdateUI to check + * for a new scan being completed to set a new source + */ +int hb_get_scancount( hb_handle_t * h) + { + return h->scanCount; + } + +/** * Closes access to libhb by freeing the hb_handle_t handle ontained in hb_init_real. * @param _h Pointer to handle to hb_handle_t. */ @@ -595,6 +1213,11 @@ void hb_close( hb_handle_t ** _h ) while( ( title = hb_list_item( h->list_title, 0 ) ) ) { hb_list_rem( h->list_title, title ); + if( title->job && title->job->filters ) + { + hb_list_close( &title->job->filters ); + } + free( title->job ); hb_title_close( &title ); } hb_list_close( &h->list_title ); @@ -604,6 +1227,7 @@ void hb_close( hb_handle_t ** _h ) hb_lock_close( &h->pause_lock ); free( h ); *_h = NULL; + } /** @@ -646,8 +1270,11 @@ static void thread_func( void * _h ) hb_log( "libhb: scan thread found %d valid title(s)", hb_list_count( h->list_title ) ); hb_lock( h->state_lock ); - h->state.state = HB_STATE_SCANDONE; - hb_unlock( h->state_lock ); + h->state.state = HB_STATE_SCANDONE; //originally state.state + hb_unlock( h->state_lock ); + /*we increment this sessions scan count by one for the MacGui + to trigger a new source being set */ + h->scanCount++; } /* Check if the work thread is done */ @@ -661,6 +1288,10 @@ static void thread_func( void * _h ) hb_lock( h->state_lock ); h->state.state = HB_STATE_WORKDONE; h->state.param.workdone.error = h->work_error; + + h->job_count = hb_count(h); + if (h->job_count < 1) + h->job_count_permanent = 0; hb_unlock( h->state_lock ); } @@ -675,19 +1306,22 @@ static void thread_func( void * _h ) /* Remove temp folder */ dir = opendir( dirname ); - while( ( entry = readdir( dir ) ) ) + if (dir) { - char filename[1024]; - if( entry->d_name[0] == '.' ) + while( ( entry = readdir( dir ) ) ) { - continue; + char filename[1024]; + if( entry->d_name[0] == '.' ) + { + continue; + } + memset( filename, 0, 1024 ); + snprintf( filename, 1023, "%s/%s", dirname, entry->d_name ); + unlink( filename ); } - memset( filename, 0, 1024 ); - snprintf( filename, 1023, "%s/%s", dirname, entry->d_name ); - unlink( filename ); + closedir( dir ); + rmdir( dirname ); } - closedir( dir ); - rmdir( dirname ); } /** @@ -712,9 +1346,18 @@ void hb_set_state( hb_handle_t * h, hb_state_t * s ) if( h->state.state == HB_STATE_WORKING ) { /* XXX Hack */ + if (h->job_count < 1) + h->job_count_permanent = 1; + h->state.param.working.job_cur = - h->job_count - hb_list_count( h->jobs ); - h->state.param.working.job_count = h->job_count; + h->job_count_permanent - hb_list_count( h->jobs ); + h->state.param.working.job_count = h->job_count_permanent; + + // Set which job is being worked on + if (h->current_job) + h->state.param.working.sequence_id = h->current_job->sequence_id; + else + h->state.param.working.sequence_id = 0; } hb_unlock( h->state_lock ); hb_unlock( h->pause_lock );