X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fhb.c;h=08bea4bf2f69fe098f984d6dd9c640f68648bef7;hb=f9341345b37e0738a140423297c222a7e40eddab;hp=06b489306168f61c46331f4b1eb3474596b70916;hpb=4b7a67719d6766455c86e47e0396582692a0d74f;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/hb.c b/libhb/hb.c index 06b48930..08bea4bf 100644 --- a/libhb/hb.c +++ b/libhb/hb.c @@ -1,8 +1,5 @@ #include "hb.h" - -#include "libavcodec/avcodec.h" -#include "libavformat/avformat.h" -#include "libswscale/swscale.h" +#include "hbffmpeg.h" struct hb_handle_s { @@ -44,10 +41,35 @@ struct hb_handle_s }; +hb_lock_t *hb_avcodec_lock; hb_work_object_t * hb_objects = NULL; static void thread_func( void * ); +void hb_avcodec_init() +{ + hb_avcodec_lock = hb_lock_init(); + av_register_all(); +} + +int hb_avcodec_open(AVCodecContext *avctx, AVCodec *codec) +{ + int ret; + hb_lock( hb_avcodec_lock ); + ret = avcodec_open(avctx, codec); + hb_unlock( hb_avcodec_lock ); + return ret; +} + +int hb_avcodec_close(AVCodecContext *avctx) +{ + int ret; + hb_lock( hb_avcodec_lock ); + ret = avcodec_close(avctx); + hb_unlock( hb_avcodec_lock ); + return ret; +} + /** * Registers work objects, by adding the work object to a liked list. * @param w Handle to hb_work_object_t to register. @@ -121,7 +143,7 @@ hb_handle_t * hb_init_real( int verbose, int update_check ) h->pause_lock = hb_lock_init(); /* libavcodec */ - av_register_all(); + hb_avcodec_init(); /* Start library thread */ hb_log( "hb_init: starting libhb thread" ); @@ -277,8 +299,11 @@ void hb_set_cpu_count( hb_handle_t * h, int cpu_count ) * @param h Handle to hb_handle_t * @param path location of VIDEO_TS folder. * @param title_index Desired title to scan. 0 for all titles. + * @param preview_count Number of preview images to generate. + * @param store_previews Whether or not to write previews to disk. */ -void hb_scan( hb_handle_t * h, const char * path, int title_index ) +void hb_scan( hb_handle_t * h, const char * path, int title_index, + int preview_count, int store_previews ) { hb_title_t * title; @@ -290,7 +315,8 @@ void hb_scan( hb_handle_t * h, const char * path, int title_index ) } 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 ); + h->scan_thread = hb_scan_init( h, path, title_index, h->list_title, + preview_count, store_previews ); } /** @@ -321,16 +347,18 @@ void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture, AVPicture pic_in, pic_preview, pic_deint, pic_crop, pic_scale; struct SwsContext * context; int i; + int rgb_width = ((job->width + 7) >> 3) << 3; + int preview_size; 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 ); + buf1 = av_malloc( avpicture_get_size( PIX_FMT_YUV420P, title->width, title->height ) ); + buf2 = av_malloc( avpicture_get_size( PIX_FMT_YUV420P, title->width, title->height ) ); + buf3 = av_malloc( avpicture_get_size( PIX_FMT_YUV420P, job->width, job->height ) ); + buf4 = av_malloc( avpicture_get_size( PIX_FMT_RGBA32, rgb_width, job->height ) ); avpicture_fill( &pic_in, buf1, PIX_FMT_YUV420P, title->width, title->height ); avpicture_fill( &pic_deint, buf2, PIX_FMT_YUV420P, @@ -338,7 +366,7 @@ void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture, avpicture_fill( &pic_scale, buf3, PIX_FMT_YUV420P, job->width, job->height ); avpicture_fill( &pic_preview, buf4, PIX_FMT_RGBA32, - job->width, job->height ); + rgb_width, job->height ); // Allocate the AVPicture frames and fill in @@ -354,7 +382,7 @@ void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture, return; } - fread( buf1, title->width * title->height * 3 / 2, 1, file ); + fread( buf1, avpicture_get_size( PIX_FMT_YUV420P, title->width, title->height), 1, file ); fclose( file ); if( job->deinterlace ) @@ -386,8 +414,8 @@ void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture, sws_freeContext( context ); // Get preview context - context = sws_getContext(job->width, job->height, PIX_FMT_YUV420P, - job->width, job->height, PIX_FMT_RGBA32, + context = sws_getContext(rgb_width, job->height, PIX_FMT_YUV420P, + rgb_width, job->height, PIX_FMT_RGBA32, swsflags, NULL, NULL, NULL); // Create preview @@ -407,6 +435,7 @@ void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture, } /* Draw the picture, centered, and draw the cropping zone */ + preview_size = pic_preview.linesize[0]; pen = buffer + ( title->height - job->height ) * ( title->width + 2 ) * 2 + ( title->width - job->width ) * 2; memset( pen, 0xFF, 4 * ( job->width + 2 ) ); @@ -417,7 +446,7 @@ void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture, nextLine = pen + 4 * ( title->width + 2 ); memset( pen, 0xFF, 4 ); pen += 4; - memcpy( pen, buf4 + 4 * job->width * i, 4 * job->width ); + memcpy( pen, buf4 + preview_size * i, 4 * job->width ); pen += 4 * job->width; memset( pen, 0xFF, 4 ); pen = nextLine; @@ -554,110 +583,20 @@ 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; + int mod = job->anamorphic.modulus ? job->anamorphic.modulus : 16; 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) + int pixel_aspect_width = job->anamorphic.par_width; + int pixel_aspect_height = job->anamorphic.par_height; + + /* If a source was really NTSC or PAL and the user specified ITU PAR + values, replace the standard PAR values with the ITU broadcast ones. */ + if( title->width == 720 && job->anamorphic.itu_par ) { // convert aspect to a scaled integer so we can test for 16:9 & 4:3 // aspect ratios ignoring insignificant differences in the LSBs of @@ -699,20 +638,122 @@ void hb_set_anamorphic_size( hb_job_t * job, } } - /* Figure out what dimensions the source would display at. */ + /* Figure out what width 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; - + + /* + 3 different ways of deciding output dimensions: + - 1: Strict anamorphic, preserve source dimensions + - 2: Loose anamorphic, round to mod16 and preserve storage aspect ratio + - 3: Power user anamorphic, specify everything + */ + int width, height; + switch( job->anamorphic.mode ) + { + case 1: + /* Strict anamorphic */ + *output_width = cropped_width; + *output_height = cropped_height; + *output_par_width = title->pixel_aspect_width; + *output_par_height = title->pixel_aspect_height; + break; + + case 2: + /* "Loose" anamorphic. + - Uses mod16-compliant dimensions, + - Allows users to set the width + */ + width = job->width; + height; // Gets set later, ignore user job->height value + + /* Gotta handle bounding dimensions. + 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) + 0.5; + + if ( job->maxHeight && (job->maxHeight < height) ) + height = job->maxHeight; + + /* Time to get picture dimensions that divide cleanly.*/ + width = MULTIPLE_MOD( width, mod); + height = MULTIPLE_MOD( height, mod); + + /* Verify these new dimensions don't violate max height and width settings */ + if ( job->maxWidth && (job->maxWidth < job->width) ) + width = job->maxWidth; + if ( job->maxHeight && (job->maxHeight < height) ) + height = job->maxHeight; + + /* 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; + break; + + case 3: + /* Anamorphic 3: Power User Jamboree + - Set everything based on specified values */ + + /* Use specified storage dimensions */ + width = job->width; + height = job->height; + + /* Bind to max dimensions */ + if( job->maxWidth && width > job->maxWidth ) + width = job->maxWidth; + if( job->maxHeight && height > job->maxHeight ) + height = job->maxHeight; + + /* Time to get picture dimensions that divide cleanly.*/ + width = MULTIPLE_MOD( width, mod); + height = MULTIPLE_MOD( height, mod); + + /* Verify we're still within max dimensions */ + if( job->maxWidth && width > job->maxWidth ) + width = job->maxWidth - (mod/2); + if( job->maxHeight && height > job->maxHeight ) + height = job->maxHeight - (mod/2); + + /* Re-ensure we have picture dimensions that divide cleanly. */ + width = MULTIPLE_MOD( width, mod ); + height = MULTIPLE_MOD( height, mod ); + + /* That finishes the storage dimensions. On to display. */ + if( job->anamorphic.dar_width && job->anamorphic.dar_height ) + { + /* We need to adjust the PAR to produce this aspect. */ + pixel_aspect_width = height * job->anamorphic.dar_width / job->anamorphic.dar_height; + pixel_aspect_height = width; + } + else + { + /* We first need the display ar. + That's the source display width divided by the source height after cropping. + Then we multiple the output height by that to get the pixel aspect width, + and the pixel aspect height is the storage width.*/ + pixel_aspect_width = height * source_display_width / cropped_height; + pixel_aspect_height = width; + } + + /* Back to caller */ + *output_width = width; + *output_height = height; + break; + } + /* 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, @@ -863,6 +904,34 @@ void hb_add( hb_handle_t * h, hb_job_t * job ) hb_list_add( title_copy->list_chapter, chapter_copy ); } + /* + * Copy the metadata + */ + if( title->metadata ) + { + title_copy->metadata = malloc( sizeof( hb_metadata_t ) ); + + if( title_copy->metadata ) + { + memcpy( title_copy->metadata, title->metadata, sizeof( hb_metadata_t ) ); + + /* + * Need to copy the artwork seperatly (TODO). + */ + if( title->metadata->coverart ) + { + title_copy->metadata->coverart = malloc( title->metadata->coverart_size ); + if( title_copy->metadata->coverart ) + { + memcpy( title_copy->metadata->coverart, title->metadata->coverart, + title->metadata->coverart_size ); + } else { + title_copy->metadata->coverart_size = 0; + } + } + } + } + /* Copy the audio track(s) we want */ title_copy->list_audio = hb_list_init();