#include "hb.h"
#include "hbffmpeg.h"
+#include <stdio.h>
+#include <unistd.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 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 hb_layout;
}
- hb_log( "Channels reported by ffmpeg (%d) != computed layout channels (%d).\n", channels, chans );
+ hb_log( "Channels reported by ffmpeg (%d) != computed layout channels (%d).", channels, chans );
switch (channels)
{
case 1:
}
/**
- * libhb initialization routine.
- * @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.
+ * Ensures that the process has been initialized.
*/
-hb_handle_t * hb_init( int verbose, int update_check )
+static void process_init()
{
if (!hb_process_initialized)
{
#if defined( SYS_MINGW ) && defined( PTW32_STATIC_LIB )
pthread_win32_process_attach_np();
#endif
- hb_process_initialized =1;
+
+#if defined( _WIN32 ) || defined( __MINGW32__ )
+ setvbuf( stdout, NULL, _IONBF, 0 );
+ setvbuf( stderr, NULL, _IONBF, 0 );
+#endif
+ hb_process_initialized = 1;
}
+}
+
+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.
+ * @param log_cb The function to register as a logger.
+ */
+void hb_register_logger( void (*log_cb)(const char* message) )
+{
+ process_init();
+
+ hb_log_callback = log_cb;
+ hb_thread_init("ioredirect", redirect_thread_func, NULL, HB_NORMAL_PRIORITY);
+}
+
+/**
+ * libhb initialization routine.
+ * @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( int verbose, int update_check )
+{
+ process_init();
+
hb_handle_t * h = calloc( sizeof( hb_handle_t ), 1 );
uint64_t date;
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 );
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 );
* @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 );
}
/**
/**
* Create preview image of desired title a index of picture.
* @param h Handle to hb_handle_t.
+ * @param title_index Index of the title to get the preview for (1-based).
+ * @param picture Index in title.
+ * @param buffer Handle to buffer were image will be drawn.
+ */
+void hb_get_preview_by_index( hb_handle_t * h, int title_index, int picture, uint8_t * buffer )
+{
+ hb_title_t * title;
+
+ title = hb_get_title_by_index( h, title_index );
+ if ( title != NULL )
+ {
+ hb_get_preview( h, title, picture, buffer );
+ }
+}
+
+/**
+ * Create preview image of desired title a index of picture.
+ * @param h Handle to hb_handle_t.
* @param title Handle to hb_title_t of desired title.
* @param picture Index in title.
- * @param buffer Handle to buufer were inage will be drawn.
+ * @param buffer Handle to buffer were image will be drawn.
*/
void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture,
uint8_t * buffer )
/**
* Calculates job width and height for anamorphic content,
*
+ * @param h Instance handle
+ * @param title_index Index of the title/job to inspect (1-based).
+ * @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_by_index( hb_handle_t * h, int title_index,
+ int *output_width, int *output_height,
+ int *output_par_width, int *output_par_height )
+{
+ hb_title_t * title;
+ 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 );
+}
+
+/**
+ * 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
+ * @param output_par_height Pointer to returned pixel height
*/
void hb_set_anamorphic_size( hb_job_t * job,
int *output_width, int *output_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:
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.
- 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 )
}
/**
+ * Applies information from the given job to the official job instance.
+ * @param h Handle to hb_handle_t.
+ * @param title_index Index of the title to apply the chapter name to (1-based).
+ * @param chapter The chapter to apply the name to (1-based).
+ * @param job Job information to apply.
+ */
+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_get_title_by_index( h, title_index );
+
+ hb_chapter_t * chapter = hb_list_item( title->list_chapter, chapter_index - 1 );
+
+ strncpy(chapter->title, chapter_name, 1023);
+ chapter->title[1023] = '\0';
+}
+
+/**
+ * Applies information from the given job to the official job instance.
+ * Currently only applies information needed for anamorphic size calculation and previews.
+ * @param h Handle to hb_handle_t.
+ * @param title_index Index of the title to apply the job information to (1-based).
+ * @param job Job information to apply.
+ */
+void hb_set_job( hb_handle_t * h, int title_index, hb_job_t * job )
+{
+ int i;
+
+ hb_title_t * title;
+ title = hb_get_title_by_index( h, title_index );
+
+ hb_job_t * job_target = title->job;
+
+ job_target->deinterlace = job->deinterlace;
+ job_target->width = job->width;
+ job_target->height = job->height;
+ job_target->maxWidth = job->maxWidth;
+ job_target->maxHeight = job->maxHeight;
+ for (i = 0; i < 4; i++)
+ {
+ job_target->crop[i] = job->crop[i];
+ }
+
+ job_target->anamorphic = job->anamorphic;
+}
+
+/**
* Adds a job to the job list.
* @param h Handle to hb_handle_t.
* @param job Handle to hb_job_t.
}
/**
+ * Gets a filter object with the given type and settings.
+ * @param filter_id The type of filter to get.
+ * @param settings The filter settings to use.
+ * @returns The requested filter object.
+ */
+hb_filter_object_t * hb_get_filter_object(int filter_id, const char * settings)
+{
+ if (filter_id == HB_FILTER_ROTATE)
+ {
+ hb_filter_rotate.settings = (char*)settings;
+ return &hb_filter_rotate;
+ }
+
+ if (filter_id == HB_FILTER_DETELECINE)
+ {
+ hb_filter_detelecine.settings = (char*)settings;
+ return &hb_filter_detelecine;
+ }
+
+ if (filter_id == HB_FILTER_DECOMB)
+ {
+ hb_filter_decomb.settings = (char*)settings;
+ return &hb_filter_decomb;
+ }
+
+ if (filter_id == HB_FILTER_DEINTERLACE)
+ {
+ hb_filter_deinterlace.settings = (char*)settings;
+ return &hb_filter_deinterlace;
+ }
+
+ if (filter_id == HB_FILTER_DEBLOCK)
+ {
+ hb_filter_deblock.settings = (char*)settings;
+ return &hb_filter_deblock;
+ }
+
+ if (filter_id == HB_FILTER_DENOISE)
+ {
+ hb_filter_denoise.settings = (char*)settings;
+ return &hb_filter_denoise;
+ }
+ return NULL;
+}
+
+/**
* Returns the state of the conversion process.
* @param h Handle to hb_handle_t.
* @param s Handle to hb_state_t which to copy the state data.
}
/**
+ * Redirects stderr to the registered callback
+ * function.
+ * @param _data Unused.
+ */
+static void redirect_thread_func(void * _data)
+{
+ 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];
+ while(fgets(line_buffer, 500, log_f) != NULL)
+ {
+ hb_log_callback(line_buffer);
+ }
+}
+
+/**
* Returns the PID.
* @param h Handle to hb_handle_t
*/
/**
* Returns the id for the given instance.
* @param h Handle to hb_handle_t
+ * @returns The ID for the given instance
*/
int hb_get_instance_id( hb_handle_t * h )
{
}
/**
+ * 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