libhb/hb.c

   1 #include "hb.h"
   2 #include "hbffmpeg.h"
   3 #include <stdio.h>
   4 #include <unistd.h>
   5 #include <fcntl.h>
   6
   7 #if defined( SYS_MINGW )
   8 #include <io.h>
   9 #if defined( PTW32_STATIC_LIB )
  10 #include <pthread.h>
  11 #endif
  12 #endif
  13
  14 struct hb_handle_s
  15 {
  16     int            id;
  17
  18     /* The "Check for update" thread */
  19     int            build;
  20     char           version[32];
  21     hb_thread_t  * update_thread;
  22
  23     /* This thread's only purpose is to check other threads'
  24        states */
  25     volatile int   die;
  26     hb_thread_t  * main_thread;
  27     int            pid;
  28
  29     /* DVD/file scan thread */
  30     hb_list_t    * list_title;
  31     hb_thread_t  * scan_thread;
  32
  33     /* The thread which processes the jobs. Others threads are launched
  34        from this one (see work.c) */
  35     hb_list_t    * jobs;
  36     hb_job_t     * current_job;
  37     int            job_count;
  38     int            job_count_permanent;
  39     volatile int   work_die;
  40     int            work_error;
  41     hb_thread_t  * work_thread;
  42
  43     int            cpu_count;
  44
  45     hb_lock_t    * state_lock;
  46     hb_state_t     state;
  47
  48     int            paused;
  49     hb_lock_t    * pause_lock;
  50     /* For MacGui active queue
  51        increments each time the scan thread completes*/
  52     int            scanCount;
  53     volatile int   scan_die;
  54
  55     /* Stash of persistent data between jobs, for stuff
  56        like correcting frame count and framerate estimates
  57        on multi-pass encodes where frames get dropped.     */
  58     hb_interjob_t * interjob;
  59
  60 };
  61
  62 hb_lock_t *hb_avcodec_lock;
  63 hb_work_object_t * hb_objects = NULL;
  64 int hb_instance_counter = 0;
  65 int hb_process_initialized = 0;
  66
  67 static void thread_func( void * );
  68 hb_title_t * hb_get_title_by_index( hb_handle_t *, int );
  69
  70 void hb_avcodec_init()
  71 {
  72     hb_avcodec_lock  = hb_lock_init();
  73     av_register_all();
  74 }
  75
  76 int hb_avcodec_open(AVCodecContext *avctx, AVCodec *codec)
  77 {
  78     int ret;
  79     hb_lock( hb_avcodec_lock );
  80     ret = avcodec_open(avctx, codec);
  81     hb_unlock( hb_avcodec_lock );
  82     return ret;
  83 }
  84
  85 int hb_av_find_stream_info(AVFormatContext *ic)
  86 {
  87     int ret;
  88     hb_lock( hb_avcodec_lock );
  89     ret = av_find_stream_info( ic );
  90     hb_unlock( hb_avcodec_lock );
  91     return ret;
  92 }
  93
  94 struct SwsContext*
  95 hb_sws_get_context(int srcW, int srcH, enum PixelFormat srcFormat,
  96                    int dstW, int dstH, enum PixelFormat dstFormat,
  97                    int flags)
  98 {
  99     struct SwsContext * ctx;
 100
 101 #if 0
 102     // sws_getContext is being depricated.  But it appears that
 103     // the new method isn't quite wrung out yet.  So when it is
 104     // this code should be fixed up and enabled.
 105     ctx = sws_alloc_context();
 106     if ( ctx )
 107     {
 108         av_set_int(ctx, "srcw", srcW);
 109         av_set_int(ctx, "srch", srcH);
 110         av_set_int(ctx, "src_format", srcFormat);
 111         av_set_int(ctx, "dstw", dstW);
 112         av_set_int(ctx, "dsth", dstH);
 113         av_set_int(ctx, "dst_format", dstFormat);
 114         av_set_int(ctx, "sws_flags", flags);
 115
 116         if (sws_init_context(ctx, NULL, NULL) < 0) {
 117             fprintf(stderr, "Cannot initialize resampling context\n");
 118             sws_freeContext(ctx);
 119             ctx = NULL;
 120         }
 121     }
 122 #else
 123     ctx = sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat,
 124                          flags, NULL, NULL, NULL);
 125 #endif
 126     return ctx;
 127 }
 128
 129 int hb_avcodec_close(AVCodecContext *avctx)
 130 {
 131     int ret;
 132     hb_lock( hb_avcodec_lock );
 133     ret = avcodec_close(avctx);
 134     hb_unlock( hb_avcodec_lock );
 135     return ret;
 136 }
 137
 138 int hb_ff_layout_xlat(int64_t ff_channel_layout, int channels)
 139 {
 140     int hb_layout;
 141
 142     switch (ff_channel_layout)
 143     {
 144         case CH_LAYOUT_MONO:
 145             hb_layout = HB_INPUT_CH_LAYOUT_MONO;
 146             break;
 147         case CH_LAYOUT_STEREO:
 148             hb_layout = HB_INPUT_CH_LAYOUT_STEREO;
 149             break;
 150         case CH_LAYOUT_SURROUND:
 151             hb_layout = HB_INPUT_CH_LAYOUT_3F;
 152             break;
 153         case CH_LAYOUT_4POINT0:
 154             hb_layout = HB_INPUT_CH_LAYOUT_3F1R;
 155             break;
 156         case CH_LAYOUT_2_2:
 157             hb_layout = HB_INPUT_CH_LAYOUT_2F2R;
 158             break;
 159         case CH_LAYOUT_QUAD:
 160             hb_layout = HB_INPUT_CH_LAYOUT_2F2R;
 161             break;
 162         case CH_LAYOUT_5POINT0:
 163             hb_layout = HB_INPUT_CH_LAYOUT_3F2R;
 164             break;
 165         case CH_LAYOUT_5POINT1:
 166             hb_layout = HB_INPUT_CH_LAYOUT_3F2R|HB_INPUT_CH_LAYOUT_HAS_LFE;
 167             break;
 168         case CH_LAYOUT_5POINT0_BACK:
 169             hb_layout = HB_INPUT_CH_LAYOUT_3F2R;
 170             break;
 171         case CH_LAYOUT_5POINT1_BACK:
 172             hb_layout = HB_INPUT_CH_LAYOUT_3F2R|HB_INPUT_CH_LAYOUT_HAS_LFE;
 173             break;
 174         case CH_LAYOUT_7POINT0:
 175             hb_layout = HB_INPUT_CH_LAYOUT_3F4R;
 176             break;
 177         case CH_LAYOUT_7POINT1:
 178             hb_layout = HB_INPUT_CH_LAYOUT_3F4R|HB_INPUT_CH_LAYOUT_HAS_LFE;
 179             break;
 180         case CH_LAYOUT_STEREO_DOWNMIX:
 181             hb_layout = HB_INPUT_CH_LAYOUT_STEREO;
 182             break;
 183         default:
 184             hb_layout = HB_INPUT_CH_LAYOUT_STEREO;
 185             break;
 186     }
 187     // Now make sure the chosen layout agrees with the number of channels
 188     // ffmpeg tells us there are.  It seems ffmpeg is sometimes confused
 189     // about this. So we will make a best guess based on the number
 190     // of channels.
 191     int chans = HB_INPUT_CH_LAYOUT_GET_DISCRETE_COUNT( hb_layout );
 192     if ( chans == channels )
 193     {
 194         return hb_layout;
 195     }
 196     hb_log( "Channels reported by ffmpeg (%d) != computed layout channels (%d).", channels, chans );
 197     switch (channels)
 198     {
 199         case 1:
 200             hb_layout = HB_INPUT_CH_LAYOUT_MONO;
 201             break;
 202         case 2:
 203             hb_layout = HB_INPUT_CH_LAYOUT_STEREO;
 204             break;
 205         case 3:
 206             hb_layout = HB_INPUT_CH_LAYOUT_3F;
 207             break;
 208         case 4:
 209             hb_layout = HB_INPUT_CH_LAYOUT_3F1R;
 210             break;
 211         case 5:
 212             hb_layout = HB_INPUT_CH_LAYOUT_3F2R;
 213             break;
 214         case 6:
 215             hb_layout = HB_INPUT_CH_LAYOUT_3F2R|HB_INPUT_CH_LAYOUT_HAS_LFE;
 216             break;
 217         case 7:
 218             hb_layout = HB_INPUT_CH_LAYOUT_3F4R;
 219             break;
 220         case 8:
 221             hb_layout = HB_INPUT_CH_LAYOUT_3F4R|HB_INPUT_CH_LAYOUT_HAS_LFE;
 222             break;
 223         default:
 224             hb_log("Unsupported number of audio channels (%d).\n", channels);
 225             hb_layout = 0;
 226             break;
 227     }
 228     return hb_layout;
 229 }
 230
 231 /**
 232  * Registers work objects, by adding the work object to a liked list.
 233  * @param w Handle to hb_work_object_t to register.
 234  */
 235 void hb_register( hb_work_object_t * w )
 236 {
 237     w->next    = hb_objects;
 238     hb_objects = w;
 239 }
 240
 241 /**
 242  * Ensures that the process has been initialized.
 243  */
 244 static void process_init()
 245 {
 246     if (!hb_process_initialized)
 247     {
 248 #if defined( SYS_MINGW ) && defined( PTW32_STATIC_LIB )
 249         pthread_win32_process_attach_np();
 250 #endif
 251
 252 #if defined( _WIN32 ) || defined( __MINGW32__ )
 253         setvbuf( stdout, NULL, _IONBF, 0 );
 254         setvbuf( stderr, NULL, _IONBF, 0 );
 255 #endif
 256         hb_process_initialized = 1;
 257     }
 258
 259 }
 260
 261 void (*hb_log_callback)(const char* message);
 262 static void redirect_thread_func(void *);
 263
 264 #if defined( SYS_MINGW )
 265 #define pipe(phandles)  _pipe (phandles, 4096, _O_BINARY)
 266 #endif
 267
 268 /**
 269  * Registers the given function as a logger. All logs will be passed to it.
 270  * @param log_cb The function to register as a logger.
 271  */
 272 void hb_register_logger( void (*log_cb)(const char* message) )
 273 {
 274     process_init();
 275
 276     hb_log_callback = log_cb;
 277     hb_thread_init("ioredirect", redirect_thread_func, NULL, HB_NORMAL_PRIORITY);
 278 }
 279
 280 /**
 281  * libhb initialization routine.
 282  * @param verbose HB_DEBUG_NONE or HB_DEBUG_ALL.
 283  * @param update_check signals libhb to check for updated version from HandBrake website.
 284  * @return Handle to hb_handle_t for use on all subsequent calls to libhb.
 285  */
 286 hb_handle_t * hb_init( int verbose, int update_check )
 287 {
 288     process_init();
 289
 290     hb_handle_t * h = calloc( sizeof( hb_handle_t ), 1 );
 291     uint64_t      date;
 292
 293     /* See hb_deep_log() and hb_log() in common.c */
 294     global_verbosity_level = verbose;
 295     if( verbose )
 296         putenv( "HB_DEBUG=1" );
 297
 298     h->id = hb_instance_counter++;
 299
 300     /* Check for an update on the website if asked to */
 301     h->build = -1;
 302
 303     if( update_check )
 304     {
 305         hb_log( "hb_init: checking for updates" );
 306         date             = hb_get_date();
 307         h->update_thread = hb_update_init( &h->build, h->version );
 308
 309         for( ;; )
 310         {
 311             if( hb_thread_has_exited( h->update_thread ) )
 312             {
 313                 /* Immediate success or failure */
 314                 hb_thread_close( &h->update_thread );
 315                 break;
 316             }
 317             if( hb_get_date() > date + 1000 )
 318             {
 319                 /* Still nothing after one second. Connection problem,
 320                    let the thread die */
 321                 hb_log( "hb_init: connection problem, not waiting for "
 322                         "update_thread" );
 323                 break;
 324             }
 325             hb_snooze( 500 );
 326         }
 327     }
 328
 329     /*
 330      * Initialise buffer pool
 331      */
 332     hb_buffer_pool_init();
 333
 334     /* CPU count detection */
 335     hb_log( "hb_init: checking cpu count" );
 336     h->cpu_count = hb_get_cpu_count();
 337
 338     h->list_title = hb_list_init();
 339     h->jobs       = hb_list_init();
 340
 341     h->state_lock  = hb_lock_init();
 342     h->state.state = HB_STATE_IDLE;
 343
 344     h->pause_lock = hb_lock_init();
 345
 346     h->interjob = calloc( sizeof( hb_interjob_t ), 1 );
 347
 348     /* libavcodec */
 349     hb_avcodec_init();
 350
 351     /* Start library thread */
 352     hb_log( "hb_init: starting libhb thread" );
 353     h->die         = 0;
 354     h->main_thread = hb_thread_init( "libhb", thread_func, h,
 355                                      HB_NORMAL_PRIORITY );
 356     hb_register( &hb_sync_video );
 357     hb_register( &hb_sync_audio );
 358         hb_register( &hb_decmpeg2 );
 359         hb_register( &hb_decvobsub );
 360     hb_register( &hb_encvobsub );
 361     hb_register( &hb_deccc608 );
 362     hb_register( &hb_decsrtsub );
 363     hb_register( &hb_decutf8sub );
 364     hb_register( &hb_dectx3gsub );
 365     hb_register( &hb_decssasub );
 366         hb_register( &hb_render );
 367         hb_register( &hb_encavcodec );
 368         hb_register( &hb_encx264 );
 369     hb_register( &hb_enctheora );
 370         hb_register( &hb_deca52 );
 371         hb_register( &hb_decdca );
 372         hb_register( &hb_decavcodec );
 373         hb_register( &hb_decavcodecv );
 374         hb_register( &hb_decavcodecvi );
 375         hb_register( &hb_decavcodecai );
 376         hb_register( &hb_declpcm );
 377         hb_register( &hb_encfaac );
 378         hb_register( &hb_enclame );
 379         hb_register( &hb_encvorbis );
 380         hb_register( &hb_muxer );
 381 #ifdef __APPLE__
 382         hb_register( &hb_encca_aac );
 383 #endif
 384         hb_register( &hb_encac3 );
 385
 386     return h;
 387 }
 388
 389 /**
 390  * libhb initialization routine.
 391  * This version is to use when calling the dylib, the macro hb_init isn't available from a dylib call!
 392  * @param verbose HB_DEBUG_NONE or HB_DEBUG_ALL.
 393  * @param update_check signals libhb to check for updated version from HandBrake website.
 394  * @return Handle to hb_handle_t for use on all subsequent calls to libhb.
 395  */
 396 hb_handle_t * hb_init_dl( int verbose, int update_check )
 397 {
 398     hb_handle_t * h = calloc( sizeof( hb_handle_t ), 1 );
 399     uint64_t      date;
 400
 401     /* See hb_log() in common.c */
 402     if( verbose > HB_DEBUG_NONE )
 403     {
 404         putenv( "HB_DEBUG=1" );
 405     }
 406
 407     h->id = hb_instance_counter++;
 408
 409     /* Check for an update on the website if asked to */
 410     h->build = -1;
 411
 412     if( update_check )
 413     {
 414         hb_log( "hb_init: checking for updates" );
 415         date             = hb_get_date();
 416         h->update_thread = hb_update_init( &h->build, h->version );
 417
 418         for( ;; )
 419         {
 420             if( hb_thread_has_exited( h->update_thread ) )
 421             {
 422                 /* Immediate success or failure */
 423                 hb_thread_close( &h->update_thread );
 424                 break;
 425             }
 426             if( hb_get_date() > date + 1000 )
 427             {
 428                 /* Still nothing after one second. Connection problem,
 429                    let the thread die */
 430                 hb_log( "hb_init: connection problem, not waiting for "
 431                         "update_thread" );
 432                 break;
 433             }
 434             hb_snooze( 500 );
 435         }
 436     }
 437
 438     /* CPU count detection */
 439     hb_log( "hb_init: checking cpu count" );
 440     h->cpu_count = hb_get_cpu_count();
 441
 442     h->list_title = hb_list_init();
 443     h->jobs       = hb_list_init();
 444     h->current_job = NULL;
 445
 446     h->state_lock  = hb_lock_init();
 447     h->state.state = HB_STATE_IDLE;
 448
 449     h->pause_lock = hb_lock_init();
 450
 451     /* libavcodec */
 452     avcodec_init();
 453     avcodec_register_all();
 454
 455     /* Start library thread */
 456     hb_log( "hb_init: starting libhb thread" );
 457     h->die         = 0;
 458     h->main_thread = hb_thread_init( "libhb", thread_func, h,
 459                                      HB_NORMAL_PRIORITY );
 460
 461     hb_register( &hb_sync_video );
 462     hb_register( &hb_sync_audio );
 463         hb_register( &hb_decmpeg2 );
 464         hb_register( &hb_decvobsub );
 465     hb_register( &hb_encvobsub );
 466     hb_register( &hb_deccc608 );
 467     hb_register( &hb_decsrtsub );
 468     hb_register( &hb_decutf8sub );
 469     hb_register( &hb_dectx3gsub );
 470     hb_register( &hb_decssasub );
 471         hb_register( &hb_render );
 472         hb_register( &hb_encavcodec );
 473         hb_register( &hb_encx264 );
 474     hb_register( &hb_enctheora );
 475         hb_register( &hb_deca52 );
 476         hb_register( &hb_decdca );
 477         hb_register( &hb_decavcodec );
 478         hb_register( &hb_decavcodecv );
 479         hb_register( &hb_decavcodecvi );
 480         hb_register( &hb_decavcodecai );
 481         hb_register( &hb_declpcm );
 482         hb_register( &hb_encfaac );
 483         hb_register( &hb_enclame );
 484         hb_register( &hb_encvorbis );
 485         hb_register( &hb_muxer );
 486 #ifdef __APPLE__
 487         hb_register( &hb_encca_aac );
 488 #endif
 489         hb_register( &hb_encac3 );
 490
 491         return h;
 492 }
 493
 494
 495 /**
 496  * Returns current version of libhb.
 497  * @param h Handle to hb_handle_t.
 498  * @return character array of version number.
 499  */
 500 char * hb_get_version( hb_handle_t * h )
 501 {
 502     return HB_PROJECT_VERSION;
 503 }
 504
 505 /**
 506  * Returns current build of libhb.
 507  * @param h Handle to hb_handle_t.
 508  * @return character array of build number.
 509  */
 510 int hb_get_build( hb_handle_t * h )
 511 {
 512     return HB_PROJECT_BUILD;
 513 }
 514
 515 /**
 516  * Checks for needed update.
 517  * @param h Handle to hb_handle_t.
 518  * @param version Pointer to handle where version will be copied.
 519  * @return update indicator.
 520  */
 521 int hb_check_update( hb_handle_t * h, char ** version )
 522 {
 523     *version = ( h->build < 0 ) ? NULL : h->version;
 524     return h->build;
 525 }
 526
 527 /**
 528  * Sets the cpu count to the desired value.
 529  * @param h Handle to hb_handle_t
 530  * @param cpu_count Number of CPUs to use.
 531  */
 532 void hb_set_cpu_count( hb_handle_t * h, int cpu_count )
 533 {
 534     cpu_count    = MAX( 1, cpu_count );
 535     cpu_count    = MIN( cpu_count, 8 );
 536     h->cpu_count = cpu_count;
 537 }
 538
 539 /**
 540  * Deletes current previews associated with titles
 541  * @param h Handle to hb_handle_t
 542  */
 543 void hb_remove_previews( hb_handle_t * h )
 544 {
 545     char            filename[1024];
 546     char            dirname[1024];
 547     hb_title_t    * title;
 548     int             i, count, len;
 549     DIR           * dir;
 550     struct dirent * entry;
 551
 552     memset( dirname, 0, 1024 );
 553     hb_get_temporary_directory( dirname );
 554     dir = opendir( dirname );
 555     if (dir == NULL) return;
 556
 557     count = hb_list_count( h->list_title );
 558     while( ( entry = readdir( dir ) ) )
 559     {
 560         if( entry->d_name[0] == '.' )
 561         {
 562             continue;
 563         }
 564         for( i = 0; i < count; i++ )
 565         {
 566             title = hb_list_item( h->list_title, i );
 567             len = snprintf( filename, 1024, "%d_%d", h->id, title->index );
 568             if (strncmp(entry->d_name, filename, len) == 0)
 569             {
 570                 snprintf( filename, 1024, "%s/%s", dirname, entry->d_name );
 571                 unlink( filename );
 572                 break;
 573             }
 574         }
 575     }
 576     closedir( dir );
 577 }
 578
 579 /**
 580  * Initializes a scan of the by calling hb_scan_init
 581  * @param h Handle to hb_handle_t
 582  * @param path location of VIDEO_TS folder.
 583  * @param title_index Desired title to scan.  0 for all titles.
 584  * @param preview_count Number of preview images to generate.
 585  * @param store_previews Whether or not to write previews to disk.
 586  */
 587 void hb_scan( hb_handle_t * h, const char * path, int title_index,
 588               int preview_count, int store_previews, uint64_t min_duration )
 589 {
 590     hb_title_t * title;
 591
 592     h->scan_die = 0;
 593
 594     /* Clean up from previous scan */
 595     hb_remove_previews( h );
 596     while( ( title = hb_list_item( h->list_title, 0 ) ) )
 597     {
 598         hb_list_rem( h->list_title, title );
 599         hb_title_close( &title );
 600     }
 601
 602     hb_log( "hb_scan: path=%s, title_index=%d", path, title_index );
 603     h->scan_thread = hb_scan_init( h, &h->scan_die, path, title_index,
 604                                    h->list_title, preview_count,
 605                                    store_previews, min_duration );
 606 }
 607
 608 /**
 609  * Returns the list of titles found.
 610  * @param h Handle to hb_handle_t
 611  * @return Handle to hb_list_t of the title list.
 612  */
 613 hb_list_t * hb_get_titles( hb_handle_t * h )
 614 {
 615     return h->list_title;
 616 }
 617
 618 /**
 619  * Create preview image of desired title a index of picture.
 620  * @param h Handle to hb_handle_t.
 621  * @param title_index Index of the title to get the preview for (1-based).
 622  * @param picture Index in title.
 623  * @param buffer Handle to buffer were image will be drawn.
 624  */
 625 void hb_get_preview_by_index( hb_handle_t * h, int title_index, int picture, uint8_t * buffer )
 626 {
 627     hb_title_t * title;
 628
 629     title = hb_get_title_by_index( h, title_index );
 630     if ( title != NULL )
 631     {
 632         hb_get_preview( h, title, picture, buffer );
 633     }
 634 }
 635
 636 /**
 637  * Create preview image of desired title a index of picture.
 638  * @param h Handle to hb_handle_t.
 639  * @param title Handle to hb_title_t of desired title.
 640  * @param picture Index in title.
 641  * @param buffer Handle to buffer were image will be drawn.
 642  */
 643 void hb_get_preview( hb_handle_t * h, hb_title_t * title, int picture,
 644                      uint8_t * buffer )
 645 {
 646     hb_job_t           * job = title->job;
 647     char                 filename[1024];
 648     FILE               * file;
 649     uint8_t            * buf1, * buf2, * buf3, * buf4, * pen;
 650     uint32_t             swsflags;
 651     AVPicture            pic_in, pic_preview, pic_deint, pic_crop, pic_scale;
 652     struct SwsContext  * context;
 653     int                  i;
 654     int                  deint_width = ((title->width + 7) >> 3) << 3;
 655     int                  rgb_width = ((job->width + 7) >> 3) << 3;
 656     int                  preview_size;
 657
 658     swsflags = SWS_LANCZOS | SWS_ACCURATE_RND;
 659
 660     buf1 = av_malloc( avpicture_get_size( PIX_FMT_YUV420P, title->width, title->height ) );
 661     buf2 = av_malloc( avpicture_get_size( PIX_FMT_YUV420P, deint_width, title->height ) );
 662     buf3 = av_malloc( avpicture_get_size( PIX_FMT_YUV420P, rgb_width, job->height ) );
 663     buf4 = av_malloc( avpicture_get_size( PIX_FMT_RGB32, rgb_width, job->height ) );
 664     avpicture_fill( &pic_in, buf1, PIX_FMT_YUV420P,
 665                     title->width, title->height );
 666     avpicture_fill( &pic_deint, buf2, PIX_FMT_YUV420P,
 667                     deint_width, title->height );
 668     avpicture_fill( &pic_scale, buf3, PIX_FMT_YUV420P,
 669                     rgb_width, job->height );
 670     avpicture_fill( &pic_preview, buf4, PIX_FMT_RGB32,
 671                     rgb_width, job->height );
 672
 673     // Allocate the AVPicture frames and fill in
 674
 675     memset( filename, 0, 1024 );
 676
 677     hb_get_tempory_filename( h, filename, "%d_%d_%d",
 678                              h->id, title->index, picture );
 679
 680     file = fopen( filename, "rb" );
 681     if( !file )
 682     {
 683         hb_log( "hb_get_preview: fopen failed" );
 684         return;
 685     }
 686
 687     fread( buf1, avpicture_get_size( PIX_FMT_YUV420P, title->width, title->height), 1, file );
 688     fclose( file );
 689
 690     if( job->deinterlace )
 691     {
 692         // Deinterlace and crop
 693         avpicture_deinterlace( &pic_deint, &pic_in, PIX_FMT_YUV420P, title->width, title->height );
 694         av_picture_crop( &pic_crop, &pic_deint, PIX_FMT_YUV420P, job->crop[0], job->crop[2] );
 695     }
 696     else
 697     {
 698         // Crop
 699         av_picture_crop( &pic_crop, &pic_in, PIX_FMT_YUV420P, job->crop[0], job->crop[2] );
 700     }
 701
 702     // Get scaling context
 703     context = hb_sws_get_context(title->width  - (job->crop[2] + job->crop[3]),
 704                              title->height - (job->crop[0] + job->crop[1]),
 705                              PIX_FMT_YUV420P,
 706                              job->width, job->height, PIX_FMT_YUV420P,
 707                              swsflags);
 708
 709     // Scale
 710     sws_scale(context,
 711               pic_crop.data, pic_crop.linesize,
 712               0, title->height - (job->crop[0] + job->crop[1]),
 713               pic_scale.data, pic_scale.linesize);
 714
 715     // Free context
 716     sws_freeContext( context );
 717
 718     // Get preview context
 719     context = hb_sws_get_context(rgb_width, job->height, PIX_FMT_YUV420P,
 720                               rgb_width, job->height, PIX_FMT_RGB32,
 721                               swsflags);
 722
 723     // Create preview
 724     sws_scale(context,
 725               pic_scale.data, pic_scale.linesize,
 726               0, job->height,
 727               pic_preview.data, pic_preview.linesize);
 728
 729     // Free context
 730     sws_freeContext( context );
 731
 732     preview_size = pic_preview.linesize[0];
 733     pen = buffer;
 734     for( i = 0; i < job->height; i++ )
 735     {
 736         memcpy( pen, buf4 + preview_size * i, 4 * job->width );
 737         pen += 4 * job->width;
 738     }
 739
 740     // Clean up
 741     avpicture_free( &pic_preview );
 742     avpicture_free( &pic_scale );
 743     avpicture_free( &pic_deint );
 744     avpicture_free( &pic_in );
 745 }
 746
 747  /**
 748  * Analyzes a frame to detect interlacing artifacts
 749  * and returns true if interlacing (combing) is found.
 750  *
 751  * Code taken from Thomas Oestreich's 32detect filter
 752  * in the Transcode project, with minor formatting changes.
 753  *
 754  * @param buf         An hb_buffer structure holding valid frame data
 755  * @param width       The frame's width in pixels
 756  * @param height      The frame's height in pixels
 757  * @param color_equal Sensitivity for detecting similar colors
 758  * @param color_diff  Sensitivity for detecting different colors
 759  * @param threshold   Sensitivity for flagging planes as combed
 760  * @param prog_equal  Sensitivity for detecting similar colors on progressive frames
 761  * @param prog_diff   Sensitivity for detecting different colors on progressive frames
 762  * @param prog_threshold Sensitivity for flagging progressive frames as combed
 763  */
 764 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 )
 765 {
 766     int j, k, n, off, cc_1, cc_2, cc[3];
 767         // int flag[3] ; // debugging flag
 768     uint16_t s1, s2, s3, s4;
 769     cc_1 = 0; cc_2 = 0;
 770
 771     int offset = 0;
 772
 773     if ( buf->flags & 16 )
 774     {
 775         /* Frame is progressive, be more discerning. */
 776         color_diff = prog_diff;
 777         color_equal = prog_equal;
 778         threshold = prog_threshold;
 779     }
 780
 781     /* One pas for Y, one pass for Cb, one pass for Cr */
 782     for( k = 0; k < 3; k++ )
 783     {
 784         if( k == 1 )
 785         {
 786             /* Y has already been checked, now offset by Y's dimensions
 787                and divide all the other values by 2, since Cr and Cb
 788                are half-size compared to Y.                               */
 789             offset = width * height;
 790             width >>= 1;
 791             height >>= 1;
 792         }
 793         else if ( k == 2 )
 794         {
 795             /* Y and Cb are done, so the offset needs to be bumped
 796                so it's width*height + (width / 2) * (height / 2)  */
 797             offset *= 5/4;
 798         }
 799
 800         for( j = 0; j < width; ++j )
 801         {
 802             off = 0;
 803
 804             for( n = 0; n < ( height - 4 ); n = n + 2 )
 805             {
 806                 /* Look at groups of 4 sequential horizontal lines */
 807                 s1 = ( ( buf->data + offset )[ off + j             ] & 0xff );
 808                 s2 = ( ( buf->data + offset )[ off + j + width     ] & 0xff );
 809                 s3 = ( ( buf->data + offset )[ off + j + 2 * width ] & 0xff );
 810                 s4 = ( ( buf->data + offset )[ off + j + 3 * width ] & 0xff );
 811
 812                 /* Note if the 1st and 2nd lines are more different in
 813                    color than the 1st and 3rd lines are similar in color.*/
 814                 if ( ( abs( s1 - s3 ) < color_equal ) &&
 815                      ( abs( s1 - s2 ) > color_diff ) )
 816                         ++cc_1;
 817
 818                 /* Note if the 2nd and 3rd lines are more different in
 819                    color than the 2nd and 4th lines are similar in color.*/
 820                 if ( ( abs( s2 - s4 ) < color_equal ) &&
 821                      ( abs( s2 - s3 ) > color_diff) )
 822                         ++cc_2;
 823
 824                 /* Now move down 2 horizontal lines before starting over.*/
 825                 off += 2 * width;
 826             }
 827         }
 828
 829         // compare results
 830         /*  The final cc score for a plane is the percentage of combed pixels it contains.
 831             Because sensitivity goes down to hundreths of a percent, multiply by 1000
 832             so it will be easy to compare against the threhold value which is an integer. */
 833         cc[k] = (int)( ( cc_1 + cc_2 ) * 1000.0 / ( width * height ) );
 834     }
 835
 836
 837     /* HandBrake is all yuv420, so weight the average percentage of all 3 planes accordingly.*/
 838     int average_cc = ( 2 * cc[0] + ( cc[1] / 2 ) + ( cc[2] / 2 ) ) / 3;
 839
 840     /* Now see if that average percentage of combed pixels surpasses the threshold percentage given by the user.*/
 841     if( average_cc > threshold )
 842     {
 843 #if 0
 844             hb_log("Average %i combed (Threshold %i) %i/%i/%i | PTS: %"PRId64" (%fs) %s", average_cc, threshold, cc[0], cc[1], cc[2], buf->start, (float)buf->start / 90000, (buf->flags & 16) ? "Film" : "Video" );
 845 #endif
 846         return 1;
 847     }
 848
 849 #if 0
 850     hb_log("SKIPPED Average %i combed (Threshold %i) %i/%i/%i | PTS: %"PRId64" (%fs) %s", average_cc, threshold, cc[0], cc[1], cc[2], buf->start, (float)buf->start / 90000, (buf->flags & 16) ? "Film" : "Video" );
 851 #endif
 852
 853     /* Reaching this point means no combing detected. */
 854     return 0;
 855
 856 }
 857
 858 /**
 859  * Calculates job width and height for anamorphic content,
 860  *
 861  * @param h Instance handle
 862  * @param title_index Index of the title/job to inspect (1-based).
 863  * @param output_width Pointer to returned storage width
 864  * @param output_height Pointer to returned storage height
 865  * @param output_par_width Pointer to returned pixel width
 866  * @param output_par_height Pointer to returned pixel height
 867  */
 868 void hb_set_anamorphic_size_by_index( hb_handle_t * h, int title_index,
 869         int *output_width, int *output_height,
 870         int *output_par_width, int *output_par_height )
 871 {
 872     hb_title_t * title;
 873     title = hb_get_title_by_index( h, title_index );
 874
 875     hb_set_anamorphic_size( title->job, output_width, output_height, output_par_width, output_par_height );
 876 }
 877
 878 /**
 879  * Calculates job width and height for anamorphic content,
 880  *
 881  * @param job Handle to hb_job_t
 882  * @param output_width Pointer to returned storage width
 883  * @param output_height Pointer to returned storage height
 884  * @param output_par_width Pointer to returned pixel width
 885  * @param output_par_height Pointer to returned pixel height
 886  */
 887 void hb_set_anamorphic_size( hb_job_t * job,
 888         int *output_width, int *output_height,
 889         int *output_par_width, int *output_par_height )
 890 {
 891     /* Set up some variables to make the math easier to follow. */
 892     hb_title_t * title = job->title;
 893     int cropped_width = title->width - job->crop[2] - job->crop[3] ;
 894     int cropped_height = title->height - job->crop[0] - job->crop[1] ;
 895     double storage_aspect = (double)cropped_width / (double)cropped_height;
 896     int mod = job->modulus ? job->modulus : 16;
 897     double aspect = title->aspect;
 898
 899     int pixel_aspect_width  = job->anamorphic.par_width;
 900     int pixel_aspect_height = job->anamorphic.par_height;
 901
 902     /* If a source was really NTSC or PAL and the user specified ITU PAR
 903        values, replace the standard PAR values with the ITU broadcast ones. */
 904     if( title->width == 720 && job->anamorphic.itu_par )
 905     {
 906         // convert aspect to a scaled integer so we can test for 16:9 & 4:3
 907         // aspect ratios ignoring insignificant differences in the LSBs of
 908         // the floating point representation.
 909         int iaspect = aspect * 9.;
 910
 911         /* Handle ITU PARs */
 912         if (title->height == 480)
 913         {
 914             /* It's NTSC */
 915             if (iaspect == 16)
 916             {
 917                 /* It's widescreen */
 918                 pixel_aspect_width = 40;
 919                 pixel_aspect_height = 33;
 920             }
 921             else if (iaspect == 12)
 922             {
 923                 /* It's 4:3 */
 924                 pixel_aspect_width = 10;
 925                 pixel_aspect_height = 11;
 926             }
 927         }
 928         else if (title->height == 576)
 929         {
 930             /* It's PAL */
 931             if(iaspect == 16)
 932             {
 933                 /* It's widescreen */
 934                 pixel_aspect_width = 16;
 935                 pixel_aspect_height = 11;
 936             }
 937             else if (iaspect == 12)
 938             {
 939                 /* It's 4:3 */
 940                 pixel_aspect_width = 12;
 941                 pixel_aspect_height = 11;
 942             }
 943         }
 944     }
 945
 946     /* Figure out what width the source would display at. */
 947     int source_display_width = cropped_width * (double)pixel_aspect_width /
 948                                (double)pixel_aspect_height ;
 949
 950     /*
 951        3 different ways of deciding output dimensions:
 952         - 1: Strict anamorphic, preserve source dimensions
 953         - 2: Loose anamorphic, round to mod16 and preserve storage aspect ratio
 954         - 3: Power user anamorphic, specify everything
 955     */
 956     int width, height;
 957     int maxWidth, maxHeight;
 958
 959     maxWidth = MULTIPLE_MOD_DOWN( job->maxWidth, mod );
 960     maxHeight = MULTIPLE_MOD_DOWN( job->maxHeight, mod );
 961
 962     switch( job->anamorphic.mode )
 963     {
 964         case 1:
 965             /* Strict anamorphic */
 966             *output_width = cropped_width;
 967             *output_height = cropped_height;
 968             *output_par_width = title->pixel_aspect_width;
 969             *output_par_height = title->pixel_aspect_height;
 970         break;
 971
 972         case 2:
 973             /* "Loose" anamorphic.
 974                 - Uses mod16-compliant dimensions,
 975                 - Allows users to set the width
 976             */
 977             width = job->width;
 978             // height: Gets set later, ignore user job->height value
 979
 980             /* Gotta handle bounding dimensions.
 981                If the width is too big, just reset it with no rescaling.
 982                Instead of using the aspect-scaled job height,
 983                we need to see if the job width divided by the storage aspect
 984                is bigger than the max. If so, set it to the max (this is sloppy).
 985                If not, set job height to job width divided by storage aspect.
 986             */
 987
 988             /* Time to get picture width that divide cleanly.*/
 989             width  = MULTIPLE_MOD( width, mod);
 990
 991             if ( maxWidth && (maxWidth < job->width) )
 992                 width = maxWidth;
 993
 994             /* Verify these new dimensions don't violate max height and width settings */
 995             height = ((double)width / storage_aspect) + 0.5;
 996
 997             /* Time to get picture height that divide cleanly.*/
 998             height = MULTIPLE_MOD( height, mod);
 999
1000             if ( maxHeight && (maxHeight < height) )
1001             {
1002                 height = maxHeight;
1003                 width = ((double)height * storage_aspect) + 0.5;
1004                 width  = MULTIPLE_MOD( width, mod);
1005             }
1006
1007             /* The film AR is the source's display width / cropped source height.
1008                The output display width is the output height * film AR.
1009                The output PAR is the output display width / output storage width. */
1010             pixel_aspect_width = height * source_display_width / cropped_height;
1011             pixel_aspect_height = width;
1012
1013             /* Pass the results back to the caller */
1014             *output_width = width;
1015             *output_height = height;
1016         break;
1017
1018         case 3:
1019             /* Anamorphic 3: Power User Jamboree
1020                - Set everything based on specified values */
1021
1022             /* Use specified storage dimensions */
1023             storage_aspect = (double)job->width / (double)job->height;
1024             width = job->width;
1025             height = job->height;
1026
1027             /* Time to get picture dimensions that divide cleanly.*/
1028             width  = MULTIPLE_MOD( width, mod);
1029             height = MULTIPLE_MOD( height, mod);
1030
1031             /* Bind to max dimensions */
1032             if( maxWidth && width > maxWidth )
1033             {
1034                 width = maxWidth;
1035                 // If we are keeping the display aspect, then we are going
1036                 // to be modifying the PAR anyway.  So it's preferred
1037                 // to let the width/height stray some from the original
1038                 // requested storage aspect.
1039                 //
1040                 // But otherwise, PAR and DAR will change the least
1041                 // if we stay as close as possible to the requested
1042                 // storage aspect.
1043                 if ( !job->anamorphic.keep_display_aspect )
1044                 {
1045                     height = ((double)width / storage_aspect) + 0.5;
1046                     height = MULTIPLE_MOD( height, mod);
1047                 }
1048             }
1049             if( maxHeight && height > maxHeight )
1050             {
1051                 height = maxHeight;
1052                 // Ditto, see comment above
1053                 if ( !job->anamorphic.keep_display_aspect )
1054                 {
1055                     width = ((double)height * storage_aspect) + 0.5;
1056                     width  = MULTIPLE_MOD( width, mod);
1057                 }
1058             }
1059
1060             /* That finishes the storage dimensions. On to display. */
1061             if( job->anamorphic.dar_width && job->anamorphic.dar_height )
1062             {
1063                 /* We need to adjust the PAR to produce this aspect. */
1064                 pixel_aspect_width = height * job->anamorphic.dar_width / job->anamorphic.dar_height;
1065                 pixel_aspect_height = width;
1066             }
1067             else
1068             {
1069                 /* If we're doing ana 3 and not specifying a DAR, care needs to be taken.
1070                    This indicates a PAR is potentially being set by the interface. But
1071                    this is an output PAR, to correct a source, and it should not be assumed
1072                    that it properly creates a display aspect ratio when applied to the source,
1073                    which could easily be stored in a different resolution. */
1074                 if( job->anamorphic.keep_display_aspect )
1075                 {
1076                     /* We can ignore the possibility of a PAR change */
1077                     pixel_aspect_width = height * ( (double)source_display_width / (double)cropped_height );
1078                     pixel_aspect_height = width;
1079                 }
1080                 else
1081                 {
1082                     int output_display_width = width * (double)pixel_aspect_width /
1083                         (double)pixel_aspect_height;
1084                     pixel_aspect_width = output_display_width;
1085                     pixel_aspect_height = width;
1086                 }
1087             }
1088
1089             /* Back to caller */
1090             *output_width = width;
1091             *output_height = height;
1092         break;
1093     }
1094
1095     /* While x264 is smart enough to reduce fractions on its own, libavcodec
1096        needs some help with the math, so lose superfluous factors.            */
1097     hb_reduce( output_par_width, output_par_height,
1098                pixel_aspect_width, pixel_aspect_height );
1099 }
1100
1101 /**
1102  * Calculates job width, height, and cropping parameters.
1103  * @param job Handle to hb_job_t.
1104  * @param aspect Desired aspect ratio. Value of -1 uses title aspect.
1105  * @param pixels Maximum desired pixel count.
1106  */
1107 void hb_set_size( hb_job_t * job, double aspect, int pixels )
1108 {
1109     hb_title_t * title = job->title;
1110
1111     int croppedWidth  = title->width - title->crop[2] - title->crop[3];
1112     int croppedHeight = title->height - title->crop[0] - title->crop[1];
1113     double croppedAspect = title->aspect * title->height * croppedWidth /
1114                            croppedHeight / title->width;
1115     int addCrop;
1116     int i, w, h;
1117
1118     if( aspect <= 0 )
1119     {
1120         /* Keep the best possible aspect ratio */
1121         aspect = croppedAspect;
1122     }
1123
1124     /* Crop if necessary to obtain the desired ratio */
1125     memcpy( job->crop, title->crop, 4 * sizeof( int ) );
1126     if( aspect < croppedAspect )
1127     {
1128         /* Need to crop on the left and right */
1129         addCrop = croppedWidth - aspect * croppedHeight * title->width /
1130                     title->aspect / title->height;
1131         if( addCrop & 3 )
1132         {
1133             addCrop = ( addCrop + 1 ) / 2;
1134             job->crop[2] += addCrop;
1135             job->crop[3] += addCrop;
1136         }
1137         else if( addCrop & 2 )
1138         {
1139             addCrop /= 2;
1140             job->crop[2] += addCrop - 1;
1141             job->crop[3] += addCrop + 1;
1142         }
1143         else
1144         {
1145             addCrop /= 2;
1146             job->crop[2] += addCrop;
1147             job->crop[3] += addCrop;
1148         }
1149     }
1150     else if( aspect > croppedAspect )
1151     {
1152         /* Need to crop on the top and bottom */
1153         addCrop = croppedHeight - croppedWidth * title->aspect *
1154             title->height / aspect / title->width;
1155         if( addCrop & 3 )
1156         {
1157             addCrop = ( addCrop + 1 ) / 2;
1158             job->crop[0] += addCrop;
1159             job->crop[1] += addCrop;
1160         }
1161         else if( addCrop & 2 )
1162         {
1163             addCrop /= 2;
1164             job->crop[0] += addCrop - 1;
1165             job->crop[1] += addCrop + 1;
1166         }
1167         else
1168         {
1169             addCrop /= 2;
1170             job->crop[0] += addCrop;
1171             job->crop[1] += addCrop;
1172         }
1173     }
1174
1175     /* Compute a resolution from the number of pixels and aspect */
1176     for( i = 0;; i++ )
1177     {
1178         w = 16 * i;
1179         h = MULTIPLE_16( (int)( (double)w / aspect ) );
1180         if( w * h > pixels )
1181         {
1182             break;
1183         }
1184     }
1185     i--;
1186     job->width  = 16 * i;
1187     job->height = MULTIPLE_16( (int)( (double)job->width / aspect ) );
1188 }
1189
1190 /**
1191  * Returns the number of jobs in the queue.
1192  * @param h Handle to hb_handle_t.
1193  * @return Number of jobs.
1194  */
1195 int hb_count( hb_handle_t * h )
1196 {
1197     return hb_list_count( h->jobs );
1198 }
1199
1200 /**
1201  * Returns handle to job at index i within the job list.
1202  * @param h Handle to hb_handle_t.
1203  * @param i Index of job.
1204  * @returns Handle to hb_job_t of desired job.
1205  */
1206 hb_job_t * hb_job( hb_handle_t * h, int i )
1207 {
1208     return hb_list_item( h->jobs, i );
1209 }
1210
1211 hb_job_t * hb_current_job( hb_handle_t * h )
1212 {
1213     return( h->current_job );
1214 }
1215
1216 /**
1217  * Applies information from the given job to the official job instance.
1218  * @param h Handle to hb_handle_t.
1219  * @param title_index Index of the title to apply the chapter name to (1-based).
1220  * @param chapter The chapter to apply the name to (1-based).
1221  * @param job Job information to apply.
1222  */
1223 void hb_set_chapter_name( hb_handle_t * h, int title_index, int chapter_index, const char * chapter_name )
1224 {
1225     hb_title_t * title;
1226     title = hb_get_title_by_index( h, title_index );
1227
1228     hb_chapter_t * chapter = hb_list_item( title->list_chapter, chapter_index - 1 );
1229
1230     strncpy(chapter->title, chapter_name, 1023);
1231     chapter->title[1023] = '\0';
1232 }
1233
1234 /**
1235  * Applies information from the given job to the official job instance.
1236  * Currently only applies information needed for anamorphic size calculation and previews.
1237  * @param h Handle to hb_handle_t.
1238  * @param title_index Index of the title to apply the job information to (1-based).
1239  * @param job Job information to apply.
1240  */
1241 void hb_set_job( hb_handle_t * h, int title_index, hb_job_t * job )
1242 {
1243         int i;
1244
1245     hb_title_t * title;
1246     title = hb_get_title_by_index( h, title_index );
1247
1248     hb_job_t * job_target = title->job;
1249
1250     job_target->deinterlace = job->deinterlace;
1251     job_target->width = job->width;
1252     job_target->height = job->height;
1253     job_target->maxWidth = job->maxWidth;
1254     job_target->maxHeight = job->maxHeight;
1255     for (i = 0; i < 4; i++)
1256     {
1257         job_target->crop[i] = job->crop[i];
1258     }
1259
1260     job_target->anamorphic = job->anamorphic;
1261 }
1262
1263 /**
1264  * Adds a job to the job list.
1265  * @param h Handle to hb_handle_t.
1266  * @param job Handle to hb_job_t.
1267  */
1268 void hb_add( hb_handle_t * h, hb_job_t * job )
1269 {
1270     hb_job_t      * job_copy;
1271     hb_title_t    * title,    * title_copy;
1272     hb_chapter_t  * chapter,  * chapter_copy;
1273     hb_audio_t    * audio;
1274     hb_subtitle_t * subtitle, * subtitle_copy;
1275     hb_attachment_t * attachment;
1276     int             i;
1277     char            audio_lang[4];
1278
1279     /* Copy the title */
1280     title      = job->title;
1281     title_copy = malloc( sizeof( hb_title_t ) );
1282     memcpy( title_copy, title, sizeof( hb_title_t ) );
1283
1284     title_copy->list_chapter = hb_list_init();
1285     for( i = 0; i < hb_list_count( title->list_chapter ); i++ )
1286     {
1287         chapter      = hb_list_item( title->list_chapter, i );
1288         chapter_copy = malloc( sizeof( hb_chapter_t ) );
1289         memcpy( chapter_copy, chapter, sizeof( hb_chapter_t ) );
1290         hb_list_add( title_copy->list_chapter, chapter_copy );
1291     }
1292
1293     /*
1294      * Copy the metadata
1295      */
1296     if( title->metadata )
1297     {
1298         title_copy->metadata = malloc( sizeof( hb_metadata_t ) );
1299
1300         if( title_copy->metadata )
1301         {
1302             memcpy( title_copy->metadata, title->metadata, sizeof( hb_metadata_t ) );
1303
1304             /*
1305              * Need to copy the artwork seperatly (TODO).
1306              */
1307             if( title->metadata->coverart )
1308             {
1309                 title_copy->metadata->coverart = malloc( title->metadata->coverart_size );
1310                 if( title_copy->metadata->coverart )
1311                 {
1312                     memcpy( title_copy->metadata->coverart, title->metadata->coverart,
1313                             title->metadata->coverart_size );
1314                 } else {
1315                     title_copy->metadata->coverart_size = 0;
1316                 }
1317             }
1318         }
1319     }
1320
1321     /* Copy the audio track(s) we want */
1322     title_copy->list_audio = hb_list_init();
1323     for( i = 0; i < hb_list_count(job->list_audio); i++ )
1324     {
1325         if( ( audio = hb_list_item( job->list_audio, i ) ) )
1326         {
1327             hb_list_add( title_copy->list_audio, hb_audio_copy(audio) );
1328         }
1329     }
1330
1331     /* Initialize subtitle list - filled out further below */
1332     title_copy->list_subtitle = hb_list_init();
1333
1334     /* Copy all the attachments */
1335     title_copy->list_attachment = hb_list_init();
1336     for( i = 0; i < hb_list_count(title->list_attachment); i++ )
1337     {
1338         if( ( attachment = hb_list_item( title->list_attachment, i ) ) )
1339         {
1340             hb_list_add( title_copy->list_attachment, hb_attachment_copy(attachment) );
1341         }
1342     }
1343
1344     /*
1345      * The following code is confusing, there are two ways in which
1346      * we select subtitles and it depends on whether this is single or
1347      * two pass mode.
1348      *
1349      * subtitle_scan may be enabled, in which case the first pass
1350      * scans all subtitles of that language. The second pass does not
1351      * select any because they are set at the end of the first pass.
1352      *
1353      * We may have manually selected a subtitle, in which case that is
1354      * selected in the first pass of a single pass, or the second of a
1355      * two pass.
1356      */
1357     memset( audio_lang, 0, sizeof( audio_lang ) );
1358
1359     if ( job->indepth_scan ) {
1360
1361         /*
1362          * Find the first audio language that is being encoded
1363          */
1364         for( i = 0; i < hb_list_count(job->list_audio); i++ )
1365         {
1366             if( ( audio = hb_list_item( job->list_audio, i ) ) )
1367             {
1368                 strncpy(audio_lang, audio->config.lang.iso639_2, sizeof(audio_lang));
1369                 break;
1370             }
1371         }
1372     }
1373
1374     /*
1375      * If doing a subtitle scan then add all the matching subtitles for this
1376      * language.
1377      */
1378     if ( job->indepth_scan )
1379     {
1380         for( i=0; i < hb_list_count( title->list_subtitle ); i++ )
1381         {
1382             subtitle = hb_list_item( title->list_subtitle, i );
1383             if( strcmp( subtitle->iso639_2, audio_lang ) == 0 &&
1384                 subtitle->source == VOBSUB )
1385             {
1386                 /*
1387                  * Matched subtitle language with audio language, so
1388                  * add this to our list to scan.
1389                  *
1390                  * We will update the subtitle list on the second pass
1391                  * later after the first pass has completed.
1392                  */
1393                 subtitle_copy = malloc( sizeof( hb_subtitle_t ) );
1394                 memcpy( subtitle_copy, subtitle, sizeof( hb_subtitle_t ) );
1395                 hb_list_add( title_copy->list_subtitle, subtitle_copy );
1396             }
1397         }
1398     } else {
1399         /*
1400          * Not doing a subtitle scan in this pass, but maybe we are in the
1401          * first pass?
1402          */
1403         if( job->pass != 1 )
1404         {
1405             /*
1406              * Copy all of them from the input job, to the title_copy/job_copy.
1407              */
1408             for(  i = 0; i < hb_list_count(job->list_subtitle); i++ ) {
1409                 if( ( subtitle = hb_list_item( job->list_subtitle, i ) ) )
1410                 {
1411                     subtitle_copy = malloc( sizeof( hb_subtitle_t ) );
1412                     memcpy( subtitle_copy, subtitle, sizeof( hb_subtitle_t ) );
1413                     hb_list_add( title_copy->list_subtitle, subtitle_copy );
1414                 }
1415             }
1416         }
1417     }
1418
1419     /* Copy the job */
1420     job_copy        = calloc( sizeof( hb_job_t ), 1 );
1421     memcpy( job_copy, job, sizeof( hb_job_t ) );
1422     title_copy->job = job_copy;
1423     job_copy->title = title_copy;
1424     job_copy->list_audio = title_copy->list_audio;
1425     job_copy->list_subtitle = title_copy->list_subtitle;   // sharing list between title and job
1426     job_copy->file  = strdup( job->file );
1427     job_copy->h     = h;
1428     job_copy->pause = h->pause_lock;
1429
1430     /* Copy the job filter list */
1431     if( job->filters )
1432     {
1433         int i;
1434         int filter_count = hb_list_count( job->filters );
1435         job_copy->filters = hb_list_init();
1436         for( i = 0; i < filter_count; i++ )
1437         {
1438             /*
1439              * Copy the filters, since the MacGui reuses the global filter objects
1440              * meaning that queued up jobs overwrite the previous filter settings.
1441              * In reality, settings is probably the only field that needs duplicating
1442              * since it's the only value that is ever changed. But name is duplicated
1443              * as well for completeness. Not copying private_data since it gets
1444              * created for each job in renderInit.
1445              */
1446             hb_filter_object_t * filter = hb_list_item( job->filters, i );
1447             hb_filter_object_t * filter_copy = malloc( sizeof( hb_filter_object_t ) );
1448             memcpy( filter_copy, filter, sizeof( hb_filter_object_t ) );
1449             if( filter->name )
1450                 filter_copy->name = strdup( filter->name );
1451             if( filter->settings )
1452                 filter_copy->settings = strdup( filter->settings );
1453             hb_list_add( job_copy->filters, filter_copy );
1454         }
1455     }
1456
1457     /* Add the job to the list */
1458     hb_list_add( h->jobs, job_copy );
1459     h->job_count = hb_count(h);
1460     h->job_count_permanent++;
1461 }
1462
1463 /**
1464  * Removes a job from the job list.
1465  * @param h Handle to hb_handle_t.
1466  * @param job Handle to hb_job_t.
1467  */
1468 void hb_rem( hb_handle_t * h, hb_job_t * job )
1469 {
1470     hb_list_rem( h->jobs, job );
1471
1472     h->job_count = hb_count(h);
1473     if (h->job_count_permanent)
1474         h->job_count_permanent--;
1475
1476     /* XXX free everything XXX */
1477 }
1478
1479 /**
1480  * Starts the conversion process.
1481  * Sets state to HB_STATE_WORKING.
1482  * calls hb_work_init, to launch work thread. Stores handle to work thread.
1483  * @param h Handle to hb_handle_t.
1484  */
1485 void hb_start( hb_handle_t * h )
1486 {
1487     /* XXX Hack */
1488     h->job_count = hb_list_count( h->jobs );
1489     h->job_count_permanent = h->job_count;
1490
1491     hb_lock( h->state_lock );
1492     h->state.state = HB_STATE_WORKING;
1493 #define p h->state.param.working
1494     p.progress  = 0.0;
1495     p.job_cur   = 1;
1496     p.job_count = h->job_count;
1497     p.rate_cur  = 0.0;
1498     p.rate_avg  = 0.0;
1499     p.hours     = -1;
1500     p.minutes   = -1;
1501     p.seconds   = -1;
1502     p.sequence_id = 0;
1503 #undef p
1504     hb_unlock( h->state_lock );
1505
1506     h->paused = 0;
1507
1508     h->work_die    = 0;
1509     h->work_thread = hb_work_init( h->jobs, h->cpu_count,
1510                                    &h->work_die, &h->work_error, &h->current_job );
1511 }
1512
1513 /**
1514  * Pauses the conversion process.
1515  * @param h Handle to hb_handle_t.
1516  */
1517 void hb_pause( hb_handle_t * h )
1518 {
1519     if( !h->paused )
1520     {
1521         hb_lock( h->pause_lock );
1522         h->paused = 1;
1523
1524         hb_current_job( h )->st_pause_date = hb_get_date();
1525
1526         hb_lock( h->state_lock );
1527         h->state.state = HB_STATE_PAUSED;
1528         hb_unlock( h->state_lock );
1529     }
1530 }
1531
1532 /**
1533  * Resumes the conversion process.
1534  * @param h Handle to hb_handle_t.
1535  */
1536 void hb_resume( hb_handle_t * h )
1537 {
1538     if( h->paused )
1539     {
1540 #define job hb_current_job( h )
1541         if( job->st_pause_date != -1 )
1542         {
1543            job->st_paused += hb_get_date() - job->st_pause_date;
1544         }
1545 #undef job
1546
1547         hb_unlock( h->pause_lock );
1548         h->paused = 0;
1549     }
1550 }
1551
1552 /**
1553  * Stops the conversion process.
1554  * @param h Handle to hb_handle_t.
1555  */
1556 void hb_stop( hb_handle_t * h )
1557 {
1558     h->work_die = 1;
1559
1560     h->job_count = hb_count(h);
1561     h->job_count_permanent = 0;
1562
1563     hb_resume( h );
1564 }
1565
1566 /**
1567  * Stops the conversion process.
1568  * @param h Handle to hb_handle_t.
1569  */
1570 void hb_scan_stop( hb_handle_t * h )
1571 {
1572     h->scan_die = 1;
1573
1574     h->job_count = hb_count(h);
1575     h->job_count_permanent = 0;
1576
1577     hb_resume( h );
1578 }
1579
1580 /**
1581  * Gets a filter object with the given type and settings.
1582  * @param filter_id The type of filter to get.
1583  * @param settings The filter settings to use.
1584  * @returns The requested filter object.
1585  */
1586 hb_filter_object_t * hb_get_filter_object(int filter_id, const char * settings)
1587 {
1588     if (filter_id == HB_FILTER_ROTATE)
1589     {
1590         hb_filter_rotate.settings = (char*)settings;
1591         return &hb_filter_rotate;
1592     }
1593
1594     if (filter_id == HB_FILTER_DETELECINE)
1595     {
1596         hb_filter_detelecine.settings = (char*)settings;
1597         return &hb_filter_detelecine;
1598     }
1599
1600     if (filter_id == HB_FILTER_DECOMB)
1601     {
1602         hb_filter_decomb.settings = (char*)settings;
1603         return &hb_filter_decomb;
1604     }
1605
1606     if (filter_id == HB_FILTER_DEINTERLACE)
1607     {
1608         hb_filter_deinterlace.settings = (char*)settings;
1609         return &hb_filter_deinterlace;
1610     }
1611
1612     if (filter_id == HB_FILTER_DEBLOCK)
1613     {
1614         hb_filter_deblock.settings = (char*)settings;
1615         return &hb_filter_deblock;
1616     }
1617
1618     if (filter_id == HB_FILTER_DENOISE)
1619     {
1620         hb_filter_denoise.settings = (char*)settings;
1621         return &hb_filter_denoise;
1622     }
1623     return NULL;
1624 }
1625
1626 /**
1627  * Returns the state of the conversion process.
1628  * @param h Handle to hb_handle_t.
1629  * @param s Handle to hb_state_t which to copy the state data.
1630  */
1631 void hb_get_state( hb_handle_t * h, hb_state_t * s )
1632 {
1633     hb_lock( h->state_lock );
1634
1635     memcpy( s, &h->state, sizeof( hb_state_t ) );
1636     if ( h->state.state == HB_STATE_SCANDONE || h->state.state == HB_STATE_WORKDONE )
1637         h->state.state = HB_STATE_IDLE;
1638
1639     hb_unlock( h->state_lock );
1640 }
1641
1642 void hb_get_state2( hb_handle_t * h, hb_state_t * s )
1643 {
1644     hb_lock( h->state_lock );
1645
1646     memcpy( s, &h->state, sizeof( hb_state_t ) );
1647
1648     hb_unlock( h->state_lock );
1649 }
1650
1651 /**
1652  * Called in MacGui in UpdateUI to check
1653  *  for a new scan being completed to set a new source
1654  */
1655 int hb_get_scancount( hb_handle_t * h)
1656  {
1657      return h->scanCount;
1658  }
1659
1660 /**
1661  * Closes access to libhb by freeing the hb_handle_t handle ontained in hb_init.
1662  * @param _h Pointer to handle to hb_handle_t.
1663  */
1664 void hb_close( hb_handle_t ** _h )
1665 {
1666     hb_handle_t * h = *_h;
1667     hb_title_t * title;
1668
1669     h->die = 1;
1670
1671     hb_thread_close( &h->main_thread );
1672
1673     while( ( title = hb_list_item( h->list_title, 0 ) ) )
1674     {
1675         hb_list_rem( h->list_title, title );
1676         if( title->job && title->job->filters )
1677         {
1678             hb_list_close( &title->job->filters );
1679         }
1680         free( title->job );
1681         hb_title_close( &title );
1682     }
1683     hb_list_close( &h->list_title );
1684
1685     hb_list_close( &h->jobs );
1686     hb_lock_close( &h->state_lock );
1687     hb_lock_close( &h->pause_lock );
1688
1689     free( h );
1690     *_h = NULL;
1691 }
1692
1693 /**
1694  * Cleans up libhb at a process level. Call before the app closes. Removes preview directory.
1695  */
1696 void hb_global_close()
1697 {
1698     char dirname[1024];
1699     DIR * dir;
1700     struct dirent * entry;
1701
1702     /* Find and remove temp folder */
1703     memset( dirname, 0, 1024 );
1704     hb_get_temporary_directory( dirname );
1705
1706     dir = opendir( dirname );
1707     if (dir)
1708     {
1709         while( ( entry = readdir( dir ) ) )
1710         {
1711             char filename[1024];
1712             if( entry->d_name[0] == '.' )
1713             {
1714                 continue;
1715             }
1716             memset( filename, 0, 1024 );
1717             snprintf( filename, 1023, "%s/%s", dirname, entry->d_name );
1718             unlink( filename );
1719         }
1720         closedir( dir );
1721         rmdir( dirname );
1722     }
1723 }
1724
1725 /**
1726  * Monitors the state of the update, scan, and work threads.
1727  * Sets scan done state when scan thread exits.
1728  * Sets work done state when work thread exits.
1729  * @param _h Handle to hb_handle_t
1730  */
1731 static void thread_func( void * _h )
1732 {
1733     hb_handle_t * h = (hb_handle_t *) _h;
1734     char dirname[1024];
1735
1736     h->pid = getpid();
1737
1738     /* Create folder for temporary files */
1739     memset( dirname, 0, 1024 );
1740     hb_get_temporary_directory( dirname );
1741
1742     hb_mkdir( dirname );
1743
1744     while( !h->die )
1745     {
1746         /* In case the check_update thread hangs, it'll die sooner or
1747            later. Then, we join it here */
1748         if( h->update_thread &&
1749             hb_thread_has_exited( h->update_thread ) )
1750         {
1751             hb_thread_close( &h->update_thread );
1752         }
1753
1754         /* Check if the scan thread is done */
1755         if( h->scan_thread &&
1756             hb_thread_has_exited( h->scan_thread ) )
1757         {
1758             hb_thread_close( &h->scan_thread );
1759
1760             if ( h->scan_die )
1761             {
1762                 hb_title_t * title;
1763
1764                 hb_remove_previews( h );
1765                 while( ( title = hb_list_item( h->list_title, 0 ) ) )
1766                 {
1767                     hb_list_rem( h->list_title, title );
1768                     hb_title_close( &title );
1769                 }
1770
1771                 hb_log( "hb_scan: canceled" );
1772             }
1773             else
1774             {
1775                 hb_log( "libhb: scan thread found %d valid title(s)",
1776                         hb_list_count( h->list_title ) );
1777             }
1778             hb_lock( h->state_lock );
1779             h->state.state = HB_STATE_SCANDONE; //originally state.state
1780                         hb_unlock( h->state_lock );
1781                         /*we increment this sessions scan count by one for the MacGui
1782                         to trigger a new source being set */
1783             h->scanCount++;
1784         }
1785
1786         /* Check if the work thread is done */
1787         if( h->work_thread &&
1788             hb_thread_has_exited( h->work_thread ) )
1789         {
1790             hb_thread_close( &h->work_thread );
1791
1792             hb_log( "libhb: work result = %d",
1793                     h->work_error );
1794             hb_lock( h->state_lock );
1795             h->state.state                = HB_STATE_WORKDONE;
1796             h->state.param.workdone.error = h->work_error;
1797
1798             h->job_count = hb_count(h);
1799             if (h->job_count < 1)
1800                 h->job_count_permanent = 0;
1801             hb_unlock( h->state_lock );
1802         }
1803
1804         hb_snooze( 50 );
1805     }
1806
1807     if( h->scan_thread )
1808     {
1809         hb_scan_stop( h );
1810         hb_thread_close( &h->scan_thread );
1811     }
1812     if( h->work_thread )
1813     {
1814         hb_stop( h );
1815         hb_thread_close( &h->work_thread );
1816     }
1817     hb_remove_previews( h );
1818 }
1819
1820 /**
1821  * Redirects stderr to the registered callback
1822  * function.
1823  * @param _data Unused.
1824  */
1825 static void redirect_thread_func(void * _data)
1826 {
1827     int pfd[2];
1828     pipe(pfd);
1829 #if defined( SYS_MINGW )
1830     // dup2 doesn't work on windows for some stupid reason
1831     stderr->_file = pfd[1];
1832 #else
1833     dup2(pfd[1], /*stderr*/ 2);
1834 #endif
1835     FILE * log_f = fdopen(pfd[0], "rb");
1836
1837     char line_buffer[500];
1838     while(fgets(line_buffer, 500, log_f) != NULL)
1839     {
1840         hb_log_callback(line_buffer);
1841     }
1842 }
1843
1844 /**
1845  * Returns the PID.
1846  * @param h Handle to hb_handle_t
1847  */
1848 int hb_get_pid( hb_handle_t * h )
1849 {
1850     return h->pid;
1851 }
1852
1853 /**
1854  * Returns the id for the given instance.
1855  * @param h Handle to hb_handle_t
1856  * @returns The ID for the given instance
1857  */
1858 int hb_get_instance_id( hb_handle_t * h )
1859 {
1860     return h->id;
1861 }
1862
1863 /**
1864  * Returns the title with the given title index.
1865  * @param h Handle to hb_handle_t
1866  * @param title_index the index of the title to get
1867  * @returns The requested title
1868  */
1869 hb_title_t * hb_get_title_by_index( hb_handle_t * h, int title_index )
1870 {
1871     hb_title_t * title;
1872     int i;
1873         int count = hb_list_count( h->list_title );
1874     for (i = 0; i < count; i++)
1875     {
1876         title = hb_list_item( h->list_title, i );
1877         if (title->index == title_index)
1878         {
1879             return title;
1880         }
1881     }
1882
1883     return NULL;
1884 }
1885
1886 /**
1887  * Sets the current state.
1888  * @param h Handle to hb_handle_t
1889  * @param s Handle to new hb_state_t
1890  */
1891 void hb_set_state( hb_handle_t * h, hb_state_t * s )
1892 {
1893     hb_lock( h->pause_lock );
1894     hb_lock( h->state_lock );
1895     memcpy( &h->state, s, sizeof( hb_state_t ) );
1896     if( h->state.state == HB_STATE_WORKING ||
1897         h->state.state == HB_STATE_SEARCHING )
1898     {
1899         /* XXX Hack */
1900         if (h->job_count < 1)
1901             h->job_count_permanent = 1;
1902
1903         h->state.param.working.job_cur =
1904             h->job_count_permanent - hb_list_count( h->jobs );
1905         h->state.param.working.job_count = h->job_count_permanent;
1906
1907         // Set which job is being worked on
1908         if (h->current_job)
1909             h->state.param.working.sequence_id = h->current_job->sequence_id;
1910         else
1911             h->state.param.working.sequence_id = 0;
1912     }
1913     hb_unlock( h->state_lock );
1914     hb_unlock( h->pause_lock );
1915 }
1916
1917 /* Passes a pointer to persistent data */
1918 hb_interjob_t * hb_interjob_get( hb_handle_t * h )
1919 {
1920     return h->interjob;
1921 }