libhb/work.c

   1 /* $Id: work.c,v 1.43 2005/03/17 16:38:49 titer Exp $
   2
   3    This file is part of the HandBrake source code.
   4    Homepage: <http://handbrake.fr/>.
   5    It may be used under the terms of the GNU General Public License. */
   6
   7 #include "hb.h"
   8 #include "a52dec/a52.h"
   9 #include "dca.h"
  10 #include "libavformat/avformat.h"
  11
  12 typedef struct
  13 {
  14     hb_list_t * jobs;
  15     hb_job_t  ** current_job;
  16     int         cpu_count;
  17     int       * error;
  18     volatile int * die;
  19
  20 } hb_work_t;
  21
  22 static void work_func();
  23 static void do_job( hb_job_t *, int cpu_count );
  24 static void work_loop( void * );
  25
  26 #define FIFO_UNBOUNDED 65536
  27 #define FIFO_UNBOUNDED_WAKE 65535
  28 #define FIFO_LARGE 32
  29 #define FIFO_LARGE_WAKE 16
  30 #define FIFO_SMALL 16
  31 #define FIFO_SMALL_WAKE 15
  32
  33 /**
  34  * Allocates work object and launches work thread with work_func.
  35  * @param jobs Handle to hb_list_t.
  36  * @param cpu_count Humber of CPUs found in system.
  37  * @param die Handle to user inititated exit indicator.
  38  * @param error Handle to error indicator.
  39  */
  40 hb_thread_t * hb_work_init( hb_list_t * jobs, int cpu_count,
  41                             volatile int * die, int * error, hb_job_t ** job )
  42 {
  43     hb_work_t * work = calloc( sizeof( hb_work_t ), 1 );
  44
  45     work->jobs      = jobs;
  46     work->current_job = job;
  47     work->cpu_count = cpu_count;
  48     work->die       = die;
  49     work->error     = error;
  50
  51     return hb_thread_init( "work", work_func, work, HB_LOW_PRIORITY );
  52 }
  53
  54 static void InitWorkState( hb_handle_t * h )
  55 {
  56     hb_state_t state;
  57
  58     state.state = HB_STATE_WORKING;
  59 #define p state.param.working
  60     p.progress  = 0.0;
  61     p.rate_cur  = 0.0;
  62     p.rate_avg  = 0.0;
  63     p.hours     = -1;
  64     p.minutes   = -1;
  65     p.seconds   = -1;
  66 #undef p
  67
  68     hb_set_state( h, &state );
  69
  70 }
  71
  72 /**
  73  * Iterates through job list and calls do_job for each job.
  74  * @param _work Handle work object.
  75  */
  76 static void work_func( void * _work )
  77 {
  78     hb_work_t  * work = _work;
  79     hb_job_t   * job;
  80
  81     hb_log( "%d job(s) to process", hb_list_count( work->jobs ) );
  82
  83     while( !*work->die && ( job = hb_list_item( work->jobs, 0 ) ) )
  84     {
  85         hb_list_rem( work->jobs, job );
  86         job->die = work->die;
  87         *(work->current_job) = job;
  88         InitWorkState( job->h );
  89         do_job( job, work->cpu_count );
  90         *(work->current_job) = NULL;
  91     }
  92
  93     *(work->error) = HB_ERROR_NONE;
  94
  95     free( work );
  96 }
  97
  98 hb_work_object_t * hb_get_work( int id )
  99 {
 100     hb_work_object_t * w;
 101     for( w = hb_objects; w; w = w->next )
 102     {
 103         if( w->id == id )
 104         {
 105             hb_work_object_t *wc = malloc( sizeof(*w) );
 106             *wc = *w;
 107             return wc;
 108         }
 109     }
 110     return NULL;
 111 }
 112
 113 hb_work_object_t * hb_codec_decoder( int codec )
 114 {
 115     switch( codec )
 116     {
 117         case HB_ACODEC_AC3:  return hb_get_work( WORK_DECA52 );
 118         case HB_ACODEC_DCA:  return hb_get_work( WORK_DECDCA );
 119         case HB_ACODEC_MPGA: return hb_get_work( WORK_DECAVCODEC );
 120         case HB_ACODEC_LPCM: return hb_get_work( WORK_DECLPCM );
 121         case HB_ACODEC_FFMPEG: return hb_get_work( WORK_DECAVCODECAI );
 122     }
 123     return NULL;
 124 }
 125
 126 hb_work_object_t * hb_codec_encoder( int codec )
 127 {
 128     switch( codec )
 129     {
 130         case HB_ACODEC_FAAC:   return hb_get_work( WORK_ENCFAAC );
 131         case HB_ACODEC_LAME:   return hb_get_work( WORK_ENCLAME );
 132         case HB_ACODEC_VORBIS: return hb_get_work( WORK_ENCVORBIS );
 133         case HB_ACODEC_CA_AAC: return hb_get_work( WORK_ENC_CA_AAC );
 134         case HB_ACODEC_AC3:    return hb_get_work( WORK_ENCAC3 );
 135     }
 136     return NULL;
 137 }
 138
 139 /**
 140  * Displays job parameters in the debug log.
 141  * @param job Handle work hb_job_t.
 142  */
 143 void hb_display_job_info( hb_job_t * job )
 144 {
 145     hb_title_t * title = job->title;
 146     hb_audio_t   * audio;
 147     hb_subtitle_t * subtitle;
 148     int             i, j;
 149
 150     hb_log("job configuration:");
 151     hb_log( " * source");
 152
 153     hb_log( "   + %s", title->path );
 154
 155     hb_log( "   + title %d, chapter(s) %d to %d", title->index,
 156             job->chapter_start, job->chapter_end );
 157
 158     if( title->container_name != NULL )
 159         hb_log( "   + container: %s", title->container_name);
 160
 161     if( title->data_rate )
 162     {
 163         hb_log( "   + data rate: %d kbps", title->data_rate / 1000 );
 164     }
 165
 166     hb_log( " * destination");
 167
 168     hb_log( "   + %s", job->file );
 169
 170     switch( job->mux )
 171     {
 172         case HB_MUX_MP4:
 173             hb_log("   + container: MPEG-4 (.mp4 and .m4v)");
 174
 175             if( job->ipod_atom )
 176                 hb_log( "     + compatibility atom for iPod 5G");
 177
 178             if( job->largeFileSize )
 179                 hb_log( "     + 64-bit formatting");
 180
 181             if( job->mp4_optimize )
 182                 hb_log( "     + optimized for progressive web downloads");
 183
 184             if( job->color_matrix )
 185                 hb_log( "     + custom color matrix: %s", job->color_matrix == 1 ? "ITU Bt.601 (SD)" : "ITU Bt.709 (HD)");
 186             break;
 187
 188         case HB_MUX_MKV:
 189             hb_log("   + container: Matroska (.mkv)");
 190             break;
 191     }
 192
 193     if( job->chapter_markers )
 194     {
 195         hb_log( "     + chapter markers" );
 196     }
 197
 198     hb_log(" * video track");
 199
 200     hb_log("   + decoder: %s", title->video_codec_name );
 201
 202     if( title->video_bitrate )
 203     {
 204         hb_log( "     + bitrate %d kbps", title->video_bitrate / 1000 );
 205     }
 206
 207     if( !job->cfr )
 208     {
 209         hb_log( "   + frame rate: same as source (around %.3f fps)",
 210             (float) title->rate / (float) title->rate_base );
 211     }
 212     else
 213     {
 214         static const char *frtypes[] = {
 215             "", "constant", "peak rate limited to"
 216         };
 217         hb_log( "   + frame rate: %.3f fps -> %s %.3f fps",
 218             (float) title->rate / (float) title->rate_base, frtypes[job->cfr],
 219             (float) job->vrate / (float) job->vrate_base );
 220     }
 221
 222     if( job->anamorphic.mode )
 223     {
 224         hb_log( "   + %s anamorphic", job->anamorphic.mode == 1 ? "strict" : job->anamorphic.mode == 2? "loose" : "custom" );
 225         if( job->anamorphic.mode == 3 && job->anamorphic.keep_display_aspect )
 226         {
 227             hb_log( "     + keeping source display aspect ratio");
 228         }
 229         hb_log( "     + storage dimensions: %d * %d -> %d * %d, crop %d/%d/%d/%d, mod %i",
 230                     title->width, title->height, job->width, job->height,
 231                     job->crop[0], job->crop[1], job->crop[2], job->crop[3], job->modulus );
 232         if( job->anamorphic.itu_par )
 233         {
 234             hb_log( "     + using ITU pixel aspect ratio values");
 235         }
 236         hb_log( "     + pixel aspect ratio: %i / %i", job->anamorphic.par_width, job->anamorphic.par_height );
 237         hb_log( "     + display dimensions: %.0f * %i",
 238             (float)( job->width * job->anamorphic.par_width / job->anamorphic.par_height ), job->height );
 239     }
 240     else
 241     {
 242         hb_log( "   + dimensions: %d * %d -> %d * %d, crop %d/%d/%d/%d, mod %i",
 243                 title->width, title->height, job->width, job->height,
 244                 job->crop[0], job->crop[1], job->crop[2], job->crop[3], job->modulus );
 245     }
 246
 247     if ( job->grayscale )
 248         hb_log( "   + grayscale mode" );
 249
 250     if( hb_list_count( job->filters ) )
 251     {
 252         hb_log("   + %s", hb_list_count( job->filters) > 1 ? "filters" : "filter" );
 253         for( i = 0; i < hb_list_count( job->filters ); i++ )
 254         {
 255             hb_filter_object_t * filter = hb_list_item( job->filters, i );
 256             if (filter->settings)
 257                 hb_log("     + %s (%s)", filter->name, filter->settings);
 258             else
 259                 hb_log("     + %s (default settings)", filter->name);
 260         }
 261     }
 262
 263     if( !job->indepth_scan )
 264     {
 265         /* Video encoder */
 266         switch( job->vcodec )
 267         {
 268             case HB_VCODEC_FFMPEG:
 269                 hb_log( "   + encoder: FFmpeg" );
 270                 break;
 271
 272             case HB_VCODEC_X264:
 273                 hb_log( "   + encoder: x264" );
 274                 if( job->x264opts != NULL && *job->x264opts != '\0' )
 275                     hb_log( "     + options: %s", job->x264opts);
 276                 break;
 277
 278             case HB_VCODEC_THEORA:
 279                 hb_log( "   + encoder: Theora" );
 280                 break;
 281         }
 282
 283         if( job->vquality >= 0.0 && job->vquality <= 1.0 )
 284         {
 285             hb_log( "     + quality: %.2f", job->vquality );
 286         }
 287         else if( job->vquality > 1 )
 288         {
 289             hb_log( "     + quality: %.2f %s", job->vquality, job->vcodec == HB_VCODEC_X264 ? "(RF)" : "(QP)" );
 290         }
 291         else
 292         {
 293             hb_log( "     + bitrate: %d kbps, pass: %d", job->vbitrate, job->pass );
 294         }
 295     }
 296
 297     for( i=0; i < hb_list_count( title->list_subtitle ); i++ )
 298     {
 299         subtitle =  hb_list_item( title->list_subtitle, i );
 300
 301         if( subtitle )
 302         {
 303             if( subtitle->source == SRTSUB )
 304             {
 305                 /* For SRT, print offset and charset too */
 306                 hb_log( " * subtitle track %i, %s (id %x) %s [%s] -> %s%s, offset: %"PRId64", charset: %s",
 307                         subtitle->track, subtitle->lang, subtitle->id, "Text", "SRT", "Pass-Through",
 308                         subtitle->config.default_track ? ", Default" : "",
 309                         subtitle->config.offset, subtitle->config.src_codeset );
 310             }
 311             else
 312             {
 313                 hb_log( " * subtitle track %i, %s (id %x) %s [%s] -> %s%s%s", subtitle->track, subtitle->lang, subtitle->id,
 314                         subtitle->format == PICTURESUB ? "Picture" : "Text",
 315                         hb_subsource_name( subtitle->source ),
 316                         job->indepth_scan ? "Foreign Audio Search" :
 317                         subtitle->config.dest == RENDERSUB ? "Render/Burn in" : "Pass-Through",
 318                         subtitle->config.force ? ", Forced Only" : "",
 319                         subtitle->config.default_track ? ", Default" : "" );
 320             }
 321         }
 322     }
 323
 324     if( !job->indepth_scan )
 325     {
 326         for( i = 0; i < hb_list_count( title->list_audio ); i++ )
 327         {
 328             audio = hb_list_item( title->list_audio, i );
 329
 330             hb_log( " * audio track %d", audio->config.out.track );
 331
 332             if( audio->config.out.name )
 333                 hb_log( "   + name: %s", audio->config.out.name );
 334
 335             hb_log( "   + decoder: %s (track %d, id %x)", audio->config.lang.description, audio->config.in.track + 1, audio->id );
 336
 337             if( ( audio->config.in.codec == HB_ACODEC_AC3 ) || ( audio->config.in.codec == HB_ACODEC_DCA) )
 338             {
 339                 hb_log( "     + bitrate: %d kbps, samplerate: %d Hz", audio->config.in.bitrate / 1000, audio->config.in.samplerate );
 340             }
 341
 342             if( (audio->config.out.codec != HB_ACODEC_AC3_PASS) && (audio->config.out.codec != HB_ACODEC_DCA_PASS) )
 343             {
 344                 for (j = 0; j < hb_audio_mixdowns_count; j++)
 345                 {
 346                     if (hb_audio_mixdowns[j].amixdown == audio->config.out.mixdown) {
 347                         hb_log( "   + mixdown: %s", hb_audio_mixdowns[j].human_readable_name );
 348                         break;
 349                     }
 350                 }
 351             }
 352
 353             if ( audio->config.out.dynamic_range_compression && (audio->config.out.codec != HB_ACODEC_AC3_PASS) && (audio->config.out.codec != HB_ACODEC_DCA_PASS))
 354             {
 355                 hb_log("   + dynamic range compression: %f", audio->config.out.dynamic_range_compression);
 356             }
 357
 358             if( (audio->config.out.codec == HB_ACODEC_AC3_PASS) || (audio->config.out.codec == HB_ACODEC_DCA_PASS) )
 359             {
 360                 hb_log( "   + %s passthrough", (audio->config.out.codec == HB_ACODEC_AC3_PASS) ?
 361                     "AC3" : "DCA" );
 362             }
 363             else
 364             {
 365                 hb_log( "   + encoder: %s",
 366                     ( audio->config.out.codec == HB_ACODEC_FAAC ) ?  "faac" :
 367                     ( ( audio->config.out.codec == HB_ACODEC_LAME ) ?  "lame" :
 368                     ( ( audio->config.out.codec == HB_ACODEC_CA_AAC ) ?  "ca_aac" :
 369                     ( ( audio->config.out.codec == HB_ACODEC_AC3 ) ?  "ffac3" :
 370                     "vorbis"  ) ) ) );
 371                 hb_log( "     + bitrate: %d kbps, samplerate: %d Hz", audio->config.out.bitrate, audio->config.out.samplerate );
 372             }
 373         }
 374     }
 375 }
 376
 377 /* Corrects framerates when actual duration and frame count numbers are known. */
 378 void correct_framerate( hb_job_t * job )
 379 {
 380     int real_frames;
 381
 382     hb_interjob_t * interjob = hb_interjob_get( job->h );
 383
 384     if( ( job->sequence_id & 0xFFFFFF ) != ( interjob->last_job & 0xFFFFFF) )
 385         return; // Interjob information is for a different encode.
 386
 387     /* Cache the original framerate before altering it. */
 388     interjob->vrate = job->vrate;
 389     interjob->vrate_base = job->vrate_base;
 390
 391     real_frames = interjob->frame_count - interjob->render_dropped;
 392
 393     job->vrate = job->vrate_base * ( (double)real_frames * 90000 / interjob->total_time );
 394 }
 395
 396 static int check_ff_audio( hb_list_t *list_audio, hb_audio_t *ff_audio )
 397 {
 398     int i;
 399
 400     for( i = 0; i < hb_list_count( list_audio ); i++ )
 401     {
 402         hb_audio_t * audio = hb_list_item( list_audio, i );
 403
 404         if ( audio == ff_audio )
 405             break;
 406
 407         if ( audio->config.in.codec == HB_ACODEC_FFMPEG &&
 408              audio->id == ff_audio->id )
 409         {
 410             hb_list_add( audio->priv.ff_audio_list, ff_audio );
 411             return 1;
 412         }
 413     }
 414     return 0;
 415 }
 416
 417 /**
 418  * Job initialization rountine.
 419  * Initializes fifos.
 420  * Creates work objects for synchronizer, video decoder, video renderer, video decoder, audio decoder, audio encoder, reader, muxer.
 421  * Launches thread for each work object with work_loop.
 422  * Loops while monitoring status of work threads and fifos.
 423  * Exits loop when conversion is done and fifos are empty.
 424  * Closes threads and frees fifos.
 425  * @param job Handle work hb_job_t.
 426  * @param cpu_count number of CPUs found in system.
 427  */
 428 static void do_job( hb_job_t * job, int cpu_count )
 429 {
 430     hb_title_t    * title;
 431     int             i, j;
 432     hb_work_object_t * w;
 433     hb_work_object_t * sync;
 434     hb_work_object_t * muxer;
 435     hb_interjob_t * interjob;
 436
 437     hb_audio_t   * audio;
 438     hb_subtitle_t * subtitle;
 439     hb_attachment_t * attachment;
 440     unsigned int subtitle_highest = 0;
 441     unsigned int subtitle_highest_id = 0;
 442     unsigned int subtitle_lowest = -1;
 443     unsigned int subtitle_lowest_id = 0;
 444     unsigned int subtitle_forced_id = 0;
 445     unsigned int subtitle_hit = 0;
 446
 447     title = job->title;
 448     interjob = hb_interjob_get( job->h );
 449
 450     if( job->pass == 2 && !job->cfr )
 451     {
 452         correct_framerate( job );
 453     }
 454
 455     job->list_work = hb_list_init();
 456
 457     hb_log( "starting job" );
 458
 459     if( job->anamorphic.mode )
 460     {
 461         hb_set_anamorphic_size(job, &job->width, &job->height, &job->anamorphic.par_width, &job->anamorphic.par_height);
 462
 463         if( job->vcodec == HB_VCODEC_FFMPEG )
 464         {
 465             /* Just to make working with ffmpeg even more fun,
 466                lavc's MPEG-4 encoder can't handle PAR values >= 255,
 467                even though AVRational does. Adjusting downwards
 468                distorts the display aspect slightly, but such is life. */
 469             while ((job->anamorphic.par_width & ~0xFF) ||
 470                    (job->anamorphic.par_height & ~0xFF))
 471             {
 472                 job->anamorphic.par_width >>= 1;
 473                 job->anamorphic.par_height >>= 1;
 474             }
 475             hb_reduce( &job->anamorphic.par_width, &job->anamorphic.par_height, job->anamorphic.par_width, job->anamorphic.par_height );
 476         }
 477     }
 478
 479     /* Keep width and height within these boundaries,
 480        but ignore for anamorphic. For "loose" anamorphic encodes,
 481        this stuff is covered in the pixel_ratio section above.    */
 482     if ( job->maxHeight && ( job->height > job->maxHeight ) && ( !job->anamorphic.mode ) )
 483     {
 484         job->height = job->maxHeight;
 485         hb_fix_aspect( job, HB_KEEP_HEIGHT );
 486         hb_log( "Height out of bounds, scaling down to %i", job->maxHeight );
 487         hb_log( "New dimensions %i * %i", job->width, job->height );
 488     }
 489     if ( job->maxWidth && ( job->width > job->maxWidth ) && ( !job->anamorphic.mode ) )
 490     {
 491         job->width = job->maxWidth;
 492         hb_fix_aspect( job, HB_KEEP_WIDTH );
 493         hb_log( "Width out of bounds, scaling down to %i", job->maxWidth );
 494         hb_log( "New dimensions %i * %i", job->width, job->height );
 495     }
 496
 497     if ( job->cfr == 0 )
 498     {
 499         /* Ensure we're using "Same as source" FPS */
 500         job->vrate_base = title->rate_base;
 501     }
 502
 503     job->fifo_mpeg2  = hb_fifo_init( FIFO_LARGE, FIFO_LARGE_WAKE );
 504     job->fifo_raw    = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE );
 505     job->fifo_sync   = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE );
 506     job->fifo_render = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE );
 507     job->fifo_mpeg4  = hb_fifo_init( FIFO_LARGE, FIFO_LARGE_WAKE );
 508
 509     /*
 510      * Audio fifos must be initialized before sync
 511      */
 512     if( !job->indepth_scan )
 513     {
 514     // if we are doing passthru, and the input codec is not the same as the output
 515     // codec, then remove this audio from the job. If we're not doing passthru and
 516     // the input codec is the 'internal' ffmpeg codec, make sure that only one
 517     // audio references that audio stream since the codec context is specific to
 518     // the audio id & multiple copies of the same stream will garble the audio
 519     // or cause aborts.
 520     for( i = 0; i < hb_list_count( title->list_audio ); )
 521     {
 522         audio = hb_list_item( title->list_audio, i );
 523         if( ( ( audio->config.out.codec == HB_ACODEC_AC3_PASS ) && ( audio->config.in.codec != HB_ACODEC_AC3 ) ) ||
 524             ( ( audio->config.out.codec == HB_ACODEC_DCA_PASS ) && ( audio->config.in.codec != HB_ACODEC_DCA ) ) )
 525         {
 526             hb_log( "Passthru requested and input codec is not the same as output codec for track %d",
 527                     audio->config.out.track );
 528             hb_list_rem( title->list_audio, audio );
 529             free( audio );
 530             continue;
 531         }
 532         if( audio->config.out.codec != HB_ACODEC_AC3_PASS &&
 533             audio->config.out.codec != HB_ACODEC_DCA_PASS &&
 534             audio->config.out.samplerate > 48000 )
 535         {
 536             hb_log( "Sample rate %d not supported.  Down-sampling to 48kHz.",
 537                     audio->config.out.samplerate );
 538             audio->config.out.samplerate = 48000;
 539         }
 540         if( audio->config.out.codec == HB_ACODEC_AC3 &&
 541             audio->config.out.bitrate > 640 )
 542         {
 543             hb_log( "Bitrate %d not supported.  Reducing to 640Kbps.",
 544                     audio->config.out.bitrate );
 545             audio->config.out.bitrate = 640;
 546         }
 547         /* Adjust output track number, in case we removed one.
 548          * Output tracks sadly still need to be in sequential order.
 549          */
 550         audio->config.out.track = i++;
 551     }
 552
 553     int requested_mixdown = 0;
 554     int requested_mixdown_index = 0;
 555     int best_mixdown = 0;
 556     int requested_bitrate = 0;
 557     int best_bitrate = 0;
 558
 559     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
 560     {
 561         audio = hb_list_item( title->list_audio, i );
 562
 563         best_mixdown = hb_get_best_mixdown( audio->config.out.codec,
 564                                             audio->config.in.channel_layout, 0 );
 565
 566         /* sense-check the current mixdown options */
 567
 568         /* sense-check the requested mixdown */
 569         if( audio->config.out.mixdown == 0 &&
 570             !( audio->config.out.codec & HB_ACODEC_PASS_FLAG ) )
 571         {
 572             /*
 573              * Mixdown wasn't specified and this is not pass-through,
 574              * set a default mixdown
 575              */
 576             audio->config.out.mixdown = hb_get_default_mixdown( audio->config.out.codec,
 577                                                                 audio->config.in.channel_layout );
 578             for (j = 0; j < hb_audio_mixdowns_count; j++)
 579             {
 580                 if (hb_audio_mixdowns[j].amixdown == audio->config.out.mixdown)
 581                 {
 582                     hb_log("work: mixdown not specified, track %i setting mixdown %s", audio->config.out.track, hb_audio_mixdowns[j].human_readable_name);
 583                     break;
 584                 }
 585             }
 586         }
 587
 588         /* log the requested mixdown */
 589         for (j = 0; j < hb_audio_mixdowns_count; j++) {
 590             if (hb_audio_mixdowns[j].amixdown == audio->config.out.mixdown) {
 591                 requested_mixdown = audio->config.out.mixdown;
 592                 requested_mixdown_index = j;
 593                 break;
 594             }
 595         }
 596
 597         if ( !( audio->config.out.codec & HB_ACODEC_PASS_FLAG ) )
 598         {
 599             if ( audio->config.out.mixdown > best_mixdown )
 600             {
 601                 audio->config.out.mixdown = best_mixdown;
 602             }
 603         }
 604
 605         if ( audio->config.out.mixdown != requested_mixdown )
 606         {
 607             /* log the output mixdown */
 608             for (j = 0; j < hb_audio_mixdowns_count; j++)
 609             {
 610                 if (hb_audio_mixdowns[j].amixdown == audio->config.out.mixdown)
 611                 {
 612                     hb_log("work: sanitizing track %i mixdown %s to %s",
 613                         audio->config.out.track,
 614                         hb_audio_mixdowns[requested_mixdown_index].human_readable_name,
 615                         hb_audio_mixdowns[j].human_readable_name);
 616                     break;
 617                 }
 618             }
 619         }
 620
 621         /* sense-check the current bitrates */
 622
 623         /* sense-check the requested bitrate */
 624         if( audio->config.out.bitrate == 0 &&
 625             !( audio->config.out.codec & HB_ACODEC_PASS_FLAG ) )
 626         {
 627             /*
 628              * Bitrate wasn't specified and this is not pass-through,
 629              * set a default bitrate
 630              */
 631             audio->config.out.bitrate = hb_get_default_audio_bitrate( audio->config.out.codec,
 632                                                                       audio->config.out.samplerate,
 633                                                                       audio->config.out.mixdown );
 634
 635             hb_log( "work: bitrate not specified, track %d setting bitrate %d",
 636                     audio->config.out.track, audio->config.out.bitrate );
 637         }
 638
 639         /* log the requested bitrate */
 640         requested_bitrate = audio->config.out.bitrate;
 641         best_bitrate = hb_get_best_audio_bitrate( audio->config.out.codec,
 642                                                   audio->config.out.bitrate,
 643                                                   audio->config.out.samplerate,
 644                                                   audio->config.out.mixdown );
 645
 646         if ( !( audio->config.out.codec & HB_ACODEC_PASS_FLAG ) )
 647         {
 648             if ( audio->config.out.bitrate != best_bitrate )
 649             {
 650                 audio->config.out.bitrate = best_bitrate;
 651             }
 652         }
 653
 654         if ( audio->config.out.bitrate != requested_bitrate )
 655         {
 656             /* log the output bitrate */
 657             hb_log( "work: sanitizing track %d audio bitrate %d to %d",
 658                     audio->config.out.track, requested_bitrate,
 659                     audio->config.out.bitrate);
 660         }
 661
 662         if (audio->config.out.codec == HB_ACODEC_VORBIS)
 663             audio->priv.config.vorbis.language = audio->config.lang.simple;
 664
 665         /* set up the audio work structures */
 666         audio->priv.fifo_raw  = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE );
 667         audio->priv.fifo_sync = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE );
 668         audio->priv.fifo_out  = hb_fifo_init( FIFO_LARGE, FIFO_LARGE_WAKE );
 669
 670         audio->priv.ff_audio_list = hb_list_init();
 671         if ( audio->config.in.codec == HB_ACODEC_FFMPEG )
 672         {
 673             if ( !check_ff_audio( title->list_audio, audio ) )
 674             {
 675                 audio->priv.fifo_in   = hb_fifo_init( FIFO_LARGE, FIFO_LARGE_WAKE );
 676             }
 677         }
 678         else
 679         {
 680             audio->priv.fifo_in   = hb_fifo_init( FIFO_LARGE, FIFO_LARGE_WAKE );
 681         }
 682     }
 683
 684     }
 685     /* Synchronization */
 686     sync = hb_sync_init( job );
 687
 688     /* Video decoder */
 689     int vcodec = title->video_codec? title->video_codec : WORK_DECMPEG2;
 690 #if defined(USE_FF_MPEG2)
 691     if (vcodec == WORK_DECMPEG2)
 692     {
 693         vcodec = WORK_DECAVCODECV;
 694         title->video_codec_param = CODEC_ID_MPEG2VIDEO;
 695     }
 696 #endif
 697     hb_list_add( job->list_work, ( w = hb_get_work( vcodec ) ) );
 698     w->codec_param = title->video_codec_param;
 699     w->fifo_in  = job->fifo_mpeg2;
 700     w->fifo_out = job->fifo_raw;
 701
 702     /* Video renderer */
 703     hb_list_add( job->list_work, ( w = hb_get_work( WORK_RENDER ) ) );
 704     w->fifo_in  = job->fifo_sync;
 705     if( !job->indepth_scan )
 706         w->fifo_out = job->fifo_render;
 707     else
 708         w->fifo_out = NULL;
 709
 710     if( !job->indepth_scan )
 711     {
 712
 713         /* Video encoder */
 714         switch( job->vcodec )
 715         {
 716         case HB_VCODEC_FFMPEG:
 717             w = hb_get_work( WORK_ENCAVCODEC );
 718             break;
 719         case HB_VCODEC_X264:
 720             w = hb_get_work( WORK_ENCX264 );
 721             break;
 722         case HB_VCODEC_THEORA:
 723             w = hb_get_work( WORK_ENCTHEORA );
 724             break;
 725         }
 726         w->fifo_in  = job->fifo_render;
 727         w->fifo_out = job->fifo_mpeg4;
 728         w->config   = &job->config;
 729
 730         hb_list_add( job->list_work, w );
 731     }
 732
 733     /*
 734      * Look for the scanned subtitle in the existing subtitle list
 735      * select_subtitle implies that we did a scan.
 736      */
 737     if ( !job->indepth_scan && interjob->select_subtitle &&
 738          ( job->pass == 0 || job->pass == 2 ) )
 739     {
 740         /*
 741          * Disable forced subtitles if we didn't find any in the scan
 742          * so that we display normal subtitles instead.
 743          */
 744         if( interjob->select_subtitle->config.force &&
 745             interjob->select_subtitle->forced_hits == 0 )
 746         {
 747             interjob->select_subtitle->config.force = 0;
 748         }
 749         for( i=0; i < hb_list_count(title->list_subtitle); i++ )
 750         {
 751             subtitle =  hb_list_item( title->list_subtitle, i );
 752
 753             if( subtitle )
 754             {
 755                 /*
 756                 * Remove the scanned subtitle from the subtitle list if
 757                 * it would result in an identical duplicate subtitle track
 758                 * or an emty track (forced and no forced hits).
 759                 */
 760                 if( ( interjob->select_subtitle->id == subtitle->id ) &&
 761                     ( ( interjob->select_subtitle->forced_hits == 0 &&
 762                         subtitle->config.force ) ||
 763                     ( subtitle->config.force == interjob->select_subtitle->config.force ) ) )
 764                 {
 765                     *subtitle = *(interjob->select_subtitle);
 766                     free( interjob->select_subtitle );
 767                     interjob->select_subtitle = NULL;
 768                     break;
 769                 }
 770             }
 771         }
 772
 773         if( interjob->select_subtitle )
 774         {
 775             /*
 776              * Its not in the existing list
 777              *
 778              * Must be second pass of a two pass with subtitle scan enabled, so
 779              * add the subtitle that we found on the first pass for use in this
 780              * pass.
 781              */
 782             hb_list_add( title->list_subtitle, interjob->select_subtitle );
 783             interjob->select_subtitle = NULL;
 784         }
 785     }
 786
 787
 788     for( i=0; i < hb_list_count(title->list_subtitle); i++ )
 789     {
 790         subtitle =  hb_list_item( title->list_subtitle, i );
 791
 792         if( subtitle )
 793         {
 794             subtitle->fifo_in   = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE );
 795             // Must set capacity of the raw-FIFO to be set >= the maximum number of subtitle
 796             // lines that could be decoded prior to a video frame in order to prevent the following
 797             // deadlock condition:
 798             //   1. Subtitle decoder blocks trying to generate more subtitle lines than will fit in the FIFO.
 799             //   2. Blocks the processing of further subtitle packets read from the input stream.
 800             //   3. And that blocks the processing of any further video packets read from the input stream.
 801             //   4. And that blocks the sync work-object from running, which is needed to consume the subtitle lines in the raw-FIFO.
 802             // Since that number is unbounded, the FIFO must be made (effectively) unbounded in capacity.
 803             subtitle->fifo_raw  = hb_fifo_init( FIFO_UNBOUNDED, FIFO_UNBOUNDED_WAKE );
 804             subtitle->fifo_sync = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE );
 805             subtitle->fifo_out  = hb_fifo_init( FIFO_SMALL, FIFO_SMALL_WAKE );
 806
 807             if( (!job->indepth_scan || job->select_subtitle_config.force) &&
 808                 subtitle->source == VOBSUB ) {
 809                 /*
 810                  * Don't add threads for subtitles when we are scanning, unless
 811                  * looking for forced subtitles.
 812                  */
 813                 w = hb_get_work( WORK_DECVOBSUB );
 814                 w->fifo_in  = subtitle->fifo_in;
 815                 w->fifo_out = subtitle->fifo_raw;
 816                 w->subtitle = subtitle;
 817                 hb_list_add( job->list_work, w );
 818             }
 819
 820             if( !job->indepth_scan && subtitle->source == CC608SUB )
 821             {
 822                 w = hb_get_work( WORK_DECCC608 );
 823                 w->fifo_in  = subtitle->fifo_in;
 824                 w->fifo_out = subtitle->fifo_raw;
 825                 hb_list_add( job->list_work, w );
 826             }
 827
 828             if( !job->indepth_scan && subtitle->source == SRTSUB )
 829             {
 830                 w = hb_get_work( WORK_DECSRTSUB );
 831                 w->fifo_in  = subtitle->fifo_in;
 832                 w->fifo_out = subtitle->fifo_raw;
 833                 w->subtitle = subtitle;
 834                 hb_list_add( job->list_work, w );
 835             }
 836
 837             if( !job->indepth_scan && subtitle->source == UTF8SUB )
 838             {
 839                 w = hb_get_work( WORK_DECUTF8SUB );
 840                 w->fifo_in  = subtitle->fifo_in;
 841                 w->fifo_out = subtitle->fifo_raw;
 842                 hb_list_add( job->list_work, w );
 843             }
 844
 845             if( !job->indepth_scan && subtitle->source == TX3GSUB )
 846             {
 847                 w = hb_get_work( WORK_DECTX3GSUB );
 848                 w->fifo_in  = subtitle->fifo_in;
 849                 w->fifo_out = subtitle->fifo_raw;
 850                 hb_list_add( job->list_work, w );
 851             }
 852
 853             if( !job->indepth_scan && subtitle->source == SSASUB )
 854             {
 855                 w = hb_get_work( WORK_DECSSASUB );
 856                 w->fifo_in  = subtitle->fifo_in;
 857                 w->fifo_out = subtitle->fifo_raw;
 858                 w->subtitle = subtitle;
 859                 hb_list_add( job->list_work, w );
 860             }
 861
 862             if( !job->indepth_scan &&
 863                 subtitle->format == PICTURESUB
 864                 && subtitle->config.dest == PASSTHRUSUB )
 865             {
 866                 /*
 867                  * Passing through a subtitle picture, this will have to
 868                  * be rle encoded before muxing.
 869                  */
 870                 w = hb_get_work( WORK_ENCVOBSUB );
 871                 w->fifo_in  = subtitle->fifo_sync;
 872                 w->fifo_out = subtitle->fifo_out;
 873                 w->subtitle = subtitle;
 874                 hb_list_add( job->list_work, w );
 875             }
 876         }
 877     }
 878
 879     if( !job->indepth_scan )
 880     {
 881         for( i = 0; i < hb_list_count( title->list_audio ); i++ )
 882         {
 883             audio = hb_list_item( title->list_audio, i );
 884
 885             /*
 886             * Audio Decoder Thread
 887             */
 888             if ( audio->priv.fifo_in )
 889             {
 890                 if ( ( w = hb_codec_decoder( audio->config.in.codec ) ) == NULL )
 891                 {
 892                     hb_error("Invalid input codec: %d", audio->config.in.codec);
 893                     *job->die = 1;
 894                     goto cleanup;
 895                 }
 896                 w->fifo_in  = audio->priv.fifo_in;
 897                 w->fifo_out = audio->priv.fifo_raw;
 898                 w->config   = &audio->priv.config;
 899                 w->audio    = audio;
 900                 w->codec_param = audio->config.in.codec_param;
 901
 902                 hb_list_add( job->list_work, w );
 903             }
 904
 905             /*
 906             * Audio Encoder Thread
 907             */
 908             if( audio->config.out.codec != HB_ACODEC_AC3_PASS &&
 909                 audio->config.out.codec != HB_ACODEC_DCA_PASS )
 910             {
 911                 /*
 912                 * Add the encoder thread if not doing AC-3 pass through
 913                 */
 914                 if ( ( w = hb_codec_encoder( audio->config.out.codec ) ) == NULL )
 915                 {
 916                     hb_error("Invalid audio codec: %#x", audio->config.out.codec);
 917                     w = NULL;
 918                     *job->die = 1;
 919                     goto cleanup;
 920                 }
 921                 w->fifo_in  = audio->priv.fifo_sync;
 922                 w->fifo_out = audio->priv.fifo_out;
 923                 w->config   = &audio->priv.config;
 924                 w->audio    = audio;
 925
 926                 hb_list_add( job->list_work, w );
 927             }
 928         }
 929     }
 930
 931     if( job->chapter_markers && job->chapter_start == job->chapter_end )
 932     {
 933         job->chapter_markers = 0;
 934         hb_log("work: only 1 chapter, disabling chapter markers");
 935     }
 936
 937     /* Display settings */
 938     hb_display_job_info( job );
 939
 940     /* Init read & write threads */
 941     job->reader = hb_reader_init( job );
 942
 943
 944     job->done = 0;
 945
 946     /* Launch processing threads */
 947     for( i = 0; i < hb_list_count( job->list_work ); i++ )
 948     {
 949         w = hb_list_item( job->list_work, i );
 950         w->done = &job->done;
 951         w->thread_sleep_interval = 10;
 952         if( w->init( w, job ) )
 953         {
 954             hb_error( "Failure to initialise thread '%s'", w->name );
 955             *job->die = 1;
 956             goto cleanup;
 957         }
 958         w->thread = hb_thread_init( w->name, work_loop, w,
 959                                     HB_LOW_PRIORITY );
 960     }
 961
 962     if ( job->indepth_scan )
 963     {
 964         muxer = NULL;
 965         w = sync;
 966         sync->done = &job->done;
 967     }
 968     else
 969     {
 970         sync->done = &job->done;
 971         sync->thread_sleep_interval = 10;
 972         if( sync->init( w, job ) )
 973         {
 974             hb_error( "Failure to initialise thread '%s'", w->name );
 975             *job->die = 1;
 976             goto cleanup;
 977         }
 978         sync->thread = hb_thread_init( sync->name, work_loop, sync,
 979                                     HB_LOW_PRIORITY );
 980
 981         // The muxer requires track information that's set up by the encoder
 982         // init routines so we have to init the muxer last.
 983         muxer = hb_muxer_init( job );
 984         w = muxer;
 985     }
 986
 987     hb_buffer_t      * buf_in, * buf_out;
 988
 989     while ( !*job->die && !*w->done && w->status != HB_WORK_DONE )
 990     {
 991         buf_in = hb_fifo_get_wait( w->fifo_in );
 992         if ( buf_in == NULL )
 993             continue;
 994         if ( *job->die )
 995         {
 996             if( buf_in )
 997             {
 998                 hb_buffer_close( &buf_in );
 999             }
1000             break;
1001         }
1002
1003         buf_out = NULL;
1004         w->status = w->work( w, &buf_in, &buf_out );
1005
1006         if( buf_in )
1007         {
1008             hb_buffer_close( &buf_in );
1009         }
1010         if ( buf_out && w->fifo_out == NULL )
1011         {
1012             hb_buffer_close( &buf_out );
1013         }
1014         if( buf_out )
1015         {
1016             while ( !*job->die )
1017             {
1018                 if ( hb_fifo_full_wait( w->fifo_out ) )
1019                 {
1020                     hb_fifo_push( w->fifo_out, buf_out );
1021                     buf_out = NULL;
1022                     break;
1023                 }
1024             }
1025         }
1026     }
1027
1028     if ( buf_out )
1029     {
1030         hb_buffer_close( &buf_out );
1031     }
1032
1033     hb_handle_t * h = job->h;
1034     hb_state_t state;
1035     hb_get_state( h, &state );
1036
1037     hb_log("work: average encoding speed for job is %f fps", state.param.working.rate_avg);
1038
1039     job->done = 1;
1040     if( muxer != NULL )
1041     {
1042         muxer->close( muxer );
1043         free( muxer );
1044
1045         if( sync->thread != NULL )
1046         {
1047             hb_thread_close( &sync->thread );
1048             sync->close( sync );
1049         }
1050         free( sync );
1051     }
1052
1053 cleanup:
1054     /* Stop the write thread (thread_close will block until the muxer finishes) */
1055     job->done = 1;
1056
1057     /* Close work objects */
1058     while( ( w = hb_list_item( job->list_work, 0 ) ) )
1059     {
1060         hb_list_rem( job->list_work, w );
1061         if( w->thread != NULL )
1062         {
1063             hb_thread_close( &w->thread );
1064             w->close( w );
1065         }
1066         free( w );
1067     }
1068
1069     hb_list_close( &job->list_work );
1070
1071     /* Stop the read thread */
1072     if( job->reader != NULL )
1073         hb_thread_close( &job->reader );
1074
1075     /* Close fifos */
1076     hb_fifo_close( &job->fifo_mpeg2 );
1077     hb_fifo_close( &job->fifo_raw );
1078     hb_fifo_close( &job->fifo_sync );
1079     hb_fifo_close( &job->fifo_render );
1080     hb_fifo_close( &job->fifo_mpeg4 );
1081
1082     for (i=0; i < hb_list_count(title->list_subtitle); i++) {
1083         subtitle =  hb_list_item( title->list_subtitle, i);
1084         if( subtitle )
1085         {
1086             hb_fifo_close( &subtitle->fifo_in );
1087             hb_fifo_close( &subtitle->fifo_raw );
1088             hb_fifo_close( &subtitle->fifo_sync );
1089             hb_fifo_close( &subtitle->fifo_out );
1090         }
1091     }
1092     for( i = 0; i < hb_list_count( title->list_audio ); i++ )
1093     {
1094         audio = hb_list_item( title->list_audio, i );
1095         if( audio->priv.fifo_in != NULL )
1096             hb_fifo_close( &audio->priv.fifo_in );
1097         if( audio->priv.fifo_raw != NULL )
1098             hb_fifo_close( &audio->priv.fifo_raw );
1099         if( audio->priv.fifo_sync != NULL )
1100             hb_fifo_close( &audio->priv.fifo_sync );
1101         if( audio->priv.fifo_out != NULL )
1102             hb_fifo_close( &audio->priv.fifo_out );
1103     }
1104
1105     if( job->indepth_scan )
1106     {
1107         /*
1108          * Before closing the title print out our subtitle stats if we need to
1109          * Find the highest and lowest.
1110          */
1111         for( i=0; i < hb_list_count( title->list_subtitle ); i++ )
1112         {
1113             subtitle =  hb_list_item( title->list_subtitle, i );
1114
1115             hb_log( "Subtitle stream 0x%x '%s': %d hits (%d forced)",
1116                     subtitle->id, subtitle->lang, subtitle->hits,
1117                     subtitle->forced_hits );
1118
1119             if( subtitle->hits == 0 )
1120                 continue;
1121
1122             if( subtitle->hits > subtitle_highest )
1123             {
1124                 subtitle_highest = subtitle->hits;
1125                 subtitle_highest_id = subtitle->id;
1126             }
1127
1128             if( subtitle->hits < subtitle_lowest )
1129             {
1130                 subtitle_lowest = subtitle->hits;
1131                 subtitle_lowest_id = subtitle->id;
1132             }
1133
1134             if( subtitle->forced_hits > 0 )
1135             {
1136                 if( subtitle_forced_id == 0 )
1137                 {
1138                     subtitle_forced_id = subtitle->id;
1139                 }
1140             }
1141         }
1142
1143
1144         if( subtitle_forced_id )
1145         {
1146             /*
1147              * If there are any subtitle streams with forced subtitles
1148              * then select it in preference to the lowest.
1149              */
1150             subtitle_hit = subtitle_forced_id;
1151             hb_log("Found a subtitle candidate id 0x%x (contains forced subs)",
1152                    subtitle_hit);
1153         } else if( subtitle_lowest < subtitle_highest )
1154         {
1155             /*
1156              * OK we have more than one, and the lowest is lower,
1157              * but how much lower to qualify for turning it on by
1158              * default?
1159              *
1160              * Let's say 10% as a default.
1161              */
1162             if( subtitle_lowest < ( subtitle_highest * 0.1 ) )
1163             {
1164                 subtitle_hit = subtitle_lowest_id;
1165                 hb_log( "Found a subtitle candidate id 0x%x",
1166                         subtitle_hit );
1167             } else {
1168                 hb_log( "No candidate subtitle detected during subtitle-scan");
1169             }
1170         }
1171     }
1172
1173     if( job->indepth_scan )
1174     {
1175         for( i=0; i < hb_list_count( title->list_subtitle ); i++ )
1176         {
1177             subtitle =  hb_list_item( title->list_subtitle, i );
1178             if( subtitle->id == subtitle_hit )
1179             {
1180                 subtitle->config = job->select_subtitle_config;
1181                 hb_list_rem( title->list_subtitle, subtitle );
1182                 interjob->select_subtitle = subtitle;
1183                 break;
1184             }
1185         }
1186     }
1187
1188     if( job->filters )
1189     {
1190         for( i = 0; i < hb_list_count( job->filters ); i++ )
1191         {
1192             hb_filter_object_t * filter = hb_list_item( job->filters, i );
1193             hb_filter_close( &filter );
1194         }
1195         hb_list_close( &job->filters );
1196     }
1197
1198     hb_buffer_pool_free();
1199
1200     hb_title_close( &job->title );
1201     free( job );
1202 }
1203
1204 /**
1205  * Performs the work object's specific work function.
1206  * Loops calling work function for associated work object. Sleeps when fifo is full.
1207  * Monitors work done indicator.
1208  * Exits loop when work indiactor is set.
1209  * @param _w Handle to work object.
1210  */
1211 static void work_loop( void * _w )
1212 {
1213     hb_work_object_t * w = _w;
1214     hb_buffer_t      * buf_in, * buf_out;
1215
1216     while( !*w->done && w->status != HB_WORK_DONE )
1217     {
1218         buf_in = hb_fifo_get_wait( w->fifo_in );
1219         if ( buf_in == NULL )
1220             continue;
1221         if ( *w->done )
1222         {
1223             if( buf_in )
1224             {
1225                 hb_buffer_close( &buf_in );
1226             }
1227             break;
1228         }
1229
1230         // Invalidate buf_out so that if there is no output
1231         // we don't try to pass along junk.
1232         buf_out = NULL;
1233         w->status = w->work( w, &buf_in, &buf_out );
1234
1235         // Propagate any chapter breaks for the worker if and only if the
1236         // output frame has the same time stamp as the input frame (any
1237         // worker that delays frames has to propagate the chapter marks itself
1238         // and workers that move chapter marks to a different time should set
1239         // 'buf_in' to NULL so that this code won't generate spurious duplicates.)
1240         if( buf_in && buf_out && buf_in->new_chap && buf_in->start == buf_out->start)
1241         {
1242             // restore log below to debug chapter mark propagation problems
1243             //hb_log("work %s: Copying Chapter Break @ %"PRId64, w->name, buf_in->start);
1244             buf_out->new_chap = buf_in->new_chap;
1245         }
1246
1247         if( buf_in )
1248         {
1249             hb_buffer_close( &buf_in );
1250         }
1251         if ( buf_out && w->fifo_out == NULL )
1252         {
1253             hb_buffer_close( &buf_out );
1254         }
1255         if( buf_out )
1256         {
1257             while ( !*w->done )
1258             {
1259                 if ( hb_fifo_full_wait( w->fifo_out ) )
1260                 {
1261                     hb_fifo_push( w->fifo_out, buf_out );
1262                     buf_out = NULL;
1263                     break;
1264                 }
1265             }
1266         }
1267     }
1268     if ( buf_out )
1269     {
1270         hb_buffer_close( &buf_out );
1271     }
1272
1273     // Consume data in incoming fifo till job complete so that
1274     // residual data does not stall the pipeline
1275     while( !*w->done )
1276     {
1277         buf_in = hb_fifo_get_wait( w->fifo_in );
1278         if ( buf_in != NULL )
1279             hb_buffer_close( &buf_in );
1280     }
1281 }