X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fwork.c;h=eea492b9c5a88060a443761c889af22d3faa2ccd;hb=e90d429b62c48a65174957cbe3bbac1a2f861ef3;hp=f4be983e3f08cb9bd85f23edce65c62a0a3bc5ed;hpb=13b34bcc04a2cea89b447ed61e74945ff3bb0e00;p=handbrake-jp%2Fhandbrake-jp-git.git

diff --git a/libhb/work.c b/libhb/work.c
index f4be983e..eea492b9 100644
--- a/libhb/work.c
+++ b/libhb/work.c
@@ -212,13 +212,9 @@ void hb_display_job_info( hb_job_t * job )
         {
             hb_log( "     + keeping source display aspect ratio"); 
         }
-        if( job->anamorphic.modulus != 16 )
-        {
-            hb_log( "     + modulus: %i", job->anamorphic.modulus ); 
-        }
-        hb_log( "     + storage dimensions: %d * %d -> %d * %d, crop %d/%d/%d/%d",
+        hb_log( "     + storage dimensions: %d * %d -> %d * %d, crop %d/%d/%d/%d, mod %i",
                     title->width, title->height, job->width, job->height,
-                    job->crop[0], job->crop[1], job->crop[2], job->crop[3] );
+                    job->crop[0], job->crop[1], job->crop[2], job->crop[3], job->modulus );
         if( job->anamorphic.itu_par )
         {
             hb_log( "     + using ITU pixel aspect ratio values"); 
@@ -385,6 +381,7 @@ static void do_job( hb_job_t * job, int cpu_count )
     hb_title_t    * title;
     int             i, j;
     hb_work_object_t * w;
+    hb_work_object_t * sync;
     hb_work_object_t * muxer;
     hb_interjob_t * interjob;
 
@@ -550,7 +547,6 @@ static void do_job( hb_job_t * job, int cpu_count )
             // So if the encoder is lame we need the output to be stereo (or multichannel
             // matrixed into stereo like dpl). If the decoder is not AC3 or DCA the
             // encoder has to handle the input format since we can't do a mixdown.
-#define CAN_MIXDOWN(a) ( a->config.in.codec & (HB_ACODEC_AC3|HB_ACODEC_DCA) )
 #define STEREO_ONLY(a) ( a->config.out.codec & HB_ACODEC_LAME )
 
             switch (audio->config.in.channel_layout & HB_INPUT_CH_LAYOUT_DISCRETE_NO_LFE_MASK)
@@ -570,16 +566,6 @@ static void do_job( hb_job_t * job, int cpu_count )
                 case HB_INPUT_CH_LAYOUT_MONO:
                     if ( STEREO_ONLY( audio ) )
                     {
-                        if ( !CAN_MIXDOWN( audio ) )
-                        {
-                            // XXX we're hosed - we can't mix up & lame can't handle
-                            // the input format. The user shouldn't be able to make
-                            // this choice. It's too late to do anything about it now
-                            // so complain in the log & let things abort in lame.
-                            hb_log( "ERROR - can't use lame mp3 audio output with "
-                                    "mono audio stream %x - output will be messed up",
-                                    audio->id );
-                        }
                         audio->config.out.mixdown = HB_AMIXDOWN_STEREO;
                     }
                     else
@@ -593,7 +579,7 @@ static void do_job( hb_job_t * job, int cpu_count )
                 // the A52 flags don't allow for a way to distinguish between DPL1 and
                 // DPL2 on a DVD so we always assume a DPL1 source for A52_DOLBY.
                 case HB_INPUT_CH_LAYOUT_DOLBY:
-                    if ( STEREO_ONLY( audio ) || !CAN_MIXDOWN( audio ) ||
+                    if ( STEREO_ONLY( audio ) ||
                          audio->config.out.mixdown > HB_AMIXDOWN_DOLBY )
                     {
                         audio->config.out.mixdown = HB_AMIXDOWN_DOLBY;
@@ -603,57 +589,31 @@ static void do_job( hb_job_t * job, int cpu_count )
                 // 4 channel discrete
                 case HB_INPUT_CH_LAYOUT_2F2R:
                 case HB_INPUT_CH_LAYOUT_3F1R:
-                    if ( CAN_MIXDOWN( audio ) )
-                    {
-                        if ( STEREO_ONLY( audio ) ||
-                             audio->config.out.mixdown > HB_AMIXDOWN_DOLBY )
-                        {
-                            audio->config.out.mixdown = HB_AMIXDOWN_DOLBY;
-                        }
-                    }
-                    else
+                    if ( STEREO_ONLY( audio ) ||
+                         audio->config.out.mixdown > HB_AMIXDOWN_DOLBY )
                     {
-                        // XXX we can't mixdown & don't have any way to specify
-                        // 4 channel discrete output so we're hosed.
-                        hb_log( "ERROR - can't handle 4 channel discrete audio stream "
-                                "%x - output will be messed up", audio->id );
+                        audio->config.out.mixdown = HB_AMIXDOWN_DOLBY;
                     }
                     break;
 
                 // 5 or 6 channel discrete
                 case HB_INPUT_CH_LAYOUT_3F2R:
-                    if ( CAN_MIXDOWN( audio ) )
+                    if ( STEREO_ONLY( audio ) )
                     {
-                        if ( STEREO_ONLY( audio ) )
+                        if ( audio->config.out.mixdown < HB_AMIXDOWN_STEREO )
                         {
-                            if ( audio->config.out.mixdown < HB_AMIXDOWN_STEREO )
-                            {
-                                audio->config.out.mixdown = HB_AMIXDOWN_STEREO;
-                            }
-                            else if ( audio->config.out.mixdown > HB_AMIXDOWN_DOLBYPLII )
-                            {
-                                audio->config.out.mixdown = HB_AMIXDOWN_DOLBYPLII;
-                            }
+                            audio->config.out.mixdown = HB_AMIXDOWN_STEREO;
                         }
-                        else if ( ! ( audio->config.in.channel_layout &
-                                        HB_INPUT_CH_LAYOUT_HAS_LFE ) )
+                        else if ( audio->config.out.mixdown > HB_AMIXDOWN_DOLBYPLII )
                         {
-                            // we don't do 5 channel discrete so mixdown to DPLII
                             audio->config.out.mixdown = HB_AMIXDOWN_DOLBYPLII;
                         }
                     }
                     else if ( ! ( audio->config.in.channel_layout &
-                                        HB_INPUT_CH_LAYOUT_HAS_LFE ) )
+                                    HB_INPUT_CH_LAYOUT_HAS_LFE ) )
                     {
-                        // XXX we can't mixdown & don't have any way to specify
-                        // 5 channel discrete output so we're hosed.
-                        hb_log( "ERROR - can't handle 5 channel discrete audio stream "
-                                "%x - output will be messed up", audio->id );
-                    }
-                    else
-                    {
-                        // we can't mixdown so force 6 channel discrete
-                        audio->config.out.mixdown = HB_AMIXDOWN_6CH;
+                        // we don't do 5 channel discrete so mixdown to DPLII
+                        audio->config.out.mixdown = HB_AMIXDOWN_DOLBYPLII;
                     }
                     break;
             }
@@ -682,12 +642,7 @@ static void do_job( hb_job_t * job, int cpu_count )
 
     }
     /* Synchronization */
-    if( hb_sync_init( job ) )
-    {
-        hb_error( "Failure to initialise sync" );
-        *job->die = 1;
-        goto cleanup;
-    }
+    sync = hb_sync_init( job );
 
     /* Video decoder */
     int vcodec = title->video_codec? title->video_codec : WORK_DECMPEG2;
@@ -699,7 +654,10 @@ static void do_job( hb_job_t * job, int cpu_count )
     /* Video renderer */
     hb_list_add( job->list_work, ( w = hb_get_work( WORK_RENDER ) ) );
     w->fifo_in  = job->fifo_sync;
-    w->fifo_out = job->fifo_render;
+    if( !job->indepth_scan )
+        w->fifo_out = job->fifo_render;
+    else
+        w->fifo_out = NULL;
 
     if( !job->indepth_scan )
     {
@@ -758,6 +716,7 @@ static void do_job( hb_job_t * job, int cpu_count )
                     *subtitle = *(interjob->select_subtitle);
                     free( interjob->select_subtitle );
                     interjob->select_subtitle = NULL;
+                    break;
                 }
             }
         }
@@ -883,6 +842,12 @@ static void do_job( hb_job_t * job, int cpu_count )
             }
         }
     }
+    
+    if( job->chapter_markers && job->chapter_start == job->chapter_end )
+    {
+        job->chapter_markers = 0;
+        hb_log("work: only 1 chapter, disabling chapter markers");
+    }
 
     /* Display settings */
     hb_display_job_info( job );
@@ -894,7 +859,7 @@ static void do_job( hb_job_t * job, int cpu_count )
     job->done = 0;
 
     /* Launch processing threads */
-    for( i = 1; i < hb_list_count( job->list_work ); i++ )
+    for( i = 0; i < hb_list_count( job->list_work ); i++ )
     {
         w = hb_list_item( job->list_work, i );
         w->done = &job->done;
@@ -909,12 +874,32 @@ static void do_job( hb_job_t * job, int cpu_count )
                                     HB_LOW_PRIORITY );
     }
 
-    // The muxer requires track information that's set up by the encoder
-    // init routines so we have to init the muxer last.
-    muxer = job->indepth_scan? NULL : hb_muxer_init( job );
+    if ( job->indepth_scan )
+    {
+        muxer = NULL;
+        w = sync;
+        sync->done = &job->done;
+    }
+    else
+    {
+        sync->done = &job->done;
+        sync->thread_sleep_interval = 10;
+        if( sync->init( w, job ) )
+        {
+            hb_error( "Failure to initialise thread '%s'", w->name );
+            *job->die = 1;
+            goto cleanup;
+        }
+        sync->thread = hb_thread_init( sync->name, work_loop, sync,
+                                    HB_LOW_PRIORITY );
 
-    w = hb_list_item( job->list_work, 0 );
-    while( !*job->die && w->status != HB_WORK_DONE )
+        // The muxer requires track information that's set up by the encoder
+        // init routines so we have to init the muxer last.
+        muxer = hb_muxer_init( job );
+        w = muxer;
+    }
+
+    while ( !*job->die && !*w->done && w->status != HB_WORK_DONE )
     {
         hb_buffer_t      * buf_in, * buf_out;
 
@@ -930,20 +915,43 @@ static void do_job( hb_job_t * job, int cpu_count )
             break;
         }
 
+        buf_out = NULL;
         w->status = w->work( w, &buf_in, &buf_out );
 
         if( buf_in )
         {
             hb_buffer_close( &buf_in );
         }
+        if ( buf_out && w->fifo_out == NULL )
+        {
+            hb_buffer_close( &buf_out );
+        }
         if( buf_out )
         {
-            hb_fifo_push_wait( w->fifo_out, buf_out );
+            while ( !*job->die )
+            {
+                if ( hb_fifo_full_wait( w->fifo_out ) )
+                {
+                    hb_fifo_push( w->fifo_out, buf_out );
+                    break;
+                }
+            }
+        }
+    }
+
+    job->done = 1;
+    if( muxer != NULL )
+    {
+        muxer->close( muxer );
+        free( muxer );
+
+        if( sync->thread != NULL )
+        {
+            hb_thread_close( &sync->thread );
+            sync->close( sync );
         }
+        free( sync );
     }
-    hb_list_rem( job->list_work, w );
-    w->close( w );
-    free( w );
 
     hb_handle_t * h = job->h;
     hb_state_t state;
@@ -953,12 +961,6 @@ static void do_job( hb_job_t * job, int cpu_count )
 
 cleanup:
     /* Stop the write thread (thread_close will block until the muxer finishes) */
-    if( muxer != NULL )
-    {
-        hb_thread_close( &muxer->thread );
-        muxer->close( muxer );
-    }
-
     job->done = 1;
 
     /* Close work objects */
@@ -1144,7 +1146,7 @@ static void work_loop( void * _w )
         if( buf_in && buf_out && buf_in->new_chap && buf_in->start == buf_out->start)
         {
             // restore log below to debug chapter mark propagation problems
-            //hb_log("work %s: Copying Chapter Break @ %lld", w->name, buf_in->start);
+            //hb_log("work %s: Copying Chapter Break @ %"PRId64, w->name, buf_in->start);
             buf_out->new_chap = buf_in->new_chap;
         }
 
@@ -1152,9 +1154,28 @@ static void work_loop( void * _w )
         {
             hb_buffer_close( &buf_in );
         }
+        if ( buf_out && w->fifo_out == NULL )
+        {
+            hb_buffer_close( &buf_out );
+        }
         if( buf_out )
         {
-            hb_fifo_push_wait( w->fifo_out, buf_out );
+            while ( !*w->done )
+            {
+                if ( hb_fifo_full_wait( w->fifo_out ) )
+                {
+                    hb_fifo_push( w->fifo_out, buf_out );
+                    break;
+                }
+            }
         }
     }
+    // Consume data in incoming fifo till job complete so that
+    // residual data does not stall the pipeline
+    while( !*w->done )
+    {
+        buf_in = hb_fifo_get_wait( w->fifo_in );
+        if ( buf_in != NULL )
+            hb_buffer_close( &buf_in );
+    }
 }