Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 |