Simplify eq()

[ffmpeg] / libavcodec / vp56.c

diff --git a/libavcodec/vp56.c b/libavcodec/vp56.c
index 7f28ed0f7acb95ded9e6408f3268875a7e5612c2..c9daaf780013510a90c6e1c974876130bfca993a 100644 (file)
--- a/libavcodec/vp56.c
+++ b/libavcodec/vp56.c
@@ -261,13 +261,14 @@ static vp56_mb_t vp56_decode_mv(vp56_context_t *s, int row, int col)
 static void vp56_add_predictors_dc(vp56_context_t *s, vp56_frame_t ref_frame)
 {
     int idx = s->scantable.permutated[0];
-    int i;
+    int b;
 
-    for (i=0; i<6; i++) {
-        vp56_ref_dc_t *ab = &s->above_blocks[s->above_block_idx[i]];
-        vp56_ref_dc_t *lb = &s->left_block[vp56_b6to4[i]];
+    for (b=0; b<6; b++) {
+        vp56_ref_dc_t *ab = &s->above_blocks[s->above_block_idx[b]];
+        vp56_ref_dc_t *lb = &s->left_block[vp56_b6to4[b]];
         int count = 0;
         int dc = 0;
+        int i;
 
         if (ref_frame == lb->ref_frame) {
             dc += lb->dc_coeff;
@@ -277,28 +278,24 @@ static void vp56_add_predictors_dc(vp56_context_t *s, vp56_frame_t ref_frame)
             dc += ab->dc_coeff;
             count++;
         }
-        if (s->avctx->codec->id == CODEC_ID_VP5) {
-            if (count < 2 && ref_frame == ab[-1].ref_frame) {
-                dc += ab[-1].dc_coeff;
-                count++;
-            }
-            if (count < 2 && ref_frame == ab[1].ref_frame) {
-                dc += ab[1].dc_coeff;
-                count++;
-            }
-        }
+        if (s->avctx->codec->id == CODEC_ID_VP5)
+            for (i=0; i<2; i++)
+                if (count < 2 && ref_frame == ab[-1+2*i].ref_frame) {
+                    dc += ab[-1+2*i].dc_coeff;
+                    count++;
+                }
         if (count == 0)
-            dc = s->prev_dc[vp56_b2p[i]][ref_frame];
+            dc = s->prev_dc[vp56_b2p[b]][ref_frame];
         else if (count == 2)
             dc /= 2;
 
-        s->block_coeff[i][idx] += dc;
-        s->prev_dc[vp56_b2p[i]][ref_frame] = s->block_coeff[i][idx];
-        ab->dc_coeff = s->block_coeff[i][idx];
+        s->block_coeff[b][idx] += dc;
+        s->prev_dc[vp56_b2p[b]][ref_frame] = s->block_coeff[b][idx];
+        ab->dc_coeff = s->block_coeff[b][idx];
         ab->ref_frame = ref_frame;
-        lb->dc_coeff = s->block_coeff[i][idx];
+        lb->dc_coeff = s->block_coeff[b][idx];
         lb->ref_frame = ref_frame;
-        s->block_coeff[i][idx] *= s->dequant_dc;
+        s->block_coeff[b][idx] *= s->dequant_dc;
     }
 }
 
@@ -400,7 +397,7 @@ static void vp56_decode_mb(vp56_context_t *s, int row, int col, int is_alpha)
     AVFrame *frame_current, *frame_ref;
     vp56_mb_t mb_type;
     vp56_frame_t ref_frame;
-    int b, ab, b_max, plan, off;
+    int b, ab, b_max, plane, off;
 
     if (s->framep[VP56_FRAME_CURRENT]->key_frame)
         mb_type = VP56_MB_INTRA;
@@ -423,22 +420,22 @@ static void vp56_decode_mb(vp56_context_t *s, int row, int col, int is_alpha)
     switch (mb_type) {
         case VP56_MB_INTRA:
             for (b=0; b<b_max; b++) {
-                plan = vp56_b2p[b+ab];
-                s->dsp.idct_put(frame_current->data[plan] + s->block_offset[b],
-                                s->stride[plan], s->block_coeff[b]);
+                plane = vp56_b2p[b+ab];
+                s->dsp.idct_put(frame_current->data[plane] + s->block_offset[b],
+                                s->stride[plane], s->block_coeff[b]);
             }
             break;
 
         case VP56_MB_INTER_NOVEC_PF:
         case VP56_MB_INTER_NOVEC_GF:
             for (b=0; b<b_max; b++) {
-                plan = vp56_b2p[b+ab];
+                plane = vp56_b2p[b+ab];
                 off = s->block_offset[b];
-                s->dsp.put_pixels_tab[1][0](frame_current->data[plan] + off,
-                                            frame_ref->data[plan] + off,
-                                            s->stride[plan], 8);
-                s->dsp.idct_add(frame_current->data[plan] + off,
-                                s->stride[plan], s->block_coeff[b]);
+                s->dsp.put_pixels_tab[1][0](frame_current->data[plane] + off,
+                                            frame_ref->data[plane] + off,
+                                            s->stride[plane], 8);
+                s->dsp.idct_add(frame_current->data[plane] + off,
+                                s->stride[plane], s->block_coeff[b]);
             }
             break;
 
@@ -452,11 +449,11 @@ static void vp56_decode_mb(vp56_context_t *s, int row, int col, int is_alpha)
             for (b=0; b<b_max; b++) {
                 int x_off = b==1 || b==3 ? 8 : 0;
                 int y_off = b==2 || b==3 ? 8 : 0;
-                plan = vp56_b2p[b+ab];
-                vp56_mc(s, b, plan, frame_ref->data[plan], s->stride[plan],
+                plane = vp56_b2p[b+ab];
+                vp56_mc(s, b, plane, frame_ref->data[plane], s->stride[plane],
                         16*col+x_off, 16*row+y_off);
-                s->dsp.idct_add(frame_current->data[plan] + s->block_offset[b],
-                                s->stride[plan], s->block_coeff[b]);
+                s->dsp.idct_add(frame_current->data[plane] + s->block_offset[b],
+                                s->stride[plane], s->block_coeff[b]);
             }
             break;
     }
@@ -498,15 +495,16 @@ static int vp56_size_changed(AVCodecContext *avctx)
 }
 
 int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
-                      uint8_t *buf, int buf_size)
+                      const uint8_t *buf, int buf_size)
 {
     vp56_context_t *s = avctx->priv_data;
     AVFrame *const p = s->framep[VP56_FRAME_CURRENT];
+    int remaining_buf_size = buf_size;
     int is_alpha, alpha_offset;
 
     if (s->has_alpha) {
         alpha_offset = bytestream_get_be24(&buf);
-        buf_size -= 3;
+        remaining_buf_size -= 3;
     }
 
     for (is_alpha=0; is_alpha < 1+s->has_alpha; is_alpha++) {
@@ -517,7 +515,7 @@ int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
 
         s->modelp = &s->models[is_alpha];
 
-        res = s->parse_header(s, buf, buf_size, &golden_frame);
+        res = s->parse_header(s, buf, remaining_buf_size, &golden_frame);
         if (!res)
             return -1;
 
@@ -554,12 +552,12 @@ int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
         s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
 
         for (block=0; block < 4*s->mb_width+6; block++) {
-            s->above_blocks[block].ref_frame = -1;
+            s->above_blocks[block].ref_frame = VP56_FRAME_NONE;
             s->above_blocks[block].dc_coeff = 0;
             s->above_blocks[block].not_null_dc = 0;
         }
-        s->above_blocks[2*s->mb_width + 2].ref_frame = 0;
-        s->above_blocks[3*s->mb_width + 4].ref_frame = 0;
+        s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT;
+        s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT;
 
         stride_y  = p->linesize[0];
         stride_uv = p->linesize[1];
@@ -575,7 +573,7 @@ int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
                 mb_row_flip = mb_row;
 
             for (block=0; block<4; block++) {
-                s->left_block[block].ref_frame = -1;
+                s->left_block[block].ref_frame = VP56_FRAME_NONE;
                 s->left_block[block].dc_coeff = 0;
                 s->left_block[block].not_null_dc = 0;
             }
@@ -622,7 +620,7 @@ int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
             FFSWAP(AVFrame *, s->framep[VP56_FRAME_GOLDEN],
                               s->framep[VP56_FRAME_GOLDEN2]);
             buf += alpha_offset;
-            buf_size -= alpha_offset;
+            remaining_buf_size -= alpha_offset;
         }
     }
 
@@ -646,7 +644,7 @@ int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
     return buf_size;
 }
 
-void vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
+av_cold void vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
 {
     vp56_context_t *s = avctx->priv_data;
     int i;
@@ -686,7 +684,7 @@ void vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
     }
 }
 
-int vp56_free(AVCodecContext *avctx)
+av_cold int vp56_free(AVCodecContext *avctx)
 {
     vp56_context_t *s = avctx->priv_data;