@@ -119,8 +119,10 @@ static int use_obmc = 0;

 static int use_aic = 0;

 static int use_aiv = 0;

 static int use_umv = 0;

+static int use_alt_scan = 0;

 static int do_deinterlace = 0;

-static int do_interlace = 0;

+static int do_interlace_dct = 0;

+static int do_interlace_me = 0;

 static int workaround_bugs = FF_BUG_AUTODETECT;

 static int error_resilience = 2;

 static int error_concealment = 3;

@@ -130,6 +132,8 @@ static int use_part = 0;

 static int packet_size = 0;

 static int error_rate = 0;

 static int strict = 0;

+static int top_field_first = -1;

+static int noise_reduction = 0;

 static int debug = 0;

 static int debug_mv = 0;

 extern int loop_input; /* currently a hack */

@@ -635,7 +639,12 @@ static void do_video_out(AVFormatContext *s,

             /* better than nothing: use input picture interlaced

                settings */

             big_picture.interlaced_frame = in_picture->interlaced_frame;

-            big_picture.top_field_first = in_picture->top_field_first;

+            if(do_interlace_me || do_interlace_dct){

+                if(top_field_first == -1)

+                    big_picture.top_field_first = in_picture->top_field_first;

+                else

+                    big_picture.top_field_first = 1;

+            }

             /* handles sameq here. This is not correct because it may

                not be a global option */

@@ -1946,6 +1955,16 @@ static void opt_strict(const char *arg)

     strict= atoi(arg);

 }

+static void opt_top_field_first(const char *arg)

+{

+    top_field_first= atoi(arg);

+}

+

+static void opt_noise_reduction(const char *arg)

+{

+    noise_reduction= atoi(arg);

+}

+

 static void opt_audio_bitrate(const char *arg)

 {

     audio_bit_rate = atoi(arg) * 1000;

@@ -2373,14 +2392,20 @@ static void opt_output_file(const char *filename)

                 if(use_part) {

                     video_enc->flags |= CODEC_FLAG_PART;

                 }

+           	if (use_alt_scan) {

+                    video_enc->flags |= CODEC_FLAG_ALT_SCAN;

+                }

                 if (b_frames) {

                     video_enc->max_b_frames = b_frames;

                     video_enc->b_frame_strategy = 0;

                     video_enc->b_quant_factor = 2.0;

                 }

-                if (do_interlace) {

+                if (do_interlace_dct) {

                     video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;

                 }

+                if (do_interlace_me) {

+                    video_enc->flags |= CODEC_FLAG_INTERLACED_ME;

+                }

                 video_enc->qmin = video_qmin;

                 video_enc->qmax = video_qmax;

                 video_enc->mb_qmin = video_mb_qmin;

@@ -2430,6 +2455,7 @@ static void opt_output_file(const char *filename)

                 video_enc->idct_algo = idct_algo;

                 video_enc->strict_std_compliance = strict;

                 video_enc->error_rate = error_rate;

+                video_enc->noise_reduction= noise_reduction;

                 if(packet_size){

                     video_enc->rtp_mode= 1;

                     video_enc->rtp_payload_size= packet_size;

@@ -2992,16 +3018,21 @@ const OptionDef options[] = {

     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },

     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace}, 

       "deinterlace pictures" },

-    { "interlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace}, 

-      "force interlacing support in encoder (MPEG2/MPEG4)" },

+    { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct}, 

+      "force interlaced dct support in encoder (MPEG2/MPEG4)" },

+    { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me}, 

+      "force interlacied me support in encoder MPEG2" },

     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },

     { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" }, 

     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },

     { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },

     { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },

     { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },

+    { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (mpeg2)" },

     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },

     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },

+    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },

+    { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },

     /* audio options */

     { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },

@@ -39,11 +39,11 @@ void get_pixels_mvi(DCTELEM *restrict block,

                     const uint8_t *restrict pixels, int line_size);

 void diff_pixels_mvi(DCTELEM *block, const uint8_t *s1, const uint8_t *s2,

                      int stride);

-int pix_abs8x8_mvi(uint8_t *pix1, uint8_t *pix2, int line_size);

+int pix_abs8x8_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h);

 int pix_abs16x16_mvi_asm(uint8_t *pix1, uint8_t *pix2, int line_size);

-int pix_abs16x16_x2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size);

-int pix_abs16x16_y2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size);

-int pix_abs16x16_xy2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size);

+int pix_abs16x16_x2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h);

+int pix_abs16x16_y2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h);

+int pix_abs16x16_xy2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h);

 #if 0

 /* These functions were the base for the optimized assembler routines,

@@ -290,11 +290,6 @@ static int sad16x16_mvi(void *s, uint8_t *a, uint8_t *b, int stride)

     return pix_abs16x16_mvi_asm(a, b, stride);

 }

-static int sad8x8_mvi(void *s, uint8_t *a, uint8_t *b, int stride)

-{

-    return pix_abs8x8_mvi(a, b, stride);

-}

-

 void dsputil_init_alpha(DSPContext* c, AVCodecContext *avctx)

 {

     c->put_pixels_tab[0][0] = put_pixels16_axp_asm;

@@ -347,12 +342,13 @@ void dsputil_init_alpha(DSPContext* c, AVCodecContext *avctx)

         c->get_pixels       = get_pixels_mvi;

         c->diff_pixels      = diff_pixels_mvi;

         c->sad[0]           = sad16x16_mvi;

-        c->sad[1]           = sad8x8_mvi;

-        c->pix_abs8x8       = pix_abs8x8_mvi;

-        c->pix_abs16x16     = pix_abs16x16_mvi_asm;

-        c->pix_abs16x16_x2  = pix_abs16x16_x2_mvi;

-        c->pix_abs16x16_y2  = pix_abs16x16_y2_mvi;

-        c->pix_abs16x16_xy2 = pix_abs16x16_xy2_mvi;

+        c->sad[1]           = pix_abs8x8_mvi;

+//        c->pix_abs[0][0]    = pix_abs16x16_mvi_asm; //FIXME function arguments for the asm must be fixed

+        c->pix_abs[0][0]    = sad16x16_mvi;

+        c->pix_abs[1][0]    = pix_abs8x8_mvi;

+        c->pix_abs[0][1]    = pix_abs16x16_x2_mvi;

+        c->pix_abs[0][2]    = pix_abs16x16_y2_mvi;

+        c->pix_abs[0][3]    = pix_abs16x16_xy2_mvi;

     }

     put_pixels_clamped_axp_p = c->put_pixels_clamped;

@@ -84,10 +84,9 @@ static inline uint64_t avg4(uint64_t l1, uint64_t l2, uint64_t l3, uint64_t l4)

     return r1 + r2;

 }

-int pix_abs8x8_mvi(uint8_t *pix1, uint8_t *pix2, int line_size)

+int pix_abs8x8_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int result = 0;

-    int h = 8;

     if ((size_t) pix2 & 0x7) {

         /* works only when pix2 is actually unaligned */

@@ -160,10 +159,9 @@ int pix_abs16x16_mvi(uint8_t *pix1, uint8_t *pix2, int line_size)

 }

 #endif

-int pix_abs16x16_x2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size)

+int pix_abs16x16_x2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int result = 0;

-    int h = 16;

     uint64_t disalign = (size_t) pix2 & 0x7;

     switch (disalign) {

@@ -234,10 +232,9 @@ int pix_abs16x16_x2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size)

     return result;

 }

-int pix_abs16x16_y2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size)

+int pix_abs16x16_y2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int result = 0;

-    int h = 16;

     if ((size_t) pix2 & 0x7) {

         uint64_t t, p2_l, p2_r;

@@ -288,10 +285,9 @@ int pix_abs16x16_y2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size)

     return result;

 }

-int pix_abs16x16_xy2_mvi(uint8_t *pix1, uint8_t *pix2, int line_size)

+int pix_abs16x16_xy2_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int result = 0;

-    int h = 16;

     uint64_t p1_l, p1_r;

     uint64_t p2_l, p2_r, p2_x;

@@ -17,7 +17,7 @@ extern "C" {

 #define FFMPEG_VERSION_INT     0x000408

 #define FFMPEG_VERSION         "0.4.8"

-#define LIBAVCODEC_BUILD       4697

+#define LIBAVCODEC_BUILD       4698

 #define LIBAVCODEC_VERSION_INT FFMPEG_VERSION_INT

 #define LIBAVCODEC_VERSION     FFMPEG_VERSION

@@ -263,7 +263,8 @@ static const __attribute__((unused)) int Motion_Est_QTab[] =

 #define CODEC_FLAG_H263P_AIV      0x00000008 ///< H263 Alternative inter vlc

 #define CODEC_FLAG_OBMC           0x00000001 ///< OBMC

 #define CODEC_FLAG_LOOP_FILTER    0x00000800 ///< loop filter

-#define CODEC_FLAG_H263P_SLICE_STRUCT 0x10000000 

+#define CODEC_FLAG_H263P_SLICE_STRUCT 0x10000000

+#define CODEC_FLAG_INTERLACED_ME  0x20000000 ///< interlaced motion estimation

 /* Unsupported options :

  * 		Syntax Arithmetic coding (SAC)

  * 		Reference Picture Selection

@@ -218,13 +218,13 @@ static void bswap_buf(uint32_t *dst, uint32_t *src, int w){

     }

 }

-static int sse8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size)

+static int sse8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)

 {

     int s, i;

     uint32_t *sq = squareTbl + 256;

     s = 0;

-    for (i = 0; i < 8; i++) {

+    for (i = 0; i < h; i++) {

         s += sq[pix1[0] - pix2[0]];

         s += sq[pix1[1] - pix2[1]];

         s += sq[pix1[2] - pix2[2]];

@@ -239,13 +239,13 @@ static int sse8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size)

     return s;

 }

-static int sse16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size)

+static int sse16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int s, i;

     uint32_t *sq = squareTbl + 256;

     s = 0;

-    for (i = 0; i < 16; i++) {

+    for (i = 0; i < h; i++) {

         s += sq[pix1[ 0] - pix2[ 0]];

         s += sq[pix1[ 1] - pix2[ 1]];

         s += sq[pix1[ 2] - pix2[ 2]];

@@ -2331,12 +2331,12 @@ static void h263_h_loop_filter_c(uint8_t *src, int stride, int qscale){

     }

 }

-static inline int pix_abs16x16_c(uint8_t *pix1, uint8_t *pix2, int line_size)

+static inline int pix_abs16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int s, i;

     s = 0;

-    for(i=0;i<16;i++) {

+    for(i=0;i<h;i++) {

         s += abs(pix1[0] - pix2[0]);

         s += abs(pix1[1] - pix2[1]);

         s += abs(pix1[2] - pix2[2]);

@@ -2359,12 +2359,12 @@ static inline int pix_abs16x16_c(uint8_t *pix1, uint8_t *pix2, int line_size)

     return s;

 }

-static int pix_abs16x16_x2_c(uint8_t *pix1, uint8_t *pix2, int line_size)

+static int pix_abs16_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int s, i;

     s = 0;

-    for(i=0;i<16;i++) {

+    for(i=0;i<h;i++) {

         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));

         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));

         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));

@@ -2387,13 +2387,13 @@ static int pix_abs16x16_x2_c(uint8_t *pix1, uint8_t *pix2, int line_size)

     return s;

 }

-static int pix_abs16x16_y2_c(uint8_t *pix1, uint8_t *pix2, int line_size)

+static int pix_abs16_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int s, i;

     uint8_t *pix3 = pix2 + line_size;

     s = 0;

-    for(i=0;i<16;i++) {

+    for(i=0;i<h;i++) {

         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));

         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));

         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));

@@ -2417,13 +2417,13 @@ static int pix_abs16x16_y2_c(uint8_t *pix1, uint8_t *pix2, int line_size)

     return s;

 }

-static int pix_abs16x16_xy2_c(uint8_t *pix1, uint8_t *pix2, int line_size)

+static int pix_abs16_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int s, i;

     uint8_t *pix3 = pix2 + line_size;

     s = 0;

-    for(i=0;i<16;i++) {

+    for(i=0;i<h;i++) {

         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));

         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));

         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));

@@ -2447,12 +2447,12 @@ static int pix_abs16x16_xy2_c(uint8_t *pix1, uint8_t *pix2, int line_size)

     return s;

 }

-static inline int pix_abs8x8_c(uint8_t *pix1, uint8_t *pix2, int line_size)

+static inline int pix_abs8_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int s, i;

     s = 0;

-    for(i=0;i<8;i++) {

+    for(i=0;i<h;i++) {

         s += abs(pix1[0] - pix2[0]);

         s += abs(pix1[1] - pix2[1]);

         s += abs(pix1[2] - pix2[2]);

@@ -2467,12 +2467,12 @@ static inline int pix_abs8x8_c(uint8_t *pix1, uint8_t *pix2, int line_size)

     return s;

 }

-static int pix_abs8x8_x2_c(uint8_t *pix1, uint8_t *pix2, int line_size)

+static int pix_abs8_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int s, i;

     s = 0;

-    for(i=0;i<8;i++) {

+    for(i=0;i<h;i++) {

         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));

         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));

         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));

@@ -2487,13 +2487,13 @@ static int pix_abs8x8_x2_c(uint8_t *pix1, uint8_t *pix2, int line_size)

     return s;

 }

-static int pix_abs8x8_y2_c(uint8_t *pix1, uint8_t *pix2, int line_size)

+static int pix_abs8_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int s, i;

     uint8_t *pix3 = pix2 + line_size;

     s = 0;

-    for(i=0;i<8;i++) {

+    for(i=0;i<h;i++) {

         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));

         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));

         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));

@@ -2509,13 +2509,13 @@ static int pix_abs8x8_y2_c(uint8_t *pix1, uint8_t *pix2, int line_size)

     return s;

 }

-static int pix_abs8x8_xy2_c(uint8_t *pix1, uint8_t *pix2, int line_size)

+static int pix_abs8_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)

 {

     int s, i;

     uint8_t *pix3 = pix2 + line_size;

     s = 0;

-    for(i=0;i<8;i++) {

+    for(i=0;i<h;i++) {

         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));

         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));

         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));

@@ -2531,14 +2531,6 @@ static int pix_abs8x8_xy2_c(uint8_t *pix1, uint8_t *pix2, int line_size)

     return s;

 }

-static int sad16x16_c(void *s, uint8_t *a, uint8_t *b, int stride){

-    return pix_abs16x16_c(a,b,stride);

-}

-

-static int sad8x8_c(void *s, uint8_t *a, uint8_t *b, int stride){

-    return pix_abs8x8_c(a,b,stride);

-}

-

 /**

  * permutes an 8x8 block.

  * @param block the block which will be permuted according to the given permutation vector

@@ -2641,10 +2633,12 @@ o2= (i1)-(i2);

 #define BUTTERFLYA(x,y) (ABS((x)+(y)) + ABS((x)-(y)))

-static int hadamard8_diff_c(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride){

+static int hadamard8_diff8x8_c(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h){

     int i;

     int temp[64];

     int sum=0;

+    

+    assert(h==8);

     for(i=0; i<8; i++){

         //FIXME try pointer walks

@@ -2735,11 +2729,13 @@ static int hadamard8_abs_c(uint8_t *src, int stride, int mean){

     return sum;

 }

-static int dct_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride){

+static int dct_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){

     MpegEncContext * const s= (MpegEncContext *)c;

     uint64_t __align8 aligned_temp[sizeof(DCTELEM)*64/8];

     DCTELEM * const temp= (DCTELEM*)aligned_temp;

     int sum=0, i;

+    

+    assert(h==8);

     s->dsp.diff_pixels(temp, src1, src2, stride);

     s->dsp.fdct(temp);

@@ -2752,13 +2748,14 @@ static int dct_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2

 void simple_idct(DCTELEM *block); //FIXME

-static int quant_psnr8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride){

+static int quant_psnr8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){

     MpegEncContext * const s= (MpegEncContext *)c;

     uint64_t __align8 aligned_temp[sizeof(DCTELEM)*64*2/8];

     DCTELEM * const temp= (DCTELEM*)aligned_temp;

     DCTELEM * const bak = ((DCTELEM*)aligned_temp)+64;

     int sum=0, i;

+    assert(h==8);

     s->mb_intra=0;

     s->dsp.diff_pixels(temp, src1, src2, stride);

@@ -2775,7 +2772,7 @@ static int quant_psnr8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *s

     return sum;

 }

-static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride){

+static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){

     MpegEncContext * const s= (MpegEncContext *)c;

     const uint8_t *scantable= s->intra_scantable.permutated;

     uint64_t __align8 aligned_temp[sizeof(DCTELEM)*64/8];

@@ -2787,6 +2784,8 @@ static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int

     uint8_t * length;

     uint8_t * last_length;

+    assert(h==8);

+

     for(i=0; i<8; i++){

         ((uint32_t*)(bak + i*stride))[0]= ((uint32_t*)(src2 + i*stride))[0];

         ((uint32_t*)(bak + i*stride))[1]= ((uint32_t*)(src2 + i*stride))[1];

@@ -2847,12 +2846,12 @@ static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int

     s->dsp.idct_add(bak, stride, temp);

-    distoration= s->dsp.sse[1](NULL, bak, src1, stride);

+    distoration= s->dsp.sse[1](NULL, bak, src1, stride, 8);

     return distoration + ((bits*s->qscale*s->qscale*109 + 64)>>7);

 }

-static int bit8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride){

+static int bit8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){

     MpegEncContext * const s= (MpegEncContext *)c;

     const uint8_t *scantable= s->intra_scantable.permutated;

     uint64_t __align8 aligned_temp[sizeof(DCTELEM)*64/8];

@@ -2861,6 +2860,8 @@ static int bit8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, in

     const int esc_length= s->ac_esc_length;

     uint8_t * length;

     uint8_t * last_length;

+

+    assert(h==8);

     s->dsp.diff_pixels(temp, src1, src2, stride);

@@ -2910,12 +2911,11 @@ static int bit8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, in

     return bits;

 }

-

-WARPER88_1616(hadamard8_diff_c, hadamard8_diff16_c)

-WARPER88_1616(dct_sad8x8_c, dct_sad16x16_c)

-WARPER88_1616(quant_psnr8x8_c, quant_psnr16x16_c)

-WARPER88_1616(rd8x8_c, rd16x16_c)

-WARPER88_1616(bit8x8_c, bit16x16_c)

+WARPER8_16_SQ(hadamard8_diff8x8_c, hadamard8_diff16_c)

+WARPER8_16_SQ(dct_sad8x8_c, dct_sad16_c)

+WARPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c)

+WARPER8_16_SQ(rd8x8_c, rd16_c)

+WARPER8_16_SQ(bit8x8_c, bit16_c)

 /* XXX: those functions should be suppressed ASAP when all IDCTs are

  converted */

@@ -2989,18 +2989,16 @@ void dsputil_init(DSPContext* c, AVCodecContext *avctx)

     c->clear_blocks = clear_blocks_c;

     c->pix_sum = pix_sum_c;

     c->pix_norm1 = pix_norm1_c;

-    c->sse[0]= sse16_c;

-    c->sse[1]= sse8_c;

     /* TODO [0] 16  [1] 8 */

-    c->pix_abs16x16     = pix_abs16x16_c;

-    c->pix_abs16x16_x2  = pix_abs16x16_x2_c;

-    c->pix_abs16x16_y2  = pix_abs16x16_y2_c;

-    c->pix_abs16x16_xy2 = pix_abs16x16_xy2_c;

-    c->pix_abs8x8     = pix_abs8x8_c;

-    c->pix_abs8x8_x2  = pix_abs8x8_x2_c;

-    c->pix_abs8x8_y2  = pix_abs8x8_y2_c;

-    c->pix_abs8x8_xy2 = pix_abs8x8_xy2_c;

+    c->pix_abs[0][0] = pix_abs16_c;

+    c->pix_abs[0][1] = pix_abs16_x2_c;

+    c->pix_abs[0][2] = pix_abs16_y2_c;

+    c->pix_abs[0][3] = pix_abs16_xy2_c;

+    c->pix_abs[1][0] = pix_abs8_c;

+    c->pix_abs[1][1] = pix_abs8_x2_c;

+    c->pix_abs[1][2] = pix_abs8_y2_c;

+    c->pix_abs[1][3] = pix_abs8_xy2_c;

 #define dspfunc(PFX, IDX, NUM) \

     c->PFX ## _pixels_tab[IDX][0] = PFX ## _pixels ## NUM ## _c;     \

@@ -3097,24 +3095,21 @@ void dsputil_init(DSPContext* c, AVCodecContext *avctx)

     c->put_mspel_pixels_tab[6]= put_mspel8_mc22_c;

     c->put_mspel_pixels_tab[7]= put_mspel8_mc32_c;

-    c->hadamard8_diff[0]= hadamard8_diff16_c;

-    c->hadamard8_diff[1]= hadamard8_diff_c;

     c->hadamard8_abs = hadamard8_abs_c;

-    

-    c->dct_sad[0]= dct_sad16x16_c;

-    c->dct_sad[1]= dct_sad8x8_c;

-    

-    c->sad[0]= sad16x16_c;

-    c->sad[1]= sad8x8_c;

-    

-    c->quant_psnr[0]= quant_psnr16x16_c;

-    c->quant_psnr[1]= quant_psnr8x8_c;

-

-    c->rd[0]= rd16x16_c;

-    c->rd[1]= rd8x8_c;

-    c->bit[0]= bit16x16_c;

-    c->bit[1]= bit8x8_c;

+#define SET_CMP_FUNC(name) \

+    c->name[0]= name ## 16_c;\

+    c->name[1]= name ## 8x8_c;

+    

+    SET_CMP_FUNC(hadamard8_diff)

+    SET_CMP_FUNC(dct_sad)

+    c->sad[0]= pix_abs16_c;

+    c->sad[1]= pix_abs8_c;

+    c->sse[0]= sse16_c;

+    c->sse[1]= sse8_c;

+    SET_CMP_FUNC(quant_psnr)

+    SET_CMP_FUNC(rd)

+    SET_CMP_FUNC(bit)

     c->add_bytes= add_bytes_c;

     c->diff_bytes= diff_bytes_c;

@@ -110,9 +110,7 @@ static void a(uint8_t *block, const uint8_t *pixels, int line_size, int h){\

 /* motion estimation */

-typedef int (*op_pixels_abs_func)(uint8_t *blk1/*align width (8 or 16)*/, uint8_t *blk2/*align 1*/, int line_size)/* __attribute__ ((const))*/;

-

-typedef int (*me_cmp_func)(void /*MpegEncContext*/ *s, uint8_t *blk1/*align width (8 or 16)*/, uint8_t *blk2/*align 1*/, int line_size)/* __attribute__ ((const))*/;

+typedef int (*me_cmp_func)(void /*MpegEncContext*/ *s, uint8_t *blk1/*align width (8 or 16)*/, uint8_t *blk2/*align 1*/, int line_size, int h)/* __attribute__ ((const))*/;

 /**

@@ -136,19 +134,21 @@ typedef struct DSPContext {

     void (*clear_blocks)(DCTELEM *blocks/*align 16*/);

     int (*pix_sum)(uint8_t * pix, int line_size);

     int (*pix_norm1)(uint8_t * pix, int line_size);

-    me_cmp_func sad[2]; /* identical to pix_absAxA except additional void * */

-    me_cmp_func sse[2];

-    me_cmp_func hadamard8_diff[2];

-    me_cmp_func dct_sad[2];

-    me_cmp_func quant_psnr[2];

-    me_cmp_func bit[2];

-    me_cmp_func rd[2];

+// 16x16 8x8 4x4 2x2 16x8 8x4 4x2 8x16 4x8 2x4

+    

+    me_cmp_func sad[4]; /* identical to pix_absAxA except additional void * */

+    me_cmp_func sse[4];

+    me_cmp_func hadamard8_diff[4];

+    me_cmp_func dct_sad[4];

+    me_cmp_func quant_psnr[4];

+    me_cmp_func bit[4];

+    me_cmp_func rd[4];

     int (*hadamard8_abs )(uint8_t *src, int stride, int mean);

-    me_cmp_func me_pre_cmp[11];

-    me_cmp_func me_cmp[11];

-    me_cmp_func me_sub_cmp[11];

-    me_cmp_func mb_cmp[11];

+    me_cmp_func me_pre_cmp[5];

+    me_cmp_func me_cmp[5];

+    me_cmp_func me_sub_cmp[5];

+    me_cmp_func mb_cmp[5];

     /* maybe create an array for 16/8/4/2 functions */

     /**

@@ -226,14 +226,7 @@ typedef struct DSPContext {

     qpel_mc_func put_h264_qpel_pixels_tab[3][16];

     qpel_mc_func avg_h264_qpel_pixels_tab[3][16];

-    op_pixels_abs_func pix_abs16x16;

-    op_pixels_abs_func pix_abs16x16_x2;

-    op_pixels_abs_func pix_abs16x16_y2;

-    op_pixels_abs_func pix_abs16x16_xy2;

-    op_pixels_abs_func pix_abs8x8;

-    op_pixels_abs_func pix_abs8x8_x2;

-    op_pixels_abs_func pix_abs8x8_y2;

-    op_pixels_abs_func pix_abs8x8_xy2;

+    me_cmp_func pix_abs[2][4];

     /* huffyuv specific */

     void (*add_bytes)(uint8_t *dst/*align 16*/, uint8_t *src/*align 16*/, int w);

@@ -484,12 +477,24 @@ void ff_mdct_calc(MDCTContext *s, FFTSample *out,

                const FFTSample *input, FFTSample *tmp);

 void ff_mdct_end(MDCTContext *s);

-#define WARPER88_1616(name8, name16)\

-static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride){\

-    return name8(s, dst           , src           , stride)\

-          +name8(s, dst+8         , src+8         , stride)\

-          +name8(s, dst  +8*stride, src  +8*stride, stride)\

-          +name8(s, dst+8+8*stride, src+8+8*stride, stride);\

+#define WARPER8_16(name8, name16)\

+static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride, int h){\

+    return name8(s, dst           , src           , stride, h)\

+          +name8(s, dst+8         , src+8         , stride, h);\

+}

+

+#define WARPER8_16_SQ(name8, name16)\

+static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride, int h){\

+    int score=0;\

+    score +=name8(s, dst           , src           , stride, 8);\

+    score +=name8(s, dst+8         , src+8         , stride, 8);\

+    if(h==16){\

+        dst += 8*stride;\

+        src += 8*stride;\

+        score +=name8(s, dst           , src           , stride, 8);\

+        score +=name8(s, dst+8         , src+8         , stride, 8);\

+    }\

+    return score;\

 }

 #ifndef HAVE_LRINTF

@@ -582,8 +582,8 @@ static int is_intra_more_likely(MpegEncContext *s){

                 uint8_t *mb_ptr     = s->current_picture.data[0] + mb_x*16 + mb_y*16*s->linesize;

                 uint8_t *last_mb_ptr= s->last_picture.data   [0] + mb_x*16 + mb_y*16*s->linesize;

-		is_intra_likely += s->dsp.pix_abs16x16(last_mb_ptr, mb_ptr                    , s->linesize);

-                is_intra_likely -= s->dsp.pix_abs16x16(last_mb_ptr, last_mb_ptr+s->linesize*16, s->linesize);

+		is_intra_likely += s->dsp.sad[0](NULL, last_mb_ptr, mb_ptr                    , s->linesize, 16);

+                is_intra_likely -= s->dsp.sad[0](NULL, last_mb_ptr, last_mb_ptr+s->linesize*16, s->linesize, 16);

             }else{

                 if(IS_INTRA(s->current_picture.mb_type[mb_xy]))

                    is_intra_likely++;

@@ -479,9 +479,9 @@ void ff_clean_mpeg4_qscales(MpegEncContext *s){

     for(i=1; i<s->mb_num; i++){

         int mb_xy= s->mb_index2xy[i];

-        if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_INTER4V)){

-            s->mb_type[mb_xy]&= ~MB_TYPE_INTER4V;

-            s->mb_type[mb_xy]|= MB_TYPE_INTER;

+        if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){

+            s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_INTER4V;

+            s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;

         }

     }

@@ -508,9 +508,9 @@ void ff_clean_mpeg4_qscales(MpegEncContext *s){

         for(i=1; i<s->mb_num; i++){

             int mb_xy= s->mb_index2xy[i];

-            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&MB_TYPE_DIRECT)){

-                s->mb_type[mb_xy]&= ~MB_TYPE_DIRECT;

-                s->mb_type[mb_xy]|= MB_TYPE_BIDIR;

+            if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){

+                s->mb_type[mb_xy]&= ~CANDIDATE_MB_TYPE_DIRECT;

+                s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR;

             }

         }

     }

@@ -523,7 +523,7 @@ void ff_clean_mpeg4_qscales(MpegEncContext *s){

  */

 int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){

     const int mb_index= s->mb_x + s->mb_y*s->mb_stride;

-    const int colocated_mb_type= s->next_picture.mb_type[mb_index]; //FIXME or next?

+    const int colocated_mb_type= s->next_picture.mb_type[mb_index];

     int xy= s->block_index[0];

     uint16_t time_pp= s->pp_time;

     uint16_t time_pb= s->pb_time;

@@ -547,18 +547,18 @@ int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){

         s->mv_type = MV_TYPE_FIELD;

         for(i=0; i<2; i++){

             if(s->top_field_first){

-                time_pp= s->pp_field_time - s->field_select_table[mb_index][i] + i;

-                time_pb= s->pb_field_time - s->field_select_table[mb_index][i] + i;

+                time_pp= s->pp_field_time - s->p_field_select_table[i][mb_index] + i;

+                time_pb= s->pb_field_time - s->p_field_select_table[i][mb_index] + i;

             }else{

-                time_pp= s->pp_field_time + s->field_select_table[mb_index][i] - i;

-                time_pb= s->pb_field_time + s->field_select_table[mb_index][i] - i;

+                time_pp= s->pp_field_time + s->p_field_select_table[i][mb_index] - i;

+                time_pb= s->pb_field_time + s->p_field_select_table[i][mb_index] - i;

             }

-            s->mv[0][i][0] = s->field_mv_table[mb_index][i][0]*time_pb/time_pp + mx;

-            s->mv[0][i][1] = s->field_mv_table[mb_index][i][1]*time_pb/time_pp + my;

-            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->field_mv_table[mb_index][i][0]

-                                : s->field_mv_table[mb_index][i][0]*(time_pb - time_pp)/time_pp;

-            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->field_mv_table[mb_index][i][1] 

-                                : s->field_mv_table[mb_index][i][1]*(time_pb - time_pp)/time_pp;

+            s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx;

+            s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my;

+            s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0]

+                                : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp;

+            s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] 

+                                : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp;

         }

         return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED;

     }else{

@@ -598,9 +598,9 @@ void ff_h263_update_motion_val(MpegEncContext * s){

             motion_y = s->mv[0][0][1] + s->mv[0][1][1];

             motion_x = (motion_x>>1) | (motion_x&1);

             for(i=0; i<2; i++){

-                s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];

-                s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];

-                s->field_select_table[mb_xy][i]= s->field_select[0][i];

+                s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0];

+                s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1];

+                s->p_field_select_table[i][mb_xy]= s->field_select[0][i];

             }

         }

@@ -744,12 +744,14 @@ void mpeg4_encode_mb(MpegEncContext * s,

         if(s->pict_type==B_TYPE){

             static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */

             int mb_type=  mb_type_table[s->mv_dir];

-            

+

             if(s->mb_x==0){

-                s->last_mv[0][0][0]= 

-                s->last_mv[0][0][1]= 

-                s->last_mv[1][0][0]= 

-                s->last_mv[1][0][1]= 0;

+                for(i=0; i<2; i++){

+                    s->last_mv[i][0][0]= 

+                    s->last_mv[i][0][1]= 

+                    s->last_mv[i][1][0]= 

+                    s->last_mv[i][1][1]= 0;

+                }

             }

             assert(s->dquant>=-2 && s->dquant<=2);

@@ -803,50 +805,64 @@ void mpeg4_encode_mb(MpegEncContext * s,

                 if(cbp)

                     put_bits(&s->pb, 1, s->interlaced_dct);

                 if(mb_type) // not diect mode

-                    put_bits(&s->pb, 1, 0); // no interlaced ME yet

+                    put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);

             }

             if(interleaved_stats){

                 s->misc_bits+= get_bits_diff(s);

             }

-            switch(mb_type)

-            {

-            case 0: /* direct */

+            if(mb_type == 0){

+                assert(s->mv_dir & MV_DIRECT);

                 h263_encode_motion(s, motion_x, 1);

                 h263_encode_motion(s, motion_y, 1);                

                 s->b_count++;

                 s->f_count++;

-                break;

-            case 1: /* bidir */

-                h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);

-                h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);

-                h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);

-                h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);

-                s->last_mv[0][0][0]= s->mv[0][0][0];

-                s->last_mv[0][0][1]= s->mv[0][0][1];

-                s->last_mv[1][0][0]= s->mv[1][0][0];

-                s->last_mv[1][0][1]= s->mv[1][0][1];

-                s->b_count++;

-                s->f_count++;

-                break;

-            case 2: /* backward */

-                h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);

-                h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);

-                s->last_mv[1][0][0]= motion_x;

-                s->last_mv[1][0][1]= motion_y;

-                s->b_count++;

-                break;

-            case 3: /* forward */

-                h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);

-                h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);

-                s->last_mv[0][0][0]= motion_x;

-                s->last_mv[0][0][1]= motion_y;

-                s->f_count++;

-                break;

-            default:

-                av_log(s->avctx, AV_LOG_ERROR, "unknown mb type\n");

-                return;

+            }else{

+                assert(mb_type > 0 && mb_type < 4);

+                if(s->mv_type != MV_TYPE_FIELD){

+                    if(s->mv_dir & MV_DIR_FORWARD){

+                        h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);

+                        h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);

+                        s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0];

+                        s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1];

+                        s->f_count++;

+                    }

+                    if(s->mv_dir & MV_DIR_BACKWARD){

+                        h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);

+                        h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);

+                        s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0];

+                        s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1];

+                        s->b_count++;

+                    }

+                }else{

+                    if(s->mv_dir & MV_DIR_FORWARD){

+                        put_bits(&s->pb, 1, s->field_select[0][0]);

+                        put_bits(&s->pb, 1, s->field_select[0][1]);

+                    }

+                    if(s->mv_dir & MV_DIR_BACKWARD){

+                        put_bits(&s->pb, 1, s->field_select[1][0]);

+                        put_bits(&s->pb, 1, s->field_select[1][1]);

+                    }

+                    if(s->mv_dir & MV_DIR_FORWARD){

+                        for(i=0; i<2; i++){

+                            h263_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0]  , s->f_code);

+                            h263_encode_motion(s, s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code);

+                            s->last_mv[0][i][0]= s->mv[0][i][0];

+                            s->last_mv[0][i][1]= s->mv[0][i][1]*2;

+                        }

+                        s->f_count++;

+                    }

+                    if(s->mv_dir & MV_DIR_BACKWARD){

+                        for(i=0; i<2; i++){

+                            h263_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0]  , s->b_code);

+                            h263_encode_motion(s, s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code);

+                            s->last_mv[1][i][0]= s->mv[1][i][0];

+                            s->last_mv[1][i][1]= s->mv[1][i][1]*2;

+                        }

+                        s->b_count++;

+                    }

+                }

             }

             if(interleaved_stats){

@@ -861,6 +877,7 @@ void mpeg4_encode_mb(MpegEncContext * s,

             if(interleaved_stats){

                 s->p_tex_bits+= get_bits_diff(s);

             }

+

         }else{ /* s->pict_type==B_TYPE */

             cbp= get_p_cbp(s, block, motion_x, motion_y);

@@ -889,7 +906,7 @@ void mpeg4_encode_mb(MpegEncContext * s,

                         if(pic==NULL || pic->pict_type!=B_TYPE) break;

                         b_pic= pic->data[0] + offset + 16; //FIXME +16

-			diff= s->dsp.pix_abs16x16(p_pic, b_pic, s->linesize);

+			diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16);

                         if(diff>s->qscale*70){ //FIXME check that 70 is optimal

                             s->mb_skiped=0;

                             break;

@@ -929,7 +946,7 @@ void mpeg4_encode_mb(MpegEncContext * s,

                 if(!s->progressive_sequence){

                     if(cbp)

                         put_bits(pb2, 1, s->interlaced_dct);

-                    put_bits(pb2, 1, 0); // no interlaced ME yet

+                    put_bits(pb2, 1, 0);

                 }