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 FFmpeg.
   6  *
   7  * FFmpeg 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  * FFmpeg 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 FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/avassert.h"
  23
  24 #include "bit_depth_template.c"
  25
  26 #define H264_CHROMA_MC(OPNAME, OP)\
  27 static void FUNCC(OPNAME ## h264_chroma_mc1)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
  28     pixel *dst = (pixel*)_dst;\
  29     pixel *src = (pixel*)_src;\
  30     const int A=(8-x)*(8-y);\
  31     const int B=(  x)*(8-y);\
  32     const int C=(8-x)*(  y);\
  33     const int D=(  x)*(  y);\
  34     int i;\
  35     stride >>= sizeof(pixel)-1;\
  36     \
  37     av_assert2(x<8 && y<8 && x>=0 && y>=0);\
  38 \
  39     if(D){\
  40         for(i=0; i<h; i++){\
  41             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
  42             dst+= stride;\
  43             src+= stride;\
  44         }\
  45     } else if (B + C) {\
  46         const int E= B+C;\
  47         const int step= C ? stride : 1;\
  48         for(i=0; i<h; i++){\
  49             OP(dst[0], (A*src[0] + E*src[step+0]));\
  50             dst+= stride;\
  51             src+= stride;\
  52         }\
  53     } else {\
  54         for(i=0; i<h; i++){\
  55             OP(dst[0], (A*src[0]));\
  56             dst+= stride;\
  57             src+= stride;\
  58         }\
  59     }\
  60 }\
  61 static void FUNCC(OPNAME ## h264_chroma_mc2)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
  62     pixel *dst = (pixel*)_dst;\
  63     pixel *src = (pixel*)_src;\
  64     const int A=(8-x)*(8-y);\
  65     const int B=(  x)*(8-y);\
  66     const int C=(8-x)*(  y);\
  67     const int D=(  x)*(  y);\
  68     int i;\
  69     stride >>= sizeof(pixel)-1;\
  70     \
  71     av_assert2(x<8 && y<8 && x>=0 && y>=0);\
  72 \
  73     if(D){\
  74         for(i=0; i<h; i++){\
  75             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
  76             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
  77             dst+= stride;\
  78             src+= stride;\
  79         }\
  80     } else if (B + C) {\
  81         const int E= B+C;\
  82         const int step= C ? stride : 1;\
  83         for(i=0; i<h; i++){\
  84             OP(dst[0], (A*src[0] + E*src[step+0]));\
  85             OP(dst[1], (A*src[1] + E*src[step+1]));\
  86             dst+= stride;\
  87             src+= stride;\
  88         }\
  89     } else {\
  90         for ( i = 0; i < h; i++){\
  91             OP(dst[0], A * src[0]);\
  92             OP(dst[1], A * src[1]);\
  93             dst += stride;\
  94             src += stride;\
  95         }\
  96     }\
  97 }\
  98 \
  99 static void FUNCC(OPNAME ## h264_chroma_mc4)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
 100     pixel *dst = (pixel*)_dst;\
 101     pixel *src = (pixel*)_src;\
 102     const int A=(8-x)*(8-y);\
 103     const int B=(  x)*(8-y);\
 104     const int C=(8-x)*(  y);\
 105     const int D=(  x)*(  y);\
 106     int i;\
 107     stride >>= sizeof(pixel)-1;\
 108     \
 109     av_assert2(x<8 && y<8 && x>=0 && y>=0);\
 110 \
 111     if(D){\
 112         for(i=0; i<h; i++){\
 113             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
 114             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
 115             OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
 116             OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
 117             dst+= stride;\
 118             src+= stride;\
 119         }\
 120     } else if (B + C) {\
 121         const int E= B+C;\
 122         const int step= C ? stride : 1;\
 123         for(i=0; i<h; i++){\
 124             OP(dst[0], (A*src[0] + E*src[step+0]));\
 125             OP(dst[1], (A*src[1] + E*src[step+1]));\
 126             OP(dst[2], (A*src[2] + E*src[step+2]));\
 127             OP(dst[3], (A*src[3] + E*src[step+3]));\
 128             dst+= stride;\
 129             src+= stride;\
 130         }\
 131     } else {\
 132         for ( i = 0; i < h; i++){\
 133             OP(dst[0], A * src[0]);\
 134             OP(dst[1], A * src[1]);\
 135             OP(dst[2], A * src[2]);\
 136             OP(dst[3], A * src[3]);\
 137             dst += stride;\
 138             src += stride;\
 139         }\
 140     }\
 141 }\
 142 \
 143 static void FUNCC(OPNAME ## h264_chroma_mc8)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
 144     pixel *dst = (pixel*)_dst;\
 145     pixel *src = (pixel*)_src;\
 146     const int A=(8-x)*(8-y);\
 147     const int B=(  x)*(8-y);\
 148     const int C=(8-x)*(  y);\
 149     const int D=(  x)*(  y);\
 150     int i;\
 151     stride >>= sizeof(pixel)-1;\
 152     \
 153     av_assert2(x<8 && y<8 && x>=0 && y>=0);\
 154 \
 155     if(D){\
 156         for(i=0; i<h; i++){\
 157             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
 158             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
 159             OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
 160             OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
 161             OP(dst[4], (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5]));\
 162             OP(dst[5], (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6]));\
 163             OP(dst[6], (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7]));\
 164             OP(dst[7], (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8]));\
 165             dst+= stride;\
 166             src+= stride;\
 167         }\
 168     } else if (B + C) {\
 169         const int E= B+C;\
 170         const int step= C ? stride : 1;\
 171         for(i=0; i<h; i++){\
 172             OP(dst[0], (A*src[0] + E*src[step+0]));\
 173             OP(dst[1], (A*src[1] + E*src[step+1]));\
 174             OP(dst[2], (A*src[2] + E*src[step+2]));\
 175             OP(dst[3], (A*src[3] + E*src[step+3]));\
 176             OP(dst[4], (A*src[4] + E*src[step+4]));\
 177             OP(dst[5], (A*src[5] + E*src[step+5]));\
 178             OP(dst[6], (A*src[6] + E*src[step+6]));\
 179             OP(dst[7], (A*src[7] + E*src[step+7]));\
 180             dst+= stride;\
 181             src+= stride;\
 182         }\
 183     } else {\
 184         for ( i = 0; i < h; i++){\
 185             OP(dst[0], A * src[0]);\
 186             OP(dst[1], A * src[1]);\
 187             OP(dst[2], A * src[2]);\
 188             OP(dst[3], A * src[3]);\
 189             OP(dst[4], A * src[4]);\
 190             OP(dst[5], A * src[5]);\
 191             OP(dst[6], A * src[6]);\
 192             OP(dst[7], A * src[7]);\
 193             dst += stride;\
 194             src += stride;\
 195         }\
 196     }\
 197 }
 198
 199 #define op_avg(a, b) a = (((a)+(((b) + 32)>>6)+1)>>1)
 200 #define op_put(a, b) a = (((b) + 32)>>6)
 201
 202 H264_CHROMA_MC(put_       , op_put)
 203 H264_CHROMA_MC(avg_       , op_avg)
 204 #undef op_avg
 205 #undef op_put