LCOV - code coverage report
Current view: directory - media/libvpx/vp8/common - mbpitch.c (source / functions) Found Hit Coverage
Test: app.info Lines: 48 0 0.0 %
Date: 2012-06-02 Functions: 4 0 0.0 %

       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 "blockd.h"
      13                 : 
      14                 : typedef enum
      15                 : {
      16                 :     PRED = 0,
      17                 :     DEST = 1
      18                 : } BLOCKSET;
      19                 : 
      20               0 : static void setup_block
      21                 : (
      22                 :     BLOCKD *b,
      23                 :     int mv_stride,
      24                 :     unsigned char **base,
      25                 :     int Stride,
      26                 :     int offset,
      27                 :     BLOCKSET bs
      28                 : )
      29                 : {
      30                 : 
      31               0 :     if (bs == DEST)
      32                 :     {
      33               0 :         b->dst_stride = Stride;
      34               0 :         b->dst = offset;
      35               0 :         b->base_dst = base;
      36                 :     }
      37                 :     else
      38                 :     {
      39               0 :         b->pre_stride = Stride;
      40               0 :         b->pre = offset;
      41               0 :         b->base_pre = base;
      42                 :     }
      43                 : 
      44               0 : }
      45                 : 
      46                 : 
      47               0 : static void setup_macroblock(MACROBLOCKD *x, BLOCKSET bs)
      48                 : {
      49                 :     int block;
      50                 : 
      51                 :     unsigned char **y, **u, **v;
      52                 : 
      53               0 :     if (bs == DEST)
      54                 :     {
      55               0 :         y = &x->dst.y_buffer;
      56               0 :         u = &x->dst.u_buffer;
      57               0 :         v = &x->dst.v_buffer;
      58                 :     }
      59                 :     else
      60                 :     {
      61               0 :         y = &x->pre.y_buffer;
      62               0 :         u = &x->pre.u_buffer;
      63               0 :         v = &x->pre.v_buffer;
      64                 :     }
      65                 : 
      66               0 :     for (block = 0; block < 16; block++) /* y blocks */
      67                 :     {
      68               0 :         setup_block(&x->block[block], x->dst.y_stride, y, x->dst.y_stride,
      69               0 :                         (block >> 2) * 4 * x->dst.y_stride + (block & 3) * 4, bs);
      70                 :     }
      71                 : 
      72               0 :     for (block = 16; block < 20; block++) /* U and V blocks */
      73                 :     {
      74               0 :         setup_block(&x->block[block], x->dst.uv_stride, u, x->dst.uv_stride,
      75               0 :                         ((block - 16) >> 1) * 4 * x->dst.uv_stride + (block & 1) * 4, bs);
      76                 : 
      77               0 :         setup_block(&x->block[block+4], x->dst.uv_stride, v, x->dst.uv_stride,
      78               0 :                         ((block - 16) >> 1) * 4 * x->dst.uv_stride + (block & 1) * 4, bs);
      79                 :     }
      80               0 : }
      81                 : 
      82               0 : void vp8_setup_block_dptrs(MACROBLOCKD *x)
      83                 : {
      84                 :     int r, c;
      85                 : 
      86               0 :     for (r = 0; r < 4; r++)
      87                 :     {
      88               0 :         for (c = 0; c < 4; c++)
      89                 :         {
      90               0 :             x->block[r*4+c].diff      = &x->diff[r * 4 * 16 + c * 4];
      91               0 :             x->block[r*4+c].predictor = x->predictor + r * 4 * 16 + c * 4;
      92                 :         }
      93                 :     }
      94                 : 
      95               0 :     for (r = 0; r < 2; r++)
      96                 :     {
      97               0 :         for (c = 0; c < 2; c++)
      98                 :         {
      99               0 :             x->block[16+r*2+c].diff      = &x->diff[256 + r * 4 * 8 + c * 4];
     100               0 :             x->block[16+r*2+c].predictor = x->predictor + 256 + r * 4 * 8 + c * 4;
     101                 : 
     102                 :         }
     103                 :     }
     104                 : 
     105               0 :     for (r = 0; r < 2; r++)
     106                 :     {
     107               0 :         for (c = 0; c < 2; c++)
     108                 :         {
     109               0 :             x->block[20+r*2+c].diff      = &x->diff[320+ r * 4 * 8 + c * 4];
     110               0 :             x->block[20+r*2+c].predictor = x->predictor + 320 + r * 4 * 8 + c * 4;
     111                 : 
     112                 :         }
     113                 :     }
     114                 : 
     115               0 :     x->block[24].diff = &x->diff[384];
     116                 : 
     117               0 :     for (r = 0; r < 25; r++)
     118                 :     {
     119               0 :         x->block[r].qcoeff  = x->qcoeff  + r * 16;
     120               0 :         x->block[r].dqcoeff = x->dqcoeff + r * 16;
     121                 :     }
     122               0 : }
     123                 : 
     124               0 : void vp8_build_block_doffsets(MACROBLOCKD *x)
     125                 : {
     126                 : 
     127                 :     /* handle the destination pitch features */
     128               0 :     setup_macroblock(x, DEST);
     129               0 :     setup_macroblock(x, PRED);
     130               0 : }

Generated by: LCOV version 1.7