Home | History | Annotate | Download | only in common
      1 /*
      2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 
     12 #include "vpx_ports/config.h"
     13 #include "recon.h"
     14 #include "blockd.h"
     15 
     16 void vp8_recon_b_c
     17 (
     18     unsigned char *pred_ptr,
     19     short *diff_ptr,
     20     unsigned char *dst_ptr,
     21     int stride
     22 )
     23 {
     24     int r, c;
     25 
     26     for (r = 0; r < 4; r++)
     27     {
     28         for (c = 0; c < 4; c++)
     29         {
     30             int a = diff_ptr[c] + pred_ptr[c] ;
     31 
     32             if (a < 0)
     33                 a = 0;
     34 
     35             if (a > 255)
     36                 a = 255;
     37 
     38             dst_ptr[c] = (unsigned char) a ;
     39         }
     40 
     41         dst_ptr += stride;
     42         diff_ptr += 16;
     43         pred_ptr += 16;
     44     }
     45 }
     46 
     47 void vp8_recon4b_c
     48 (
     49     unsigned char *pred_ptr,
     50     short *diff_ptr,
     51     unsigned char *dst_ptr,
     52     int stride
     53 )
     54 {
     55     int r, c;
     56 
     57     for (r = 0; r < 4; r++)
     58     {
     59         for (c = 0; c < 16; c++)
     60         {
     61             int a = diff_ptr[c] + pred_ptr[c] ;
     62 
     63             if (a < 0)
     64                 a = 0;
     65 
     66             if (a > 255)
     67                 a = 255;
     68 
     69             dst_ptr[c] = (unsigned char) a ;
     70         }
     71 
     72         dst_ptr += stride;
     73         diff_ptr += 16;
     74         pred_ptr += 16;
     75     }
     76 }
     77 
     78 void vp8_recon2b_c
     79 (
     80     unsigned char *pred_ptr,
     81     short *diff_ptr,
     82     unsigned char *dst_ptr,
     83     int stride
     84 )
     85 {
     86     int r, c;
     87 
     88     for (r = 0; r < 4; r++)
     89     {
     90         for (c = 0; c < 8; c++)
     91         {
     92             int a = diff_ptr[c] + pred_ptr[c] ;
     93 
     94             if (a < 0)
     95                 a = 0;
     96 
     97             if (a > 255)
     98                 a = 255;
     99 
    100             dst_ptr[c] = (unsigned char) a ;
    101         }
    102 
    103         dst_ptr += stride;
    104         diff_ptr += 8;
    105         pred_ptr += 8;
    106     }
    107 }
    108 
    109 void vp8_recon_mby_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *x)
    110 {
    111 #if ARCH_ARM
    112     BLOCKD *b = &x->block[0];
    113     RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    114 
    115     /*b = &x->block[4];*/
    116     b += 4;
    117     RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    118 
    119     /*b = &x->block[8];*/
    120     b += 4;
    121     RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    122 
    123     /*b = &x->block[12];*/
    124     b += 4;
    125     RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    126 #else
    127     int i;
    128 
    129     for (i = 0; i < 16; i += 4)
    130     {
    131         BLOCKD *b = &x->block[i];
    132 
    133         RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    134     }
    135 #endif
    136 }
    137 
    138 void vp8_recon_mb_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *x)
    139 {
    140 #if ARCH_ARM
    141     BLOCKD *b = &x->block[0];
    142 
    143     RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    144     b += 4;
    145     RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    146     b += 4;
    147     RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    148     b += 4;
    149     RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    150     b += 4;
    151 
    152     /*b = &x->block[16];*/
    153 
    154     RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    155     b++;
    156     b++;
    157     RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    158     b++;
    159     b++;
    160     RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    161     b++;
    162     b++;
    163     RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    164 #else
    165     int i;
    166 
    167     for (i = 0; i < 16; i += 4)
    168     {
    169         BLOCKD *b = &x->block[i];
    170 
    171         RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    172     }
    173 
    174     for (i = 16; i < 24; i += 2)
    175     {
    176         BLOCKD *b = &x->block[i];
    177 
    178         RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
    179     }
    180 #endif
    181 }
    182