Subversion Repositories oc-h264-encoder

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

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

+++ x264/common/common.c        2009-10-27 16:45:55.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 --exclude=.git --exclude=.gitignore -Naur ../x264/common/common.h x264/common/common.h

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

+++ x264/common/common.h        2009-10-27 16:45:55.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

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

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

+++ x264/common/frame.c 2009-10-27 16:45:55.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 --exclude=.git --exclude=.gitignore -Naur ../x264/common/mdate.c x264/common/mdate.c

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

+++ x264/common/mdate.c 2009-10-27 16:45:55.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 --exclude=.git --exclude=.gitignore -Naur ../x264/common/pixel.c x264/common/pixel.c

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

+++ x264/common/pixel.c 2009-10-27 16:45:55.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 --exclude=.git --exclude=.gitignore -Naur ../x264/configure x264/configure

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

+++ x264/configure      2009-10-27 16:45:55.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 --exclude=.git --exclude=.gitignore -Naur ../x264/encoder/analyse.c x264/encoder/analyse.c

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

+++ x264/encoder/analyse.c      2009-10-27 16:45:55.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,76 @@

     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*/

+    //fprintf(stderr, "x264_analyse_init_costs: beginning loop of 2*4*2048");

+

     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 );

+    //fprintf(stderr, "\tfinished\n");

+    /* -- for now jb

     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 );

     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 +326,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)];

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

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

+++ x264/encoder/analyse_gen_init_array.sh      2009-10-27 16:45:55.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 --exclude=.git --exclude=.gitignore -Naur ../x264/encoder/encoder.c x264/encoder/encoder.c

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

+++ x264/encoder/encoder.c      2009-10-27 16:45:55.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 --exclude=.git --exclude=.gitignore -Naur ../x264/encoder/me.c x264/encoder/me.c

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

+++ x264/encoder/me.c   2009-10-27 16:45:55.000000000 +0100

@@ -182,6 +182,7 @@

     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;

@@ -197,7 +198,7 @@

     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]));

     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;

@@ -251,6 +252,7 @@

     {

     case X264_ME_DIA:

         /* diamond search, radius 1 */

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

         i = 0;

         bcost <<= 4;

         do

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

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

+++ x264/encoder/slicetype.c    2009-10-27 16:45:55.000000000 +0100

@@ -909,7 +909,9 @@

     /* Restore frametypes for all frames that haven't actually been decided yet. */

     for( j = reset_start; j <= num_frames; j++ )

-        frames[j]->i_type = X264_TYPE_AUTO;

+      frames[j]->i_type = X264_TYPE_AUTO;

+

+    return;

 }

 void x264_slicetype_decide( x264_t *h )

diff --exclude=.git --exclude=.gitignore -Naur ../x264/link.ld x264/link.ld

--- ../x264/link.ld     1970-01-01 01:00:00.000000000 +0100

+++ x264/link.ld        2009-10-27 16:45:55.000000000 +0100

@@ -0,0 +1,100 @@

+/*

+MEMORY

+        {

+        vectors : ORIGIN = 0x00000000, LENGTH = 0x00002000

+        flash   : ORIGIN = 0x04000000, LENGTH = 0x00200000

+        ram     : ORIGIN = 0x00002000, LENGTH = 0x001fe000

+        icm     : ORIGIN = 0x00800000, LENGTH = 0x00004000

+        }

+ */

+

+MEMORY

+       {

+/*

+       reset    : ORIGIN = 0x00000000, LENGTH = 0x00000200

+       vectors  : ORIGIN = 0x00000200, LENGTH = 0x00001E00

+        text     : ORIGIN = 0x00002000, LENGTH = 0x000fe000

+       data     : ORIGIN = 0x00100000, LENGTH = 0x00fe0000

+       stack    : ORIGIN = 0x001fe000, LENGTH = 0x00010000

+*/

+       yuv_data : ORIGIN = 25M, LENGTH = 7M

+       }

+

+/*

+MEMORY

+        {

+        reset   : ORIGIN = 0xc0000000, LENGTH = 0x00000200

+        vectors : ORIGIN = 0xc0000200, LENGTH = 0x00001000

+        ram     : ORIGIN = 0xc0001200, LENGTH = 0x00FFED00

+        }

+*/

+SECTIONS

+{

+/*

+       .reset :

+        {

+        *(.reset)

+        } > reset

+

+

+

+       .vectors :

+        {

+        _vec_start = .;

+        *(.vectors)

+        _vec_end = .;

+        } > vectors

+

+        .text :

+        {

+        *(.text)

+        } > text

+

+      .rodata :

+        {

+        *(.rodata)

+        *(.rodata.*)

+        } > text

+

+     .icm :

+        {

+        _icm_start = .;

+        *(.icm)

+        _icm_end = .;

+        } > data

+

+     .data :

+        {

+        _dst_beg = .;

+        *(.data)

+        _dst_end = .;

+        } > data

+

+      .bss :

+        {

+        *(.bss)

+        } > data

+

+       .heap :

+       {

+       _heap_start = .;

+       *(.heap)

+       _heap_end = .;

+       } > data

+

+      .stack (NOLOAD) :

+        {

+        *(.stack)

+        _src_addr = .;

+        } > data

+*/

+       .yuv_data :

+       {

+       _yuv_data_start = .;

+       __yuv_data_start = .;

+       *(.yuv_data)

+       _yuv_data_end = .;

+       __yuv_data_end = .;

+       } > yuv_data

+

+}

diff --exclude=.git --exclude=.gitignore -Naur ../x264/Makefile x264/Makefile

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

+++ x264/Makefile       2009-10-27 17:30:09.000000000 +0100

@@ -91,7 +91,54 @@

 $(SONAME): .depend $(OBJS) $(OBJASM)

        $(CC) -shared -o $@ $(OBJS) $(OBJASM) $(SOFLAGS) $(LDFLAGS)

-x264$(EXE): $(OBJCLI) libx264.a

+

+## OR32-specific build rules

+##

+## Essentially we create some sample YUV video data

+## and embed it in an ELF file, in a section called yuv_data.

+## In the linker script we then link this section to a place

+## in ram and tell x264 to look here when it wants data.

+##

+## You can download sample h264 encoded CIF sequences

+## here: http://www.tkn.tu-berlin.de/research/evalvid/cif.html

+##

+##

+GEN_FILES=encoder/analyse_init_log2.c

+VIDEO_DATA_FILE=yuv_data.elf

+H264_VIDEO_FILE ?= ../test-sequences/football_cif.264

+YUV_VIDEO_FILE ?= video_data.yuv

+# We will use a limit of about 5MB of video data to encode

+# For CIF resultion of 4:2:0 this is about 30 frames. It's

+# possible to convert a set amount of data with ffmpeg but

+# it's probably not wise to attempt to encode partial frames

+NUM_FRAMES=30

+

+$(H264_VIDEO_FILE):

+       @echo; echo;

+       @echo "\tNo sample video file to embed! Please edit the Makefile"

+       @echo "\tand set the variable H264_VIDEO_FILE to the location of "

+       @echo "\ta raw h264 bitstream file, or set this variable on the"

+       @echo "\tcommand line when calling make, eg.:"

+       @echo "\t\tH264_VIDEO_FILE=../football_cif.264 make"; echo

+       exit 1

+$(YUV_VIDEO_FILE): $(H264_VIDEO_FILE)

+# First convert it to raw YUV, only about 5MB large, so for cif take 30 frames

+       ffmpeg -i $(H264_VIDEO_FILE) -vframes $(NUM_FRAMES) $(YUV_VIDEO_FILE)

+$(VIDEO_DATA_FILE): $(YUV_VIDEO_FILE)

+       or32-elf-ld -r -b binary -o yuv_data.o $(YUV_VIDEO_FILE)

+       or32-elf-objcopy --rename-section .data=.yuv_data yuv_data.o

+       mv yuv_data.o $(VIDEO_DATA_FILE)

+encoder/analyse_init_log2.c: encoder/analyse_gen_init_array.sh

+       cd encoder && chmod a+x analyse_gen_init_array.sh && ./analyse_gen_init_array.sh

+#OR32_DEPS= reset.o except.o uart.o syscalls.o $(VIDEO_DATA_FILE)

+

+OR32_DEPS= $(VIDEO_DATA_FILE) $(GEN_FILES)

+

+sim: x264$(EXE)

+       or32-elf-sim -f or1ksim_x264.cfg $<

+

+

+x264$(EXE): $(OR32_DEPS) $(OBJCLI) libx264.a

        $(CC) -o $@ $+ $(LDFLAGS)

 checkasm: tools/checkasm.o libx264.a

@@ -147,12 +194,13 @@

 endif

 clean:

-       rm -f $(OBJS) $(OBJASM) $(OBJCLI) $(SONAME) *.a x264 x264.exe .depend TAGS

+       rm -f $(OBJS) $(OBJASM) $(OBJCLI) $(SONAME) *.a x264 x264.exe .depend TAGS $(YUV_VIDEO_FILE)

        rm -f checkasm checkasm.exe tools/checkasm.o tools/checkasm-a.o

        rm -f $(SRC2:%.c=%.gcda) $(SRC2:%.c=%.gcno)

        - sed -e 's/ *-fprofile-\(generate\|use\)//g' config.mak > config.mak2 && mv config.mak2 config.mak

 distclean: clean

+       rm -f $(OR32_DEPS) uart0* $(GEN_FILES)

        rm -f config.mak config.h x264.pc

        rm -rf test/

diff --exclude=.git --exclude=.gitignore -Naur ../x264/muxers.c x264/muxers.c

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

+++ x264/muxers.c       2009-10-27 16:45:55.000000000 +0100

@@ -52,15 +52,32 @@

 typedef struct

 {

-    FILE *fh;

-    int width, height;

-    int next_frame;

+  //FILE *fh;

+  char *fh;

+

+  int width, height;

+  int next_frame;

+

 } yuv_input_t;

+void init_yuv_dataspace(char* yuv_dat_addr, hnd_t *p_handle, x264_param_t *p_param)

+{

+  yuv_input_t *h = malloc( sizeof(yuv_input_t) );

+  V(fprintf( stderr, "init_yuv_dataspace: h addr = 0x%.8x\n", h));

+  h->fh = yuv_dat_addr;

+  V(fprintf( stderr, "init_yuv_dataspace: h->fh 0x%.8x\n",h->fh));

+  h->width = p_param->i_width;

+  V(fprintf( stderr, "init_yuv_dataspace: h->width %d\n",h->width));

+  h->height = p_param->i_height;

+  V(fprintf( stderr, "init_yuv_dataspace: h->height %d\n",h->height));

+  h->next_frame = 0;

+  *p_handle = (hnd_t *)h;

+}

+

 /* raw 420 yuv file operation */

 int open_file_yuv( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param )

 {

-    yuv_input_t *h = malloc( sizeof(yuv_input_t) );

+  yuv_input_t *h = malloc( sizeof(yuv_input_t) );

     if( !h )

         return -1;

     h->width = p_param->i_width;

@@ -80,7 +97,10 @@

 int get_frame_total_yuv( hnd_t handle )

 {

-    yuv_input_t *h = handle;

+      yuv_input_t *h = handle;

+

+      V(fprintf(stderr, "get_frame_total_yuv args: handle: 0x%.8x, h: 0x%.8x\n", handle, h));

+      /*

     int i_frame_total = 0;

     if( !fseek( h->fh, 0, SEEK_END ) )

@@ -88,24 +108,45 @@

         uint64_t i_size = ftell( h->fh );

         fseek( h->fh, 0, SEEK_SET );

         i_frame_total = (int)(i_size / ( h->width * h->height * 3 / 2 ));

-    }

+       }*/

+

+#ifdef      USE_HARDCODED_FRAME_NUM

+      return (int)HARDCODED_FRAME_NUM;

+#else

+      fprintf( stderr, "get_frame_total_yuv: %d %d %d %d\n",

+                h->width, h->height,

+                YUV_DATA_SIZE,

+                (int)(YUV_DATA_SIZE / ( h->width * h->height * 3 / 2 )));

+      return (int)(YUV_DATA_SIZE / ( h->width * h->height * 3 / 2 ));//i_frame_total;

+

+#endif

-    return i_frame_total;

 }

 int read_frame_yuv( x264_picture_t *p_pic, hnd_t handle, int i_frame )

 {

     yuv_input_t *h = handle;

-

+    int i;

+

     if( i_frame != h->next_frame )

-        if( fseek( h->fh, (uint64_t)i_frame * h->width * h->height * 3 / 2, SEEK_SET ) )

-            return -1;

-

-    if( fread( p_pic->img.plane[0], 1, h->width * h->height, h->fh ) <= 0

-     || fread( p_pic->img.plane[1], 1, h->width * h->height / 4, h->fh ) <= 0

-     || fread( p_pic->img.plane[2], 1, h->width * h->height / 4, h->fh ) <= 0 )

-        return -1;

+      //if( fseek( h->fh, (uint64_t)i_frame * h->width * h->height * 3 / 2, SEEK_SET ) )

+      // Progress pointer to beginning of this frame

+      h->fh = (void*) YUV_DATA_ADDR + i_frame * h->width * h->height * 3 / 2;

+      //return -1;

+

+    //if( fread( p_pic->img.plane[0], 1, h->width * h->height, h->fh ) <= 0

+    for (i=0;i<h->width * h->height;i++) p_pic->img.plane[0][i] = h->fh[i];

+    h->fh += h->width * h->height;

+    //|| fread( p_pic->img.plane[1], 1, h->width * h->height / 4, h->fh ) <= 0

+    for (i=0;i<(h->width * h->height) / 4;i++) p_pic->img.plane[1][i] = h->fh[i];

+    h->fh += (h->width * h->height) / 4;

+

+    //|| fread( p_pic->img.plane[2], 1, h->width * h->height / 4, h->fh ) <= 0 )

+    for (i=0;i<(h->width * h->height) / 4;i++) p_pic->img.plane[2][i] = h->fh[i];

+    h->fh += (h->width * h->height) / 4;

+    //return -1;

+

     h->next_frame = i_frame+1;

     return 0;

@@ -113,12 +154,15 @@

 int close_file_yuv(hnd_t handle)

 {

+  return 0;

+  /* // -- jb

     yuv_input_t *h = handle;

     if( !h || !h->fh )

         return 0;

     fclose( h->fh );

     free( h );

     return 0;

+  */

 }

 /* YUV4MPEG2 raw 420 yuv file operation */

@@ -530,11 +574,21 @@

 }

 #endif

+#ifdef ENC_OUT_ADDR

+char * enc_out_pos;

+#endif

 int open_file_bsf( char *psz_filename, hnd_t *p_handle )

 {

+#ifdef ENC_OUT_ADDR

+  V(fprintf(stderr, "open_file_bsf\n"));

+  // Use a hardcoded memory location for outputting encoded data to

+  p_handle = (void *) ENC_OUT_ADDR;

+  enc_out_pos = (char *) ENC_OUT_ADDR;

+#else

     if( !(*p_handle = fopen(psz_filename, "w+b")) )

         return -1;

+#endif

     return 0;

 }

@@ -546,9 +600,16 @@

 int write_nalu_bsf( hnd_t handle, uint8_t *p_nalu, int i_size )

 {

+#ifdef ENC_OUT_ADDR

+  V(fprintf(stderr, "write_nalu_bsf: writing %d bytes from 0x%.8x\n", i_size, (unsigned long) enc_out_pos));

+  // Just write to the spot in memory and increment the pointer

+  int i; for (i=0;i<i_size;i++) *enc_out_pos++ = p_nalu[i];

+  return i_size;

+#else

     if( fwrite( p_nalu, i_size, 1, (FILE*)handle ) > 0 )

         return i_size;

     return -1;

+#endif

 }

 int set_eop_bsf( hnd_t handle,  x264_picture_t *p_picture )

@@ -558,6 +619,9 @@

 int close_file_bsf( hnd_t handle )

 {

+#ifdef ENC_OUT_ADDR

+  return 0;

+#endif

     if( !handle || handle == stdout )

         return 0;

diff --exclude=.git --exclude=.gitignore -Naur ../x264/muxers.h x264/muxers.h

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

+++ x264/muxers.h       2009-10-27 16:45:55.000000000 +0100

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

 typedef void *hnd_t;

 int open_file_yuv( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param );

+void init_yuv_dataspace(char* yuv_dat_addr, hnd_t *p_handle, x264_param_t *p_param);

 int get_frame_total_yuv( hnd_t handle );

 int read_frame_yuv( x264_picture_t *p_pic, hnd_t handle, int i_frame );

 int close_file_yuv( hnd_t handle );

diff --exclude=.git --exclude=.gitignore -Naur ../x264/or1ksim_x264.cfg x264/or1ksim_x264.cfg

--- ../x264/or1ksim_x264.cfg    1970-01-01 01:00:00.000000000 +0100

+++ x264/or1ksim_x264.cfg       2009-10-27 16:45:55.000000000 +0100

@@ -0,0 +1,886 @@

+/* sim.cfg -- Simulator configuration script file

+   Copyright (C) 2001-2002, Marko Mlinar, markom@opencores.org

+

+This file is part of OpenRISC 1000 Architectural Simulator.

+It contains the default configuration and help about configuring

+the simulator.

+

+This program is free software; you can redistribute it and/or modify

+it under the terms of the GNU General Public License as published by

+the Free Software Foundation; either version 2 of the License, or

+(at your option) any later version.

+

+This program is distributed in the hope that it will be useful,

+but WITHOUT ANY WARRANTY; without even the implied warranty of

+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+GNU General Public License for more details.

+

+You should have received a copy of the GNU General Public License

+along with this program; if not, write to the Free Software

+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */

+

+

+/* INTRODUCTION

+

+   The ork1sim has various parameters, that are set in configuration files

+   like this one. The user can switch between configurations at startup by

+   specifying the required configuration file with the -f <filename.cfg> option.

+   If no configuration file is specified or1ksim searches for the default

+   configuration file sim.cfg. First it searches for './sim.cfg'. If this

+   file is not found, it searches for '~/or1k/sim.cfg'. If this file is

+   not found too, it reverts to the built-in default configuration.

+

+   NOTE: Users should not rely on the built-in configuration, since the

+         default configuration may differ between version.

+         Rather create a configuration file that sets all critical values.

+

+   This file may contain (standard C) comments only - no // support.

+

+   Configure files may be be included, using:

+   include "file_name_to_include"

+

+   Like normal configuration files, the included file is divided into

+   sections. Each section is described in detail also.

+

+   Some section have subsections. One example of such a subsection is:

+

+   device <index>

+     instance specific parameters...

+   enddevice

+

+   which creates a device instance.

+*/