@@ -1604,7 +1604,7 @@ test_deps _muxer _demuxer                                               \

     mmf                                                                 \

     mov                                                                 \

     pcm_mulaw=mulaw                                                     \

-    mxf                                                                 \

+    mxf="mxf mxf_d10"                                                   \

     nut                                                                 \

     ogg                                                                 \

     rawvideo=pixfmt                                                     \

@@ -38,8 +38,8 @@ Force displayed width.

 @item -y @var{height}

 Force displayed height.

 @item -s @var{size}

-Set frame size (WxH or abbreviation), needed for videos which don't

-contain a header with the frame size like raw YUV.

+This option has been removed. Use private format options for specifying the

+input video size.

 @item -an

 Disable audio.

 @item -vn

@@ -89,7 +89,8 @@ Read @var{input_file}.

 @section Advanced options

 @table @option

 @item -pix_fmt @var{format}

-Set pixel format.

+This option has been removed. Use private options for specifying the

+input pixel format.

 @item -stats

 Show the stream duration, the codec parameters, the current position in

 the stream and the audio/video synchronisation drift.

@@ -2323,16 +2323,19 @@ static int transcode(AVFormatContext **output_files,

                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");

                     ffmpeg_exit(1);

                 }

+

+                if (!codec->width || !codec->height) {

+                    codec->width  = icodec->width;

+                    codec->height = icodec->height;

+                }

+

                 ost->video_resample = codec->width   != icodec->width  ||

                                       codec->height  != icodec->height ||

                                       codec->pix_fmt != icodec->pix_fmt;

                 if (ost->video_resample) {

                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;

                 }

-                if (!codec->width || !codec->height) {

-                    codec->width  = icodec->width;

-                    codec->height = icodec->height;

-                }

+

                 ost->resample_height = icodec->height;

                 ost->resample_width  = icodec->width;

                 ost->resample_pix_fmt= icodec->pix_fmt;

@@ -223,9 +223,6 @@ static int fs_screen_width;

 static int fs_screen_height;

 static int screen_width = 0;

 static int screen_height = 0;

-static int frame_width = 0;

-static int frame_height = 0;

-static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;

 static int audio_disable;

 static int video_disable;

 static int wanted_stream[AVMEDIA_TYPE_NB]={

@@ -2813,15 +2810,9 @@ static void event_loop(void)

 static int opt_frame_size(const char *opt, const char *arg)

 {

-    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {

-        fprintf(stderr, "Incorrect frame size\n");

-        return AVERROR(EINVAL);

-    }

-    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {

-        fprintf(stderr, "Frame size must be a multiple of 2\n");

-        return AVERROR(EINVAL);

-    }

-    return 0;

+    av_log(NULL, AV_LOG_ERROR,

+           "Option '%s' has been removed, use private format options instead\n", opt);

+    return AVERROR(EINVAL);

 }

 static int opt_width(const char *opt, const char *arg)

@@ -2848,8 +2839,9 @@ static int opt_format(const char *opt, const char *arg)

 static int opt_frame_pix_fmt(const char *opt, const char *arg)

 {

-    frame_pix_fmt = av_get_pix_fmt(arg);

-    return 0;

+    av_log(NULL, AV_LOG_ERROR,

+           "Option '%s' has been removed, use private format options instead\n", opt);

+    return AVERROR(EINVAL);

 }

 static int opt_sync(const char *opt, const char *arg)

@@ -166,6 +166,140 @@ void ff_init_cabac_states(CABACContext *c){

 #include "avcodec.h"

 #include "cabac.h"

+static void put_cabac(CABACContext *c, uint8_t * const state, int bit){

+    int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + *state];

+

+    if(bit == ((*state)&1)){

+        c->range -= RangeLPS;

+        *state= ff_h264_mps_state[*state];

+    }else{

+        c->low += c->range - RangeLPS;

+        c->range = RangeLPS;

+        *state= ff_h264_lps_state[*state];

+    }

+

+    renorm_cabac_encoder(c);

+

+#ifdef STRICT_LIMITS

+    c->symCount++;

+#endif

+}

+

+/**

+ * @param bit 0 -> write zero bit, !=0 write one bit

+ */

+static void put_cabac_bypass(CABACContext *c, int bit){

+    c->low += c->low;

+

+    if(bit){

+        c->low += c->range;

+    }

+//FIXME optimize

+    if(c->low<0x200){

+        put_cabac_bit(c, 0);

+    }else if(c->low<0x400){

+        c->outstanding_count++;

+        c->low -= 0x200;

+    }else{

+        put_cabac_bit(c, 1);

+        c->low -= 0x400;

+    }

+

+#ifdef STRICT_LIMITS

+    c->symCount++;

+#endif

+}

+

+/**

+ *

+ * @return the number of bytes written

+ */

+static int put_cabac_terminate(CABACContext *c, int bit){

+    c->range -= 2;

+

+    if(!bit){

+        renorm_cabac_encoder(c);

+    }else{

+        c->low += c->range;

+        c->range= 2;

+

+        renorm_cabac_encoder(c);

+

+        assert(c->low <= 0x1FF);

+        put_cabac_bit(c, c->low>>9);

+        put_bits(&c->pb, 2, ((c->low>>7)&3)|1);

+

+        flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong

+    }

+

+#ifdef STRICT_LIMITS

+    c->symCount++;

+#endif

+

+    return (put_bits_count(&c->pb)+7)>>3;

+}

+

+/**

+ * put (truncated) unary binarization.

+ */

+static void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){

+    int i;

+

+    assert(v <= max);

+

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

+        put_cabac(c, state, 1);

+        if(i < max_index) state++;

+    }

+    if(truncated==0 || v<max)

+        put_cabac(c, state, 0);

+}

+

+/**

+ * put unary exp golomb k-th order binarization.

+ */

+static void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int max, int is_signed, int k, int max_index){

+    int i;

+

+    if(v==0)

+        put_cabac(c, state, 0);

+    else{

+        const int sign= v < 0;

+

+        if(is_signed) v= FFABS(v);

+

+        if(v<max){

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

+                put_cabac(c, state, 1);

+                if(i < max_index) state++;

+            }

+

+            put_cabac(c, state, 0);

+        }else{

+            int m= 1<<k;

+

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

+                put_cabac(c, state, 1);

+                if(i < max_index) state++;

+            }

+

+            v -= max;

+            while(v >= m){ //FIXME optimize

+                put_cabac_bypass(c, 1);

+                v-= m;

+                m+= m;

+            }

+            put_cabac_bypass(c, 0);

+            while(m>>=1){

+                put_cabac_bypass(c, v&m);

+            }

+        }

+

+        if(is_signed)

+            put_cabac_bypass(c, sign);

+    }

+}

+

 int main(void){

     CABACContext c;

     uint8_t b[9*SIZE];

@@ -90,178 +90,6 @@ static inline void renorm_cabac_encoder(CABACContext *c){

     }

 }

-#ifdef TEST

-static void put_cabac(CABACContext *c, uint8_t * const state, int bit){

-    int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + *state];

-

-    if(bit == ((*state)&1)){

-        c->range -= RangeLPS;

-        *state= ff_h264_mps_state[*state];

-    }else{

-        c->low += c->range - RangeLPS;

-        c->range = RangeLPS;

-        *state= ff_h264_lps_state[*state];

-    }

-

-    renorm_cabac_encoder(c);

-

-#ifdef STRICT_LIMITS

-    c->symCount++;

-#endif

-}

-

-static void put_cabac_static(CABACContext *c, int RangeLPS, int bit){

-    assert(c->range > RangeLPS);

-

-    if(!bit){

-        c->range -= RangeLPS;

-    }else{

-        c->low += c->range - RangeLPS;

-        c->range = RangeLPS;

-    }

-

-    renorm_cabac_encoder(c);

-

-#ifdef STRICT_LIMITS

-    c->symCount++;

-#endif

-}

-

-/**

- * @param bit 0 -> write zero bit, !=0 write one bit

- */

-static void put_cabac_bypass(CABACContext *c, int bit){

-    c->low += c->low;

-

-    if(bit){

-        c->low += c->range;

-    }

-//FIXME optimize

-    if(c->low<0x200){

-        put_cabac_bit(c, 0);

-    }else if(c->low<0x400){

-        c->outstanding_count++;

-        c->low -= 0x200;

-    }else{

-        put_cabac_bit(c, 1);

-        c->low -= 0x400;

-    }

-

-#ifdef STRICT_LIMITS

-    c->symCount++;

-#endif

-}

-

-/**

- *

- * @return the number of bytes written

- */

-static int put_cabac_terminate(CABACContext *c, int bit){

-    c->range -= 2;

-

-    if(!bit){

-        renorm_cabac_encoder(c);

-    }else{

-        c->low += c->range;

-        c->range= 2;

-

-        renorm_cabac_encoder(c);

-

-        assert(c->low <= 0x1FF);

-        put_cabac_bit(c, c->low>>9);

-        put_bits(&c->pb, 2, ((c->low>>7)&3)|1);

-

-        flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong

-    }

-

-#ifdef STRICT_LIMITS

-    c->symCount++;

-#endif

-

-    return (put_bits_count(&c->pb)+7)>>3;

-}

-

-/**

- * put (truncated) unary binarization.

- */

-static void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){

-    int i;

-

-    assert(v <= max);

-

-#if 1

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

-        put_cabac(c, state, 1);

-        if(i < max_index) state++;

-    }

-    if(truncated==0 || v<max)

-        put_cabac(c, state, 0);

-#else

-    if(v <= max_index){

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

-            put_cabac(c, state+i, 1);

-        }

-        if(truncated==0 || v<max)

-            put_cabac(c, state+i, 0);

-    }else{

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

-            put_cabac(c, state+i, 1);

-        }

-        for(; i<v; i++){

-            put_cabac(c, state+max_index, 1);

-        }

-        if(truncated==0 || v<max)

-            put_cabac(c, state+max_index, 0);

-    }

-#endif

-}

-

-/**

- * put unary exp golomb k-th order binarization.

- */

-static void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int max, int is_signed, int k, int max_index){

-    int i;

-

-    if(v==0)

-        put_cabac(c, state, 0);

-    else{

-        const int sign= v < 0;

-

-        if(is_signed) v= FFABS(v);

-

-        if(v<max){

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

-                put_cabac(c, state, 1);

-                if(i < max_index) state++;

-            }

-

-            put_cabac(c, state, 0);

-        }else{

-            int m= 1<<k;

-

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

-                put_cabac(c, state, 1);

-                if(i < max_index) state++;

-            }

-

-            v -= max;

-            while(v >= m){ //FIXME optimize

-                put_cabac_bypass(c, 1);

-                v-= m;

-                m+= m;

-            }

-            put_cabac_bypass(c, 0);

-            while(m>>=1){

-                put_cabac_bypass(c, v&m);

-            }

-        }

-

-        if(is_signed)

-            put_cabac_bypass(c, sign);

-    }

-}

-#endif /* TEST */

-

 static void refill(CABACContext *c){

 #if CABAC_BITS == 16

         c->low+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);

@@ -190,7 +190,6 @@ static void idct_mmx_init(void)

 DECLARE_ALIGNED(16, static DCTELEM, block)[64];

 DECLARE_ALIGNED(8,  static DCTELEM, block1)[64];

-DECLARE_ALIGNED(8,  static DCTELEM, block_org)[64];

 static inline void mmx_emms(void)

 {

@@ -246,9 +245,6 @@ static int dct_error(const struct algo *dct, int test, int is_idct, int speed, c

             break;

         }

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

-            block_org[i] = block1[i];

-

         if (dct->format == MMX_PERM) {

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

                 block[idct_mmx_perm[i]] = block1[i];

@@ -2832,7 +2832,7 @@ av_cold void dsputil_static_init(void)

 int ff_check_alignment(void){

     static int did_fail=0;

-    DECLARE_ALIGNED(16, int, aligned);

+    LOCAL_ALIGNED_16(int, aligned);

     if((intptr_t)&aligned & 15){

         if(!did_fail){

@@ -374,30 +374,6 @@ int ff_init_me(MpegEncContext *s){

     return 0;

 }

-#if 0

-static int pix_dev(uint8_t * pix, int line_size, int mean)

-{

-    int s, i, j;

-

-    s = 0;

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

-        for (j = 0; j < 16; j += 8) {

-            s += FFABS(pix[0]-mean);

-            s += FFABS(pix[1]-mean);

-            s += FFABS(pix[2]-mean);

-            s += FFABS(pix[3]-mean);

-            s += FFABS(pix[4]-mean);

-            s += FFABS(pix[5]-mean);

-            s += FFABS(pix[6]-mean);

-            s += FFABS(pix[7]-mean);

-            pix += 8;

-        }

-        pix += line_size - 16;

-    }

-    return s;

-}

-#endif

-

 static inline void no_motion_search(MpegEncContext * s,

                                     int *mx_ptr, int *my_ptr)

 {

@@ -1214,30 +1190,6 @@ void ff_estimate_p_frame_motion(MpegEncContext * s,

             intra_score= s->dsp.mb_cmp[0](s, c->scratchpad, pix, s->linesize, 16);

         }

-#if 0 //FIXME

-        /* get chroma score */

-        if(c->avctx->mb_cmp&FF_CMP_CHROMA){

-            for(i=1; i<3; i++){

-                uint8_t *dest_c;

-                int mean;

-

-                if(s->out_format == FMT_H263){

-                    mean= (s->dc_val[i][mb_x + mb_y*s->b8_stride] + 4)>>3; //FIXME not exact but simple ;)

-                }else{

-                    mean= (s->last_dc[i] + 4)>>3;

-                }

-                dest_c = s->new_picture.f.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;

-

-                mean*= 0x01010101;

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

-                    *(uint32_t*)(&c->scratchpad[i*s->uvlinesize+ 0]) = mean;

-                    *(uint32_t*)(&c->scratchpad[i*s->uvlinesize+ 4]) = mean;

-                }

-

-                intra_score+= s->dsp.mb_cmp[1](s, c->scratchpad, dest_c, s->uvlinesize);

-            }

-        }

-#endif

         intra_score += c->mb_penalty_factor*16;

         if(intra_score < dmin){

@@ -1850,10 +1802,6 @@ void ff_estimate_b_frame_motion(MpegEncContext * s,

         if(dmin>256*256*16) type&= ~CANDIDATE_MB_TYPE_DIRECT; //do not try direct mode if it is invalid for this MB

         if(s->codec_id == CODEC_ID_MPEG4 && type&CANDIDATE_MB_TYPE_DIRECT && s->flags&CODEC_FLAG_MV0 && *(uint32_t*)s->b_direct_mv_table[xy])

             type |= CANDIDATE_MB_TYPE_DIRECT0;

-#if 0

-        if(s->out_format == FMT_MPEG1)

-            type |= CANDIDATE_MB_TYPE_INTRA;

-#endif

     }

     s->mb_type[mb_y*s->mb_stride + mb_x]= type;

@@ -44,75 +44,6 @@

     COPY3_IF_LT(dmin, d, bx, hx, by, hy)\

 }

-#if 0

-static int hpel_motion_search)(MpegEncContext * s,

-                                  int *mx_ptr, int *my_ptr, int dmin,

-                                  uint8_t *ref_data[3],

-                                  int size)

-{

-    const int xx = 16 * s->mb_x + 8*(n&1);

-    const int yy = 16 * s->mb_y + 8*(n>>1);

-    const int mx = *mx_ptr;

-    const int my = *my_ptr;

-    const int penalty_factor= c->sub_penalty_factor;

-

-    LOAD_COMMON

-

- //   INIT;

- //FIXME factorize

-    me_cmp_func cmp, chroma_cmp, cmp_sub, chroma_cmp_sub;

-

-    if(s->no_rounding /*FIXME b_type*/){

-        hpel_put= &s->dsp.put_no_rnd_pixels_tab[size];

-        chroma_hpel_put= &s->dsp.put_no_rnd_pixels_tab[size+1];

-    }else{

-        hpel_put=& s->dsp.put_pixels_tab[size];

-        chroma_hpel_put= &s->dsp.put_pixels_tab[size+1];

-    }

-    cmpf= s->dsp.me_cmp[size];

-    chroma_cmpf= s->dsp.me_cmp[size+1];

-    cmp_sub= s->dsp.me_sub_cmp[size];

-    chroma_cmp_sub= s->dsp.me_sub_cmp[size+1];

-

-    if(c->skip){ //FIXME somehow move up (benchmark)

-        *mx_ptr = 0;

-        *my_ptr = 0;

-        return dmin;

-    }

-

-    if(c->avctx->me_cmp != c->avctx->me_sub_cmp){

-        CMP_HPEL(dmin, 0, 0, mx, my, size);

-        if(mx || my)

-            dmin += (mv_penalty[2*mx - pred_x] + mv_penalty[2*my - pred_y])*penalty_factor;

-    }

-

-    if (mx > xmin && mx < xmax &&

-        my > ymin && my < ymax) {

-        int bx=2*mx, by=2*my;

-        int d= dmin;

-

-        CHECK_HALF_MV(1, 1, mx-1, my-1)

-        CHECK_HALF_MV(0, 1, mx  , my-1)

-        CHECK_HALF_MV(1, 1, mx  , my-1)

-        CHECK_HALF_MV(1, 0, mx-1, my  )

-        CHECK_HALF_MV(1, 0, mx  , my  )

-        CHECK_HALF_MV(1, 1, mx-1, my  )

-        CHECK_HALF_MV(0, 1, mx  , my  )

-        CHECK_HALF_MV(1, 1, mx  , my  )

-

-        assert(bx >= xmin*2 || bx <= xmax*2 || by >= ymin*2 || by <= ymax*2);

-

-        *mx_ptr = bx;

-        *my_ptr = by;

-    }else{

-        *mx_ptr =2*mx;

-        *my_ptr =2*my;

-    }

-

-    return dmin;

-}

-

-#else

 static int hpel_motion_search(MpegEncContext * s,

                                   int *mx_ptr, int *my_ptr, int dmin,

                                   int src_index, int ref_index,

@@ -220,7 +151,6 @@ static int hpel_motion_search(MpegEncContext * s,

     return dmin;

 }

-#endif

 static int no_sub_motion_search(MpegEncContext * s,

           int *mx_ptr, int *my_ptr, int dmin,

@@ -323,7 +253,6 @@ static int qpel_motion_search(MpegEncContext * s,

         int best_pos[8][2];

         memset(best, 64, sizeof(int)*8);

-#if 1

         if(s->me.dia_size>=2){

             const int tl= score_map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];

             const int bl= score_map[(index+(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];

@@ -412,76 +341,6 @@ static int qpel_motion_search(MpegEncContext * s,

             CHECK_QUARTER_MV(nx&3, ny&3, nx>>2, ny>>2)

         }

-#if 0

-            const int tl= score_map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];

-            const int bl= score_map[(index+(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];

-            const int tr= score_map[(index-(1<<ME_MAP_SHIFT)+1)&(ME_MAP_SIZE-1)];

-            const int br= score_map[(index+(1<<ME_MAP_SHIFT)+1)&(ME_MAP_SIZE-1)];

-//            if(l < r && l < t && l < b && l < tl && l < bl && l < tr && l < br && bl < tl){

-            if(tl<br){

-

-//            nx= FFMAX(4*mx - bx, bx - 4*mx);

-//            ny= FFMAX(4*my - by, by - 4*my);

-

-            static int stats[7][7], count;

-            count++;

-            stats[4*mx - bx + 3][4*my - by + 3]++;

-            if(256*256*256*64 % count ==0){

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

-                    if((i%7)==0) printf("\n");

-                    printf("%6d ", stats[0][i]);

-                }

-                printf("\n");

-            }

-            }

-#endif

-#else

-

-        CHECK_QUARTER_MV(2, 2, mx-1, my-1)

-        CHECK_QUARTER_MV(0, 2, mx  , my-1)

-        CHECK_QUARTER_MV(2, 2, mx  , my-1)

-        CHECK_QUARTER_MV(2, 0, mx  , my  )

-        CHECK_QUARTER_MV(2, 2, mx  , my  )

-        CHECK_QUARTER_MV(0, 2, mx  , my  )

-        CHECK_QUARTER_MV(2, 2, mx-1, my  )

-        CHECK_QUARTER_MV(2, 0, mx-1, my  )

-

-        nx= bx;

-        ny= by;

-

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

-            int ox[8]= {0, 1, 1, 1, 0,-1,-1,-1};

-            int oy[8]= {1, 1, 0,-1,-1,-1, 0, 1};

-            CHECK_QUARTER_MV((nx + ox[i])&3, (ny + oy[i])&3, (nx + ox[i])>>2, (ny + oy[i])>>2)

-        }

-#endif

-#if 0

-        //outer ring

-        CHECK_QUARTER_MV(1, 3, mx-1, my-1)

-        CHECK_QUARTER_MV(1, 2, mx-1, my-1)

-        CHECK_QUARTER_MV(1, 1, mx-1, my-1)

-        CHECK_QUARTER_MV(2, 1, mx-1, my-1)

-        CHECK_QUARTER_MV(3, 1, mx-1, my-1)

-        CHECK_QUARTER_MV(0, 1, mx  , my-1)

-        CHECK_QUARTER_MV(1, 1, mx  , my-1)

-        CHECK_QUARTER_MV(2, 1, mx  , my-1)

-        CHECK_QUARTER_MV(3, 1, mx  , my-1)

-        CHECK_QUARTER_MV(3, 2, mx  , my-1)

-        CHECK_QUARTER_MV(3, 3, mx  , my-1)

-        CHECK_QUARTER_MV(3, 0, mx  , my  )

-        CHECK_QUARTER_MV(3, 1, mx  , my  )

-        CHECK_QUARTER_MV(3, 2, mx  , my  )

-        CHECK_QUARTER_MV(3, 3, mx  , my  )

-        CHECK_QUARTER_MV(2, 3, mx  , my  )

-        CHECK_QUARTER_MV(1, 3, mx  , my  )

-        CHECK_QUARTER_MV(0, 3, mx  , my  )

-        CHECK_QUARTER_MV(3, 3, mx-1, my  )

-        CHECK_QUARTER_MV(2, 3, mx-1, my  )

-        CHECK_QUARTER_MV(1, 3, mx-1, my  )

-        CHECK_QUARTER_MV(1, 2, mx-1, my  )

-        CHECK_QUARTER_MV(1, 1, mx-1, my  )

-        CHECK_QUARTER_MV(1, 0, mx-1, my  )

-#endif

         assert(bx >= xmin*4 && bx <= xmax*4 && by >= ymin*4 && by <= ymax*4);

         *mx_ptr = bx;

@@ -34,17 +34,6 @@

 #include "mathops.h"

 #include "simple_idct.h"

-#if 0

-#define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */

-#define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */

-#define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */

-#define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */

-#define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */

-#define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */

-#define W7 565  /* 2048*sqrt (2)*cos (7*pi/16) */

-#define ROW_SHIFT 8

-#define COL_SHIFT 17

-#else

 #define W1  22725  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

 #define W2  21407  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

 #define W3  19266  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

@@ -54,7 +43,6 @@

 #define W7  4520   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

 #define ROW_SHIFT 11

 #define COL_SHIFT 20 // 6

-#endif

 static inline void idctRowCondDC (DCTELEM * row)

 {

@@ -74,20 +74,11 @@ extern VLC ff_vc1_ac_coeff_table[8];

 //@}

-#if 0 //original bfraction from vc9data.h, not conforming to standard

-/* Denominator used for ff_vc1_bfraction_lut */

-#define B_FRACTION_DEN  840

-

-/* bfraction is fractional, we scale to the GCD 3*5*7*8 = 840 */

-extern const int16_t ff_vc1_bfraction_lut[23];

-#else

 /* Denominator used for ff_vc1_bfraction_lut */

 #define B_FRACTION_DEN  256

 /* pre-computed scales for all bfractions and base=256 */

 extern const int16_t ff_vc1_bfraction_lut[23];

-#endif

-

 extern const uint8_t ff_vc1_bfraction_bits[23];

 extern const uint8_t ff_vc1_bfraction_codes[23];

@@ -37,11 +37,7 @@

 #define C1 22725 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

 #define C2 21407 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

 #define C3 19266 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

-#if 0

-#define C4 16384 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

-#else

 #define C4 16383 //cos(i*M_PI/16)*sqrt(2)*(1<<14) - 0.5

-#endif

 #define C5 12873 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

 #define C6 8867  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

 #define C7 4520  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

@@ -80,135 +76,6 @@ DECLARE_ALIGNED(8, static const int16_t, coeffs)[]= {

  C3, -C1,  C3, -C1

 };

-#if 0

-static void unused_var_killer(void)

-{

-        int a= wm1010 + d40000;

-        temp[0]=a;

-}

-

-static void inline idctCol (int16_t * col, int16_t *input)

-{

-#undef C0

-#undef C1

-#undef C2

-#undef C3

-#undef C4

-#undef C5

-#undef C6

-#undef C7

-        int a0, a1, a2, a3, b0, b1, b2, b3;

-        const int C0 = 23170; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

-        const int C1 = 22725; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

-        const int C2 = 21407; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

-        const int C3 = 19266; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

-        const int C4 = 16383; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

-        const int C5 = 12873; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

-        const int C6 = 8867;  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

-        const int C7 = 4520;  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5

-/*

-        if( !(col[8*1] | col[8*2] |col[8*3] |col[8*4] |col[8*5] |col[8*6] | col[8*7])) {

-                col[8*0] = col[8*1] = col[8*2] = col[8*3] = col[8*4] =

-                        col[8*5] = col[8*6] = col[8*7] = col[8*0]<<3;

-                return;

-        }*/

-

-col[8*0] = input[8*0 + 0];

-col[8*1] = input[8*2 + 0];

-col[8*2] = input[8*0 + 1];

-col[8*3] = input[8*2 + 1];

-col[8*4] = input[8*4 + 0];

-col[8*5] = input[8*6 + 0];

-col[8*6] = input[8*4 + 1];

-col[8*7] = input[8*6 + 1];

-

-        a0 = C4*col[8*0] + C2*col[8*2] + C4*col[8*4] + C6*col[8*6] + (1<<(COL_SHIFT-1));

-        a1 = C4*col[8*0] + C6*col[8*2] - C4*col[8*4] - C2*col[8*6] + (1<<(COL_SHIFT-1));

-        a2 = C4*col[8*0] - C6*col[8*2] - C4*col[8*4] + C2*col[8*6] + (1<<(COL_SHIFT-1));

-        a3 = C4*col[8*0] - C2*col[8*2] + C4*col[8*4] - C6*col[8*6] + (1<<(COL_SHIFT-1));

-

-        b0 = C1*col[8*1] + C3*col[8*3] + C5*col[8*5] + C7*col[8*7];

-        b1 = C3*col[8*1] - C7*col[8*3] - C1*col[8*5] - C5*col[8*7];

-        b2 = C5*col[8*1] - C1*col[8*3] + C7*col[8*5] + C3*col[8*7];

-        b3 = C7*col[8*1] - C5*col[8*3] + C3*col[8*5] - C1*col[8*7];

-

-        col[8*0] = (a0 + b0) >> COL_SHIFT;

-        col[8*1] = (a1 + b1) >> COL_SHIFT;

-        col[8*2] = (a2 + b2) >> COL_SHIFT;

-        col[8*3] = (a3 + b3) >> COL_SHIFT;

-        col[8*4] = (a3 - b3) >> COL_SHIFT;

-        col[8*5] = (a2 - b2) >> COL_SHIFT;

-        col[8*6] = (a1 - b1) >> COL_SHIFT;