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