Subversion Repositories oc-h264-encoder

diff -Naur --exclude=.git --exclude=.gitignore x264/common/common.c x264-or/common/common.c

--- x264/common/common.c        2009-10-25 17:41:22.000000000 +0100

+++ x264-or/common/common.c     2009-10-28 15:05:29.000000000 +0100

@@ -764,8 +764,10 @@

     align_buf = malloc( i_size );

 #elif defined( HAVE_MALLOC_H )

     align_buf = memalign( 16, i_size );

+    //fprintf(stderr, "memalign, result addr: 0x%.8x\n", (unsigned int) align_buf);

 #else

     uint8_t *buf = malloc( i_size + 15 + sizeof(void **) + sizeof(int) );

+    //fprintf(stderr, "malloc, result addr: 0x%.8x\n", (unsigned int) buf);

     if( buf )

     {

         align_buf = buf + 15 + sizeof(void **) + sizeof(int);

diff -Naur --exclude=.git --exclude=.gitignore x264/common/common.h x264-or/common/common.h

--- x264/common/common.h        2009-10-25 17:41:22.000000000 +0100

+++ x264-or/common/common.h     2009-11-10 22:42:24.000000000 +0100

@@ -51,7 +51,8 @@

 #define X264_BFRAME_MAX 16

 #define X264_THREAD_MAX 128

 #define X264_PCM_COST (386*8)

-#define X264_LOOKAHEAD_MAX 250

+//#define X264_LOOKAHEAD_MAX 250

+#define X264_LOOKAHEAD_MAX 140

 // arbitrary, but low because SATD scores are 1/4 normal

 #define X264_LOOKAHEAD_QP 12

@@ -260,7 +261,7 @@

  */

 #define X264_SCAN8_SIZE (6*8)

 #define X264_SCAN8_0 (4+1*8)

-

+/* this array indicates the position in the */

 static const int x264_scan8[16+2*4+3] =

 {

     /* Luma */

@@ -518,7 +519,9 @@

             /* space for p_fenc and p_fdec */

 #define FENC_STRIDE 16

 #define FDEC_STRIDE 32

-            ALIGNED_16( uint8_t fenc_buf[24*FENC_STRIDE] );

+         /* comment regarding FDEC_STRIDE: the catch with fdec is that the chroma blocks must be aligned to 8 and the luma blocks must be aligned to 16 but we need to have pixels on the left side for prediction so we have a lot of padding on the left side. so for luma: X X X X X X X X X X X X X X X L _ _ _ _ _ ... where X are junk, L is the left pixel, _ are normal pixels, so 32 wide total */

+

+         ALIGNED_16( uint8_t fenc_buf[24*FENC_STRIDE] ); /* FENC stores both Y, U, and V, 16x16 + 8x8 + 8x8 = 24 * 16*/

             ALIGNED_16( uint8_t fdec_buf[27*FDEC_STRIDE] );

             /* i4x4 and i8x8 backup data, for skipping the encode stage when possible */

@@ -551,9 +554,29 @@

             /* pointer over mb of the references */

             int i_fref[2];

-            uint8_t *p_fref[2][32][4+2]; /* last: lN, lH, lV, lHV, cU, cV */

-            uint16_t *p_integral[2][16];

-

+            uint8_t *p_fref[2][32][4+2]; /* last: 4hpel pointers, 2 chroma pointers: lN (normal), lH (horizontally interpolated), lV (vertically interpolated), lHV (center position), cU (chroma U), cV (chroma V)

+                                           Important!: This is our post-motion compensation frame data, stored in half-pixel (hpel) resolution.

+                                           During motion compensation, hpel data is calculated via  6-tap FIR filter (very similar to Lanczos). It is an even filter (even function) so every input pixel corresponds to 4 output pixels

+                                           one of those 4 is equal to the input, so the data contains one fullpel pixel, one H, one V, one C (aka HV)

+                                           From this data, qpel is calculated via interpolation, which is easy and quick to do.

+                                           F 0 H 1 F

+                                           2 3 4 5 6

+                                           V 7 C 8 V

+                                           9 A B C D

+                                           F _ H _ F

+                                           Here 0 is the average of F and H

+                                           2 is the average of F and V

+                                           3 is the average of H and V

+                                           4 is the average of H and C

+                                           etc.

+                                           So each qpel position is the result of averaging two known hpel positions.*/

+         uint16_t *p_integral[2][16]; /* pointers to "integral": for each position X,Y, it's the sum of values in an 8x8 block with that point X,Y as the upper left of that block

+                                         Discussion on this value:

+                                         < pengvado> Dark_Shikari: "sum of values in an 8x8 block" is what I would call "dc". the variable name comes because it used to be an indefinite integral, i.e. the sum of everything above and to the left of that point.

+                                         < pengvado> but if you're only interested in 16x16, 16x8, 8x16, and 8x8, then caching 8x8 dcs is strictly faster

+                                      */

+

+

             /* fref stride */

             int     i_stride[3];

         } pic;

diff -Naur --exclude=.git --exclude=.gitignore x264/common/frame.c x264-or/common/frame.c

--- x264/common/frame.c 2009-10-25 17:41:10.000000000 +0100

+++ x264-or/common/frame.c      2009-10-28 15:05:29.000000000 +0100

@@ -31,6 +31,8 @@

     x264_frame_t *frame;

     int i, j;

+    //V(fprintf(stderr, "x264_frame_new\n"));

+

     int i_mb_count = h->mb.i_mb_count;

     int i_stride, i_width, i_lines;

     int i_padv = PADV << h->param.b_interlaced;

@@ -981,11 +983,14 @@

 x264_frame_t *x264_frame_pop_unused( x264_t *h, int b_fdec )

 {

+  //V(fprintf(stderr, "x264_frame_pop_unused\n"));

     x264_frame_t *frame;

     if( h->frames.unused[b_fdec][0] )

         frame = x264_frame_pop( h->frames.unused[b_fdec] );

     else

         frame = x264_frame_new( h, b_fdec );

+

+    //V(fprintf(stderr, "x264_frame_pop_unused: frame ptr = 0x%.8x\n", (unsigned long) frame));

     if( !frame )

         return NULL;

     frame->b_last_minigop_bframe = 0;

diff -Naur --exclude=.git --exclude=.gitignore x264/common/macroblock.c x264-or/common/macroblock.c

--- x264/common/macroblock.c    2009-10-25 17:41:22.000000000 +0100

+++ x264-or/common/macroblock.c 2009-11-09 13:02:31.000000000 +0100

@@ -118,7 +118,7 @@

     int i_count = 0;

-    if( i_refc == -2 )

+    if( i_refc == -2 )/* -2 = unavailable */

     {

         i_refc = h->mb.cache.ref[i_list][X264_SCAN8_0 - 8 - 1];

         mv_c   = h->mb.cache.mv[i_list][X264_SCAN8_0 - 8 - 1];

diff -Naur --exclude=.git --exclude=.gitignore x264/common/mdate.c x264-or/common/mdate.c

--- x264/common/mdate.c 2009-10-25 17:41:10.000000000 +0100

+++ x264-or/common/mdate.c      2009-10-28 15:05:29.000000000 +0100

@@ -32,9 +32,12 @@

 int64_t x264_mdate( void )

 {

 #ifndef __MINGW32__

+  /* --jb

     struct timeval tv_date;

     gettimeofday( &tv_date, NULL );

     return( (int64_t) tv_date.tv_sec * 1000000 + (int64_t) tv_date.tv_usec );

+  */

+  return 0;

 #else

     struct _timeb tb;

     _ftime(&tb);

diff -Naur --exclude=.git --exclude=.gitignore x264/common/pixel.c x264-or/common/pixel.c

--- x264/common/pixel.c 2009-10-25 17:41:10.000000000 +0100

+++ x264-or/common/pixel.c      2009-10-28 15:05:29.000000000 +0100

@@ -22,6 +22,7 @@

  *****************************************************************************/

 #include "common.h"

+#include "x264.h"

 #ifdef HAVE_MMX

 #   include "x86/pixel.h"

@@ -40,6 +41,7 @@

 /****************************************************************************

  * pixel_sad_WxH

  ****************************************************************************/

+/*  V(fprintf(stderr, "pixel_sad %d x %d, *pix1: 0x%.8x *pix2: 0x%.8x i_stride_pix1: %d i_stride_pix2: %d\n", lx, ly, (unsigned long) pix1, (unsigned long) pix2, i_stride_pix1, i_stride_pix2)); \*/

 #define PIXEL_SAD_C( name, lx, ly ) \

 static int name( uint8_t *pix1, int i_stride_pix1,  \

                  uint8_t *pix2, int i_stride_pix2 ) \

@@ -387,6 +389,7 @@

 /****************************************************************************

  * pixel_sad_x4

+ * Debug printf :   V(fprintf(stderr, "x264_pixel_sadx4 size : *fenc: 0x%.8x *pix0: 0x%.8x *pix1: 0x%.8x *pix2: 0x%.8x *pix3: 0x%.8x i_stride: %d  *scores: 0x%.8x\n", (unsigned long) fenc, (unsigned long) pix0, (unsigned long) pix1, (unsigned long)pix2, (unsigned long)pix3, i_stride, (unsigned long) scores)); \

  ****************************************************************************/

 #define SAD_X( size ) \

 static void x264_pixel_sad_x3_##size( uint8_t *fenc, uint8_t *pix0, uint8_t *pix1, uint8_t *pix2, int i_stride, int scores[3] )\

diff -Naur --exclude=.git --exclude=.gitignore x264/configure x264-or/configure

--- x264/configure      2009-10-25 17:41:10.000000000 +0100

+++ x264-or/configure   2009-10-28 15:05:29.000000000 +0100

@@ -29,7 +29,7 @@

     rm -f conftest.c

     [ -n "$1" ] && echo "#include <$1>" > conftest.c

     echo "int main () { $3 return 0; }" >> conftest.c

-    $CC conftest.c $CFLAGS $LDFLAGS $2 -o conftest 2>$DEVNULL

+    $CC conftest.c $CFLAGS $LDFLAGS $2 -o conftest #2>$DEVNULL

 }

 as_check() {

diff -Naur --exclude=.git --exclude=.gitignore x264/encoder/analyse.c x264-or/encoder/analyse.c

--- x264/encoder/analyse.c      2009-10-25 17:41:10.000000000 +0100

+++ x264-or/encoder/analyse.c   2009-11-09 13:11:23.000000000 +0100

@@ -27,6 +27,7 @@

 #include <unistd.h>

 #include "common/common.h"

+#include "x264.h"

 #include "common/cpu.h"

 #include "macroblock.h"

 #include "me.h"

@@ -34,6 +35,7 @@

 #include "analyse.h"

 #include "rdo.c"

+

 typedef struct

 {

     /* 16x16 */

@@ -233,40 +235,75 @@

     5, 3, 3, 1

 };

+extern const float x264_analyse_init_log2_array[]; //jb

+

 static void x264_analyse_update_cache( x264_t *h, x264_mb_analysis_t *a );

 static uint16_t x264_cost_ref[92][3][33];

 static x264_pthread_mutex_t cost_ref_mutex = X264_PTHREAD_MUTEX_INITIALIZER;

+/*

+float log2f( float n )

+{

+// log(n)/log(2) is log2.

+//return log10( n ) / log10( 2 );

+  return (float) (log( n ) / _M_LOG2_E);

+}

+*/

 int x264_analyse_init_costs( x264_t *h, int qp )

 {

     int i, j;

     int lambda = x264_lambda_tab[qp];

+    float tmp_f,lambda_f = lambda;

+

     if( h->cost_mv[lambda] )

         return 0;

+

+    fprintf( stderr,

+            "x264_analyse_init_costs: lambda (= x264_lambda_tab[%d])  = %d\n",

+            qp, lambda);

+

     /* factor of 4 from qpel, 2 from sign, and 2 because mv can be opposite from mvp */

     CHECKED_MALLOC( h->cost_mv[lambda], (4*4*2048 + 1) * sizeof(uint16_t) );

+

     h->cost_mv[lambda] += 2*4*2048;

+

+    /* Computationally expensive thing: logs, floating point math, much of -- jb*/

     for( i = 0; i <= 2*4*2048; i++ )

-    {

-        h->cost_mv[lambda][-i] =

-        h->cost_mv[lambda][i]  = lambda * (log2f(i+1)*2 + 0.718f + !!i) + .5f;

-    }

+      {

+

+         //h->cost_mv[lambda][i]  = lambda * (log2f(i+1)*2 + 0.718f + !!i) + .5f;

+         //h->cost_mv[lambda][i]  = lambda * (log2(i+1)*2 + 0.718f + !!i) + .5f;

+

+       // precalulated array, doing the above few calculations for us

+       tmp_f = lambda_f * x264_analyse_init_log2_array[i];

+       tmp_f += .5f;

+       h->cost_mv[lambda][-i] =

+         h->cost_mv[lambda][i]  = tmp_f;

+

+

+      }

     x264_pthread_mutex_lock( &cost_ref_mutex );

+

     for( i = 0; i < 3; i++ )

-        for( j = 0; j < 33; j++ )

-            x264_cost_ref[lambda][i][j] = i ? lambda * bs_size_te( i, j ) : 0;

+      for( j = 0; j < 33; j++ )

+       x264_cost_ref[lambda][i][j] = i ? lambda * bs_size_te( i, j ) : 0;

+

     x264_pthread_mutex_unlock( &cost_ref_mutex );

+

+    /* for now, disable -- jb

     if( h->param.analyse.i_me_method >= X264_ME_ESA && !h->cost_mv_fpel[lambda][0] )

-    {

+      {

+       printf("analyse_init_costs: h->param.analyse.i_me_method >= X264_ME_ESA && !h->cost_mv_fpel[lambda][0]\n");

         for( j=0; j<4; j++ )

-        {

+         {

             CHECKED_MALLOC( h->cost_mv_fpel[lambda][j], (4*2048 + 1) * sizeof(uint16_t) );

             h->cost_mv_fpel[lambda][j] += 2*2048;

             for( i = -2*2048; i < 2*2048; i++ )

-                h->cost_mv_fpel[lambda][j][i] = h->cost_mv[lambda][i*4+j];

+             h->cost_mv_fpel[lambda][j][i] = h->cost_mv[lambda][i*4+j];

         }

     }

+    */

     return 0;

 fail:

     return -1;

@@ -288,6 +325,7 @@

 /* initialize an array of lambda*nbits for all possible mvs */

 static void x264_mb_analyse_load_costs( x264_t *h, x264_mb_analysis_t *a )

 {

+  //V(fprintf(stderr, "x264_mb_analyse_load_costs() called\n"));

     a->p_cost_mv = h->cost_mv[a->i_lambda];

     a->p_cost_ref0 = x264_cost_ref[a->i_lambda][x264_clip3(h->sh.i_num_ref_idx_l0_active-1,0,2)];

     a->p_cost_ref1 = x264_cost_ref[a->i_lambda][x264_clip3(h->sh.i_num_ref_idx_l1_active-1,0,2)];

@@ -1161,6 +1199,7 @@

     (m)->p_fenc[1] = &(src)[1][((xoff)>>1)+((yoff)>>1)*FENC_STRIDE]; \

     (m)->p_fenc[2] = &(src)[2][((xoff)>>1)+((yoff)>>1)*FENC_STRIDE];

+

 #define LOAD_HPELS(m, src, list, ref, xoff, yoff) \

     (m)->p_fref[0] = &(src)[0][(xoff)+(yoff)*(m)->i_stride[0]]; \

     (m)->p_fref[1] = &(src)[1][(xoff)+(yoff)*(m)->i_stride[0]]; \

@@ -1183,20 +1222,35 @@

     /* 16x16 Search on all ref frame */

     m.i_pixel = PIXEL_16x16;

-    m.p_cost_mv = a->p_cost_mv;

-    LOAD_FENC( &m, h->mb.pic.p_fenc, 0, 0 );

+    m.p_cost_mv = a->p_cost_mv; /* where a->p_cost_mv = h->cost_mv[a->i_lambda] from x264_mb_analyse_init(). a->i_lambda related to qp of MB, and h->cost_mv[] calculated at beginning in x264_mb_analyse_local_costs() */

+    /* LOAD_FENC(m, src, xoff, yoff) :

+       h->mb.pic.p_fenc: pointer over mb of the frame to be compressed, i think array of 3 pointers, one each to Y, Cb, Cr data.

+       x264_me_t m is loaded with appropriate stride variables, and pointers to the appropriate pixels

+       Essentially loads the me struct with stride and offsets, this is done in a macro because it's  convenient

+       because the many partitions can use the same macro to setup x264_me_t struct

+     */

+    LOAD_FENC( &m, h->mb.pic.p_fenc, 0, 0 );

+    //printf("x264_mb_analyse_inter_p16x16: m.i_stride[0]: %d\n",m.i_stride[0]);

+    //printf("x264_mb_analyse_inter_p16x16: m.i_stride[1]: %d\n",m.i_stride[1]);

+    //usually m.i_stride[0] is 416 and m.i_stride[1] is 208  -- jb

     a->l0.me16x16.cost = INT_MAX;

+

+    //printf("x264_mb_analyse_inter_p16x16: h->mb.pic.i_fref[0] = %d\n",h->mb.pic.i_fref[0]);

+

+    // Usually just the single reference frame here

     for( i_ref = 0; i_ref < h->mb.pic.i_fref[0]; i_ref++ )

     {

-        const int i_ref_cost = REF_COST( 0, i_ref );

-        i_halfpel_thresh -= i_ref_cost;

+      const int i_ref_cost = REF_COST( 0, i_ref ); /* looks in a->p_cost_ref0/1[], which is set in x264_mb_analyse_load_costs() */

+      i_halfpel_thresh -= i_ref_cost;

         m.i_ref_cost = i_ref_cost;

         m.i_ref = i_ref;

         /* search with ref */

-        LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref, 0, 0 );

-        x264_mb_predict_mv_16x16( h, 0, i_ref, m.mvp );

+       /*          m,             src,           list, ref, xoff, yoff */

+        LOAD_HPELS( &m, h->mb.pic.p_fref[0][i_ref], 0, i_ref,  0 ,   0 );

+       /*                        h,i_list, i_ref, int16_t mvp[2] */

+        x264_mb_predict_mv_16x16( h,     0, i_ref, m.mvp         );

         x264_mb_predict_mv_ref16x16( h, 0, i_ref, mvc, &i_mvc );

         x264_me_search_ref( h, &m, mvc, i_mvc, p_halfpel_thresh );

diff -Naur --exclude=.git --exclude=.gitignore x264/encoder/analyse_gen_init_array.sh x264-or/encoder/analyse_gen_init_array.sh

--- x264/encoder/analyse_gen_init_array.sh      1970-01-01 01:00:00.000000000 +0100

+++ x264-or/encoder/analyse_gen_init_array.sh   2009-10-28 15:05:29.000000000 +0100

@@ -0,0 +1,32 @@

+#!/bin/bash

+# Pre-generate an array of numbers according to the algorithm from analyse_init_costs()

+# to speedup calculation. Here we calculate the stuff in brackets:

+# lambda * (log2f(i+1)*2 + 0.718f + !!i) + .5f;

+outfile=analyse_init_log2.c

+

+echo; echo "Generating analyse_init_log2_array[] to $outfile"

+echo "This may take a minute or two..."

+

+#Size of the array: 4*2*2048

+numvals=16384

+

+rm  -f $outfile

+

+echo "const float x264_analyse_init_log2_array[] = {" >> $outfile

+

+n=0

+

+    for num in `seq 1 $numvals`;

+    do

+# Use bc to do the calculation, scale down to the output to one decimal place

+       newnum=`echo "a=((l($num)/l(2))*2)+1.718; scale=1; a=(a*2)/2; a" | bc -l`

+       echo -n $newnum >> $outfile

+       if [ $num -lt $numvals ]; then echo -n ", " >> $outfile; fi;

+       # Newline every 16 values

+       let "n = $num % 16"

+       if [ $n -eq 0 ]; then echo >> $outfile; fi;

+    done

+echo "};" >> $outfile

+

+echo "finished"

+echo

diff -Naur --exclude=.git --exclude=.gitignore x264/encoder/encoder.c x264-or/encoder/encoder.c

--- x264/encoder/encoder.c      2009-10-25 17:41:22.000000000 +0100

+++ x264-or/encoder/encoder.c   2009-10-28 15:05:29.000000000 +0100

@@ -62,6 +62,9 @@

 static void x264_frame_dump( x264_t *h )

 {

+  //printf("frame_dump()\n");

+  return;

+

     FILE *f = fopen( h->param.psz_dump_yuv, "r+b" );

     int i, y;

     if( !f )

@@ -301,6 +304,7 @@

     if( ( h->param.b_cabac && (h->cabac.p_end - h->cabac.p < 2500) )

      || ( h->out.bs.p_end - h->out.bs.p < 2500 ) )

     {

+      //V(fprintf(stderr, "x264_bitstream_check_buffer: h->out.bs.p = 0x%.8x, h->out.bs.p_end = 0x%.8x\n",h->out.bs.p_end, h->out.bs.p ));

         intptr_t delta;

         int i;

@@ -695,6 +699,8 @@

 static void mbcmp_init( x264_t *h )

 {

     int satd = !h->mb.b_lossless && h->param.analyse.i_subpel_refine > 1;

+    //V(if (satd)fprintf(stderr, "macroblock compare functions. satd enabled\n"));

+    //V(if (!satd)fprintf(stderr, "macroblock compare functions. satd not enabled\n"));

     memcpy( h->pixf.mbcmp, satd ? h->pixf.satd : h->pixf.sad_aligned, sizeof(h->pixf.mbcmp) );

     memcpy( h->pixf.mbcmp_unaligned, satd ? h->pixf.satd : h->pixf.sad, sizeof(h->pixf.mbcmp_unaligned) );

     h->pixf.intra_mbcmp_x3_16x16 = satd ? h->pixf.intra_satd_x3_16x16 : h->pixf.intra_sad_x3_16x16;

@@ -750,15 +756,14 @@

     x264_t *h;

     char buf[1000], *p;

     int i, qp, i_slicetype_length;

-

+

     CHECKED_MALLOCZERO( h, sizeof(x264_t) );

-

+

     /* Create a copy of param */

     memcpy( &h->param, param, sizeof(x264_param_t) );

-

     if( param->param_free )

         param->param_free( param );

-

+

     if( x264_validate_parameters( h ) < 0 )

         goto fail;

@@ -772,7 +777,7 @@

         h->param.rc.psz_stat_in = strdup( h->param.rc.psz_stat_in );

     x264_set_aspect_ratio( h, param, 1 );

-

+

     x264_reduce_fraction( &h->param.i_fps_num, &h->param.i_fps_den );

     /* Init x264_t */

@@ -831,8 +836,8 @@

     h->i_ref0 = 0;

     h->i_ref1 = 0;

-    x264_rdo_init();

-

+    x264_rdo_init();

+

     /* init CPU functions */

     x264_predict_16x16_init( h->param.cpu, h->predict_16x16 );

     x264_predict_8x8c_init( h->param.cpu, h->predict_8x8c );

@@ -870,17 +875,25 @@

         p += sprintf( p, " none!" );

     x264_log( h, X264_LOG_INFO, "%s\n", buf );

+    /* // should skip during cycle accurate -- jb    */

+    // Check the different quantisation points and their costs

     for( qp = h->param.rc.i_qp_min; qp <= h->param.rc.i_qp_max; qp++ )

+      {

+       //printf("%d\n", qp);

         if( x264_analyse_init_costs( h, qp ) )

-            goto fail;

+         goto fail;

+      }

     if( x264_analyse_init_costs( h, X264_LOOKAHEAD_QP ) )

         goto fail;

     if( h->cost_mv[1][2013] != 24 )

-    {

+      {

+       //fprintf(stderr, "h->cost_mv[1][2013] = %d\n",h->cost_mv[1][2013]);

         x264_log( h, X264_LOG_ERROR, "MV cost test failed: x264 has been miscompiled!\n" );

         goto fail;

     }

+    //exit(0); // jb

+

     h->out.i_nal = 0;

     h->out.i_bitstream = X264_MAX( 1000000, h->param.i_width * h->param.i_height * 4

         * ( h->param.rc.i_rc_method == X264_RC_ABR ? pow( 0.95, h->param.rc.i_qp_min )

@@ -908,16 +921,17 @@

         if( x264_macroblock_cache_init( h->thread[i] ) < 0 )

             goto fail;

     }

-

+

     if( x264_lookahead_init( h, i_slicetype_length ) )

         goto fail;

     if( x264_ratecontrol_new( h ) < 0 )

         goto fail;

-

+

+    /* // skip this for now, it's a fopen() call we won't really do, plus it's an option we'll never need --jb

     if( h->param.psz_dump_yuv )

     {

-        /* create or truncate the reconstructed video file */

+    //create or truncate the reconstructed video file

         FILE *f = fopen( h->param.psz_dump_yuv, "w" );

         if( f )

             fclose( f );

@@ -927,6 +941,8 @@

             goto fail;

         }

     }

+    */

+

     x264_log( h, X264_LOG_INFO, "profile %s, level %d.%d\n",

         h->sps->i_profile_idc == PROFILE_BASELINE ? "Baseline" :

@@ -1307,6 +1323,8 @@

     int slice_max_size = h->param.i_slice_max_size > 0 ? (h->param.i_slice_max_size-3-NALU_OVERHEAD)*8 : INT_MAX;

     int starting_bits = bs_pos(&h->out.bs);

+    //V(fprintf(stderr, "x264_slice_write\n"));

+

     /* Slice */

     x264_nal_start( h, h->i_nal_type, h->i_nal_ref_idc );

@@ -1320,6 +1338,7 @@

         /* init cabac */

         x264_cabac_context_init( &h->cabac, h->sh.i_type, h->sh.i_qp, h->sh.i_cabac_init_idc );

         x264_cabac_encode_init ( &h->cabac, h->out.bs.p, h->out.bs.p_end );

+       //V(fprintf(stderr, "\tcabac inited\n"));

     }

     h->mb.i_last_qp = h->sh.i_qp;

     h->mb.i_last_dqp = 0;

@@ -1362,7 +1381,10 @@

         x264_macroblock_encode( h );

         if( x264_bitstream_check_buffer( h ) )

+         {

+           //V(fprintf(stderr, "\tx264_bitstream_check_buffer failed\n"));

             return -1;

+         }

         if( h->param.b_cabac )

         {

@@ -1522,6 +1544,8 @@

         x264_fdec_filter_row( h, h->sps->i_mb_height );

     }

+    //V(fprintf(stderr, "x264_slice_write ok\n"));

+

     return 0;

 }

@@ -1625,8 +1649,8 @@

     int     i_nal_type, i;

     int     i_nal_ref_idc;

-    int   i_global_qp;

+    int   i_global_qp;

     if( h->param.i_threads > 1)

     {

         int i = ++h->i_thread_phase;

@@ -1653,6 +1677,7 @@

     /* no data out */

     *pi_nal = 0;

     *pp_nal = NULL;

+

     /* ------------------- Setup new frame from picture -------------------- */

     if( pic_in != NULL )

@@ -1663,7 +1688,10 @@

             return -1;

         if( x264_frame_copy_picture( h, fenc, pic_in ) < 0 )

+         {

+           //V(fprintf(stderr, "x264_frame_copy_picture returned >0\n"));

             return -1;

+         }

         if( h->param.i_width != 16 * h->sps->i_mb_width ||

             h->param.i_height != 16 * h->sps->i_mb_height )

@@ -1684,13 +1712,15 @@

         /* 2: Place the frame into the queue for its slice type decision */

         x264_lookahead_put_frame( h, fenc );

-

+

+       //V(fprintf(stderr, "x264_encoder_encode setup new frame from picture\n"));

+

         if( h->frames.i_input <= h->frames.i_delay + 1 - h->param.i_threads )

         {

             /* Nothing yet to encode, waiting for filling of buffers */

             pic_out->i_type = X264_TYPE_AUTO;

             return 0;

-        }

+        }

     }

     else

     {

@@ -1873,7 +1903,10 @@

     }

     else

         if( (intptr_t)x264_slices_write( h ) )

+         {

+           //V(fprintf(stderr, "x264_encoder_encode(): x264_slices_write() failed\n"));

             return -1;

+         }

     return x264_encoder_frame_end( thread_oldest, thread_current, pp_nal, pi_nal, pic_out );

 }

diff -Naur --exclude=.git --exclude=.gitignore x264/encoder/me.c x264-or/encoder/me.c

--- x264/encoder/me.c   2009-10-25 17:41:10.000000000 +0100

+++ x264-or/encoder/me.c        2009-11-10 13:36:34.000000000 +0100

@@ -33,17 +33,17 @@

  * the subme=8,9 values are much higher because any amount of satd search makes

  * up its time by reducing the number of qpel-rd iterations. */

 static const int subpel_iterations[][4] =

-   {{0,0,0,0},

-    {1,1,0,0},

-    {0,1,1,0},

-    {0,2,1,0},

-    {0,2,1,1},

-    {0,2,1,2},

-    {0,0,2,2},

-    {0,0,2,2},

-    {0,0,4,10},

-    {0,0,4,10},

-    {0,0,4,10}};

+  {{0,0,0,0},

+   {1,1,0,0},

+   {0,1,1,0},

+   {0,2,1,0},

+   {0,2,1,1},

+   {0,2,1,2},

+   {0,0,2,2},

+   {0,0,2,2},

+   {0,0,4,10},

+   {0,0,4,10},

+   {0,0,4,10}};

 /* (x-1)%6 */

 static const int mod6m1[8] = {5,0,1,2,3,4,5,0};

@@ -53,1108 +53,1114 @@

 static void refine_subpel( x264_t *h, x264_me_t *m, int hpel_iters, int qpel_iters, int *p_halfpel_thresh, int b_refine_qpel );

-#define BITS_MVD( mx, my )\

-    (p_cost_mvx[(mx)<<2] + p_cost_mvy[(my)<<2])

+#define BITS_MVD( mx, my )                     \

+  (p_cost_mvx[(mx)<<2] + p_cost_mvy[(my)<<2])

-#define COST_MV( mx, my )\

-{\

-    int cost = h->pixf.fpelcmp[i_pixel]( p_fenc, FENC_STRIDE,\

-                   &p_fref[(my)*stride+(mx)], stride )\

-             + BITS_MVD(mx,my);\

-    COPY3_IF_LT( bcost, cost, bmx, mx, bmy, my );\

-}

-

-#define COST_MV_HPEL( mx, my ) \

-{ \

-    int stride2 = 16; \

+#define COST_MV( mx, my )                                              \

+  {                                                                    \

+    int cost = h->pixf.fpelcmp[i_pixel]( p_fenc, FENC_STRIDE,          \

+                                        &p_fref[(my)*stride+(mx)], stride ) \

+      + BITS_MVD(mx,my);                                               \

+    COPY3_IF_LT( bcost, cost, bmx, mx, bmy, my );                      \

+  }

+

+#define COST_MV_HPEL( mx, my )                                         \

+  {                                                                    \

+    int stride2 = 16;                                                  \

     uint8_t *src = h->mc.get_ref( pix, &stride2, m->p_fref, stride, mx, my, bw, bh ); \

     int cost = h->pixf.fpelcmp[i_pixel]( p_fenc, FENC_STRIDE, src, stride2 ) \

-             + p_cost_mvx[ mx ] + p_cost_mvy[ my ]; \

-    COPY3_IF_LT( bpred_cost, cost, bpred_mx, mx, bpred_my, my ); \

-}

-

-#define COST_MV_X3_DIR( m0x, m0y, m1x, m1y, m2x, m2y, costs )\

-{\

-    uint8_t *pix_base = p_fref + bmx + bmy*stride;\

-    h->pixf.fpelcmp_x3[i_pixel]( p_fenc,\

-        pix_base + (m0x) + (m0y)*stride,\

-        pix_base + (m1x) + (m1y)*stride,\

-        pix_base + (m2x) + (m2y)*stride,\

-        stride, costs );\

-    (costs)[0] += BITS_MVD( bmx+(m0x), bmy+(m0y) );\

-    (costs)[1] += BITS_MVD( bmx+(m1x), bmy+(m1y) );\

-    (costs)[2] += BITS_MVD( bmx+(m2x), bmy+(m2y) );\

-}

-

-#define COST_MV_X4_DIR( m0x, m0y, m1x, m1y, m2x, m2y, m3x, m3y, costs )\

-{\

-    uint8_t *pix_base = p_fref + bmx + bmy*stride;\

-    h->pixf.fpelcmp_x4[i_pixel]( p_fenc,\

-        pix_base + (m0x) + (m0y)*stride,\

-        pix_base + (m1x) + (m1y)*stride,\

-        pix_base + (m2x) + (m2y)*stride,\

-        pix_base + (m3x) + (m3y)*stride,\

-        stride, costs );\

-    (costs)[0] += BITS_MVD( bmx+(m0x), bmy+(m0y) );\

-    (costs)[1] += BITS_MVD( bmx+(m1x), bmy+(m1y) );\

-    (costs)[2] += BITS_MVD( bmx+(m2x), bmy+(m2y) );\

-    (costs)[3] += BITS_MVD( bmx+(m3x), bmy+(m3y) );\

-}

-

-#define COST_MV_X4( m0x, m0y, m1x, m1y, m2x, m2y, m3x, m3y )\

-{\

-    uint8_t *pix_base = p_fref + omx + omy*stride;\

-    h->pixf.fpelcmp_x4[i_pixel]( p_fenc,\

-        pix_base + (m0x) + (m0y)*stride,\

-        pix_base + (m1x) + (m1y)*stride,\

-        pix_base + (m2x) + (m2y)*stride,\

-        pix_base + (m3x) + (m3y)*stride,\

-        stride, costs );\

-    costs[0] += BITS_MVD( omx+(m0x), omy+(m0y) );\

-    costs[1] += BITS_MVD( omx+(m1x), omy+(m1y) );\

-    costs[2] += BITS_MVD( omx+(m2x), omy+(m2y) );\

-    costs[3] += BITS_MVD( omx+(m3x), omy+(m3y) );\

-    COPY3_IF_LT( bcost, costs[0], bmx, omx+(m0x), bmy, omy+(m0y) );\

-    COPY3_IF_LT( bcost, costs[1], bmx, omx+(m1x), bmy, omy+(m1y) );\

-    COPY3_IF_LT( bcost, costs[2], bmx, omx+(m2x), bmy, omy+(m2y) );\

-    COPY3_IF_LT( bcost, costs[3], bmx, omx+(m3x), bmy, omy+(m3y) );\

-}

-

-#define COST_MV_X3_ABS( m0x, m0y, m1x, m1y, m2x, m2y )\

-{\

-    h->pixf.fpelcmp_x3[i_pixel]( p_fenc,\

-        p_fref + (m0x) + (m0y)*stride,\

-        p_fref + (m1x) + (m1y)*stride,\

-        p_fref + (m2x) + (m2y)*stride,\

-        stride, costs );\

-    costs[0] += p_cost_mvx[(m0x)<<2]; /* no cost_mvy */\

-    costs[1] += p_cost_mvx[(m1x)<<2];\

-    costs[2] += p_cost_mvx[(m2x)<<2];\

-    COPY3_IF_LT( bcost, costs[0], bmx, m0x, bmy, m0y );\

-    COPY3_IF_LT( bcost, costs[1], bmx, m1x, bmy, m1y );\

-    COPY3_IF_LT( bcost, costs[2], bmx, m2x, bmy, m2y );\

-}

+      + p_cost_mvx[ mx ] + p_cost_mvy[ my ];                           \

+    COPY3_IF_LT( bpred_cost, cost, bpred_mx, mx, bpred_my, my );       \

+  }

+

+#define COST_MV_X3_DIR( m0x, m0y, m1x, m1y, m2x, m2y, costs )          \

+  {                                                                    \

+    uint8_t *pix_base = p_fref + bmx + bmy*stride;                     \

+    h->pixf.fpelcmp_x3[i_pixel]( p_fenc,                               \

+                                pix_base + (m0x) + (m0y)*stride,       \

+                                pix_base + (m1x) + (m1y)*stride,       \

+                                pix_base + (m2x) + (m2y)*stride,       \

+                                stride, costs );                       \

+    (costs)[0] += BITS_MVD( bmx+(m0x), bmy+(m0y) );                    \

+    (costs)[1] += BITS_MVD( bmx+(m1x), bmy+(m1y) );                    \

+    (costs)[2] += BITS_MVD( bmx+(m2x), bmy+(m2y) );                    \

+  }

+

+#define COST_MV_X4_DIR( m0x, m0y, m1x, m1y, m2x, m2y, m3x, m3y, costs )        \

+  {                                                                    \

+    uint8_t *pix_base = p_fref + bmx + bmy*stride;                     \

+    h->pixf.fpelcmp_x4[i_pixel]( p_fenc,                               \

+                                pix_base + (m0x) + (m0y)*stride,       \

+                                pix_base + (m1x) + (m1y)*stride,       \

+                                pix_base + (m2x) + (m2y)*stride,       \

+                                pix_base + (m3x) + (m3y)*stride,       \

+                                stride, costs );                       \

+    (costs)[0] += BITS_MVD( bmx+(m0x), bmy+(m0y) );                    \

+    (costs)[1] += BITS_MVD( bmx+(m1x), bmy+(m1y) );                    \

+    (costs)[2] += BITS_MVD( bmx+(m2x), bmy+(m2y) );                    \

+    (costs)[3] += BITS_MVD( bmx+(m3x), bmy+(m3y) );                    \

+  }

+

+#define COST_MV_X4( m0x, m0y, m1x, m1y, m2x, m2y, m3x, m3y )           \

+  {                                                                    \

+    uint8_t *pix_base = p_fref + omx + omy*stride;                     \

+    h->pixf.fpelcmp_x4[i_pixel]( p_fenc,                               \

+                                pix_base + (m0x) + (m0y)*stride,       \

+                                pix_base + (m1x) + (m1y)*stride,       \

+                                pix_base + (m2x) + (m2y)*stride,       \

+                                pix_base + (m3x) + (m3y)*stride,       \

+                                stride, costs );                       \

+    costs[0] += BITS_MVD( omx+(m0x), omy+(m0y) );                      \

+    costs[1] += BITS_MVD( omx+(m1x), omy+(m1y) );                      \

+    costs[2] += BITS_MVD( omx+(m2x), omy+(m2y) );                      \

+    costs[3] += BITS_MVD( omx+(m3x), omy+(m3y) );                      \

+    COPY3_IF_LT( bcost, costs[0], bmx, omx+(m0x), bmy, omy+(m0y) );    \

+    COPY3_IF_LT( bcost, costs[1], bmx, omx+(m1x), bmy, omy+(m1y) );    \

+    COPY3_IF_LT( bcost, costs[2], bmx, omx+(m2x), bmy, omy+(m2y) );    \

+    COPY3_IF_LT( bcost, costs[3], bmx, omx+(m3x), bmy, omy+(m3y) );    \

+  }

+

+#define COST_MV_X3_ABS( m0x, m0y, m1x, m1y, m2x, m2y )         \

+  {                                                            \

+    h->pixf.fpelcmp_x3[i_pixel]( p_fenc,                       \

+                                p_fref + (m0x) + (m0y)*stride, \

+                                p_fref + (m1x) + (m1y)*stride, \

+                                p_fref + (m2x) + (m2y)*stride, \

+                                stride, costs );               \

+    costs[0] += p_cost_mvx[(m0x)<<2]; /* no cost_mvy */                \

+    costs[1] += p_cost_mvx[(m1x)<<2];                          \

+    costs[2] += p_cost_mvx[(m2x)<<2];                          \

+    COPY3_IF_LT( bcost, costs[0], bmx, m0x, bmy, m0y );                \

+    COPY3_IF_LT( bcost, costs[1], bmx, m1x, bmy, m1y );                \

+    COPY3_IF_LT( bcost, costs[2], bmx, m2x, bmy, m2y );                \

+  }

 /*  1  */

 /* 101 */

 /*  1  */

-#define DIA1_ITER( mx, my )\

-{\

-    omx = mx; omy = my;\

-    COST_MV_X4( 0,-1, 0,1, -1,0, 1,0 );\

-}

-

-#define CROSS( start, x_max, y_max )\

-{\

-    i = start;\

-    if( x_max <= X264_MIN(mv_x_max-omx, omx-mv_x_min) )\

-        for( ; i < x_max-2; i+=4 )\

-            COST_MV_X4( i,0, -i,0, i+2,0, -i-2,0 );\

-    for( ; i < x_max; i+=2 )\

-    {\

-        if( omx+i <= mv_x_max )\

-            COST_MV( omx+i, omy );\

-        if( omx-i >= mv_x_min )\

-            COST_MV( omx-i, omy );\

-    }\

-    i = start;\

-    if( y_max <= X264_MIN(mv_y_max-omy, omy-mv_y_min) )\

-        for( ; i < y_max-2; i+=4 )\

-            COST_MV_X4( 0,i, 0,-i, 0,i+2, 0,-i-2 );\

-    for( ; i < y_max; i+=2 )\

-    {\

-        if( omy+i <= mv_y_max )\

-            COST_MV( omx, omy+i );\

-        if( omy-i >= mv_y_min )\

-            COST_MV( omx, omy-i );\

-    }\

-}

+#define DIA1_ITER( mx, my )                    \

+  {                                            \

+    omx = mx; omy = my;                                \

+    COST_MV_X4( 0,-1, 0,1, -1,0, 1,0 );                \

+  }

+

+#define CROSS( start, x_max, y_max )                   \

+  {                                                    \

+    i = start;                                         \

+    if( x_max <= X264_MIN(mv_x_max-omx, omx-mv_x_min) )        \

+      for( ; i < x_max-2; i+=4 )                       \

+       COST_MV_X4( i,0, -i,0, i+2,0, -i-2,0 );         \

+    for( ; i < x_max; i+=2 )                           \

+      {                                                        \

+        if( omx+i <= mv_x_max )                                \

+         COST_MV( omx+i, omy );                        \

+        if( omx-i >= mv_x_min )                                \

+         COST_MV( omx-i, omy );                        \

+      }                                                        \

+    i = start;                                         \

+    if( y_max <= X264_MIN(mv_y_max-omy, omy-mv_y_min) )        \

+      for( ; i < y_max-2; i+=4 )                       \

+       COST_MV_X4( 0,i, 0,-i, 0,i+2, 0,-i-2 );         \

+    for( ; i < y_max; i+=2 )                           \

+      {                                                        \

+        if( omy+i <= mv_y_max )                                \

+         COST_MV( omx, omy+i );                        \

+        if( omy-i >= mv_y_min )                                \

+         COST_MV( omx, omy-i );                        \

+      }                                                        \

+  }

 void x264_me_search_ref( x264_t *h, x264_me_t *m, int16_t (*mvc)[2], int i_mvc, int *p_halfpel_thresh )

 {

-    const int bw = x264_pixel_size[m->i_pixel].w;

-    const int bh = x264_pixel_size[m->i_pixel].h;

-    const int i_pixel = m->i_pixel;

-    const int stride = m->i_stride[0];

-    int i_me_range = h->param.analyse.i_me_range;

-    int bmx, bmy, bcost;

-    int bpred_mx = 0, bpred_my = 0, bpred_cost = COST_MAX;

-    int omx, omy, pmx, pmy;

-    uint8_t *p_fenc = m->p_fenc[0];

-    uint8_t *p_fref = m->p_fref[0];

-    ALIGNED_ARRAY_16( uint8_t, pix,[16*16] );

-

-    int i, j;

-    int dir;

-    int costs[16];

-

-    int mv_x_min = h->mb.mv_min_fpel[0];

-    int mv_y_min = h->mb.mv_min_fpel[1];

-    int mv_x_max = h->mb.mv_max_fpel[0];

-    int mv_y_max = h->mb.mv_max_fpel[1];

+  const int bw = x264_pixel_size[m->i_pixel].w; // x264_pixel_size[] in common/pixel.h

+  const int bh = x264_pixel_size[m->i_pixel].h;

+  const int i_pixel = m->i_pixel; // macroblock pixel size

+  const int stride = m->i_stride[0]; // array stride (usually used only in Y direction)

+  int i_me_range = h->param.analyse.i_me_range; /* integer pixel motion estimation search range (from predicted mv) */

+  int bmx, bmy, bcost;

+  int bpred_mx = 0, bpred_my = 0, bpred_cost = COST_MAX;

+  int omx, omy, pmx, pmy;

+  uint8_t *p_fenc = m->p_fenc[0];

+  uint8_t *p_fref = m->p_fref[0];

+  //V(fprintf(stderr, "s264_me_search_ref *p_fenc = 0x%.8x *p_fref = 0x%.8x\n", (unsigned long) p_fenc, (unsigned long) p_fref));

+  ALIGNED_ARRAY_16( uint8_t, pix,[16*16] );

+

+  int i, j;

+  int dir;

+  int costs[16];

+

+  //fprintf(stderr, "x264_me_search_ref: x264_t *h = 0x%.8x\n", (unsigned int) h);

+  /* Ranges for MVs - perhaps we're on/near the frame boarder and can't go beyond it, these ranges indicate that. They're set in x264_mb_analyse_init() */

+  int mv_x_min = h->mb.mv_min_fpel[0];

+  int mv_y_min = h->mb.mv_min_fpel[1];

+  int mv_x_max = h->mb.mv_max_fpel[0];

+  int mv_y_max = h->mb.mv_max_fpel[1];

 #define CHECK_MVRANGE(mx,my) ( mx >= mv_x_min && mx <= mv_x_max && my >= mv_y_min && my <= mv_y_max )

-    const uint16_t *p_cost_mvx = m->p_cost_mv - m->mvp[0];

-    const uint16_t *p_cost_mvy = m->p_cost_mv - m->mvp[1];

-

-    bmx = x264_clip3( m->mvp[0], mv_x_min*4, mv_x_max*4 );

-    bmy = x264_clip3( m->mvp[1], mv_y_min*4, mv_y_max*4 );

-    pmx = ( bmx + 2 ) >> 2;

-    pmy = ( bmy + 2 ) >> 2;

-    bcost = COST_MAX;

+  const uint16_t *p_cost_mvx = m->p_cost_mv - m->mvp[0];

+  const uint16_t *p_cost_mvy = m->p_cost_mv - m->mvp[1];

+  //V(fprintf(stderr, "p_cost_mvx: 0x%.8x, ( m->p_cost_mv: 0x%.8x m->mvp[0]: 0x%.8x )p_cost_mvy: 0x%.8x (m->p_cost_mv: 0x%.8x  m->mvp[1]: 0x%.8x)\n", (unsigned long) p_cost_mvx, (unsigned long) m->p_cost_mv, (unsigned long) m->mvp[0], (unsigned long) p_cost_mvy, (unsigned long) m->p_cost_mv, (unsigned long) m->mvp[1]));

+

+  /* m->mvp has the media MV (x in [0] and y in [1]) */

+  bmx = x264_clip3( m->mvp[0], mv_x_min*4, mv_x_max*4 );

+  bmy = x264_clip3( m->mvp[1], mv_y_min*4, mv_y_max*4 );

+  pmx = ( bmx + 2 ) >> 2;

+  pmy = ( bmy + 2 ) >> 2;

+  bcost = COST_MAX;

-    /* try extra predictors if provided */

-    if( h->mb.i_subpel_refine >= 3 )

+  /* try extra predictors if provided */

+  if( h->mb.i_subpel_refine >= 3 )

     {

-        uint32_t bmv = pack16to32_mask(bmx,bmy);

-        COST_MV_HPEL( bmx, bmy );

-        for( i = 0; i < i_mvc; i++ )

+      uint32_t bmv = pack16to32_mask(bmx,bmy);

+      COST_MV_HPEL( bmx, bmy );

+      for( i = 0; i < i_mvc; i++ )

         {

-            if( *(uint32_t*)mvc[i] && (bmv - *(uint32_t*)mvc[i]) )

+         if( *(uint32_t*)mvc[i] && (bmv - *(uint32_t*)mvc[i]) )

             {

-                int mx = x264_clip3( mvc[i][0], mv_x_min*4, mv_x_max*4 );

-                int my = x264_clip3( mvc[i][1], mv_y_min*4, mv_y_max*4 );