LCOV - code coverage report
Current view: top level - libavcodec - rv34dsp.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 57 57 100.0 %
Date: 2017-12-10 21:22:29 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * RV30/40 decoder common dsp functions
       3             :  * Copyright (c) 2007 Mike Melanson, Konstantin Shishkov
       4             :  * Copyright (c) 2011 Janne Grunau
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : /**
      24             :  * @file
      25             :  * RV30/40 decoder common dsp functions
      26             :  */
      27             : 
      28             : #include "rv34dsp.h"
      29             : #include "libavutil/common.h"
      30             : 
      31             : /**
      32             :  * @name RV30/40 inverse transform functions
      33             :  * @{
      34             :  */
      35             : 
      36      373191 : static av_always_inline void rv34_row_transform(int temp[16], int16_t *block)
      37             : {
      38             :     int i;
      39             : 
      40     1865955 :     for(i = 0; i < 4; i++){
      41     1492764 :         const int z0 = 13*(block[i+4*0] +    block[i+4*2]);
      42     1492764 :         const int z1 = 13*(block[i+4*0] -    block[i+4*2]);
      43     1492764 :         const int z2 =  7* block[i+4*1] - 17*block[i+4*3];
      44     1492764 :         const int z3 = 17* block[i+4*1] +  7*block[i+4*3];
      45             : 
      46     1492764 :         temp[4*i+0] = z0 + z3;
      47     1492764 :         temp[4*i+1] = z1 + z2;
      48     1492764 :         temp[4*i+2] = z1 - z2;
      49     1492764 :         temp[4*i+3] = z0 - z3;
      50             :     }
      51      373191 : }
      52             : 
      53             : /**
      54             :  * Real Video 3.0/4.0 inverse transform + sample reconstruction
      55             :  * Code is almost the same as in SVQ3, only scaling is different.
      56             :  */
      57      365013 : static void rv34_idct_add_c(uint8_t *dst, ptrdiff_t stride, int16_t *block){
      58             :     int      temp[16];
      59             :     int      i;
      60             : 
      61      365013 :     rv34_row_transform(temp, block);
      62      365013 :     memset(block, 0, 16*sizeof(int16_t));
      63             : 
      64     1825065 :     for(i = 0; i < 4; i++){
      65     1460052 :         const int z0 = 13*(temp[4*0+i] +    temp[4*2+i]) + 0x200;
      66     1460052 :         const int z1 = 13*(temp[4*0+i] -    temp[4*2+i]) + 0x200;
      67     1460052 :         const int z2 =  7* temp[4*1+i] - 17*temp[4*3+i];
      68     1460052 :         const int z3 = 17* temp[4*1+i] +  7*temp[4*3+i];
      69             : 
      70     1460052 :         dst[0] = av_clip_uint8( dst[0] + ( (z0 + z3) >> 10 ) );
      71     1460052 :         dst[1] = av_clip_uint8( dst[1] + ( (z1 + z2) >> 10 ) );
      72     1460052 :         dst[2] = av_clip_uint8( dst[2] + ( (z1 - z2) >> 10 ) );
      73     1460052 :         dst[3] = av_clip_uint8( dst[3] + ( (z0 - z3) >> 10 ) );
      74             : 
      75     1460052 :         dst  += stride;
      76             :     }
      77      365013 : }
      78             : 
      79             : /**
      80             :  * RealVideo 3.0/4.0 inverse transform for DC block
      81             :  *
      82             :  * Code is almost the same as rv34_inv_transform()
      83             :  * but final coefficients are multiplied by 1.5 and have no rounding.
      84             :  */
      85        8178 : static void rv34_inv_transform_noround_c(int16_t *block){
      86             :     int temp[16];
      87             :     int i;
      88             : 
      89        8178 :     rv34_row_transform(temp, block);
      90             : 
      91       40890 :     for(i = 0; i < 4; i++){
      92       32712 :         const int z0 = 39*(temp[4*0+i] +    temp[4*2+i]);
      93       32712 :         const int z1 = 39*(temp[4*0+i] -    temp[4*2+i]);
      94       32712 :         const int z2 = 21* temp[4*1+i] - 51*temp[4*3+i];
      95       32712 :         const int z3 = 51* temp[4*1+i] + 21*temp[4*3+i];
      96             : 
      97       32712 :         block[i*4+0] = (z0 + z3) >> 11;
      98       32712 :         block[i*4+1] = (z1 + z2) >> 11;
      99       32712 :         block[i*4+2] = (z1 - z2) >> 11;
     100       32712 :         block[i*4+3] = (z0 - z3) >> 11;
     101             :     }
     102        8178 : }
     103             : 
     104      617612 : static void rv34_idct_dc_add_c(uint8_t *dst, ptrdiff_t stride, int dc)
     105             : {
     106             :     int i, j;
     107             : 
     108      617612 :     dc = (13*13*dc + 0x200) >> 10;
     109     3088060 :     for (i = 0; i < 4; i++)
     110             :     {
     111    12352240 :         for (j = 0; j < 4; j++)
     112     9881792 :             dst[j] = av_clip_uint8( dst[j] + dc );
     113             : 
     114     2470448 :         dst += stride;
     115             :     }
     116      617612 : }
     117             : 
     118        9175 : static void rv34_inv_transform_dc_noround_c(int16_t *block)
     119             : {
     120        9175 :     int16_t dc = (13 * 13 * 3 * block[0]) >> 11;
     121             :     int i, j;
     122             : 
     123       45875 :     for (i = 0; i < 4; i++, block += 4)
     124      183500 :         for (j = 0; j < 4; j++)
     125      146800 :             block[j] = dc;
     126        9175 : }
     127             : 
     128             : /** @} */ // transform
     129             : 
     130             : 
     131           9 : av_cold void ff_rv34dsp_init(RV34DSPContext *c)
     132             : {
     133           9 :     c->rv34_inv_transform    = rv34_inv_transform_noround_c;
     134           9 :     c->rv34_inv_transform_dc = rv34_inv_transform_dc_noround_c;
     135             : 
     136           9 :     c->rv34_idct_add    = rv34_idct_add_c;
     137           9 :     c->rv34_idct_dc_add = rv34_idct_dc_add_c;
     138             : 
     139             :     if (ARCH_ARM)
     140             :         ff_rv34dsp_init_arm(c);
     141             :     if (ARCH_X86)
     142           9 :         ff_rv34dsp_init_x86(c);
     143           9 : }

Generated by: LCOV version 1.13