git.sesse.net Git - ffmpeg/blob - libavcodec/h264chroma_template.c

   1 /*
   2  * Copyright (c) 2000, 2001 Fabrice Bellard
   3  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <assert.h>
  23 #include <stddef.h>
  24
  25 #include "bit_depth_template.c"
  26
  27 #define H264_CHROMA_MC(OPNAME, OP)\
  28 static void FUNCC(OPNAME ## h264_chroma_mc2)(uint8_t *_dst /*align 8*/, uint8_t *_src /*align 1*/, ptrdiff_t stride, int h, int x, int y)\
  29 {\
  30     pixel *dst = (pixel*)_dst;\
  31     pixel *src = (pixel*)_src;\
  32     const int A=(8-x)*(8-y);\
  33     const int B=(  x)*(8-y);\
  34     const int C=(8-x)*(  y);\
  35     const int D=(  x)*(  y);\
  36     int i;\
  37     stride /= sizeof(pixel);\
  38     \
  39     assert(x<8 && y<8 && x>=0 && y>=0);\
  40 \
  41     if(D){\
  42         for(i=0; i<h; i++){\
  43             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
  44             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
  45             dst+= stride;\
  46             src+= stride;\
  47         }\
  48     } else if (B + C) {\
  49         const int E= B+C;\
  50         const ptrdiff_t step = C ? stride : 1;\
  51         for(i=0; i<h; i++){\
  52             OP(dst[0], (A*src[0] + E*src[step+0]));\
  53             OP(dst[1], (A*src[1] + E*src[step+1]));\
  54             dst+= stride;\
  55             src+= stride;\
  56         }\
  57     } else {\
  58         for ( i = 0; i < h; i++){\
  59             OP(dst[0], A * src[0]);\
  60             OP(dst[1], A * src[1]);\
  61             dst += stride;\
  62             src += stride;\
  63         }\
  64     }\
  65 }\
  66 \
  67 static void FUNCC(OPNAME ## h264_chroma_mc4)(uint8_t *_dst /*align 8*/, uint8_t *_src /*align 1*/, ptrdiff_t stride, int h, int x, int y)\
  68 {\
  69     pixel *dst = (pixel*)_dst;\
  70     pixel *src = (pixel*)_src;\
  71     const int A=(8-x)*(8-y);\
  72     const int B=(  x)*(8-y);\
  73     const int C=(8-x)*(  y);\
  74     const int D=(  x)*(  y);\
  75     int i;\
  76     stride /= sizeof(pixel);\
  77     \
  78     assert(x<8 && y<8 && x>=0 && y>=0);\
  79 \
  80     if(D){\
  81         for(i=0; i<h; i++){\
  82             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
  83             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
  84             OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
  85             OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
  86             dst+= stride;\
  87             src+= stride;\
  88         }\
  89     } else if (B + C) {\
  90         const int E= B+C;\
  91         const ptrdiff_t step = C ? stride : 1;\
  92         for(i=0; i<h; i++){\
  93             OP(dst[0], (A*src[0] + E*src[step+0]));\
  94             OP(dst[1], (A*src[1] + E*src[step+1]));\
  95             OP(dst[2], (A*src[2] + E*src[step+2]));\
  96             OP(dst[3], (A*src[3] + E*src[step+3]));\
  97             dst+= stride;\
  98             src+= stride;\
  99         }\
 100     } else {\
 101         for ( i = 0; i < h; i++){\
 102             OP(dst[0], A * src[0]);\
 103             OP(dst[1], A * src[1]);\
 104             OP(dst[2], A * src[2]);\
 105             OP(dst[3], A * src[3]);\
 106             dst += stride;\
 107             src += stride;\
 108         }\
 109     }\
 110 }\
 111 \
 112 static void FUNCC(OPNAME ## h264_chroma_mc8)(uint8_t *_dst /*align 8*/, uint8_t *_src /*align 1*/, ptrdiff_t stride, int h, int x, int y)\
 113 {\
 114     pixel *dst = (pixel*)_dst;\
 115     pixel *src = (pixel*)_src;\
 116     const int A=(8-x)*(8-y);\
 117     const int B=(  x)*(8-y);\
 118     const int C=(8-x)*(  y);\
 119     const int D=(  x)*(  y);\
 120     int i;\
 121     stride /= sizeof(pixel);\
 122     \
 123     assert(x<8 && y<8 && x>=0 && y>=0);\
 124 \
 125     if(D){\
 126         for(i=0; i<h; i++){\
 127             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
 128             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
 129             OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
 130             OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
 131             OP(dst[4], (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5]));\
 132             OP(dst[5], (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6]));\
 133             OP(dst[6], (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7]));\
 134             OP(dst[7], (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8]));\
 135             dst+= stride;\
 136             src+= stride;\
 137         }\
 138     } else if (B + C) {\
 139         const int E= B+C;\
 140         const ptrdiff_t step = C ? stride : 1;\
 141         for(i=0; i<h; i++){\
 142             OP(dst[0], (A*src[0] + E*src[step+0]));\
 143             OP(dst[1], (A*src[1] + E*src[step+1]));\
 144             OP(dst[2], (A*src[2] + E*src[step+2]));\
 145             OP(dst[3], (A*src[3] + E*src[step+3]));\
 146             OP(dst[4], (A*src[4] + E*src[step+4]));\
 147             OP(dst[5], (A*src[5] + E*src[step+5]));\
 148             OP(dst[6], (A*src[6] + E*src[step+6]));\
 149             OP(dst[7], (A*src[7] + E*src[step+7]));\
 150             dst+= stride;\
 151             src+= stride;\
 152         }\
 153     } else {\
 154         for ( i = 0; i < h; i++){\
 155             OP(dst[0], A * src[0]);\
 156             OP(dst[1], A * src[1]);\
 157             OP(dst[2], A * src[2]);\
 158             OP(dst[3], A * src[3]);\
 159             OP(dst[4], A * src[4]);\
 160             OP(dst[5], A * src[5]);\
 161             OP(dst[6], A * src[6]);\
 162             OP(dst[7], A * src[7]);\
 163             dst += stride;\
 164             src += stride;\
 165         }\
 166     }\
 167 }
 168
 169 #define op_avg(a, b) a = (((a)+(((b) + 32)>>6)+1)>>1)
 170 #define op_put(a, b) a = (((b) + 32)>>6)
 171
 172 H264_CHROMA_MC(put_       , op_put)
 173 H264_CHROMA_MC(avg_       , op_avg)
 174 #undef op_avg
 175 #undef op_put