#include "hbffmpeg.h"
#include <stdio.h>
#include <unistd.h>
-#include <io.h>
#include <fcntl.h>
-#if defined( SYS_MINGW ) && defined( PTW32_STATIC_LIB )
+#if defined( SYS_MINGW )
+#include <io.h>
+#if defined( PTW32_STATIC_LIB )
#include <pthread.h>
#endif
+#endif
struct hb_handle_s
{
int work_error;
hb_thread_t * work_thread;
- int cpu_count;
-
hb_lock_t * state_lock;
hb_state_t state;
int hb_process_initialized = 0;
static void thread_func( void * );
+hb_title_t * hb_get_title_by_index( hb_handle_t *, int );
void hb_avcodec_init()
{
return ret;
}
+int hb_av_find_stream_info(AVFormatContext *ic)
+{
+ int ret;
+ hb_lock( hb_avcodec_lock );
+ ret = av_find_stream_info( ic );
+ hb_unlock( hb_avcodec_lock );
+ return ret;
+}
+
+struct SwsContext*
+hb_sws_get_context(int srcW, int srcH, enum PixelFormat srcFormat,
+ int dstW, int dstH, enum PixelFormat dstFormat,
+ int flags)
+{
+ struct SwsContext * ctx;
+
+#if 0
+ // sws_getContext is being depricated. But it appears that
+ // the new method isn't quite wrung out yet. So when it is
+ // this code should be fixed up and enabled.
+ ctx = sws_alloc_context();
+ if ( ctx )
+ {
+ av_set_int(ctx, "srcw", srcW);
+ av_set_int(ctx, "srch", srcH);
+ av_set_int(ctx, "src_format", srcFormat);
+ av_set_int(ctx, "dstw", dstW);
+ av_set_int(ctx, "dsth", dstH);
+ av_set_int(ctx, "dst_format", dstFormat);
+ av_set_int(ctx, "sws_flags", flags);
+
+ if (sws_init_context(ctx, NULL, NULL) < 0) {
+ fprintf(stderr, "Cannot initialize resampling context\n");
+ sws_freeContext(ctx);
+ ctx = NULL;
+ }
+ }
+#else
+ ctx = sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat,
+ flags, NULL, NULL, NULL);
+#endif
+ return ctx;
+}
+
int hb_avcodec_close(AVCodecContext *avctx)
{
int ret;
int hb_ff_layout_xlat(int64_t ff_channel_layout, int channels)
{
+ int hb_layout;
+
switch (ff_channel_layout)
{
case CH_LAYOUT_MONO:
- return HB_INPUT_CH_LAYOUT_MONO;
+ hb_layout = HB_INPUT_CH_LAYOUT_MONO;
+ break;
case CH_LAYOUT_STEREO:
- return HB_INPUT_CH_LAYOUT_STEREO;
+ hb_layout = HB_INPUT_CH_LAYOUT_STEREO;
+ break;
case CH_LAYOUT_SURROUND:
- return HB_INPUT_CH_LAYOUT_3F;
+ hb_layout = HB_INPUT_CH_LAYOUT_3F;
+ break;
case CH_LAYOUT_4POINT0:
- return HB_INPUT_CH_LAYOUT_3F1R;
+ hb_layout = HB_INPUT_CH_LAYOUT_3F1R;
+ break;
case CH_LAYOUT_2_2:
- return HB_INPUT_CH_LAYOUT_2F2R;
+ hb_layout = HB_INPUT_CH_LAYOUT_2F2R;
+ break;
case CH_LAYOUT_QUAD:
- return HB_INPUT_CH_LAYOUT_2F2R;
+ hb_layout = HB_INPUT_CH_LAYOUT_2F2R;
+ break;
case CH_LAYOUT_5POINT0:
- // ffmpeg like to neglect to signal LFE
- if (channels == 6)
- return HB_INPUT_CH_LAYOUT_3F2R|HB_INPUT_CH_LAYOUT_HAS_LFE;
- return HB_INPUT_CH_LAYOUT_3F2R;
+ hb_layout = HB_INPUT_CH_LAYOUT_3F2R;
+ break;
case CH_LAYOUT_5POINT1:
- return HB_INPUT_CH_LAYOUT_3F2R|HB_INPUT_CH_LAYOUT_HAS_LFE;
+ hb_layout = HB_INPUT_CH_LAYOUT_3F2R|HB_INPUT_CH_LAYOUT_HAS_LFE;
+ break;
case CH_LAYOUT_5POINT0_BACK:
- // ffmpeg like to neglect to signal LFE
- if (channels == 6)
- return HB_INPUT_CH_LAYOUT_3F2R|HB_INPUT_CH_LAYOUT_HAS_LFE;
- return HB_INPUT_CH_LAYOUT_3F2R;
+ hb_layout = HB_INPUT_CH_LAYOUT_3F2R;
+ break;
case CH_LAYOUT_5POINT1_BACK:
- return HB_INPUT_CH_LAYOUT_3F2R|HB_INPUT_CH_LAYOUT_HAS_LFE;
+ hb_layout = HB_INPUT_CH_LAYOUT_3F2R|HB_INPUT_CH_LAYOUT_HAS_LFE;
+ break;
case CH_LAYOUT_7POINT0:
- // ffmpeg like to neglect to signal LFE
- if (channels == 8)
- return HB_INPUT_CH_LAYOUT_3F4R|HB_INPUT_CH_LAYOUT_HAS_LFE;
- return HB_INPUT_CH_LAYOUT_3F4R;
+ hb_layout = HB_INPUT_CH_LAYOUT_3F4R;
+ break;
case CH_LAYOUT_7POINT1:
- return HB_INPUT_CH_LAYOUT_3F4R|HB_INPUT_CH_LAYOUT_HAS_LFE;
+ hb_layout = HB_INPUT_CH_LAYOUT_3F4R|HB_INPUT_CH_LAYOUT_HAS_LFE;
+ break;
case CH_LAYOUT_STEREO_DOWNMIX:
- return HB_INPUT_CH_LAYOUT_STEREO;
+ hb_layout = HB_INPUT_CH_LAYOUT_STEREO;
+ break;
+ default:
+ hb_layout = HB_INPUT_CH_LAYOUT_STEREO;
+ break;
+ }
+ // Now make sure the chosen layout agrees with the number of channels
+ // ffmpeg tells us there are. It seems ffmpeg is sometimes confused
+ // about this. So we will make a best guess based on the number
+ // of channels.
+ int chans = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT( hb_layout );
+ if ( chans == channels )
+ {
+ return hb_layout;
+ }
+ hb_log( "Channels reported by ffmpeg (%d) != computed layout channels (%d).", channels, chans );
+ switch (channels)
+ {
+ case 1:
+ hb_layout = HB_INPUT_CH_LAYOUT_MONO;
+ break;
+ case 2:
+ hb_layout = HB_INPUT_CH_LAYOUT_STEREO;
+ break;
+ case 3:
+ hb_layout = HB_INPUT_CH_LAYOUT_3F;
+ break;
+ case 4:
+ hb_layout = HB_INPUT_CH_LAYOUT_3F1R;
+ break;
+ case 5:
+ hb_layout = HB_INPUT_CH_LAYOUT_3F2R;
+ break;
+ case 6:
+ hb_layout = HB_INPUT_CH_LAYOUT_3F2R|HB_INPUT_CH_LAYOUT_HAS_LFE;
+ break;
+ case 7:
+ hb_layout = HB_INPUT_CH_LAYOUT_3F4R;
+ break;
+ case 8:
+ hb_layout = HB_INPUT_CH_LAYOUT_3F4R|HB_INPUT_CH_LAYOUT_HAS_LFE;
+ break;
default:
- return HB_INPUT_CH_LAYOUT_STEREO;
+ hb_log("Unsupported number of audio channels (%d).\n", channels);
+ hb_layout = 0;
+ break;
}
- return HB_INPUT_CH_LAYOUT_STEREO;
+ return hb_layout;
}
/**
void (*hb_log_callback)(const char* message);
static void redirect_thread_func(void *);
+
+#if defined( SYS_MINGW )
#define pipe(phandles) _pipe (phandles, 4096, _O_BINARY)
+#endif
/**
* Registers the given function as a logger. All logs will be passed to it.
*/
hb_buffer_pool_init();
- /* 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();
hb_register( &hb_encvobsub );
hb_register( &hb_deccc608 );
hb_register( &hb_decsrtsub );
+ hb_register( &hb_decutf8sub );
+ hb_register( &hb_dectx3gsub );
+ hb_register( &hb_decssasub );
hb_register( &hb_render );
hb_register( &hb_encavcodec );
hb_register( &hb_encx264 );
#ifdef __APPLE__
hb_register( &hb_encca_aac );
#endif
+ hb_register( &hb_encac3 );
return h;
}
}
}
- /* 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;
hb_register( &hb_encvobsub );
hb_register( &hb_deccc608 );
hb_register( &hb_decsrtsub );
+ hb_register( &hb_decutf8sub );
+ hb_register( &hb_dectx3gsub );
+ hb_register( &hb_decssasub );
hb_register( &hb_render );
hb_register( &hb_encavcodec );
hb_register( &hb_encx264 );
#ifdef __APPLE__
hb_register( &hb_encca_aac );
#endif
+ hb_register( &hb_encac3 );
return h;
}
}
/**
- * Sets the cpu count to the desired value.
- * @param h Handle to hb_handle_t
- * @param cpu_count Number of CPUs to use.
- */
-void hb_set_cpu_count( hb_handle_t * h, int cpu_count )
-{
- cpu_count = MAX( 1, cpu_count );
- cpu_count = MIN( cpu_count, 8 );
- h->cpu_count = cpu_count;
-}
-
-/**
* Deletes current previews associated with titles
* @param h Handle to hb_handle_t
*/
* @param store_previews Whether or not to write previews to disk.
*/
void hb_scan( hb_handle_t * h, const char * path, int title_index,
- int preview_count, int store_previews )
+ int preview_count, int store_previews, uint64_t min_duration )
{
hb_title_t * title;
hb_log( "hb_scan: path=%s, title_index=%d", path, title_index );
h->scan_thread = hb_scan_init( h, &h->scan_die, path, title_index,
h->list_title, preview_count,
- store_previews );
+ store_previews, min_duration );
}
/**
{
hb_title_t * title;
- title = hb_list_item( h->list_title, title_index - 1 );
+ title = hb_get_title_by_index( h, title_index );
if ( title != NULL )
{
hb_get_preview( h, title, picture, buffer );
AVPicture pic_in, pic_preview, pic_deint, pic_crop, pic_scale;
struct SwsContext * context;
int i;
+ int deint_width = ((title->width + 7) >> 3) << 3;
int rgb_width = ((job->width + 7) >> 3) << 3;
int preview_size;
swsflags = SWS_LANCZOS | SWS_ACCURATE_RND;
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 ) );
+ buf2 = av_malloc( avpicture_get_size( PIX_FMT_YUV420P, deint_width, title->height ) );
buf3 = av_malloc( avpicture_get_size( PIX_FMT_YUV420P, rgb_width, job->height ) );
buf4 = av_malloc( avpicture_get_size( PIX_FMT_RGB32, rgb_width, job->height ) );
avpicture_fill( &pic_in, buf1, PIX_FMT_YUV420P,
title->width, title->height );
avpicture_fill( &pic_deint, buf2, PIX_FMT_YUV420P,
- title->width, title->height );
+ deint_width, title->height );
avpicture_fill( &pic_scale, buf3, PIX_FMT_YUV420P,
rgb_width, job->height );
avpicture_fill( &pic_preview, buf4, PIX_FMT_RGB32,
}
// Get scaling context
- context = sws_getContext(title->width - (job->crop[2] + job->crop[3]),
+ context = hb_sws_get_context(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);
+ swsflags);
// Scale
sws_scale(context,
sws_freeContext( context );
// Get preview context
- context = sws_getContext(rgb_width, job->height, PIX_FMT_YUV420P,
+ context = hb_sws_get_context(rgb_width, job->height, PIX_FMT_YUV420P,
rgb_width, job->height, PIX_FMT_RGB32,
- swsflags, NULL, NULL, NULL);
+ swsflags);
// Create preview
sws_scale(context,
int *output_par_width, int *output_par_height )
{
hb_title_t * title;
- title = hb_list_item( h->list_title, title_index - 1 );
+ title = hb_get_title_by_index( h, title_index );
hb_set_anamorphic_size( title->job, output_width, output_height, output_par_width, output_par_height );
}
- 3: Power user anamorphic, specify everything
*/
int width, height;
+ int maxWidth, maxHeight;
+
+ maxWidth = MULTIPLE_MOD_DOWN( job->maxWidth, mod );
+ maxHeight = MULTIPLE_MOD_DOWN( job->maxHeight, mod );
+
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;
+ *output_width = MULTIPLE_MOD( cropped_width, 2 );
+ *output_height = MULTIPLE_MOD( cropped_height, 2 );
+ // adjust the source PAR for new width/height
+ // new PAR = source PAR * ( old width / new_width ) * ( new_height / old_height )
+ pixel_aspect_width = title->pixel_aspect_width * cropped_width * (*output_height);
+ pixel_aspect_height = title->pixel_aspect_height * (*output_width) * cropped_height;
break;
case 2:
If not, set job height to job width divided by storage aspect.
*/
- if ( job->maxWidth && (job->maxWidth < job->width) )
- width = job->maxWidth;
-
/* Time to get picture width that divide cleanly.*/
width = MULTIPLE_MOD( width, mod);
- /* Verify these new dimensions don't violate max height and width settings */
- if ( job->maxWidth && (job->maxWidth < job->width) )
- width = job->maxWidth;
+ if ( maxWidth && (maxWidth < job->width) )
+ width = maxWidth;
+ /* Verify these new dimensions don't violate max height and width settings */
height = ((double)width / storage_aspect) + 0.5;
-
- if ( job->maxHeight && (job->maxHeight < height) )
- height = job->maxHeight;
/* Time to get picture height that divide cleanly.*/
height = MULTIPLE_MOD( height, mod);
-
- /* Verify these new dimensions don't violate max height and width settings */
- if ( job->maxHeight && (job->maxHeight < height) )
- height = job->maxHeight;
+
+ if ( maxHeight && (maxHeight < height) )
+ {
+ height = maxHeight;
+ width = ((double)height * storage_aspect) + 0.5;
+ width = MULTIPLE_MOD( width, mod);
+ }
/* 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;
+ pixel_aspect_width = height * cropped_width * pixel_aspect_width;
+ pixel_aspect_height = width * cropped_height * pixel_aspect_height;
/* Pass the results back to the caller */
*output_width = width;
- Set everything based on specified values */
/* Use specified storage dimensions */
+ storage_aspect = (double)job->width / (double)job->height;
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 );
+ /* Bind to max dimensions */
+ if( maxWidth && width > maxWidth )
+ {
+ width = maxWidth;
+ // If we are keeping the display aspect, then we are going
+ // to be modifying the PAR anyway. So it's preferred
+ // to let the width/height stray some from the original
+ // requested storage aspect.
+ //
+ // But otherwise, PAR and DAR will change the least
+ // if we stay as close as possible to the requested
+ // storage aspect.
+ if ( !job->anamorphic.keep_display_aspect )
+ {
+ height = ((double)width / storage_aspect) + 0.5;
+ height = MULTIPLE_MOD( height, mod);
+ }
+ }
+ if( maxHeight && height > maxHeight )
+ {
+ height = maxHeight;
+ // Ditto, see comment above
+ if ( !job->anamorphic.keep_display_aspect )
+ {
+ width = ((double)height * storage_aspect) + 0.5;
+ width = MULTIPLE_MOD( width, mod);
+ }
+ }
/* That finishes the storage dimensions. On to display. */
if( job->anamorphic.dar_width && job->anamorphic.dar_height )
void hb_set_chapter_name( hb_handle_t * h, int title_index, int chapter_index, const char * chapter_name )
{
hb_title_t * title;
- title = hb_list_item( h->list_title, title_index - 1 );
+ title = hb_get_title_by_index( h, title_index );
hb_chapter_t * chapter = hb_list_item( title->list_chapter, chapter_index - 1 );
int i;
hb_title_t * title;
- title = hb_list_item( h->list_title, title_index - 1 );
+ title = hb_get_title_by_index( h, title_index );
hb_job_t * job_target = title->job;
hb_chapter_t * chapter, * chapter_copy;
hb_audio_t * audio;
hb_subtitle_t * subtitle, * subtitle_copy;
+ hb_attachment_t * attachment;
int i;
char audio_lang[4];
/* Copy the audio track(s) we want */
title_copy->list_audio = hb_list_init();
-
for( i = 0; i < hb_list_count(job->list_audio); i++ )
{
if( ( audio = hb_list_item( job->list_audio, i ) ) )
}
}
+ /* Initialize subtitle list - filled out further below */
title_copy->list_subtitle = hb_list_init();
+
+ /* Copy all the attachments */
+ title_copy->list_attachment = hb_list_init();
+ for( i = 0; i < hb_list_count(title->list_attachment); i++ )
+ {
+ if( ( attachment = hb_list_item( title->list_attachment, i ) ) )
+ {
+ hb_list_add( title_copy->list_attachment, hb_attachment_copy(attachment) );
+ }
+ }
/*
* The following code is confusing, there are two ways in which
h->paused = 0;
h->work_die = 0;
- h->work_thread = hb_work_init( h->jobs, h->cpu_count,
- &h->work_die, &h->work_error, &h->current_job );
+ h->work_thread = hb_work_init( h->jobs, &h->work_die, &h->work_error, &h->current_job );
}
/**
{
if (filter_id == HB_FILTER_ROTATE)
{
- hb_filter_rotate.settings = strdup(settings);
+ hb_filter_rotate.settings = (char*)settings;
return &hb_filter_rotate;
}
if (filter_id == HB_FILTER_DETELECINE)
{
- hb_filter_detelecine.settings = strdup(settings);
+ hb_filter_detelecine.settings = (char*)settings;
return &hb_filter_detelecine;
}
if (filter_id == HB_FILTER_DECOMB)
{
- hb_filter_decomb.settings = strdup(settings);
+ hb_filter_decomb.settings = (char*)settings;
return &hb_filter_decomb;
}
if (filter_id == HB_FILTER_DEINTERLACE)
{
- hb_filter_deinterlace.settings = strdup(settings);
+ hb_filter_deinterlace.settings = (char*)settings;
return &hb_filter_deinterlace;
}
if (filter_id == HB_FILTER_DEBLOCK)
{
- hb_filter_deblock.settings = strdup(settings);
+ hb_filter_deblock.settings = (char*)settings;
return &hb_filter_deblock;
}
if (filter_id == HB_FILTER_DENOISE)
{
- hb_filter_denoise.settings = strdup(settings);
+ hb_filter_denoise.settings = (char*)settings;
return &hb_filter_denoise;
}
+ return NULL;
}
/**
{
int pfd[2];
pipe(pfd);
+#if defined( SYS_MINGW )
+ // dup2 doesn't work on windows for some stupid reason
stderr->_file = pfd[1];
+#else
+ dup2(pfd[1], /*stderr*/ 2);
+#endif
FILE * log_f = fdopen(pfd[0], "rb");
char line_buffer[500];
}
/**
+ * Returns the title with the given title index.
+ * @param h Handle to hb_handle_t
+ * @param title_index the index of the title to get
+ * @returns The requested title
+ */
+hb_title_t * hb_get_title_by_index( hb_handle_t * h, int title_index )
+{
+ hb_title_t * title;
+ int i;
+ int count = hb_list_count( h->list_title );
+ for (i = 0; i < count; i++)
+ {
+ title = hb_list_item( h->list_title, i );
+ if (title->index == title_index)
+ {
+ return title;
+ }
+ }
+
+ return NULL;
+}
+
+/**
* Sets the current state.
* @param h Handle to hb_handle_t
* @param s Handle to new hb_state_t
OSDN Git Service
