dsputil: create 16/32-bit dctcoef versions of some functions
[ffmpeg.git] / libavcodec / dsputil_template.c
1 /*
2  * DSP utils
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * gmc & q-pel & 32/64 bit based MC by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of Libav.
9  *
10  * Libav is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * Libav is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 /**
26  * @file
27  * DSP utils
28  */
29
30 #include "bit_depth_template.c"
31
32 static inline void FUNC(copy_block2)(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
33 {
34     int i;
35     for(i=0; i<h; i++)
36     {
37         AV_WN2P(dst   , AV_RN2P(src   ));
38         dst+=dstStride;
39         src+=srcStride;
40     }
41 }
42
43 static inline void FUNC(copy_block4)(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
44 {
45     int i;
46     for(i=0; i<h; i++)
47     {
48         AV_WN4P(dst   , AV_RN4P(src   ));
49         dst+=dstStride;
50         src+=srcStride;
51     }
52 }
53
54 static inline void FUNC(copy_block8)(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
55 {
56     int i;
57     for(i=0; i<h; i++)
58     {
59         AV_WN4P(dst                , AV_RN4P(src                ));
60         AV_WN4P(dst+4*sizeof(pixel), AV_RN4P(src+4*sizeof(pixel)));
61         dst+=dstStride;
62         src+=srcStride;
63     }
64 }
65
66 static inline void FUNC(copy_block16)(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
67 {
68     int i;
69     for(i=0; i<h; i++)
70     {
71         AV_WN4P(dst                 , AV_RN4P(src                 ));
72         AV_WN4P(dst+ 4*sizeof(pixel), AV_RN4P(src+ 4*sizeof(pixel)));
73         AV_WN4P(dst+ 8*sizeof(pixel), AV_RN4P(src+ 8*sizeof(pixel)));
74         AV_WN4P(dst+12*sizeof(pixel), AV_RN4P(src+12*sizeof(pixel)));
75         dst+=dstStride;
76         src+=srcStride;
77     }
78 }
79
80 /* draw the edges of width 'w' of an image of size width, height */
81 //FIXME check that this is ok for mpeg4 interlaced
82 static void FUNCC(draw_edges)(uint8_t *_buf, int _wrap, int width, int height, int w, int h, int sides)
83 {
84     pixel *buf = (pixel*)_buf;
85     int wrap = _wrap / sizeof(pixel);
86     pixel *ptr, *last_line;
87     int i;
88
89     /* left and right */
90     ptr = buf;
91     for(i=0;i<height;i++) {
92 #if BIT_DEPTH > 8
93         int j;
94         for (j = 0; j < w; j++) {
95             ptr[j-w] = ptr[0];
96             ptr[j+width] = ptr[width-1];
97         }
98 #else
99         memset(ptr - w, ptr[0], w);
100         memset(ptr + width, ptr[width-1], w);
101 #endif
102         ptr += wrap;
103     }
104
105     /* top and bottom + corners */
106     buf -= w;
107     last_line = buf + (height - 1) * wrap;
108     if (sides & EDGE_TOP)
109         for(i = 0; i < h; i++)
110             memcpy(buf - (i + 1) * wrap, buf, (width + w + w) * sizeof(pixel)); // top
111     if (sides & EDGE_BOTTOM)
112         for (i = 0; i < h; i++)
113             memcpy(last_line + (i + 1) * wrap, last_line, (width + w + w) * sizeof(pixel)); // bottom
114 }
115
116 /**
117  * Copy a rectangular area of samples to a temporary buffer and replicate the border samples.
118  * @param buf destination buffer
119  * @param src source buffer
120  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
121  * @param block_w width of block
122  * @param block_h height of block
123  * @param src_x x coordinate of the top left sample of the block in the source buffer
124  * @param src_y y coordinate of the top left sample of the block in the source buffer
125  * @param w width of the source buffer
126  * @param h height of the source buffer
127  */
128 void FUNC(ff_emulated_edge_mc)(uint8_t *buf, const uint8_t *src, int linesize, int block_w, int block_h,
129                                     int src_x, int src_y, int w, int h){
130     int x, y;
131     int start_y, start_x, end_y, end_x;
132
133     if(src_y>= h){
134         src+= (h-1-src_y)*linesize;
135         src_y=h-1;
136     }else if(src_y<=-block_h){
137         src+= (1-block_h-src_y)*linesize;
138         src_y=1-block_h;
139     }
140     if(src_x>= w){
141         src+= (w-1-src_x)*sizeof(pixel);
142         src_x=w-1;
143     }else if(src_x<=-block_w){
144         src+= (1-block_w-src_x)*sizeof(pixel);
145         src_x=1-block_w;
146     }
147
148     start_y= FFMAX(0, -src_y);
149     start_x= FFMAX(0, -src_x);
150     end_y= FFMIN(block_h, h-src_y);
151     end_x= FFMIN(block_w, w-src_x);
152     assert(start_y < end_y && block_h);
153     assert(start_x < end_x && block_w);
154
155     w    = end_x - start_x;
156     src += start_y*linesize + start_x*sizeof(pixel);
157     buf += start_x*sizeof(pixel);
158
159     //top
160     for(y=0; y<start_y; y++){
161         memcpy(buf, src, w*sizeof(pixel));
162         buf += linesize;
163     }
164
165     // copy existing part
166     for(; y<end_y; y++){
167         memcpy(buf, src, w*sizeof(pixel));
168         src += linesize;
169         buf += linesize;
170     }
171
172     //bottom
173     src -= linesize;
174     for(; y<block_h; y++){
175         memcpy(buf, src, w*sizeof(pixel));
176         buf += linesize;
177     }
178
179     buf -= block_h * linesize + start_x*sizeof(pixel);
180     while (block_h--){
181         pixel *bufp = (pixel*)buf;
182        //left
183         for(x=0; x<start_x; x++){
184             bufp[x] = bufp[start_x];
185         }
186
187        //right
188         for(x=end_x; x<block_w; x++){
189             bufp[x] = bufp[end_x - 1];
190         }
191         buf += linesize;
192     }
193 }
194
195 #define DCTELEM_FUNCS(dctcoef, suffix)                                  \
196 static void FUNCC(add_pixels8 ## suffix)(uint8_t *restrict _pixels,     \
197                                          DCTELEM *_block,               \
198                                          int line_size)                 \
199 {                                                                       \
200     int i;                                                              \
201     pixel *restrict pixels = (pixel *restrict)_pixels;                  \
202     dctcoef *block = (dctcoef*)_block;                                  \
203     line_size /= sizeof(pixel);                                         \
204                                                                         \
205     for(i=0;i<8;i++) {                                                  \
206         pixels[0] += block[0];                                          \
207         pixels[1] += block[1];                                          \
208         pixels[2] += block[2];                                          \
209         pixels[3] += block[3];                                          \
210         pixels[4] += block[4];                                          \
211         pixels[5] += block[5];                                          \
212         pixels[6] += block[6];                                          \
213         pixels[7] += block[7];                                          \
214         pixels += line_size;                                            \
215         block += 8;                                                     \
216     }                                                                   \
217 }                                                                       \
218                                                                         \
219 static void FUNCC(add_pixels4 ## suffix)(uint8_t *restrict _pixels,     \
220                                          DCTELEM *_block,               \
221                                          int line_size)                 \
222 {                                                                       \
223     int i;                                                              \
224     pixel *restrict pixels = (pixel *restrict)_pixels;                  \
225     dctcoef *block = (dctcoef*)_block;                                  \
226     line_size /= sizeof(pixel);                                         \
227                                                                         \
228     for(i=0;i<4;i++) {                                                  \
229         pixels[0] += block[0];                                          \
230         pixels[1] += block[1];                                          \
231         pixels[2] += block[2];                                          \
232         pixels[3] += block[3];                                          \
233         pixels += line_size;                                            \
234         block += 4;                                                     \
235     }                                                                   \
236 }                                                                       \
237                                                                         \
238 static void FUNCC(clear_block ## suffix)(DCTELEM *block)                \
239 {                                                                       \
240     memset(block, 0, sizeof(dctcoef)*64);                               \
241 }                                                                       \
242                                                                         \
243 /**                                                                     \
244  * memset(blocks, 0, sizeof(DCTELEM)*6*64)                              \
245  */                                                                     \
246 static void FUNCC(clear_blocks ## suffix)(DCTELEM *blocks)              \
247 {                                                                       \
248     memset(blocks, 0, sizeof(dctcoef)*6*64);                            \
249 }
250
251 DCTELEM_FUNCS(DCTELEM, _16)
252 #if BIT_DEPTH > 8
253 DCTELEM_FUNCS(dctcoef, _32)
254 #endif
255
256 #define PIXOP2(OPNAME, OP) \
257 static void FUNCC(OPNAME ## _pixels2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
258     int i;\
259     for(i=0; i<h; i++){\
260         OP(*((pixel2*)(block  )), AV_RN2P(pixels  ));\
261         pixels+=line_size;\
262         block +=line_size;\
263     }\
264 }\
265 static void FUNCC(OPNAME ## _pixels4)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
266     int i;\
267     for(i=0; i<h; i++){\
268         OP(*((pixel4*)(block  )), AV_RN4P(pixels  ));\
269         pixels+=line_size;\
270         block +=line_size;\
271     }\
272 }\
273 static void FUNCC(OPNAME ## _pixels8)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
274     int i;\
275     for(i=0; i<h; i++){\
276         OP(*((pixel4*)(block                )), AV_RN4P(pixels                ));\
277         OP(*((pixel4*)(block+4*sizeof(pixel))), AV_RN4P(pixels+4*sizeof(pixel)));\
278         pixels+=line_size;\
279         block +=line_size;\
280     }\
281 }\
282 static inline void FUNCC(OPNAME ## _no_rnd_pixels8)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
283     FUNCC(OPNAME ## _pixels8)(block, pixels, line_size, h);\
284 }\
285 \
286 static inline void FUNC(OPNAME ## _no_rnd_pixels8_l2)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
287                                                 int src_stride1, int src_stride2, int h){\
288     int i;\
289     for(i=0; i<h; i++){\
290         pixel4 a,b;\
291         a= AV_RN4P(&src1[i*src_stride1  ]);\
292         b= AV_RN4P(&src2[i*src_stride2  ]);\
293         OP(*((pixel4*)&dst[i*dst_stride  ]), no_rnd_avg_pixel4(a, b));\
294         a= AV_RN4P(&src1[i*src_stride1+4*sizeof(pixel)]);\
295         b= AV_RN4P(&src2[i*src_stride2+4*sizeof(pixel)]);\
296         OP(*((pixel4*)&dst[i*dst_stride+4*sizeof(pixel)]), no_rnd_avg_pixel4(a, b));\
297     }\
298 }\
299 \
300 static inline void FUNC(OPNAME ## _pixels8_l2)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
301                                                 int src_stride1, int src_stride2, int h){\
302     int i;\
303     for(i=0; i<h; i++){\
304         pixel4 a,b;\
305         a= AV_RN4P(&src1[i*src_stride1  ]);\
306         b= AV_RN4P(&src2[i*src_stride2  ]);\
307         OP(*((pixel4*)&dst[i*dst_stride  ]), rnd_avg_pixel4(a, b));\
308         a= AV_RN4P(&src1[i*src_stride1+4*sizeof(pixel)]);\
309         b= AV_RN4P(&src2[i*src_stride2+4*sizeof(pixel)]);\
310         OP(*((pixel4*)&dst[i*dst_stride+4*sizeof(pixel)]), rnd_avg_pixel4(a, b));\
311     }\
312 }\
313 \
314 static inline void FUNC(OPNAME ## _pixels4_l2)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
315                                                 int src_stride1, int src_stride2, int h){\
316     int i;\
317     for(i=0; i<h; i++){\
318         pixel4 a,b;\
319         a= AV_RN4P(&src1[i*src_stride1  ]);\
320         b= AV_RN4P(&src2[i*src_stride2  ]);\
321         OP(*((pixel4*)&dst[i*dst_stride  ]), rnd_avg_pixel4(a, b));\
322     }\
323 }\
324 \
325 static inline void FUNC(OPNAME ## _pixels2_l2)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
326                                                 int src_stride1, int src_stride2, int h){\
327     int i;\
328     for(i=0; i<h; i++){\
329         pixel4 a,b;\
330         a= AV_RN2P(&src1[i*src_stride1  ]);\
331         b= AV_RN2P(&src2[i*src_stride2  ]);\
332         OP(*((pixel2*)&dst[i*dst_stride  ]), rnd_avg_pixel4(a, b));\
333     }\
334 }\
335 \
336 static inline void FUNC(OPNAME ## _pixels16_l2)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
337                                                 int src_stride1, int src_stride2, int h){\
338     FUNC(OPNAME ## _pixels8_l2)(dst  , src1  , src2  , dst_stride, src_stride1, src_stride2, h);\
339     FUNC(OPNAME ## _pixels8_l2)(dst+8*sizeof(pixel), src1+8*sizeof(pixel), src2+8*sizeof(pixel), dst_stride, src_stride1, src_stride2, h);\
340 }\
341 \
342 static inline void FUNC(OPNAME ## _no_rnd_pixels16_l2)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
343                                                 int src_stride1, int src_stride2, int h){\
344     FUNC(OPNAME ## _no_rnd_pixels8_l2)(dst  , src1  , src2  , dst_stride, src_stride1, src_stride2, h);\
345     FUNC(OPNAME ## _no_rnd_pixels8_l2)(dst+8*sizeof(pixel), src1+8*sizeof(pixel), src2+8*sizeof(pixel), dst_stride, src_stride1, src_stride2, h);\
346 }\
347 \
348 static inline void FUNCC(OPNAME ## _no_rnd_pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
349     FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\
350 }\
351 \
352 static inline void FUNCC(OPNAME ## _pixels8_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
353     FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\
354 }\
355 \
356 static inline void FUNCC(OPNAME ## _no_rnd_pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
357     FUNC(OPNAME ## _no_rnd_pixels8_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
358 }\
359 \
360 static inline void FUNCC(OPNAME ## _pixels8_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
361     FUNC(OPNAME ## _pixels8_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
362 }\
363 \
364 static inline void FUNC(OPNAME ## _pixels8_l4)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, const uint8_t *src4,\
365                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
366     /* FIXME HIGH BIT DEPTH */\
367     int i;\
368     for(i=0; i<h; i++){\
369         uint32_t a, b, c, d, l0, l1, h0, h1;\
370         a= AV_RN32(&src1[i*src_stride1]);\
371         b= AV_RN32(&src2[i*src_stride2]);\
372         c= AV_RN32(&src3[i*src_stride3]);\
373         d= AV_RN32(&src4[i*src_stride4]);\
374         l0=  (a&0x03030303UL)\
375            + (b&0x03030303UL)\
376            + 0x02020202UL;\
377         h0= ((a&0xFCFCFCFCUL)>>2)\
378           + ((b&0xFCFCFCFCUL)>>2);\
379         l1=  (c&0x03030303UL)\
380            + (d&0x03030303UL);\
381         h1= ((c&0xFCFCFCFCUL)>>2)\
382           + ((d&0xFCFCFCFCUL)>>2);\
383         OP(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
384         a= AV_RN32(&src1[i*src_stride1+4]);\
385         b= AV_RN32(&src2[i*src_stride2+4]);\
386         c= AV_RN32(&src3[i*src_stride3+4]);\
387         d= AV_RN32(&src4[i*src_stride4+4]);\
388         l0=  (a&0x03030303UL)\
389            + (b&0x03030303UL)\
390            + 0x02020202UL;\
391         h0= ((a&0xFCFCFCFCUL)>>2)\
392           + ((b&0xFCFCFCFCUL)>>2);\
393         l1=  (c&0x03030303UL)\
394            + (d&0x03030303UL);\
395         h1= ((c&0xFCFCFCFCUL)>>2)\
396           + ((d&0xFCFCFCFCUL)>>2);\
397         OP(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
398     }\
399 }\
400 \
401 static inline void FUNCC(OPNAME ## _pixels4_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
402     FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\
403 }\
404 \
405 static inline void FUNCC(OPNAME ## _pixels4_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
406     FUNC(OPNAME ## _pixels4_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
407 }\
408 \
409 static inline void FUNCC(OPNAME ## _pixels2_x2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
410     FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels+sizeof(pixel), line_size, line_size, line_size, h);\
411 }\
412 \
413 static inline void FUNCC(OPNAME ## _pixels2_y2)(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
414     FUNC(OPNAME ## _pixels2_l2)(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
415 }\
416 \
417 static inline void FUNC(OPNAME ## _no_rnd_pixels8_l4)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, const uint8_t *src4,\
418                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
419     /* FIXME HIGH BIT DEPTH*/\
420     int i;\
421     for(i=0; i<h; i++){\
422         uint32_t a, b, c, d, l0, l1, h0, h1;\
423         a= AV_RN32(&src1[i*src_stride1]);\
424         b= AV_RN32(&src2[i*src_stride2]);\
425         c= AV_RN32(&src3[i*src_stride3]);\
426         d= AV_RN32(&src4[i*src_stride4]);\
427         l0=  (a&0x03030303UL)\
428            + (b&0x03030303UL)\
429            + 0x01010101UL;\
430         h0= ((a&0xFCFCFCFCUL)>>2)\
431           + ((b&0xFCFCFCFCUL)>>2);\
432         l1=  (c&0x03030303UL)\
433            + (d&0x03030303UL);\
434         h1= ((c&0xFCFCFCFCUL)>>2)\
435           + ((d&0xFCFCFCFCUL)>>2);\
436         OP(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
437         a= AV_RN32(&src1[i*src_stride1+4]);\
438         b= AV_RN32(&src2[i*src_stride2+4]);\
439         c= AV_RN32(&src3[i*src_stride3+4]);\
440         d= AV_RN32(&src4[i*src_stride4+4]);\
441         l0=  (a&0x03030303UL)\
442            + (b&0x03030303UL)\
443            + 0x01010101UL;\
444         h0= ((a&0xFCFCFCFCUL)>>2)\
445           + ((b&0xFCFCFCFCUL)>>2);\
446         l1=  (c&0x03030303UL)\
447            + (d&0x03030303UL);\
448         h1= ((c&0xFCFCFCFCUL)>>2)\
449           + ((d&0xFCFCFCFCUL)>>2);\
450         OP(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
451     }\
452 }\
453 static inline void FUNC(OPNAME ## _pixels16_l4)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, const uint8_t *src4,\
454                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
455     FUNC(OPNAME ## _pixels8_l4)(dst  , src1  , src2  , src3  , src4  , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
456     FUNC(OPNAME ## _pixels8_l4)(dst+8*sizeof(pixel), src1+8*sizeof(pixel), src2+8*sizeof(pixel), src3+8*sizeof(pixel), src4+8*sizeof(pixel), dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
457 }\
458 static inline void FUNC(OPNAME ## _no_rnd_pixels16_l4)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, const uint8_t *src4,\
459                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
460     FUNC(OPNAME ## _no_rnd_pixels8_l4)(dst  , src1  , src2  , src3  , src4  , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
461     FUNC(OPNAME ## _no_rnd_pixels8_l4)(dst+8*sizeof(pixel), src1+8*sizeof(pixel), src2+8*sizeof(pixel), src3+8*sizeof(pixel), src4+8*sizeof(pixel), dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
462 }\
463 \
464 static inline void FUNCC(OPNAME ## _pixels2_xy2)(uint8_t *_block, const uint8_t *_pixels, int line_size, int h)\
465 {\
466         int i, a0, b0, a1, b1;\
467         pixel *block = (pixel*)_block;\
468         const pixel *pixels = (const pixel*)_pixels;\
469         line_size /= sizeof(pixel);\
470         a0= pixels[0];\
471         b0= pixels[1] + 2;\
472         a0 += b0;\
473         b0 += pixels[2];\
474 \
475         pixels+=line_size;\
476         for(i=0; i<h; i+=2){\
477             a1= pixels[0];\
478             b1= pixels[1];\
479             a1 += b1;\
480             b1 += pixels[2];\
481 \
482             block[0]= (a1+a0)>>2; /* FIXME non put */\
483             block[1]= (b1+b0)>>2;\
484 \
485             pixels+=line_size;\
486             block +=line_size;\
487 \
488             a0= pixels[0];\
489             b0= pixels[1] + 2;\
490             a0 += b0;\
491             b0 += pixels[2];\
492 \
493             block[0]= (a1+a0)>>2;\
494             block[1]= (b1+b0)>>2;\
495             pixels+=line_size;\
496             block +=line_size;\
497         }\
498 }\
499 \
500 static inline void FUNCC(OPNAME ## _pixels4_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
501 {\
502         /* FIXME HIGH BIT DEPTH */\
503         int i;\
504         const uint32_t a= AV_RN32(pixels  );\
505         const uint32_t b= AV_RN32(pixels+1);\
506         uint32_t l0=  (a&0x03030303UL)\
507                     + (b&0x03030303UL)\
508                     + 0x02020202UL;\
509         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
510                    + ((b&0xFCFCFCFCUL)>>2);\
511         uint32_t l1,h1;\
512 \
513         pixels+=line_size;\
514         for(i=0; i<h; i+=2){\
515             uint32_t a= AV_RN32(pixels  );\
516             uint32_t b= AV_RN32(pixels+1);\
517             l1=  (a&0x03030303UL)\
518                + (b&0x03030303UL);\
519             h1= ((a&0xFCFCFCFCUL)>>2)\
520               + ((b&0xFCFCFCFCUL)>>2);\
521             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
522             pixels+=line_size;\
523             block +=line_size;\
524             a= AV_RN32(pixels  );\
525             b= AV_RN32(pixels+1);\
526             l0=  (a&0x03030303UL)\
527                + (b&0x03030303UL)\
528                + 0x02020202UL;\
529             h0= ((a&0xFCFCFCFCUL)>>2)\
530               + ((b&0xFCFCFCFCUL)>>2);\
531             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
532             pixels+=line_size;\
533             block +=line_size;\
534         }\
535 }\
536 \
537 static inline void FUNCC(OPNAME ## _pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
538 {\
539     /* FIXME HIGH BIT DEPTH */\
540     int j;\
541     for(j=0; j<2; j++){\
542         int i;\
543         const uint32_t a= AV_RN32(pixels  );\
544         const uint32_t b= AV_RN32(pixels+1);\
545         uint32_t l0=  (a&0x03030303UL)\
546                     + (b&0x03030303UL)\
547                     + 0x02020202UL;\
548         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
549                    + ((b&0xFCFCFCFCUL)>>2);\
550         uint32_t l1,h1;\
551 \
552         pixels+=line_size;\
553         for(i=0; i<h; i+=2){\
554             uint32_t a= AV_RN32(pixels  );\
555             uint32_t b= AV_RN32(pixels+1);\
556             l1=  (a&0x03030303UL)\
557                + (b&0x03030303UL);\
558             h1= ((a&0xFCFCFCFCUL)>>2)\
559               + ((b&0xFCFCFCFCUL)>>2);\
560             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
561             pixels+=line_size;\
562             block +=line_size;\
563             a= AV_RN32(pixels  );\
564             b= AV_RN32(pixels+1);\
565             l0=  (a&0x03030303UL)\
566                + (b&0x03030303UL)\
567                + 0x02020202UL;\
568             h0= ((a&0xFCFCFCFCUL)>>2)\
569               + ((b&0xFCFCFCFCUL)>>2);\
570             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
571             pixels+=line_size;\
572             block +=line_size;\
573         }\
574         pixels+=4-line_size*(h+1);\
575         block +=4-line_size*h;\
576     }\
577 }\
578 \
579 static inline void FUNCC(OPNAME ## _no_rnd_pixels8_xy2)(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
580 {\
581     /* FIXME HIGH BIT DEPTH */\
582     int j;\
583     for(j=0; j<2; j++){\
584         int i;\
585         const uint32_t a= AV_RN32(pixels  );\
586         const uint32_t b= AV_RN32(pixels+1);\
587         uint32_t l0=  (a&0x03030303UL)\
588                     + (b&0x03030303UL)\
589                     + 0x01010101UL;\
590         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
591                    + ((b&0xFCFCFCFCUL)>>2);\
592         uint32_t l1,h1;\
593 \
594         pixels+=line_size;\
595         for(i=0; i<h; i+=2){\
596             uint32_t a= AV_RN32(pixels  );\
597             uint32_t b= AV_RN32(pixels+1);\
598             l1=  (a&0x03030303UL)\
599                + (b&0x03030303UL);\
600             h1= ((a&0xFCFCFCFCUL)>>2)\
601               + ((b&0xFCFCFCFCUL)>>2);\
602             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
603             pixels+=line_size;\
604             block +=line_size;\
605             a= AV_RN32(pixels  );\
606             b= AV_RN32(pixels+1);\
607             l0=  (a&0x03030303UL)\
608                + (b&0x03030303UL)\
609                + 0x01010101UL;\
610             h0= ((a&0xFCFCFCFCUL)>>2)\
611               + ((b&0xFCFCFCFCUL)>>2);\
612             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
613             pixels+=line_size;\
614             block +=line_size;\
615         }\
616         pixels+=4-line_size*(h+1);\
617         block +=4-line_size*h;\
618     }\
619 }\
620 \
621 CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16)    , FUNCC(OPNAME ## _pixels8)    , 8*sizeof(pixel))\
622 CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_x2) , FUNCC(OPNAME ## _pixels8_x2) , 8*sizeof(pixel))\
623 CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_y2) , FUNCC(OPNAME ## _pixels8_y2) , 8*sizeof(pixel))\
624 CALL_2X_PIXELS(FUNCC(OPNAME ## _pixels16_xy2), FUNCC(OPNAME ## _pixels8_xy2), 8*sizeof(pixel))\
625 av_unused CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16)    , FUNCC(OPNAME ## _pixels8) , 8*sizeof(pixel))\
626 CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_x2) , FUNCC(OPNAME ## _no_rnd_pixels8_x2) , 8*sizeof(pixel))\
627 CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_y2) , FUNCC(OPNAME ## _no_rnd_pixels8_y2) , 8*sizeof(pixel))\
628 CALL_2X_PIXELS(FUNCC(OPNAME ## _no_rnd_pixels16_xy2), FUNCC(OPNAME ## _no_rnd_pixels8_xy2), 8*sizeof(pixel))\
629
630 #define op_avg(a, b) a = rnd_avg_pixel4(a, b)
631 #define op_put(a, b) a = b
632
633 PIXOP2(avg, op_avg)
634 PIXOP2(put, op_put)
635 #undef op_avg
636 #undef op_put
637
638 #define put_no_rnd_pixels8_c  put_pixels8_c
639 #define put_no_rnd_pixels16_c put_pixels16_c
640
641 static void FUNCC(put_no_rnd_pixels16_l2)(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h){
642     FUNC(put_no_rnd_pixels16_l2)(dst, a, b, stride, stride, stride, h);
643 }
644
645 static void FUNCC(put_no_rnd_pixels8_l2)(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h){
646     FUNC(put_no_rnd_pixels8_l2)(dst, a, b, stride, stride, stride, h);
647 }
648
649 #define H264_CHROMA_MC(OPNAME, OP)\
650 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){\
651     pixel *dst = (pixel*)_dst;\
652     pixel *src = (pixel*)_src;\
653     const int A=(8-x)*(8-y);\
654     const int B=(  x)*(8-y);\
655     const int C=(8-x)*(  y);\
656     const int D=(  x)*(  y);\
657     int i;\
658     stride /= sizeof(pixel);\
659     \
660     assert(x<8 && y<8 && x>=0 && y>=0);\
661 \
662     if(D){\
663         for(i=0; i<h; i++){\
664             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
665             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
666             dst+= stride;\
667             src+= stride;\
668         }\
669     }else{\
670         const int E= B+C;\
671         const int step= C ? stride : 1;\
672         for(i=0; i<h; i++){\
673             OP(dst[0], (A*src[0] + E*src[step+0]));\
674             OP(dst[1], (A*src[1] + E*src[step+1]));\
675             dst+= stride;\
676             src+= stride;\
677         }\
678     }\
679 }\
680 \
681 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){\
682     pixel *dst = (pixel*)_dst;\
683     pixel *src = (pixel*)_src;\
684     const int A=(8-x)*(8-y);\
685     const int B=(  x)*(8-y);\
686     const int C=(8-x)*(  y);\
687     const int D=(  x)*(  y);\
688     int i;\
689     stride /= sizeof(pixel);\
690     \
691     assert(x<8 && y<8 && x>=0 && y>=0);\
692 \
693     if(D){\
694         for(i=0; i<h; i++){\
695             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
696             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
697             OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
698             OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
699             dst+= stride;\
700             src+= stride;\
701         }\
702     }else{\
703         const int E= B+C;\
704         const int step= C ? stride : 1;\
705         for(i=0; i<h; i++){\
706             OP(dst[0], (A*src[0] + E*src[step+0]));\
707             OP(dst[1], (A*src[1] + E*src[step+1]));\
708             OP(dst[2], (A*src[2] + E*src[step+2]));\
709             OP(dst[3], (A*src[3] + E*src[step+3]));\
710             dst+= stride;\
711             src+= stride;\
712         }\
713     }\
714 }\
715 \
716 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){\
717     pixel *dst = (pixel*)_dst;\
718     pixel *src = (pixel*)_src;\
719     const int A=(8-x)*(8-y);\
720     const int B=(  x)*(8-y);\
721     const int C=(8-x)*(  y);\
722     const int D=(  x)*(  y);\
723     int i;\
724     stride /= sizeof(pixel);\
725     \
726     assert(x<8 && y<8 && x>=0 && y>=0);\
727 \
728     if(D){\
729         for(i=0; i<h; i++){\
730             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
731             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
732             OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
733             OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
734             OP(dst[4], (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5]));\
735             OP(dst[5], (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6]));\
736             OP(dst[6], (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7]));\
737             OP(dst[7], (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8]));\
738             dst+= stride;\
739             src+= stride;\
740         }\
741     }else{\
742         const int E= B+C;\
743         const int step= C ? stride : 1;\
744         for(i=0; i<h; i++){\
745             OP(dst[0], (A*src[0] + E*src[step+0]));\
746             OP(dst[1], (A*src[1] + E*src[step+1]));\
747             OP(dst[2], (A*src[2] + E*src[step+2]));\
748             OP(dst[3], (A*src[3] + E*src[step+3]));\
749             OP(dst[4], (A*src[4] + E*src[step+4]));\
750             OP(dst[5], (A*src[5] + E*src[step+5]));\
751             OP(dst[6], (A*src[6] + E*src[step+6]));\
752             OP(dst[7], (A*src[7] + E*src[step+7]));\
753             dst+= stride;\
754             src+= stride;\
755         }\
756     }\
757 }
758
759 #define op_avg(a, b) a = (((a)+(((b) + 32)>>6)+1)>>1)
760 #define op_put(a, b) a = (((b) + 32)>>6)
761
762 H264_CHROMA_MC(put_       , op_put)
763 H264_CHROMA_MC(avg_       , op_avg)
764 #undef op_avg
765 #undef op_put
766
767 #define H264_LOWPASS(OPNAME, OP, OP2) \
768 static av_unused void FUNC(OPNAME ## h264_qpel2_h_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
769     const int h=2;\
770     INIT_CLIP\
771     int i;\
772     pixel *dst = (pixel*)_dst;\
773     pixel *src = (pixel*)_src;\
774     dstStride /= sizeof(pixel);\
775     srcStride /= sizeof(pixel);\
776     for(i=0; i<h; i++)\
777     {\
778         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));\
779         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]));\
780         dst+=dstStride;\
781         src+=srcStride;\
782     }\
783 }\
784 \
785 static av_unused void FUNC(OPNAME ## h264_qpel2_v_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
786     const int w=2;\
787     INIT_CLIP\
788     int i;\
789     pixel *dst = (pixel*)_dst;\
790     pixel *src = (pixel*)_src;\
791     dstStride /= sizeof(pixel);\
792     srcStride /= sizeof(pixel);\
793     for(i=0; i<w; i++)\
794     {\
795         const int srcB= src[-2*srcStride];\
796         const int srcA= src[-1*srcStride];\
797         const int src0= src[0 *srcStride];\
798         const int src1= src[1 *srcStride];\
799         const int src2= src[2 *srcStride];\
800         const int src3= src[3 *srcStride];\
801         const int src4= src[4 *srcStride];\
802         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
803         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
804         dst++;\
805         src++;\
806     }\
807 }\
808 \
809 static av_unused void FUNC(OPNAME ## h264_qpel2_hv_lowpass)(uint8_t *_dst, int16_t *tmp, uint8_t *_src, int dstStride, int tmpStride, int srcStride){\
810     const int h=2;\
811     const int w=2;\
812     const int pad = (BIT_DEPTH > 9) ? (-10 * ((1<<BIT_DEPTH)-1)) : 0;\
813     INIT_CLIP\
814     int i;\
815     pixel *dst = (pixel*)_dst;\
816     pixel *src = (pixel*)_src;\
817     dstStride /= sizeof(pixel);\
818     srcStride /= sizeof(pixel);\
819     src -= 2*srcStride;\
820     for(i=0; i<h+5; i++)\
821     {\
822         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]) + pad;\
823         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]) + pad;\
824         tmp+=tmpStride;\
825         src+=srcStride;\
826     }\
827     tmp -= tmpStride*(h+5-2);\
828     for(i=0; i<w; i++)\
829     {\
830         const int tmpB= tmp[-2*tmpStride] - pad;\
831         const int tmpA= tmp[-1*tmpStride] - pad;\
832         const int tmp0= tmp[0 *tmpStride] - pad;\
833         const int tmp1= tmp[1 *tmpStride] - pad;\
834         const int tmp2= tmp[2 *tmpStride] - pad;\
835         const int tmp3= tmp[3 *tmpStride] - pad;\
836         const int tmp4= tmp[4 *tmpStride] - pad;\
837         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
838         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
839         dst++;\
840         tmp++;\
841     }\
842 }\
843 static void FUNC(OPNAME ## h264_qpel4_h_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
844     const int h=4;\
845     INIT_CLIP\
846     int i;\
847     pixel *dst = (pixel*)_dst;\
848     pixel *src = (pixel*)_src;\
849     dstStride /= sizeof(pixel);\
850     srcStride /= sizeof(pixel);\
851     for(i=0; i<h; i++)\
852     {\
853         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));\
854         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]));\
855         OP(dst[2], (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]));\
856         OP(dst[3], (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]));\
857         dst+=dstStride;\
858         src+=srcStride;\
859     }\
860 }\
861 \
862 static void FUNC(OPNAME ## h264_qpel4_v_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
863     const int w=4;\
864     INIT_CLIP\
865     int i;\
866     pixel *dst = (pixel*)_dst;\
867     pixel *src = (pixel*)_src;\
868     dstStride /= sizeof(pixel);\
869     srcStride /= sizeof(pixel);\
870     for(i=0; i<w; i++)\
871     {\
872         const int srcB= src[-2*srcStride];\
873         const int srcA= src[-1*srcStride];\
874         const int src0= src[0 *srcStride];\
875         const int src1= src[1 *srcStride];\
876         const int src2= src[2 *srcStride];\
877         const int src3= src[3 *srcStride];\
878         const int src4= src[4 *srcStride];\
879         const int src5= src[5 *srcStride];\
880         const int src6= src[6 *srcStride];\
881         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
882         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
883         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));\
884         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));\
885         dst++;\
886         src++;\
887     }\
888 }\
889 \
890 static void FUNC(OPNAME ## h264_qpel4_hv_lowpass)(uint8_t *_dst, int16_t *tmp, uint8_t *_src, int dstStride, int tmpStride, int srcStride){\
891     const int h=4;\
892     const int w=4;\
893     const int pad = (BIT_DEPTH > 9) ? (-10 * ((1<<BIT_DEPTH)-1)) : 0;\
894     INIT_CLIP\
895     int i;\
896     pixel *dst = (pixel*)_dst;\
897     pixel *src = (pixel*)_src;\
898     dstStride /= sizeof(pixel);\
899     srcStride /= sizeof(pixel);\
900     src -= 2*srcStride;\
901     for(i=0; i<h+5; i++)\
902     {\
903         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]) + pad;\
904         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]) + pad;\
905         tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]) + pad;\
906         tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]) + pad;\
907         tmp+=tmpStride;\
908         src+=srcStride;\
909     }\
910     tmp -= tmpStride*(h+5-2);\
911     for(i=0; i<w; i++)\
912     {\
913         const int tmpB= tmp[-2*tmpStride] - pad;\
914         const int tmpA= tmp[-1*tmpStride] - pad;\
915         const int tmp0= tmp[0 *tmpStride] - pad;\
916         const int tmp1= tmp[1 *tmpStride] - pad;\
917         const int tmp2= tmp[2 *tmpStride] - pad;\
918         const int tmp3= tmp[3 *tmpStride] - pad;\
919         const int tmp4= tmp[4 *tmpStride] - pad;\
920         const int tmp5= tmp[5 *tmpStride] - pad;\
921         const int tmp6= tmp[6 *tmpStride] - pad;\
922         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
923         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
924         OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));\
925         OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));\
926         dst++;\
927         tmp++;\
928     }\
929 }\
930 \
931 static void FUNC(OPNAME ## h264_qpel8_h_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
932     const int h=8;\
933     INIT_CLIP\
934     int i;\
935     pixel *dst = (pixel*)_dst;\
936     pixel *src = (pixel*)_src;\
937     dstStride /= sizeof(pixel);\
938     srcStride /= sizeof(pixel);\
939     for(i=0; i<h; i++)\
940     {\
941         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]));\
942         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]));\
943         OP(dst[2], (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]));\
944         OP(dst[3], (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]));\
945         OP(dst[4], (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]));\
946         OP(dst[5], (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]));\
947         OP(dst[6], (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]));\
948         OP(dst[7], (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]));\
949         dst+=dstStride;\
950         src+=srcStride;\
951     }\
952 }\
953 \
954 static void FUNC(OPNAME ## h264_qpel8_v_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
955     const int w=8;\
956     INIT_CLIP\
957     int i;\
958     pixel *dst = (pixel*)_dst;\
959     pixel *src = (pixel*)_src;\
960     dstStride /= sizeof(pixel);\
961     srcStride /= sizeof(pixel);\
962     for(i=0; i<w; i++)\
963     {\
964         const int srcB= src[-2*srcStride];\
965         const int srcA= src[-1*srcStride];\
966         const int src0= src[0 *srcStride];\
967         const int src1= src[1 *srcStride];\
968         const int src2= src[2 *srcStride];\
969         const int src3= src[3 *srcStride];\
970         const int src4= src[4 *srcStride];\
971         const int src5= src[5 *srcStride];\
972         const int src6= src[6 *srcStride];\
973         const int src7= src[7 *srcStride];\
974         const int src8= src[8 *srcStride];\
975         const int src9= src[9 *srcStride];\
976         const int src10=src[10*srcStride];\
977         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
978         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
979         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));\
980         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));\
981         OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*5 + (src2+src7));\
982         OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*5 + (src3+src8));\
983         OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*5 + (src4+src9));\
984         OP(dst[7*dstStride], (src7+src8)*20 - (src6+src9)*5 + (src5+src10));\
985         dst++;\
986         src++;\
987     }\
988 }\
989 \
990 static void FUNC(OPNAME ## h264_qpel8_hv_lowpass)(uint8_t *_dst, int16_t *tmp, uint8_t *_src, int dstStride, int tmpStride, int srcStride){\
991     const int h=8;\
992     const int w=8;\
993     const int pad = (BIT_DEPTH > 9) ? (-10 * ((1<<BIT_DEPTH)-1)) : 0;\
994     INIT_CLIP\
995     int i;\
996     pixel *dst = (pixel*)_dst;\
997     pixel *src = (pixel*)_src;\
998     dstStride /= sizeof(pixel);\
999     srcStride /= sizeof(pixel);\
1000     src -= 2*srcStride;\
1001     for(i=0; i<h+5; i++)\
1002     {\
1003         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]) + pad;\
1004         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]) + pad;\
1005         tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]) + pad;\
1006         tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]) + pad;\
1007         tmp[4]= (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]) + pad;\
1008         tmp[5]= (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]) + pad;\
1009         tmp[6]= (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]) + pad;\
1010         tmp[7]= (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]) + pad;\
1011         tmp+=tmpStride;\
1012         src+=srcStride;\
1013     }\
1014     tmp -= tmpStride*(h+5-2);\
1015     for(i=0; i<w; i++)\
1016     {\
1017         const int tmpB= tmp[-2*tmpStride] - pad;\
1018         const int tmpA= tmp[-1*tmpStride] - pad;\
1019         const int tmp0= tmp[0 *tmpStride] - pad;\
1020         const int tmp1= tmp[1 *tmpStride] - pad;\
1021         const int tmp2= tmp[2 *tmpStride] - pad;\
1022         const int tmp3= tmp[3 *tmpStride] - pad;\
1023         const int tmp4= tmp[4 *tmpStride] - pad;\
1024         const int tmp5= tmp[5 *tmpStride] - pad;\
1025         const int tmp6= tmp[6 *tmpStride] - pad;\
1026         const int tmp7= tmp[7 *tmpStride] - pad;\
1027         const int tmp8= tmp[8 *tmpStride] - pad;\
1028         const int tmp9= tmp[9 *tmpStride] - pad;\
1029         const int tmp10=tmp[10*tmpStride] - pad;\
1030         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
1031         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
1032         OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));\
1033         OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));\
1034         OP2(dst[4*dstStride], (tmp4+tmp5)*20 - (tmp3+tmp6)*5 + (tmp2+tmp7));\
1035         OP2(dst[5*dstStride], (tmp5+tmp6)*20 - (tmp4+tmp7)*5 + (tmp3+tmp8));\
1036         OP2(dst[6*dstStride], (tmp6+tmp7)*20 - (tmp5+tmp8)*5 + (tmp4+tmp9));\
1037         OP2(dst[7*dstStride], (tmp7+tmp8)*20 - (tmp6+tmp9)*5 + (tmp5+tmp10));\
1038         dst++;\
1039         tmp++;\
1040     }\
1041 }\
1042 \
1043 static void FUNC(OPNAME ## h264_qpel16_v_lowpass)(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1044     FUNC(OPNAME ## h264_qpel8_v_lowpass)(dst                , src                , dstStride, srcStride);\
1045     FUNC(OPNAME ## h264_qpel8_v_lowpass)(dst+8*sizeof(pixel), src+8*sizeof(pixel), dstStride, srcStride);\
1046     src += 8*srcStride;\
1047     dst += 8*dstStride;\
1048     FUNC(OPNAME ## h264_qpel8_v_lowpass)(dst                , src                , dstStride, srcStride);\
1049     FUNC(OPNAME ## h264_qpel8_v_lowpass)(dst+8*sizeof(pixel), src+8*sizeof(pixel), dstStride, srcStride);\
1050 }\
1051 \
1052 static void FUNC(OPNAME ## h264_qpel16_h_lowpass)(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1053     FUNC(OPNAME ## h264_qpel8_h_lowpass)(dst                , src                , dstStride, srcStride);\
1054     FUNC(OPNAME ## h264_qpel8_h_lowpass)(dst+8*sizeof(pixel), src+8*sizeof(pixel), dstStride, srcStride);\
1055     src += 8*srcStride;\
1056     dst += 8*dstStride;\
1057     FUNC(OPNAME ## h264_qpel8_h_lowpass)(dst                , src                , dstStride, srcStride);\
1058     FUNC(OPNAME ## h264_qpel8_h_lowpass)(dst+8*sizeof(pixel), src+8*sizeof(pixel), dstStride, srcStride);\
1059 }\
1060 \
1061 static void FUNC(OPNAME ## h264_qpel16_hv_lowpass)(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
1062     FUNC(OPNAME ## h264_qpel8_hv_lowpass)(dst                , tmp  , src                , dstStride, tmpStride, srcStride);\
1063     FUNC(OPNAME ## h264_qpel8_hv_lowpass)(dst+8*sizeof(pixel), tmp+8, src+8*sizeof(pixel), dstStride, tmpStride, srcStride);\
1064     src += 8*srcStride;\
1065     dst += 8*dstStride;\
1066     FUNC(OPNAME ## h264_qpel8_hv_lowpass)(dst                , tmp  , src                , dstStride, tmpStride, srcStride);\
1067     FUNC(OPNAME ## h264_qpel8_hv_lowpass)(dst+8*sizeof(pixel), tmp+8, src+8*sizeof(pixel), dstStride, tmpStride, srcStride);\
1068 }\
1069
1070 #define H264_MC(OPNAME, SIZE) \
1071 static av_unused void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc00)(uint8_t *dst, uint8_t *src, int stride){\
1072     FUNCC(OPNAME ## pixels ## SIZE)(dst, src, stride, SIZE);\
1073 }\
1074 \
1075 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc10)(uint8_t *dst, uint8_t *src, int stride){\
1076     uint8_t half[SIZE*SIZE*sizeof(pixel)];\
1077     FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(half, src, SIZE*sizeof(pixel), stride);\
1078     FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, src, half, stride, stride, SIZE*sizeof(pixel), SIZE);\
1079 }\
1080 \
1081 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc20)(uint8_t *dst, uint8_t *src, int stride){\
1082     FUNC(OPNAME ## h264_qpel ## SIZE ## _h_lowpass)(dst, src, stride, stride);\
1083 }\
1084 \
1085 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc30)(uint8_t *dst, uint8_t *src, int stride){\
1086     uint8_t half[SIZE*SIZE*sizeof(pixel)];\
1087     FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(half, src, SIZE*sizeof(pixel), stride);\
1088     FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, src+sizeof(pixel), half, stride, stride, SIZE*sizeof(pixel), SIZE);\
1089 }\
1090 \
1091 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc01)(uint8_t *dst, uint8_t *src, int stride){\
1092     uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
1093     uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
1094     uint8_t half[SIZE*SIZE*sizeof(pixel)];\
1095     FUNC(copy_block ## SIZE )(full, src - stride*2, SIZE*sizeof(pixel),  stride, SIZE + 5);\
1096     FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(half, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
1097     FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, full_mid, half, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
1098 }\
1099 \
1100 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc02)(uint8_t *dst, uint8_t *src, int stride){\
1101     uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
1102     uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
1103     FUNC(copy_block ## SIZE )(full, src - stride*2, SIZE*sizeof(pixel),  stride, SIZE + 5);\
1104     FUNC(OPNAME ## h264_qpel ## SIZE ## _v_lowpass)(dst, full_mid, stride, SIZE*sizeof(pixel));\
1105 }\
1106 \
1107 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc03)(uint8_t *dst, uint8_t *src, int stride){\
1108     uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
1109     uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
1110     uint8_t half[SIZE*SIZE*sizeof(pixel)];\
1111     FUNC(copy_block ## SIZE )(full, src - stride*2, SIZE*sizeof(pixel),  stride, SIZE + 5);\
1112     FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(half, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
1113     FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, full_mid+SIZE*sizeof(pixel), half, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
1114 }\
1115 \
1116 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc11)(uint8_t *dst, uint8_t *src, int stride){\
1117     uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
1118     uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
1119     uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
1120     uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
1121     FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src, SIZE*sizeof(pixel), stride);\
1122     FUNC(copy_block ## SIZE )(full, src - stride*2, SIZE*sizeof(pixel),  stride, SIZE + 5);\
1123     FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
1124     FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
1125 }\
1126 \
1127 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc31)(uint8_t *dst, uint8_t *src, int stride){\
1128     uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
1129     uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
1130     uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
1131     uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
1132     FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src, SIZE*sizeof(pixel), stride);\
1133     FUNC(copy_block ## SIZE )(full, src - stride*2 + sizeof(pixel), SIZE*sizeof(pixel),  stride, SIZE + 5);\
1134     FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
1135     FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
1136 }\
1137 \
1138 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc13)(uint8_t *dst, uint8_t *src, int stride){\
1139     uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
1140     uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
1141     uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
1142     uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
1143     FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src + stride, SIZE*sizeof(pixel), stride);\
1144     FUNC(copy_block ## SIZE )(full, src - stride*2, SIZE*sizeof(pixel),  stride, SIZE + 5);\
1145     FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
1146     FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
1147 }\
1148 \
1149 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc33)(uint8_t *dst, uint8_t *src, int stride){\
1150     uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
1151     uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
1152     uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
1153     uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
1154     FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src + stride, SIZE*sizeof(pixel), stride);\
1155     FUNC(copy_block ## SIZE )(full, src - stride*2 + sizeof(pixel), SIZE*sizeof(pixel),  stride, SIZE + 5);\
1156     FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
1157     FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
1158 }\
1159 \
1160 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc22)(uint8_t *dst, uint8_t *src, int stride){\
1161     int16_t tmp[SIZE*(SIZE+5)*sizeof(pixel)];\
1162     FUNC(OPNAME ## h264_qpel ## SIZE ## _hv_lowpass)(dst, tmp, src, stride, SIZE*sizeof(pixel), stride);\
1163 }\
1164 \
1165 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc21)(uint8_t *dst, uint8_t *src, int stride){\
1166     int16_t tmp[SIZE*(SIZE+5)*sizeof(pixel)];\
1167     uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
1168     uint8_t halfHV[SIZE*SIZE*sizeof(pixel)];\
1169     FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src, SIZE*sizeof(pixel), stride);\
1170     FUNC(put_h264_qpel ## SIZE ## _hv_lowpass)(halfHV, tmp, src, SIZE*sizeof(pixel), SIZE*sizeof(pixel), stride);\
1171     FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfHV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
1172 }\
1173 \
1174 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc23)(uint8_t *dst, uint8_t *src, int stride){\
1175     int16_t tmp[SIZE*(SIZE+5)*sizeof(pixel)];\
1176     uint8_t halfH[SIZE*SIZE*sizeof(pixel)];\
1177     uint8_t halfHV[SIZE*SIZE*sizeof(pixel)];\
1178     FUNC(put_h264_qpel ## SIZE ## _h_lowpass)(halfH, src + stride, SIZE*sizeof(pixel), stride);\
1179     FUNC(put_h264_qpel ## SIZE ## _hv_lowpass)(halfHV, tmp, src, SIZE*sizeof(pixel), SIZE*sizeof(pixel), stride);\
1180     FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfH, halfHV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
1181 }\
1182 \
1183 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc12)(uint8_t *dst, uint8_t *src, int stride){\
1184     uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
1185     uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
1186     int16_t tmp[SIZE*(SIZE+5)*sizeof(pixel)];\
1187     uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
1188     uint8_t halfHV[SIZE*SIZE*sizeof(pixel)];\
1189     FUNC(copy_block ## SIZE )(full, src - stride*2, SIZE*sizeof(pixel),  stride, SIZE + 5);\
1190     FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
1191     FUNC(put_h264_qpel ## SIZE ## _hv_lowpass)(halfHV, tmp, src, SIZE*sizeof(pixel), SIZE*sizeof(pixel), stride);\
1192     FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfV, halfHV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
1193 }\
1194 \
1195 static void FUNCC(OPNAME ## h264_qpel ## SIZE ## _mc32)(uint8_t *dst, uint8_t *src, int stride){\
1196     uint8_t full[SIZE*(SIZE+5)*sizeof(pixel)];\
1197     uint8_t * const full_mid= full + SIZE*2*sizeof(pixel);\
1198     int16_t tmp[SIZE*(SIZE+5)*sizeof(pixel)];\
1199     uint8_t halfV[SIZE*SIZE*sizeof(pixel)];\
1200     uint8_t halfHV[SIZE*SIZE*sizeof(pixel)];\
1201     FUNC(copy_block ## SIZE )(full, src - stride*2 + sizeof(pixel), SIZE*sizeof(pixel),  stride, SIZE + 5);\
1202     FUNC(put_h264_qpel ## SIZE ## _v_lowpass)(halfV, full_mid, SIZE*sizeof(pixel), SIZE*sizeof(pixel));\
1203     FUNC(put_h264_qpel ## SIZE ## _hv_lowpass)(halfHV, tmp, src, SIZE*sizeof(pixel), SIZE*sizeof(pixel), stride);\
1204     FUNC(OPNAME ## pixels ## SIZE ## _l2)(dst, halfV, halfHV, stride, SIZE*sizeof(pixel), SIZE*sizeof(pixel), SIZE);\
1205 }\
1206
1207 #define op_avg(a, b)  a = (((a)+CLIP(((b) + 16)>>5)+1)>>1)
1208 //#define op_avg2(a, b) a = (((a)*w1+cm[((b) + 16)>>5]*w2 + o + 64)>>7)
1209 #define op_put(a, b)  a = CLIP(((b) + 16)>>5)
1210 #define op2_avg(a, b)  a = (((a)+CLIP(((b) + 512)>>10)+1)>>1)
1211 #define op2_put(a, b)  a = CLIP(((b) + 512)>>10)
1212
1213 H264_LOWPASS(put_       , op_put, op2_put)
1214 H264_LOWPASS(avg_       , op_avg, op2_avg)
1215 H264_MC(put_, 2)
1216 H264_MC(put_, 4)
1217 H264_MC(put_, 8)
1218 H264_MC(put_, 16)
1219 H264_MC(avg_, 4)
1220 H264_MC(avg_, 8)
1221 H264_MC(avg_, 16)
1222
1223 #undef op_avg
1224 #undef op_put
1225 #undef op2_avg
1226 #undef op2_put
1227
1228 #if BIT_DEPTH == 8
1229 #   define put_h264_qpel8_mc00_8_c  ff_put_pixels8x8_8_c
1230 #   define avg_h264_qpel8_mc00_8_c  ff_avg_pixels8x8_8_c
1231 #   define put_h264_qpel16_mc00_8_c ff_put_pixels16x16_8_c
1232 #   define avg_h264_qpel16_mc00_8_c ff_avg_pixels16x16_8_c
1233 #elif BIT_DEPTH == 9
1234 #   define put_h264_qpel8_mc00_9_c  ff_put_pixels8x8_9_c
1235 #   define avg_h264_qpel8_mc00_9_c  ff_avg_pixels8x8_9_c
1236 #   define put_h264_qpel16_mc00_9_c ff_put_pixels16x16_9_c
1237 #   define avg_h264_qpel16_mc00_9_c ff_avg_pixels16x16_9_c
1238 #elif BIT_DEPTH == 10
1239 #   define put_h264_qpel8_mc00_10_c  ff_put_pixels8x8_10_c
1240 #   define avg_h264_qpel8_mc00_10_c  ff_avg_pixels8x8_10_c
1241 #   define put_h264_qpel16_mc00_10_c ff_put_pixels16x16_10_c
1242 #   define avg_h264_qpel16_mc00_10_c ff_avg_pixels16x16_10_c
1243 #endif
1244
1245 void FUNCC(ff_put_pixels8x8)(uint8_t *dst, uint8_t *src, int stride) {
1246     FUNCC(put_pixels8)(dst, src, stride, 8);
1247 }
1248 void FUNCC(ff_avg_pixels8x8)(uint8_t *dst, uint8_t *src, int stride) {
1249     FUNCC(avg_pixels8)(dst, src, stride, 8);
1250 }
1251 void FUNCC(ff_put_pixels16x16)(uint8_t *dst, uint8_t *src, int stride) {
1252     FUNCC(put_pixels16)(dst, src, stride, 16);
1253 }
1254 void FUNCC(ff_avg_pixels16x16)(uint8_t *dst, uint8_t *src, int stride) {
1255     FUNCC(avg_pixels16)(dst, src, stride, 16);
1256 }