Don't copy the frame before passing it to x264, let x264 look directly into our HB...

[handbrake-jp/handbrake-jp-git.git] / libhb / encx264.c

diff --git a/libhb/encx264.c b/libhb/encx264.c
index 0de2e9f..b7e08b8 100644 (file)
--- a/libhb/encx264.c
+++ b/libhb/encx264.c
@@ -23,18 +23,18 @@ hb_work_object_t hb_encx264 =
     encx264Close
 };
 
-// 16 is probably overkill but it's also the maximum for h.264 reference frames
-#define MAX_INFLIGHT_FRAMES 16
+#define DTS_BUFFER_SIZE 32 
 
 struct hb_work_private_s
 {
     hb_job_t       * job;
     x264_t         * x264;
     x264_picture_t   pic_in;
+    uint8_t         *x264_allocated_pic;
 
     // Internal queue of DTS start/stop values.
-    int64_t        dts_start[MAX_INFLIGHT_FRAMES];
-    int64_t        dts_stop[MAX_INFLIGHT_FRAMES];
+    int64_t        dts_start[DTS_BUFFER_SIZE];
+    int64_t        dts_stop[DTS_BUFFER_SIZE];
 
     int64_t        dts_write_index;
     int64_t        dts_read_index;
@@ -69,7 +69,16 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job )
     param.i_height     = job->height;
     param.i_fps_num    = job->vrate;
     param.i_fps_den    = job->vrate_base;
-    param.i_keyint_max = 20 * job->vrate / job->vrate_base;
+    
+    if (job->vrate_base != 1080000)
+    {
+        /* If the fps isn't 25, adjust the key intervals. Add 1 because
+           we want 24, not 23 with a truncated remainder.               */
+        param.i_keyint_min     = (job->vrate / job->vrate_base) + 1;
+        param.i_keyint_max = (10 * job->vrate / job->vrate_base) + 1;
+        hb_log("encx264: keyint-min: %i, keyint-max: %i", param.i_keyint_min, param.i_keyint_max);        
+    }
+    
     param.i_log_level  = X264_LOG_INFO;
     if( job->h264_level )
     {
@@ -99,8 +108,11 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job )
 
     if( job->x264opts != NULL && *job->x264opts != '\0' )
     {
-        char *x264opts = strdup(job->x264opts);
-        while( *x264opts )
+        char *x264opts, *x264opts_start;
+
+        x264opts = x264opts_start = strdup(job->x264opts);
+
+        while( x264opts_start && *x264opts )
         {
             char *name = x264opts;
             char *value;
@@ -161,7 +173,7 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job )
             if( ret == X264_PARAM_BAD_VALUE )
                 hb_log( "x264 options: Bad argument %s=%s", name, value ? value : "(null)" );
         }
-        free(x264opts);
+        free(x264opts_start);
     }
 
 
@@ -230,7 +242,9 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job )
     memcpy( &w->config->h264.pps[1], nal[2].p_payload, nal[2].i_payload );
 
     x264_picture_alloc( &pv->pic_in, X264_CSP_I420,
-            job->width, job->height );
+                        job->width, job->height );
+
+    pv->x264_allocated_pic = pv->pic_in.img.plane[0];
 
     pv->dts_write_index = 0;
     pv->dts_read_index = 0;
@@ -242,6 +256,11 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job )
 void encx264Close( hb_work_object_t * w )
 {
     hb_work_private_t * pv = w->private_data;
+    /*
+     * Patch the x264 allocated data back in so that x264 can free it
+     * we have been using our own buffers during the encode to avoid copying.
+     */
+    pv->pic_in.img.plane[0] = pv->x264_allocated_pic;
     x264_picture_clean( &pv->pic_in );
     x264_encoder_close( pv->x264 );
     free( pv );
@@ -263,8 +282,11 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
 
     if( in->data )
     {
-        /* XXX avoid this memcpy ? */
-        memcpy( pv->pic_in.img.plane[0], in->data, job->width * job->height );
+        /*
+         * Point x264 at our current buffers Y(UV) data.
+         */
+        pv->pic_in.img.plane[0] = in->data;
+
         if( job->grayscale )
         {
             /* XXX x264 has currently no option for grayscale encoding */
@@ -273,10 +295,12 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
         }
         else
         {
-            memcpy( pv->pic_in.img.plane[1], in->data + job->width * job->height,
-                    job->width * job->height / 4 );
-            memcpy( pv->pic_in.img.plane[2], in->data + 5 * job->width *
-                    job->height / 4, job->width * job->height / 4 );
+            /*
+             * Point x264 at our buffers (Y)UV data
+             */
+            pv->pic_in.img.plane[1] = in->data + job->width * job->height;
+            pv->pic_in.img.plane[2] = in->data + 5 * job->width *
+                job->height / 4;
         }
 
         if( in->new_chap && job->chapter_markers )
@@ -301,8 +325,8 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
         pv->pic_in.i_qpplus1 = 0;
 
         // Remember current PTS value, use as DTS later
-        pv->dts_start[pv->dts_write_index & (MAX_INFLIGHT_FRAMES-1)] = in->start;
-        pv->dts_stop[pv->dts_write_index & (MAX_INFLIGHT_FRAMES-1)]  = in->stop;
+        pv->dts_start[pv->dts_write_index & (DTS_BUFFER_SIZE-1)] = in->start;
+        pv->dts_stop[pv->dts_write_index & (DTS_BUFFER_SIZE-1)]  = in->stop;
         pv->dts_write_index++;
 
         /* Feed the input DTS to x264 so it can figure out proper output PTS */
@@ -342,8 +366,8 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
         int64_t dts_start, dts_stop;
 
         /* Get next DTS value to use */
-        dts_start = pv->dts_start[pv->dts_read_index & (MAX_INFLIGHT_FRAMES-1)];
-        dts_stop  = pv->dts_stop[pv->dts_read_index & (MAX_INFLIGHT_FRAMES-1)];
+        dts_start = pv->dts_start[pv->dts_read_index & (DTS_BUFFER_SIZE-1)];
+        dts_stop  = pv->dts_stop[pv->dts_read_index & (DTS_BUFFER_SIZE-1)];
         pv->dts_read_index++;
 
         for( i = 0; i < i_nal; i++ )