LCOV - code coverage report
Current view: directory - media/libvpx/vp8/common - extend.c (source / functions) Found Hit Coverage
Test: app.info Lines: 54 0 0.0 %
Date: 2012-06-02 Functions: 3 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 "extend.h"
      13                 : #include "vpx_mem/vpx_mem.h"
      14                 : 
      15                 : 
      16               0 : static void copy_and_extend_plane
      17                 : (
      18                 :     unsigned char *s, /* source */
      19                 :     int sp,           /* source pitch */
      20                 :     unsigned char *d, /* destination */
      21                 :     int dp,           /* destination pitch */
      22                 :     int h,            /* height */
      23                 :     int w,            /* width */
      24                 :     int et,           /* extend top border */
      25                 :     int el,           /* extend left border */
      26                 :     int eb,           /* extend bottom border */
      27                 :     int er            /* extend right border */
      28                 : )
      29                 : {
      30                 :     int i;
      31                 :     unsigned char *src_ptr1, *src_ptr2;
      32                 :     unsigned char *dest_ptr1, *dest_ptr2;
      33                 :     int linesize;
      34                 : 
      35                 :     /* copy the left and right most columns out */
      36               0 :     src_ptr1 = s;
      37               0 :     src_ptr2 = s + w - 1;
      38               0 :     dest_ptr1 = d - el;
      39               0 :     dest_ptr2 = d + w;
      40                 : 
      41               0 :     for (i = 0; i < h; i++)
      42                 :     {
      43               0 :         vpx_memset(dest_ptr1, src_ptr1[0], el);
      44               0 :         vpx_memcpy(dest_ptr1 + el, src_ptr1, w);
      45               0 :         vpx_memset(dest_ptr2, src_ptr2[0], er);
      46               0 :         src_ptr1  += sp;
      47               0 :         src_ptr2  += sp;
      48               0 :         dest_ptr1 += dp;
      49               0 :         dest_ptr2 += dp;
      50                 :     }
      51                 : 
      52                 :     /* Now copy the top and bottom lines into each line of the respective
      53                 :      * borders
      54                 :      */
      55               0 :     src_ptr1 = d - el;
      56               0 :     src_ptr2 = d + dp * (h - 1) - el;
      57               0 :     dest_ptr1 = d + dp * (-et) - el;
      58               0 :     dest_ptr2 = d + dp * (h) - el;
      59               0 :     linesize = el + er + w;
      60                 : 
      61               0 :     for (i = 0; i < et; i++)
      62                 :     {
      63               0 :         vpx_memcpy(dest_ptr1, src_ptr1, linesize);
      64               0 :         dest_ptr1 += dp;
      65                 :     }
      66                 : 
      67               0 :     for (i = 0; i < eb; i++)
      68                 :     {
      69               0 :         vpx_memcpy(dest_ptr2, src_ptr2, linesize);
      70               0 :         dest_ptr2 += dp;
      71                 :     }
      72               0 : }
      73                 : 
      74                 : 
      75               0 : void vp8_copy_and_extend_frame(YV12_BUFFER_CONFIG *src,
      76                 :                                YV12_BUFFER_CONFIG *dst)
      77                 : {
      78               0 :     int et = dst->border;
      79               0 :     int el = dst->border;
      80               0 :     int eb = dst->border + dst->y_height - src->y_height;
      81               0 :     int er = dst->border + dst->y_width - src->y_width;
      82                 : 
      83               0 :     copy_and_extend_plane(src->y_buffer, src->y_stride,
      84                 :                           dst->y_buffer, dst->y_stride,
      85                 :                           src->y_height, src->y_width,
      86                 :                           et, el, eb, er);
      87                 : 
      88               0 :     et = dst->border >> 1;
      89               0 :     el = dst->border >> 1;
      90               0 :     eb = (dst->border >> 1) + dst->uv_height - src->uv_height;
      91               0 :     er = (dst->border >> 1) + dst->uv_width - src->uv_width;
      92                 : 
      93               0 :     copy_and_extend_plane(src->u_buffer, src->uv_stride,
      94                 :                           dst->u_buffer, dst->uv_stride,
      95                 :                           src->uv_height, src->uv_width,
      96                 :                           et, el, eb, er);
      97                 : 
      98               0 :     copy_and_extend_plane(src->v_buffer, src->uv_stride,
      99                 :                           dst->v_buffer, dst->uv_stride,
     100                 :                           src->uv_height, src->uv_width,
     101                 :                           et, el, eb, er);
     102               0 : }
     103                 : 
     104                 : 
     105                 : /* note the extension is only for the last row, for intra prediction purpose */
     106               0 : void vp8_extend_mb_row(YV12_BUFFER_CONFIG *ybf, unsigned char *YPtr, unsigned char *UPtr, unsigned char *VPtr)
     107                 : {
     108                 :     int i;
     109                 : 
     110               0 :     YPtr += ybf->y_stride * 14;
     111               0 :     UPtr += ybf->uv_stride * 6;
     112               0 :     VPtr += ybf->uv_stride * 6;
     113                 : 
     114               0 :     for (i = 0; i < 4; i++)
     115                 :     {
     116               0 :         YPtr[i] = YPtr[-1];
     117               0 :         UPtr[i] = UPtr[-1];
     118               0 :         VPtr[i] = VPtr[-1];
     119                 :     }
     120                 : 
     121               0 :     YPtr += ybf->y_stride;
     122               0 :     UPtr += ybf->uv_stride;
     123               0 :     VPtr += ybf->uv_stride;
     124                 : 
     125               0 :     for (i = 0; i < 4; i++)
     126                 :     {
     127               0 :         YPtr[i] = YPtr[-1];
     128               0 :         UPtr[i] = UPtr[-1];
     129               0 :         VPtr[i] = VPtr[-1];
     130                 :     }
     131               0 : }

Generated by: LCOV version 1.7