3 * Copyright (c) 2000, 2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * gmc & q-pel & 32/64 bit based MC by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg 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.
15 * FFmpeg 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.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * @file libavcodec/dsputil.c
32 //#include "simple_idct.h"
33 //#include "faandct.h"
34 //#include "faanidct.h"
36 //#include "mpegvideo.h"
44 uint8_t ff_cropTbl
[256 + 2 * MAX_NEG_CROP
] = {0, };
45 uint32_t ff_squareTbl
[512] = {0, };
47 // 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size
48 #define pb_7f (~0UL/255 * 0x7f)
49 #define pb_80 (~0UL/255 * 0x80)
51 const uint8_t ff_zigzag_direct
[64] = {
52 0, 1, 8, 16, 9, 2, 3, 10,
53 17, 24, 32, 25, 18, 11, 4, 5,
54 12, 19, 26, 33, 40, 48, 41, 34,
55 27, 20, 13, 6, 7, 14, 21, 28,
56 35, 42, 49, 56, 57, 50, 43, 36,
57 29, 22, 15, 23, 30, 37, 44, 51,
58 58, 59, 52, 45, 38, 31, 39, 46,
59 53, 60, 61, 54, 47, 55, 62, 63
62 /* Specific zigzag scan for 248 idct. NOTE that unlike the
63 specification, we interleave the fields */
64 const uint8_t ff_zigzag248_direct
[64] = {
65 0, 8, 1, 9, 16, 24, 2, 10,
66 17, 25, 32, 40, 48, 56, 33, 41,
67 18, 26, 3, 11, 4, 12, 19, 27,
68 34, 42, 49, 57, 50, 58, 35, 43,
69 20, 28, 5, 13, 6, 14, 21, 29,
70 36, 44, 51, 59, 52, 60, 37, 45,
71 22, 30, 7, 15, 23, 31, 38, 46,
72 53, 61, 54, 62, 39, 47, 55, 63,
75 /* not permutated inverse zigzag_direct + 1 for MMX quantizer */
76 DECLARE_ALIGNED(16, uint16_t, inv_zigzag_direct16
)[64];
78 const uint8_t ff_alternate_horizontal_scan
[64] = {
79 0, 1, 2, 3, 8, 9, 16, 17,
80 10, 11, 4, 5, 6, 7, 15, 14,
81 13, 12, 19, 18, 24, 25, 32, 33,
82 26, 27, 20, 21, 22, 23, 28, 29,
83 30, 31, 34, 35, 40, 41, 48, 49,
84 42, 43, 36, 37, 38, 39, 44, 45,
85 46, 47, 50, 51, 56, 57, 58, 59,
86 52, 53, 54, 55, 60, 61, 62, 63,
89 const uint8_t ff_alternate_vertical_scan
[64] = {
90 0, 8, 16, 24, 1, 9, 2, 10,
91 17, 25, 32, 40, 48, 56, 57, 49,
92 41, 33, 26, 18, 3, 11, 4, 12,
93 19, 27, 34, 42, 50, 58, 35, 43,
94 51, 59, 20, 28, 5, 13, 6, 14,
95 21, 29, 36, 44, 52, 60, 37, 45,
96 53, 61, 22, 30, 7, 15, 23, 31,
97 38, 46, 54, 62, 39, 47, 55, 63,
100 /* a*inverse[b]>>32 == a/b for all 0<=a<=16909558 && 2<=b<=256
101 * for a>16909558, is an overestimate by less than 1 part in 1<<24 */
102 const uint32_t ff_inverse
[257]={
103 0, 4294967295U,2147483648U,1431655766, 1073741824, 858993460, 715827883, 613566757,
104 536870912, 477218589, 429496730, 390451573, 357913942, 330382100, 306783379, 286331154,
105 268435456, 252645136, 238609295, 226050911, 214748365, 204522253, 195225787, 186737709,
106 178956971, 171798692, 165191050, 159072863, 153391690, 148102321, 143165577, 138547333,
107 134217728, 130150525, 126322568, 122713352, 119304648, 116080198, 113025456, 110127367,
108 107374183, 104755300, 102261127, 99882961, 97612894, 95443718, 93368855, 91382283,
109 89478486, 87652394, 85899346, 84215046, 82595525, 81037119, 79536432, 78090315,
110 76695845, 75350304, 74051161, 72796056, 71582789, 70409300, 69273667, 68174085,
111 67108864, 66076420, 65075263, 64103990, 63161284, 62245903, 61356676, 60492498,
112 59652324, 58835169, 58040099, 57266231, 56512728, 55778797, 55063684, 54366675,
113 53687092, 53024288, 52377650, 51746594, 51130564, 50529028, 49941481, 49367441,
114 48806447, 48258060, 47721859, 47197443, 46684428, 46182445, 45691142, 45210183,
115 44739243, 44278014, 43826197, 43383509, 42949673, 42524429, 42107523, 41698712,
116 41297763, 40904451, 40518560, 40139882, 39768216, 39403370, 39045158, 38693400,
117 38347923, 38008561, 37675152, 37347542, 37025581, 36709123, 36398028, 36092163,
118 35791395, 35495598, 35204650, 34918434, 34636834, 34359739, 34087043, 33818641,
119 33554432, 33294321, 33038210, 32786010, 32537632, 32292988, 32051995, 31814573,
120 31580642, 31350127, 31122952, 30899046, 30678338, 30460761, 30246249, 30034737,
121 29826162, 29620465, 29417585, 29217465, 29020050, 28825284, 28633116, 28443493,
122 28256364, 28071682, 27889399, 27709467, 27531842, 27356480, 27183338, 27012373,
123 26843546, 26676816, 26512144, 26349493, 26188825, 26030105, 25873297, 25718368,
124 25565282, 25414008, 25264514, 25116768, 24970741, 24826401, 24683721, 24542671,
125 24403224, 24265352, 24129030, 23994231, 23860930, 23729102, 23598722, 23469767,
126 23342214, 23216040, 23091223, 22967740, 22845571, 22724695, 22605092, 22486740,
127 22369622, 22253717, 22139007, 22025474, 21913099, 21801865, 21691755, 21582751,
128 21474837, 21367997, 21262215, 21157475, 21053762, 20951060, 20849356, 20748635,
129 20648882, 20550083, 20452226, 20355296, 20259280, 20164166, 20069941, 19976593,
130 19884108, 19792477, 19701685, 19611723, 19522579, 19434242, 19346700, 19259944,
131 19173962, 19088744, 19004281, 18920561, 18837576, 18755316, 18673771, 18592933,
132 18512791, 18433337, 18354562, 18276457, 18199014, 18122225, 18046082, 17970575,
133 17895698, 17821442, 17747799, 17674763, 17602325, 17530479, 17459217, 17388532,
134 17318417, 17248865, 17179870, 17111424, 17043522, 16976156, 16909321, 16843010,
138 /* Input permutation for the simple_idct_mmx */
139 static const uint8_t simple_mmx_permutation
[64]={
140 0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
141 0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
142 0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
143 0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
144 0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
145 0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
146 0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
147 0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
150 static const uint8_t idct_sse2_row_perm
[8] = {0, 4, 1, 5, 2, 6, 3, 7};
152 void ff_init_scantable(uint8_t *permutation
, ScanTable
*st
, const uint8_t *src_scantable
){
156 st
->scantable
= src_scantable
;
160 j
= src_scantable
[i
];
161 st
->permutated
[i
] = permutation
[j
];
170 j
= st
->permutated
[i
];
172 st
->raster_end
[i
]= end
;
176 static int pix_sum_c(uint8_t * pix
, int line_size
)
181 for (i
= 0; i
< 16; i
++) {
182 for (j
= 0; j
< 16; j
+= 8) {
193 pix
+= line_size
- 16;
198 static int pix_norm1_c(uint8_t * pix
, int line_size
)
201 uint32_t *sq
= ff_squareTbl
+ 256;
204 for (i
= 0; i
< 16; i
++) {
205 for (j
= 0; j
< 16; j
+= 8) {
216 #if LONG_MAX > 2147483647
217 register uint64_t x
=*(uint64_t*)pix
;
219 s
+= sq
[(x
>>8)&0xff];
220 s
+= sq
[(x
>>16)&0xff];
221 s
+= sq
[(x
>>24)&0xff];
222 s
+= sq
[(x
>>32)&0xff];
223 s
+= sq
[(x
>>40)&0xff];
224 s
+= sq
[(x
>>48)&0xff];
225 s
+= sq
[(x
>>56)&0xff];
227 register uint32_t x
=*(uint32_t*)pix
;
229 s
+= sq
[(x
>>8)&0xff];
230 s
+= sq
[(x
>>16)&0xff];
231 s
+= sq
[(x
>>24)&0xff];
232 x
=*(uint32_t*)(pix
+4);
234 s
+= sq
[(x
>>8)&0xff];
235 s
+= sq
[(x
>>16)&0xff];
236 s
+= sq
[(x
>>24)&0xff];
241 pix
+= line_size
- 16;
246 static void bswap_buf(uint32_t *dst
, const uint32_t *src
, int w
){
249 for(i
=0; i
+8<=w
; i
+=8){
250 dst
[i
+0]= bswap_32(src
[i
+0]);
251 dst
[i
+1]= bswap_32(src
[i
+1]);
252 dst
[i
+2]= bswap_32(src
[i
+2]);
253 dst
[i
+3]= bswap_32(src
[i
+3]);
254 dst
[i
+4]= bswap_32(src
[i
+4]);
255 dst
[i
+5]= bswap_32(src
[i
+5]);
256 dst
[i
+6]= bswap_32(src
[i
+6]);
257 dst
[i
+7]= bswap_32(src
[i
+7]);
260 dst
[i
+0]= bswap_32(src
[i
+0]);
264 static int sse4_c(void *v
, uint8_t * pix1
, uint8_t * pix2
, int line_size
, int h
)
267 uint32_t *sq
= ff_squareTbl
+ 256;
270 for (i
= 0; i
< h
; i
++) {
271 s
+= sq
[pix1
[0] - pix2
[0]];
272 s
+= sq
[pix1
[1] - pix2
[1]];
273 s
+= sq
[pix1
[2] - pix2
[2]];
274 s
+= sq
[pix1
[3] - pix2
[3]];
281 static int sse8_c(void *v
, uint8_t * pix1
, uint8_t * pix2
, int line_size
, int h
)
284 uint32_t *sq
= ff_squareTbl
+ 256;
287 for (i
= 0; i
< h
; i
++) {
288 s
+= sq
[pix1
[0] - pix2
[0]];
289 s
+= sq
[pix1
[1] - pix2
[1]];
290 s
+= sq
[pix1
[2] - pix2
[2]];
291 s
+= sq
[pix1
[3] - pix2
[3]];
292 s
+= sq
[pix1
[4] - pix2
[4]];
293 s
+= sq
[pix1
[5] - pix2
[5]];
294 s
+= sq
[pix1
[6] - pix2
[6]];
295 s
+= sq
[pix1
[7] - pix2
[7]];
302 static int sse16_c(void *v
, uint8_t *pix1
, uint8_t *pix2
, int line_size
, int h
)
305 uint32_t *sq
= ff_squareTbl
+ 256;
308 for (i
= 0; i
< h
; i
++) {
309 s
+= sq
[pix1
[ 0] - pix2
[ 0]];
310 s
+= sq
[pix1
[ 1] - pix2
[ 1]];
311 s
+= sq
[pix1
[ 2] - pix2
[ 2]];
312 s
+= sq
[pix1
[ 3] - pix2
[ 3]];
313 s
+= sq
[pix1
[ 4] - pix2
[ 4]];
314 s
+= sq
[pix1
[ 5] - pix2
[ 5]];
315 s
+= sq
[pix1
[ 6] - pix2
[ 6]];
316 s
+= sq
[pix1
[ 7] - pix2
[ 7]];
317 s
+= sq
[pix1
[ 8] - pix2
[ 8]];
318 s
+= sq
[pix1
[ 9] - pix2
[ 9]];
319 s
+= sq
[pix1
[10] - pix2
[10]];
320 s
+= sq
[pix1
[11] - pix2
[11]];
321 s
+= sq
[pix1
[12] - pix2
[12]];
322 s
+= sq
[pix1
[13] - pix2
[13]];
323 s
+= sq
[pix1
[14] - pix2
[14]];
324 s
+= sq
[pix1
[15] - pix2
[15]];
332 /* draw the edges of width 'w' of an image of size width, height */
333 //FIXME check that this is ok for mpeg4 interlaced
334 static void draw_edges_c(uint8_t *buf
, int wrap
, int width
, int height
, int w
)
336 uint8_t *ptr
, *last_line
;
339 last_line
= buf
+ (height
- 1) * wrap
;
342 memcpy(buf
- (i
+ 1) * wrap
, buf
, width
);
343 memcpy(last_line
+ (i
+ 1) * wrap
, last_line
, width
);
347 for(i
=0;i
<height
;i
++) {
348 memset(ptr
- w
, ptr
[0], w
);
349 memset(ptr
+ width
, ptr
[width
-1], w
);
354 memset(buf
- (i
+ 1) * wrap
- w
, buf
[0], w
); /* top left */
355 memset(buf
- (i
+ 1) * wrap
+ width
, buf
[width
-1], w
); /* top right */
356 memset(last_line
+ (i
+ 1) * wrap
- w
, last_line
[0], w
); /* top left */
357 memset(last_line
+ (i
+ 1) * wrap
+ width
, last_line
[width
-1], w
); /* top right */
362 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
363 * @param buf destination buffer
364 * @param src source buffer
365 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
366 * @param block_w width of block
367 * @param block_h height of block
368 * @param src_x x coordinate of the top left sample of the block in the source buffer
369 * @param src_y y coordinate of the top left sample of the block in the source buffer
370 * @param w width of the source buffer
371 * @param h height of the source buffer
373 void ff_emulated_edge_mc(uint8_t *buf
, uint8_t *src
, int linesize
, int block_w
, int block_h
,
374 int src_x
, int src_y
, int w
, int h
){
376 int start_y
, start_x
, end_y
, end_x
;
379 src
+= (h
-1-src_y
)*linesize
;
381 }else if(src_y
<=-block_h
){
382 src
+= (1-block_h
-src_y
)*linesize
;
388 }else if(src_x
<=-block_w
){
389 src
+= (1-block_w
-src_x
);
393 start_y
= FFMAX(0, -src_y
);
394 start_x
= FFMAX(0, -src_x
);
395 end_y
= FFMIN(block_h
, h
-src_y
);
396 end_x
= FFMIN(block_w
, w
-src_x
);
398 // copy existing part
399 for(y
=start_y
; y
<end_y
; y
++){
400 for(x
=start_x
; x
<end_x
; x
++){
401 buf
[x
+ y
*linesize
]= src
[x
+ y
*linesize
];
406 for(y
=0; y
<start_y
; y
++){
407 for(x
=start_x
; x
<end_x
; x
++){
408 buf
[x
+ y
*linesize
]= buf
[x
+ start_y
*linesize
];
413 for(y
=end_y
; y
<block_h
; y
++){
414 for(x
=start_x
; x
<end_x
; x
++){
415 buf
[x
+ y
*linesize
]= buf
[x
+ (end_y
-1)*linesize
];
419 for(y
=0; y
<block_h
; y
++){
421 for(x
=0; x
<start_x
; x
++){
422 buf
[x
+ y
*linesize
]= buf
[start_x
+ y
*linesize
];
426 for(x
=end_x
; x
<block_w
; x
++){
427 buf
[x
+ y
*linesize
]= buf
[end_x
- 1 + y
*linesize
];
432 static void get_pixels_c(DCTELEM
*restrict block
, const uint8_t *pixels
, int line_size
)
436 /* read the pixels */
438 block
[0] = pixels
[0];
439 block
[1] = pixels
[1];
440 block
[2] = pixels
[2];
441 block
[3] = pixels
[3];
442 block
[4] = pixels
[4];
443 block
[5] = pixels
[5];
444 block
[6] = pixels
[6];
445 block
[7] = pixels
[7];
451 static void diff_pixels_c(DCTELEM
*restrict block
, const uint8_t *s1
,
452 const uint8_t *s2
, int stride
){
455 /* read the pixels */
457 block
[0] = s1
[0] - s2
[0];
458 block
[1] = s1
[1] - s2
[1];
459 block
[2] = s1
[2] - s2
[2];
460 block
[3] = s1
[3] - s2
[3];
461 block
[4] = s1
[4] - s2
[4];
462 block
[5] = s1
[5] - s2
[5];
463 block
[6] = s1
[6] - s2
[6];
464 block
[7] = s1
[7] - s2
[7];
472 static void put_pixels_clamped_c(const DCTELEM
*block
, uint8_t *restrict pixels
,
476 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
478 /* read the pixels */
480 pixels
[0] = cm
[block
[0]];
481 pixels
[1] = cm
[block
[1]];
482 pixels
[2] = cm
[block
[2]];
483 pixels
[3] = cm
[block
[3]];
484 pixels
[4] = cm
[block
[4]];
485 pixels
[5] = cm
[block
[5]];
486 pixels
[6] = cm
[block
[6]];
487 pixels
[7] = cm
[block
[7]];
494 static void put_pixels_clamped4_c(const DCTELEM
*block
, uint8_t *restrict pixels
,
498 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
500 /* read the pixels */
502 pixels
[0] = cm
[block
[0]];
503 pixels
[1] = cm
[block
[1]];
504 pixels
[2] = cm
[block
[2]];
505 pixels
[3] = cm
[block
[3]];
512 static void put_pixels_clamped2_c(const DCTELEM
*block
, uint8_t *restrict pixels
,
516 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
518 /* read the pixels */
520 pixels
[0] = cm
[block
[0]];
521 pixels
[1] = cm
[block
[1]];
528 static void put_signed_pixels_clamped_c(const DCTELEM
*block
,
529 uint8_t *restrict pixels
,
534 for (i
= 0; i
< 8; i
++) {
535 for (j
= 0; j
< 8; j
++) {
538 else if (*block
> 127)
541 *pixels
= (uint8_t)(*block
+ 128);
545 pixels
+= (line_size
- 8);
549 static void put_pixels_nonclamped_c(const DCTELEM
*block
, uint8_t *restrict pixels
,
554 /* read the pixels */
556 pixels
[0] = block
[0];
557 pixels
[1] = block
[1];
558 pixels
[2] = block
[2];
559 pixels
[3] = block
[3];
560 pixels
[4] = block
[4];
561 pixels
[5] = block
[5];
562 pixels
[6] = block
[6];
563 pixels
[7] = block
[7];
570 static void add_pixels_clamped_c(const DCTELEM
*block
, uint8_t *restrict pixels
,
574 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
576 /* read the pixels */
578 pixels
[0] = cm
[pixels
[0] + block
[0]];
579 pixels
[1] = cm
[pixels
[1] + block
[1]];
580 pixels
[2] = cm
[pixels
[2] + block
[2]];
581 pixels
[3] = cm
[pixels
[3] + block
[3]];
582 pixels
[4] = cm
[pixels
[4] + block
[4]];
583 pixels
[5] = cm
[pixels
[5] + block
[5]];
584 pixels
[6] = cm
[pixels
[6] + block
[6]];
585 pixels
[7] = cm
[pixels
[7] + block
[7]];
591 static void add_pixels_clamped4_c(const DCTELEM
*block
, uint8_t *restrict pixels
,
595 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
597 /* read the pixels */
599 pixels
[0] = cm
[pixels
[0] + block
[0]];
600 pixels
[1] = cm
[pixels
[1] + block
[1]];
601 pixels
[2] = cm
[pixels
[2] + block
[2]];
602 pixels
[3] = cm
[pixels
[3] + block
[3]];
608 static void add_pixels_clamped2_c(const DCTELEM
*block
, uint8_t *restrict pixels
,
612 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
614 /* read the pixels */
616 pixels
[0] = cm
[pixels
[0] + block
[0]];
617 pixels
[1] = cm
[pixels
[1] + block
[1]];
623 static void add_pixels8_c(uint8_t *restrict pixels
, DCTELEM
*block
, int line_size
)
627 pixels
[0] += block
[0];
628 pixels
[1] += block
[1];
629 pixels
[2] += block
[2];
630 pixels
[3] += block
[3];
631 pixels
[4] += block
[4];
632 pixels
[5] += block
[5];
633 pixels
[6] += block
[6];
634 pixels
[7] += block
[7];
640 static void add_pixels4_c(uint8_t *restrict pixels
, DCTELEM
*block
, int line_size
)
644 pixels
[0] += block
[0];
645 pixels
[1] += block
[1];
646 pixels
[2] += block
[2];
647 pixels
[3] += block
[3];
653 static int sum_abs_dctelem_c(DCTELEM
*block
)
657 sum
+= FFABS(block
[i
]);
661 static void fill_block16_c(uint8_t *block
, uint8_t value
, int line_size
, int h
)
665 for (i
= 0; i
< h
; i
++) {
666 memset(block
, value
, 16);
671 static void fill_block8_c(uint8_t *block
, uint8_t value
, int line_size
, int h
)
675 for (i
= 0; i
< h
; i
++) {
676 memset(block
, value
, 8);
681 static void scale_block_c(const uint8_t src
[64]/*align 8*/, uint8_t *dst
/*align 8*/, int linesize
)
684 uint16_t *dst1
= (uint16_t *) dst
;
685 uint16_t *dst2
= (uint16_t *)(dst
+ linesize
);
687 for (j
= 0; j
< 8; j
++) {
688 for (i
= 0; i
< 8; i
++) {
689 dst1
[i
] = dst2
[i
] = src
[i
] * 0x0101;
699 #define PIXOP2(OPNAME, OP) \
700 static void OPNAME ## _pixels(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
704 OP(*((uint64_t*)block), AV_RN64(pixels));\
710 static void OPNAME ## _no_rnd_pixels_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
714 const uint64_t a= AV_RN64(pixels );\
715 const uint64_t b= AV_RN64(pixels+1);\
716 OP(*((uint64_t*)block), (a&b) + (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
722 static void OPNAME ## _pixels_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
726 const uint64_t a= AV_RN64(pixels );\
727 const uint64_t b= AV_RN64(pixels+1);\
728 OP(*((uint64_t*)block), (a|b) - (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
734 static void OPNAME ## _no_rnd_pixels_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
738 const uint64_t a= AV_RN64(pixels );\
739 const uint64_t b= AV_RN64(pixels+line_size);\
740 OP(*((uint64_t*)block), (a&b) + (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
746 static void OPNAME ## _pixels_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
750 const uint64_t a= AV_RN64(pixels );\
751 const uint64_t b= AV_RN64(pixels+line_size);\
752 OP(*((uint64_t*)block), (a|b) - (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
758 static void OPNAME ## _pixels_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
761 const uint64_t a= AV_RN64(pixels );\
762 const uint64_t b= AV_RN64(pixels+1);\
763 uint64_t l0= (a&0x0303030303030303ULL)\
764 + (b&0x0303030303030303ULL)\
765 + 0x0202020202020202ULL;\
766 uint64_t h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
767 + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
771 for(i=0; i<h; i+=2){\
772 uint64_t a= AV_RN64(pixels );\
773 uint64_t b= AV_RN64(pixels+1);\
774 l1= (a&0x0303030303030303ULL)\
775 + (b&0x0303030303030303ULL);\
776 h1= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
777 + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
778 OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
781 a= AV_RN64(pixels );\
782 b= AV_RN64(pixels+1);\
783 l0= (a&0x0303030303030303ULL)\
784 + (b&0x0303030303030303ULL)\
785 + 0x0202020202020202ULL;\
786 h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
787 + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
788 OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
794 static void OPNAME ## _no_rnd_pixels_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
797 const uint64_t a= AV_RN64(pixels );\
798 const uint64_t b= AV_RN64(pixels+1);\
799 uint64_t l0= (a&0x0303030303030303ULL)\
800 + (b&0x0303030303030303ULL)\
801 + 0x0101010101010101ULL;\
802 uint64_t h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
803 + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
807 for(i=0; i<h; i+=2){\
808 uint64_t a= AV_RN64(pixels );\
809 uint64_t b= AV_RN64(pixels+1);\
810 l1= (a&0x0303030303030303ULL)\
811 + (b&0x0303030303030303ULL);\
812 h1= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
813 + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
814 OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
817 a= AV_RN64(pixels );\
818 b= AV_RN64(pixels+1);\
819 l0= (a&0x0303030303030303ULL)\
820 + (b&0x0303030303030303ULL)\
821 + 0x0101010101010101ULL;\
822 h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
823 + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
824 OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
830 CALL_2X_PIXELS(OPNAME ## _pixels16_c , OPNAME ## _pixels_c , 8)\
831 CALL_2X_PIXELS(OPNAME ## _pixels16_x2_c , OPNAME ## _pixels_x2_c , 8)\
832 CALL_2X_PIXELS(OPNAME ## _pixels16_y2_c , OPNAME ## _pixels_y2_c , 8)\
833 CALL_2X_PIXELS(OPNAME ## _pixels16_xy2_c, OPNAME ## _pixels_xy2_c, 8)\
834 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_x2_c , OPNAME ## _no_rnd_pixels_x2_c , 8)\
835 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_y2_c , OPNAME ## _no_rnd_pixels_y2_c , 8)\
836 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_xy2_c, OPNAME ## _no_rnd_pixels_xy2_c, 8)
838 #define op_avg(a, b) a = ( ((a)|(b)) - ((((a)^(b))&0xFEFEFEFEFEFEFEFEULL)>>1) )
839 #else // 64 bit variant
841 #define PIXOP2(OPNAME, OP) \
842 static void OPNAME ## _pixels2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
845 OP(*((uint16_t*)(block )), AV_RN16(pixels ));\
850 static void OPNAME ## _pixels4_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
853 OP(*((uint32_t*)(block )), AV_RN32(pixels ));\
858 static void OPNAME ## _pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
861 OP(*((uint32_t*)(block )), AV_RN32(pixels ));\
862 OP(*((uint32_t*)(block+4)), AV_RN32(pixels+4));\
867 static inline void OPNAME ## _no_rnd_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
868 OPNAME ## _pixels8_c(block, pixels, line_size, h);\
871 static inline void OPNAME ## _no_rnd_pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
872 int src_stride1, int src_stride2, int h){\
876 a= AV_RN32(&src1[i*src_stride1 ]);\
877 b= AV_RN32(&src2[i*src_stride2 ]);\
878 OP(*((uint32_t*)&dst[i*dst_stride ]), no_rnd_avg32(a, b));\
879 a= AV_RN32(&src1[i*src_stride1+4]);\
880 b= AV_RN32(&src2[i*src_stride2+4]);\
881 OP(*((uint32_t*)&dst[i*dst_stride+4]), no_rnd_avg32(a, b));\
885 static inline void OPNAME ## _pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
886 int src_stride1, int src_stride2, int h){\
890 a= AV_RN32(&src1[i*src_stride1 ]);\
891 b= AV_RN32(&src2[i*src_stride2 ]);\
892 OP(*((uint32_t*)&dst[i*dst_stride ]), rnd_avg32(a, b));\
893 a= AV_RN32(&src1[i*src_stride1+4]);\
894 b= AV_RN32(&src2[i*src_stride2+4]);\
895 OP(*((uint32_t*)&dst[i*dst_stride+4]), rnd_avg32(a, b));\
899 static inline void OPNAME ## _pixels4_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
900 int src_stride1, int src_stride2, int h){\
904 a= AV_RN32(&src1[i*src_stride1 ]);\
905 b= AV_RN32(&src2[i*src_stride2 ]);\
906 OP(*((uint32_t*)&dst[i*dst_stride ]), rnd_avg32(a, b));\
910 static inline void OPNAME ## _pixels2_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
911 int src_stride1, int src_stride2, int h){\
915 a= AV_RN16(&src1[i*src_stride1 ]);\
916 b= AV_RN16(&src2[i*src_stride2 ]);\
917 OP(*((uint16_t*)&dst[i*dst_stride ]), rnd_avg32(a, b));\
921 static inline void OPNAME ## _pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
922 int src_stride1, int src_stride2, int h){\
923 OPNAME ## _pixels8_l2(dst , src1 , src2 , dst_stride, src_stride1, src_stride2, h);\
924 OPNAME ## _pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);\
927 static inline void OPNAME ## _no_rnd_pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
928 int src_stride1, int src_stride2, int h){\
929 OPNAME ## _no_rnd_pixels8_l2(dst , src1 , src2 , dst_stride, src_stride1, src_stride2, h);\
930 OPNAME ## _no_rnd_pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);\
933 static inline void OPNAME ## _no_rnd_pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
934 OPNAME ## _no_rnd_pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\
937 static inline void OPNAME ## _pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
938 OPNAME ## _pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\
941 static inline void OPNAME ## _no_rnd_pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
942 OPNAME ## _no_rnd_pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
945 static inline void OPNAME ## _pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
946 OPNAME ## _pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
949 static inline void OPNAME ## _pixels8_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,\
950 int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
953 uint32_t a, b, c, d, l0, l1, h0, h1;\
954 a= AV_RN32(&src1[i*src_stride1]);\
955 b= AV_RN32(&src2[i*src_stride2]);\
956 c= AV_RN32(&src3[i*src_stride3]);\
957 d= AV_RN32(&src4[i*src_stride4]);\
958 l0= (a&0x03030303UL)\
961 h0= ((a&0xFCFCFCFCUL)>>2)\
962 + ((b&0xFCFCFCFCUL)>>2);\
963 l1= (c&0x03030303UL)\
965 h1= ((c&0xFCFCFCFCUL)>>2)\
966 + ((d&0xFCFCFCFCUL)>>2);\
967 OP(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
968 a= AV_RN32(&src1[i*src_stride1+4]);\
969 b= AV_RN32(&src2[i*src_stride2+4]);\
970 c= AV_RN32(&src3[i*src_stride3+4]);\
971 d= AV_RN32(&src4[i*src_stride4+4]);\
972 l0= (a&0x03030303UL)\
975 h0= ((a&0xFCFCFCFCUL)>>2)\
976 + ((b&0xFCFCFCFCUL)>>2);\
977 l1= (c&0x03030303UL)\
979 h1= ((c&0xFCFCFCFCUL)>>2)\
980 + ((d&0xFCFCFCFCUL)>>2);\
981 OP(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
985 static inline void OPNAME ## _pixels4_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
986 OPNAME ## _pixels4_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\
989 static inline void OPNAME ## _pixels4_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
990 OPNAME ## _pixels4_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
993 static inline void OPNAME ## _pixels2_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
994 OPNAME ## _pixels2_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\
997 static inline void OPNAME ## _pixels2_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
998 OPNAME ## _pixels2_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
1001 static inline void OPNAME ## _no_rnd_pixels8_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,\
1002 int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
1004 for(i=0; i<h; i++){\
1005 uint32_t a, b, c, d, l0, l1, h0, h1;\
1006 a= AV_RN32(&src1[i*src_stride1]);\
1007 b= AV_RN32(&src2[i*src_stride2]);\
1008 c= AV_RN32(&src3[i*src_stride3]);\
1009 d= AV_RN32(&src4[i*src_stride4]);\
1010 l0= (a&0x03030303UL)\
1013 h0= ((a&0xFCFCFCFCUL)>>2)\
1014 + ((b&0xFCFCFCFCUL)>>2);\
1015 l1= (c&0x03030303UL)\
1016 + (d&0x03030303UL);\
1017 h1= ((c&0xFCFCFCFCUL)>>2)\
1018 + ((d&0xFCFCFCFCUL)>>2);\
1019 OP(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1020 a= AV_RN32(&src1[i*src_stride1+4]);\
1021 b= AV_RN32(&src2[i*src_stride2+4]);\
1022 c= AV_RN32(&src3[i*src_stride3+4]);\
1023 d= AV_RN32(&src4[i*src_stride4+4]);\
1024 l0= (a&0x03030303UL)\
1027 h0= ((a&0xFCFCFCFCUL)>>2)\
1028 + ((b&0xFCFCFCFCUL)>>2);\
1029 l1= (c&0x03030303UL)\
1030 + (d&0x03030303UL);\
1031 h1= ((c&0xFCFCFCFCUL)>>2)\
1032 + ((d&0xFCFCFCFCUL)>>2);\
1033 OP(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1036 static inline void OPNAME ## _pixels16_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,\
1037 int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
1038 OPNAME ## _pixels8_l4(dst , src1 , src2 , src3 , src4 , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
1039 OPNAME ## _pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
1041 static inline void OPNAME ## _no_rnd_pixels16_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,\
1042 int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
1043 OPNAME ## _no_rnd_pixels8_l4(dst , src1 , src2 , src3 , src4 , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
1044 OPNAME ## _no_rnd_pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
1047 static inline void OPNAME ## _pixels2_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
1049 int i, a0, b0, a1, b1;\
1056 for(i=0; i<h; i+=2){\
1062 block[0]= (a1+a0)>>2; /* FIXME non put */\
1063 block[1]= (b1+b0)>>2;\
1073 block[0]= (a1+a0)>>2;\
1074 block[1]= (b1+b0)>>2;\
1080 static inline void OPNAME ## _pixels4_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
1083 const uint32_t a= AV_RN32(pixels );\
1084 const uint32_t b= AV_RN32(pixels+1);\
1085 uint32_t l0= (a&0x03030303UL)\
1088 uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
1089 + ((b&0xFCFCFCFCUL)>>2);\
1093 for(i=0; i<h; i+=2){\
1094 uint32_t a= AV_RN32(pixels );\
1095 uint32_t b= AV_RN32(pixels+1);\
1096 l1= (a&0x03030303UL)\
1097 + (b&0x03030303UL);\
1098 h1= ((a&0xFCFCFCFCUL)>>2)\
1099 + ((b&0xFCFCFCFCUL)>>2);\
1100 OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1103 a= AV_RN32(pixels );\
1104 b= AV_RN32(pixels+1);\
1105 l0= (a&0x03030303UL)\
1108 h0= ((a&0xFCFCFCFCUL)>>2)\
1109 + ((b&0xFCFCFCFCUL)>>2);\
1110 OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1116 static inline void OPNAME ## _pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
1119 for(j=0; j<2; j++){\
1121 const uint32_t a= AV_RN32(pixels );\
1122 const uint32_t b= AV_RN32(pixels+1);\
1123 uint32_t l0= (a&0x03030303UL)\
1126 uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
1127 + ((b&0xFCFCFCFCUL)>>2);\
1131 for(i=0; i<h; i+=2){\
1132 uint32_t a= AV_RN32(pixels );\
1133 uint32_t b= AV_RN32(pixels+1);\
1134 l1= (a&0x03030303UL)\
1135 + (b&0x03030303UL);\
1136 h1= ((a&0xFCFCFCFCUL)>>2)\
1137 + ((b&0xFCFCFCFCUL)>>2);\
1138 OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1141 a= AV_RN32(pixels );\
1142 b= AV_RN32(pixels+1);\
1143 l0= (a&0x03030303UL)\
1146 h0= ((a&0xFCFCFCFCUL)>>2)\
1147 + ((b&0xFCFCFCFCUL)>>2);\
1148 OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1152 pixels+=4-line_size*(h+1);\
1153 block +=4-line_size*h;\
1157 static inline void OPNAME ## _no_rnd_pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
1160 for(j=0; j<2; j++){\
1162 const uint32_t a= AV_RN32(pixels );\
1163 const uint32_t b= AV_RN32(pixels+1);\
1164 uint32_t l0= (a&0x03030303UL)\
1167 uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
1168 + ((b&0xFCFCFCFCUL)>>2);\
1172 for(i=0; i<h; i+=2){\
1173 uint32_t a= AV_RN32(pixels );\
1174 uint32_t b= AV_RN32(pixels+1);\
1175 l1= (a&0x03030303UL)\
1176 + (b&0x03030303UL);\
1177 h1= ((a&0xFCFCFCFCUL)>>2)\
1178 + ((b&0xFCFCFCFCUL)>>2);\
1179 OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1182 a= AV_RN32(pixels );\
1183 b= AV_RN32(pixels+1);\
1184 l0= (a&0x03030303UL)\
1187 h0= ((a&0xFCFCFCFCUL)>>2)\
1188 + ((b&0xFCFCFCFCUL)>>2);\
1189 OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1193 pixels+=4-line_size*(h+1);\
1194 block +=4-line_size*h;\
1198 CALL_2X_PIXELS(OPNAME ## _pixels16_c , OPNAME ## _pixels8_c , 8)\
1199 CALL_2X_PIXELS(OPNAME ## _pixels16_x2_c , OPNAME ## _pixels8_x2_c , 8)\
1200 CALL_2X_PIXELS(OPNAME ## _pixels16_y2_c , OPNAME ## _pixels8_y2_c , 8)\
1201 CALL_2X_PIXELS(OPNAME ## _pixels16_xy2_c, OPNAME ## _pixels8_xy2_c, 8)\
1202 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_c , OPNAME ## _pixels8_c , 8)\
1203 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_x2_c , OPNAME ## _no_rnd_pixels8_x2_c , 8)\
1204 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_y2_c , OPNAME ## _no_rnd_pixels8_y2_c , 8)\
1205 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_xy2_c, OPNAME ## _no_rnd_pixels8_xy2_c, 8)\
1207 #define op_avg(a, b) a = rnd_avg32(a, b)
1209 #define op_put(a, b) a = b
1216 #define avg2(a,b) ((a+b+1)>>1)
1217 #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
1219 static void put_no_rnd_pixels16_l2_c(uint8_t *dst
, const uint8_t *a
, const uint8_t *b
, int stride
, int h
){
1220 put_no_rnd_pixels16_l2(dst
, a
, b
, stride
, stride
, stride
, h
);
1223 static void put_no_rnd_pixels8_l2_c(uint8_t *dst
, const uint8_t *a
, const uint8_t *b
, int stride
, int h
){
1224 put_no_rnd_pixels8_l2(dst
, a
, b
, stride
, stride
, stride
, h
);
1227 static void gmc1_c(uint8_t *dst
, uint8_t *src
, int stride
, int h
, int x16
, int y16
, int rounder
)
1229 const int A
=(16-x16
)*(16-y16
);
1230 const int B
=( x16
)*(16-y16
);
1231 const int C
=(16-x16
)*( y16
);
1232 const int D
=( x16
)*( y16
);
1237 dst
[0]= (A
*src
[0] + B
*src
[1] + C
*src
[stride
+0] + D
*src
[stride
+1] + rounder
)>>8;
1238 dst
[1]= (A
*src
[1] + B
*src
[2] + C
*src
[stride
+1] + D
*src
[stride
+2] + rounder
)>>8;
1239 dst
[2]= (A
*src
[2] + B
*src
[3] + C
*src
[stride
+2] + D
*src
[stride
+3] + rounder
)>>8;
1240 dst
[3]= (A
*src
[3] + B
*src
[4] + C
*src
[stride
+3] + D
*src
[stride
+4] + rounder
)>>8;
1241 dst
[4]= (A
*src
[4] + B
*src
[5] + C
*src
[stride
+4] + D
*src
[stride
+5] + rounder
)>>8;
1242 dst
[5]= (A
*src
[5] + B
*src
[6] + C
*src
[stride
+5] + D
*src
[stride
+6] + rounder
)>>8;
1243 dst
[6]= (A
*src
[6] + B
*src
[7] + C
*src
[stride
+6] + D
*src
[stride
+7] + rounder
)>>8;
1244 dst
[7]= (A
*src
[7] + B
*src
[8] + C
*src
[stride
+7] + D
*src
[stride
+8] + rounder
)>>8;
1250 void ff_gmc_c(uint8_t *dst
, uint8_t *src
, int stride
, int h
, int ox
, int oy
,
1251 int dxx
, int dxy
, int dyx
, int dyy
, int shift
, int r
, int width
, int height
)
1254 const int s
= 1<<shift
;
1264 for(x
=0; x
<8; x
++){ //XXX FIXME optimize
1265 int src_x
, src_y
, frac_x
, frac_y
, index
;
1269 frac_x
= src_x
&(s
-1);
1270 frac_y
= src_y
&(s
-1);
1274 if((unsigned)src_x
< width
){
1275 if((unsigned)src_y
< height
){
1276 index
= src_x
+ src_y
*stride
;
1277 dst
[y
*stride
+ x
]= ( ( src
[index
]*(s
-frac_x
)
1278 + src
[index
+1]* frac_x
)*(s
-frac_y
)
1279 + ( src
[index
+stride
]*(s
-frac_x
)
1280 + src
[index
+stride
+1]* frac_x
)* frac_y
1283 index
= src_x
+ av_clip(src_y
, 0, height
)*stride
;
1284 dst
[y
*stride
+ x
]= ( ( src
[index
]*(s
-frac_x
)
1285 + src
[index
+1]* frac_x
)*s
1289 if((unsigned)src_y
< height
){
1290 index
= av_clip(src_x
, 0, width
) + src_y
*stride
;
1291 dst
[y
*stride
+ x
]= ( ( src
[index
]*(s
-frac_y
)
1292 + src
[index
+stride
]* frac_y
)*s
1295 index
= av_clip(src_x
, 0, width
) + av_clip(src_y
, 0, height
)*stride
;
1296 dst
[y
*stride
+ x
]= src
[index
];
1308 static inline void put_tpel_pixels_mc00_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1310 case 2: put_pixels2_c (dst
, src
, stride
, height
); break;
1311 case 4: put_pixels4_c (dst
, src
, stride
, height
); break;
1312 case 8: put_pixels8_c (dst
, src
, stride
, height
); break;
1313 case 16:put_pixels16_c(dst
, src
, stride
, height
); break;
1317 static inline void put_tpel_pixels_mc10_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1319 for (i
=0; i
< height
; i
++) {
1320 for (j
=0; j
< width
; j
++) {
1321 dst
[j
] = (683*(2*src
[j
] + src
[j
+1] + 1)) >> 11;
1328 static inline void put_tpel_pixels_mc20_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1330 for (i
=0; i
< height
; i
++) {
1331 for (j
=0; j
< width
; j
++) {
1332 dst
[j
] = (683*(src
[j
] + 2*src
[j
+1] + 1)) >> 11;
1339 static inline void put_tpel_pixels_mc01_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1341 for (i
=0; i
< height
; i
++) {
1342 for (j
=0; j
< width
; j
++) {
1343 dst
[j
] = (683*(2*src
[j
] + src
[j
+stride
] + 1)) >> 11;
1350 static inline void put_tpel_pixels_mc11_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1352 for (i
=0; i
< height
; i
++) {
1353 for (j
=0; j
< width
; j
++) {
1354 dst
[j
] = (2731*(4*src
[j
] + 3*src
[j
+1] + 3*src
[j
+stride
] + 2*src
[j
+stride
+1] + 6)) >> 15;
1361 static inline void put_tpel_pixels_mc12_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1363 for (i
=0; i
< height
; i
++) {
1364 for (j
=0; j
< width
; j
++) {
1365 dst
[j
] = (2731*(3*src
[j
] + 2*src
[j
+1] + 4*src
[j
+stride
] + 3*src
[j
+stride
+1] + 6)) >> 15;
1372 static inline void put_tpel_pixels_mc02_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1374 for (i
=0; i
< height
; i
++) {
1375 for (j
=0; j
< width
; j
++) {
1376 dst
[j
] = (683*(src
[j
] + 2*src
[j
+stride
] + 1)) >> 11;
1383 static inline void put_tpel_pixels_mc21_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1385 for (i
=0; i
< height
; i
++) {
1386 for (j
=0; j
< width
; j
++) {
1387 dst
[j
] = (2731*(3*src
[j
] + 4*src
[j
+1] + 2*src
[j
+stride
] + 3*src
[j
+stride
+1] + 6)) >> 15;
1394 static inline void put_tpel_pixels_mc22_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1396 for (i
=0; i
< height
; i
++) {
1397 for (j
=0; j
< width
; j
++) {
1398 dst
[j
] = (2731*(2*src
[j
] + 3*src
[j
+1] + 3*src
[j
+stride
] + 4*src
[j
+stride
+1] + 6)) >> 15;
1405 static inline void avg_tpel_pixels_mc00_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1407 case 2: avg_pixels2_c (dst
, src
, stride
, height
); break;
1408 case 4: avg_pixels4_c (dst
, src
, stride
, height
); break;
1409 case 8: avg_pixels8_c (dst
, src
, stride
, height
); break;
1410 case 16:avg_pixels16_c(dst
, src
, stride
, height
); break;
1414 static inline void avg_tpel_pixels_mc10_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1416 for (i
=0; i
< height
; i
++) {
1417 for (j
=0; j
< width
; j
++) {
1418 dst
[j
] = (dst
[j
] + ((683*(2*src
[j
] + src
[j
+1] + 1)) >> 11) + 1) >> 1;
1425 static inline void avg_tpel_pixels_mc20_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1427 for (i
=0; i
< height
; i
++) {
1428 for (j
=0; j
< width
; j
++) {
1429 dst
[j
] = (dst
[j
] + ((683*(src
[j
] + 2*src
[j
+1] + 1)) >> 11) + 1) >> 1;
1436 static inline void avg_tpel_pixels_mc01_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1438 for (i
=0; i
< height
; i
++) {
1439 for (j
=0; j
< width
; j
++) {
1440 dst
[j
] = (dst
[j
] + ((683*(2*src
[j
] + src
[j
+stride
] + 1)) >> 11) + 1) >> 1;
1447 static inline void avg_tpel_pixels_mc11_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1449 for (i
=0; i
< height
; i
++) {
1450 for (j
=0; j
< width
; j
++) {
1451 dst
[j
] = (dst
[j
] + ((2731*(4*src
[j
] + 3*src
[j
+1] + 3*src
[j
+stride
] + 2*src
[j
+stride
+1] + 6)) >> 15) + 1) >> 1;
1458 static inline void avg_tpel_pixels_mc12_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1460 for (i
=0; i
< height
; i
++) {
1461 for (j
=0; j
< width
; j
++) {
1462 dst
[j
] = (dst
[j
] + ((2731*(3*src
[j
] + 2*src
[j
+1] + 4*src
[j
+stride
] + 3*src
[j
+stride
+1] + 6)) >> 15) + 1) >> 1;
1469 static inline void avg_tpel_pixels_mc02_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1471 for (i
=0; i
< height
; i
++) {
1472 for (j
=0; j
< width
; j
++) {
1473 dst
[j
] = (dst
[j
] + ((683*(src
[j
] + 2*src
[j
+stride
] + 1)) >> 11) + 1) >> 1;
1480 static inline void avg_tpel_pixels_mc21_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1482 for (i
=0; i
< height
; i
++) {
1483 for (j
=0; j
< width
; j
++) {
1484 dst
[j
] = (dst
[j
] + ((2731*(3*src
[j
] + 4*src
[j
+1] + 2*src
[j
+stride
] + 3*src
[j
+stride
+1] + 6)) >> 15) + 1) >> 1;
1491 static inline void avg_tpel_pixels_mc22_c(uint8_t *dst
, const uint8_t *src
, int stride
, int width
, int height
){
1493 for (i
=0; i
< height
; i
++) {
1494 for (j
=0; j
< width
; j
++) {
1495 dst
[j
] = (dst
[j
] + ((2731*(2*src
[j
] + 3*src
[j
+1] + 3*src
[j
+stride
] + 4*src
[j
+stride
+1] + 6)) >> 15) + 1) >> 1;
1502 #define TPEL_WIDTH(width)\
1503 static void put_tpel_pixels ## width ## _mc00_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1504 void put_tpel_pixels_mc00_c(dst, src, stride, width, height);}\
1505 static void put_tpel_pixels ## width ## _mc10_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1506 void put_tpel_pixels_mc10_c(dst, src, stride, width, height);}\
1507 static void put_tpel_pixels ## width ## _mc20_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1508 void put_tpel_pixels_mc20_c(dst, src, stride, width, height);}\
1509 static void put_tpel_pixels ## width ## _mc01_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1510 void put_tpel_pixels_mc01_c(dst, src, stride, width, height);}\
1511 static void put_tpel_pixels ## width ## _mc11_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1512 void put_tpel_pixels_mc11_c(dst, src, stride, width, height);}\
1513 static void put_tpel_pixels ## width ## _mc21_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1514 void put_tpel_pixels_mc21_c(dst, src, stride, width, height);}\
1515 static void put_tpel_pixels ## width ## _mc02_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1516 void put_tpel_pixels_mc02_c(dst, src, stride, width, height);}\
1517 static void put_tpel_pixels ## width ## _mc12_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1518 void put_tpel_pixels_mc12_c(dst, src, stride, width, height);}\
1519 static void put_tpel_pixels ## width ## _mc22_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1520 void put_tpel_pixels_mc22_c(dst, src, stride, width, height);}
1523 #define H264_CHROMA_MC(OPNAME, OP)\
1524 static void OPNAME ## h264_chroma_mc2_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
1525 const int A=(8-x)*(8-y);\
1526 const int B=( x)*(8-y);\
1527 const int C=(8-x)*( y);\
1528 const int D=( x)*( y);\
1531 assert(x<8 && y<8 && x>=0 && y>=0);\
1534 for(i=0; i<h; i++){\
1535 OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
1536 OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
1542 const int step= C ? stride : 1;\
1543 for(i=0; i<h; i++){\
1544 OP(dst[0], (A*src[0] + E*src[step+0]));\
1545 OP(dst[1], (A*src[1] + E*src[step+1]));\
1552 static void OPNAME ## h264_chroma_mc4_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
1553 const int A=(8-x)*(8-y);\
1554 const int B=( x)*(8-y);\
1555 const int C=(8-x)*( y);\
1556 const int D=( x)*( y);\
1559 assert(x<8 && y<8 && x>=0 && y>=0);\
1562 for(i=0; i<h; i++){\
1563 OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
1564 OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
1565 OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
1566 OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
1572 const int step= C ? stride : 1;\
1573 for(i=0; i<h; i++){\
1574 OP(dst[0], (A*src[0] + E*src[step+0]));\
1575 OP(dst[1], (A*src[1] + E*src[step+1]));\
1576 OP(dst[2], (A*src[2] + E*src[step+2]));\
1577 OP(dst[3], (A*src[3] + E*src[step+3]));\
1584 static void OPNAME ## h264_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
1585 const int A=(8-x)*(8-y);\
1586 const int B=( x)*(8-y);\
1587 const int C=(8-x)*( y);\
1588 const int D=( x)*( y);\
1591 assert(x<8 && y<8 && x>=0 && y>=0);\
1594 for(i=0; i<h; i++){\
1595 OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
1596 OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
1597 OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
1598 OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
1599 OP(dst[4], (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5]));\
1600 OP(dst[5], (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6]));\
1601 OP(dst[6], (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7]));\
1602 OP(dst[7], (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8]));\
1608 const int step= C ? stride : 1;\
1609 for(i=0; i<h; i++){\
1610 OP(dst[0], (A*src[0] + E*src[step+0]));\
1611 OP(dst[1], (A*src[1] + E*src[step+1]));\
1612 OP(dst[2], (A*src[2] + E*src[step+2]));\
1613 OP(dst[3], (A*src[3] + E*src[step+3]));\
1614 OP(dst[4], (A*src[4] + E*src[step+4]));\
1615 OP(dst[5], (A*src[5] + E*src[step+5]));\
1616 OP(dst[6], (A*src[6] + E*src[step+6]));\
1617 OP(dst[7], (A*src[7] + E*src[step+7]));\
1624 #define op_avg(a, b) a = (((a)+(((b) + 32)>>6)+1)>>1)
1625 #define op_put(a, b) a = (((b) + 32)>>6)
1627 H264_CHROMA_MC(put_
, op_put
)
1628 H264_CHROMA_MC(avg_
, op_avg
)
1632 static void put_no_rnd_vc1_chroma_mc8_c(uint8_t *dst
/*align 8*/, uint8_t *src
/*align 1*/, int stride
, int h
, int x
, int y
){
1633 const int A
=(8-x
)*(8-y
);
1634 const int B
=( x
)*(8-y
);
1635 const int C
=(8-x
)*( y
);
1636 const int D
=( x
)*( y
);
1639 assert(x
<8 && y
<8 && x
>=0 && y
>=0);
1643 dst
[0] = (A
*src
[0] + B
*src
[1] + C
*src
[stride
+0] + D
*src
[stride
+1] + 32 - 4) >> 6;
1644 dst
[1] = (A
*src
[1] + B
*src
[2] + C
*src
[stride
+1] + D
*src
[stride
+2] + 32 - 4) >> 6;
1645 dst
[2] = (A
*src
[2] + B
*src
[3] + C
*src
[stride
+2] + D
*src
[stride
+3] + 32 - 4) >> 6;
1646 dst
[3] = (A
*src
[3] + B
*src
[4] + C
*src
[stride
+3] + D
*src
[stride
+4] + 32 - 4) >> 6;
1647 dst
[4] = (A
*src
[4] + B
*src
[5] + C
*src
[stride
+4] + D
*src
[stride
+5] + 32 - 4) >> 6;
1648 dst
[5] = (A
*src
[5] + B
*src
[6] + C
*src
[stride
+5] + D
*src
[stride
+6] + 32 - 4) >> 6;
1649 dst
[6] = (A
*src
[6] + B
*src
[7] + C
*src
[stride
+6] + D
*src
[stride
+7] + 32 - 4) >> 6;
1650 dst
[7] = (A
*src
[7] + B
*src
[8] + C
*src
[stride
+7] + D
*src
[stride
+8] + 32 - 4) >> 6;
1656 static void avg_no_rnd_vc1_chroma_mc8_c(uint8_t *dst
/*align 8*/, uint8_t *src
/*align 1*/, int stride
, int h
, int x
, int y
){
1657 const int A
=(8-x
)*(8-y
);
1658 const int B
=( x
)*(8-y
);
1659 const int C
=(8-x
)*( y
);
1660 const int D
=( x
)*( y
);
1663 assert(x
<8 && y
<8 && x
>=0 && y
>=0);
1667 dst
[0] = avg2(dst
[0], ((A
*src
[0] + B
*src
[1] + C
*src
[stride
+0] + D
*src
[stride
+1] + 32 - 4) >> 6));
1668 dst
[1] = avg2(dst
[1], ((A
*src
[1] + B
*src
[2] + C
*src
[stride
+1] + D
*src
[stride
+2] + 32 - 4) >> 6));
1669 dst
[2] = avg2(dst
[2], ((A
*src
[2] + B
*src
[3] + C
*src
[stride
+2] + D
*src
[stride
+3] + 32 - 4) >> 6));
1670 dst
[3] = avg2(dst
[3], ((A
*src
[3] + B
*src
[4] + C
*src
[stride
+3] + D
*src
[stride
+4] + 32 - 4) >> 6));
1671 dst
[4] = avg2(dst
[4], ((A
*src
[4] + B
*src
[5] + C
*src
[stride
+4] + D
*src
[stride
+5] + 32 - 4) >> 6));
1672 dst
[5] = avg2(dst
[5], ((A
*src
[5] + B
*src
[6] + C
*src
[stride
+5] + D
*src
[stride
+6] + 32 - 4) >> 6));
1673 dst
[6] = avg2(dst
[6], ((A
*src
[6] + B
*src
[7] + C
*src
[stride
+6] + D
*src
[stride
+7] + 32 - 4) >> 6));
1674 dst
[7] = avg2(dst
[7], ((A
*src
[7] + B
*src
[8] + C
*src
[stride
+7] + D
*src
[stride
+8] + 32 - 4) >> 6));
1680 #define QPEL_MC(r, OPNAME, RND, OP) \
1681 static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
1682 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1686 OP(dst[0], (src[0]+src[1])*20 - (src[0]+src[2])*6 + (src[1]+src[3])*3 - (src[2]+src[4]));\
1687 OP(dst[1], (src[1]+src[2])*20 - (src[0]+src[3])*6 + (src[0]+src[4])*3 - (src[1]+src[5]));\
1688 OP(dst[2], (src[2]+src[3])*20 - (src[1]+src[4])*6 + (src[0]+src[5])*3 - (src[0]+src[6]));\
1689 OP(dst[3], (src[3]+src[4])*20 - (src[2]+src[5])*6 + (src[1]+src[6])*3 - (src[0]+src[7]));\
1690 OP(dst[4], (src[4]+src[5])*20 - (src[3]+src[6])*6 + (src[2]+src[7])*3 - (src[1]+src[8]));\
1691 OP(dst[5], (src[5]+src[6])*20 - (src[4]+src[7])*6 + (src[3]+src[8])*3 - (src[2]+src[8]));\
1692 OP(dst[6], (src[6]+src[7])*20 - (src[5]+src[8])*6 + (src[4]+src[8])*3 - (src[3]+src[7]));\
1693 OP(dst[7], (src[7]+src[8])*20 - (src[6]+src[8])*6 + (src[5]+src[7])*3 - (src[4]+src[6]));\
1699 static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1701 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1705 const int src0= src[0*srcStride];\
1706 const int src1= src[1*srcStride];\
1707 const int src2= src[2*srcStride];\
1708 const int src3= src[3*srcStride];\
1709 const int src4= src[4*srcStride];\
1710 const int src5= src[5*srcStride];\
1711 const int src6= src[6*srcStride];\
1712 const int src7= src[7*srcStride];\
1713 const int src8= src[8*srcStride];\
1714 OP(dst[0*dstStride], (src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4));\
1715 OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5));\
1716 OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6));\
1717 OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7));\
1718 OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8));\
1719 OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8));\
1720 OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7));\
1721 OP(dst[7*dstStride], (src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6));\
1727 static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
1728 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1733 OP(dst[ 0], (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]));\
1734 OP(dst[ 1], (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]));\
1735 OP(dst[ 2], (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]));\
1736 OP(dst[ 3], (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]));\
1737 OP(dst[ 4], (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]));\
1738 OP(dst[ 5], (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9]));\
1739 OP(dst[ 6], (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10]));\
1740 OP(dst[ 7], (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11]));\
1741 OP(dst[ 8], (src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12]));\
1742 OP(dst[ 9], (src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13]));\
1743 OP(dst[10], (src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14]));\
1744 OP(dst[11], (src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15]));\
1745 OP(dst[12], (src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16]));\
1746 OP(dst[13], (src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16]));\
1747 OP(dst[14], (src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15]));\
1748 OP(dst[15], (src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14]));\
1754 static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1755 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1760 const int src0= src[0*srcStride];\
1761 const int src1= src[1*srcStride];\
1762 const int src2= src[2*srcStride];\
1763 const int src3= src[3*srcStride];\
1764 const int src4= src[4*srcStride];\
1765 const int src5= src[5*srcStride];\
1766 const int src6= src[6*srcStride];\
1767 const int src7= src[7*srcStride];\
1768 const int src8= src[8*srcStride];\
1769 const int src9= src[9*srcStride];\
1770 const int src10= src[10*srcStride];\
1771 const int src11= src[11*srcStride];\
1772 const int src12= src[12*srcStride];\
1773 const int src13= src[13*srcStride];\
1774 const int src14= src[14*srcStride];\
1775 const int src15= src[15*srcStride];\
1776 const int src16= src[16*srcStride];\
1777 OP(dst[ 0*dstStride], (src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 ));\
1778 OP(dst[ 1*dstStride], (src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 ));\
1779 OP(dst[ 2*dstStride], (src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 ));\
1780 OP(dst[ 3*dstStride], (src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 ));\
1781 OP(dst[ 4*dstStride], (src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 ));\
1782 OP(dst[ 5*dstStride], (src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 ));\
1783 OP(dst[ 6*dstStride], (src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10));\
1784 OP(dst[ 7*dstStride], (src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11));\
1785 OP(dst[ 8*dstStride], (src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12));\
1786 OP(dst[ 9*dstStride], (src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13));\
1787 OP(dst[10*dstStride], (src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14));\
1788 OP(dst[11*dstStride], (src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15));\
1789 OP(dst[12*dstStride], (src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16));\
1790 OP(dst[13*dstStride], (src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16));\
1791 OP(dst[14*dstStride], (src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15));\
1792 OP(dst[15*dstStride], (src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14));\
1798 static void OPNAME ## qpel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){\
1799 OPNAME ## pixels8_c(dst, src, stride, 8);\
1802 static void OPNAME ## qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
1804 put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
1805 OPNAME ## pixels8_l2(dst, src, half, stride, stride, 8, 8);\
1808 static void OPNAME ## qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
1809 OPNAME ## mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);\
1812 static void OPNAME ## qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
1814 put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
1815 OPNAME ## pixels8_l2(dst, src+1, half, stride, stride, 8, 8);\
1818 static void OPNAME ## qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
1819 uint8_t full[16*9];\
1821 copy_block9(full, src, 16, stride, 9);\
1822 put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
1823 OPNAME ## pixels8_l2(dst, full, half, stride, 16, 8, 8);\
1826 static void OPNAME ## qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
1827 uint8_t full[16*9];\
1828 copy_block9(full, src, 16, stride, 9);\
1829 OPNAME ## mpeg4_qpel8_v_lowpass(dst, full, stride, 16);\
1832 static void OPNAME ## qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
1833 uint8_t full[16*9];\
1835 copy_block9(full, src, 16, stride, 9);\
1836 put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
1837 OPNAME ## pixels8_l2(dst, full+16, half, stride, 16, 8, 8);\
1839 void ff_ ## OPNAME ## qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
1840 uint8_t full[16*9];\
1843 uint8_t halfHV[64];\
1844 copy_block9(full, src, 16, stride, 9);\
1845 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1846 put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1847 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1848 OPNAME ## pixels8_l4(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1850 static void OPNAME ## qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
1851 uint8_t full[16*9];\
1853 uint8_t halfHV[64];\
1854 copy_block9(full, src, 16, stride, 9);\
1855 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1856 put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
1857 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1858 OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
1860 void ff_ ## OPNAME ## qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
1861 uint8_t full[16*9];\
1864 uint8_t halfHV[64];\
1865 copy_block9(full, src, 16, stride, 9);\
1866 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1867 put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1868 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1869 OPNAME ## pixels8_l4(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1871 static void OPNAME ## qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
1872 uint8_t full[16*9];\
1874 uint8_t halfHV[64];\
1875 copy_block9(full, src, 16, stride, 9);\
1876 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1877 put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
1878 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1879 OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
1881 void ff_ ## OPNAME ## qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
1882 uint8_t full[16*9];\
1885 uint8_t halfHV[64];\
1886 copy_block9(full, src, 16, stride, 9);\
1887 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1888 put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1889 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1890 OPNAME ## pixels8_l4(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1892 static void OPNAME ## qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
1893 uint8_t full[16*9];\
1895 uint8_t halfHV[64];\
1896 copy_block9(full, src, 16, stride, 9);\
1897 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1898 put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
1899 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1900 OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1902 void ff_ ## OPNAME ## qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
1903 uint8_t full[16*9];\
1906 uint8_t halfHV[64];\
1907 copy_block9(full, src, 16, stride, 9);\
1908 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full , 8, 16, 9);\
1909 put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1910 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1911 OPNAME ## pixels8_l4(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1913 static void OPNAME ## qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
1914 uint8_t full[16*9];\
1916 uint8_t halfHV[64];\
1917 copy_block9(full, src, 16, stride, 9);\
1918 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1919 put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
1920 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1921 OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1923 static void OPNAME ## qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
1925 uint8_t halfHV[64];\
1926 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1927 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1928 OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
1930 static void OPNAME ## qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
1932 uint8_t halfHV[64];\
1933 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1934 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1935 OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1937 void ff_ ## OPNAME ## qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
1938 uint8_t full[16*9];\
1941 uint8_t halfHV[64];\
1942 copy_block9(full, src, 16, stride, 9);\
1943 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1944 put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1945 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1946 OPNAME ## pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);\
1948 static void OPNAME ## qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
1949 uint8_t full[16*9];\
1951 copy_block9(full, src, 16, stride, 9);\
1952 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1953 put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
1954 OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1956 void ff_ ## OPNAME ## qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
1957 uint8_t full[16*9];\
1960 uint8_t halfHV[64];\
1961 copy_block9(full, src, 16, stride, 9);\
1962 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1963 put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1964 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1965 OPNAME ## pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);\
1967 static void OPNAME ## qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
1968 uint8_t full[16*9];\
1970 copy_block9(full, src, 16, stride, 9);\
1971 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1972 put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
1973 OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1975 static void OPNAME ## qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
1977 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1978 OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1980 static void OPNAME ## qpel16_mc00_c (uint8_t *dst, uint8_t *src, int stride){\
1981 OPNAME ## pixels16_c(dst, src, stride, 16);\
1984 static void OPNAME ## qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
1986 put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
1987 OPNAME ## pixels16_l2(dst, src, half, stride, stride, 16, 16);\
1990 static void OPNAME ## qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
1991 OPNAME ## mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);\
1994 static void OPNAME ## qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
1996 put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
1997 OPNAME ## pixels16_l2(dst, src+1, half, stride, stride, 16, 16);\
2000 static void OPNAME ## qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
2001 uint8_t full[24*17];\
2003 copy_block17(full, src, 24, stride, 17);\
2004 put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
2005 OPNAME ## pixels16_l2(dst, full, half, stride, 24, 16, 16);\
2008 static void OPNAME ## qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
2009 uint8_t full[24*17];\
2010 copy_block17(full, src, 24, stride, 17);\
2011 OPNAME ## mpeg4_qpel16_v_lowpass(dst, full, stride, 24);\
2014 static void OPNAME ## qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
2015 uint8_t full[24*17];\
2017 copy_block17(full, src, 24, stride, 17);\
2018 put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
2019 OPNAME ## pixels16_l2(dst, full+24, half, stride, 24, 16, 16);\
2021 void ff_ ## OPNAME ## qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
2022 uint8_t full[24*17];\
2023 uint8_t halfH[272];\
2024 uint8_t halfV[256];\
2025 uint8_t halfHV[256];\
2026 copy_block17(full, src, 24, stride, 17);\
2027 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2028 put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
2029 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2030 OPNAME ## pixels16_l4(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
2032 static void OPNAME ## qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
2033 uint8_t full[24*17];\
2034 uint8_t halfH[272];\
2035 uint8_t halfHV[256];\
2036 copy_block17(full, src, 24, stride, 17);\
2037 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2038 put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
2039 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2040 OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
2042 void ff_ ## OPNAME ## qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
2043 uint8_t full[24*17];\
2044 uint8_t halfH[272];\
2045 uint8_t halfV[256];\
2046 uint8_t halfHV[256];\
2047 copy_block17(full, src, 24, stride, 17);\
2048 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2049 put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
2050 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2051 OPNAME ## pixels16_l4(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
2053 static void OPNAME ## qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
2054 uint8_t full[24*17];\
2055 uint8_t halfH[272];\
2056 uint8_t halfHV[256];\
2057 copy_block17(full, src, 24, stride, 17);\
2058 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2059 put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
2060 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2061 OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
2063 void ff_ ## OPNAME ## qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
2064 uint8_t full[24*17];\
2065 uint8_t halfH[272];\
2066 uint8_t halfV[256];\
2067 uint8_t halfHV[256];\
2068 copy_block17(full, src, 24, stride, 17);\
2069 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2070 put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
2071 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2072 OPNAME ## pixels16_l4(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
2074 static void OPNAME ## qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
2075 uint8_t full[24*17];\
2076 uint8_t halfH[272];\
2077 uint8_t halfHV[256];\
2078 copy_block17(full, src, 24, stride, 17);\
2079 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2080 put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
2081 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2082 OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
2084 void ff_ ## OPNAME ## qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
2085 uint8_t full[24*17];\
2086 uint8_t halfH[272];\
2087 uint8_t halfV[256];\
2088 uint8_t halfHV[256];\
2089 copy_block17(full, src, 24, stride, 17);\
2090 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full , 16, 24, 17);\
2091 put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
2092 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2093 OPNAME ## pixels16_l4(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
2095 static void OPNAME ## qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
2096 uint8_t full[24*17];\
2097 uint8_t halfH[272];\
2098 uint8_t halfHV[256];\
2099 copy_block17(full, src, 24, stride, 17);\
2100 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2101 put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
2102 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2103 OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
2105 static void OPNAME ## qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
2106 uint8_t halfH[272];\
2107 uint8_t halfHV[256];\
2108 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
2109 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2110 OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
2112 static void OPNAME ## qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
2113 uint8_t halfH[272];\
2114 uint8_t halfHV[256];\
2115 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
2116 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2117 OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
2119 void ff_ ## OPNAME ## qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
2120 uint8_t full[24*17];\
2121 uint8_t halfH[272];\
2122 uint8_t halfV[256];\
2123 uint8_t halfHV[256];\
2124 copy_block17(full, src, 24, stride, 17);\
2125 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2126 put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
2127 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2128 OPNAME ## pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);\
2130 static void OPNAME ## qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
2131 uint8_t full[24*17];\
2132 uint8_t halfH[272];\
2133 copy_block17(full, src, 24, stride, 17);\
2134 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2135 put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
2136 OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
2138 void ff_ ## OPNAME ## qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
2139 uint8_t full[24*17];\
2140 uint8_t halfH[272];\
2141 uint8_t halfV[256];\
2142 uint8_t halfHV[256];\
2143 copy_block17(full, src, 24, stride, 17);\
2144 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2145 put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
2146 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2147 OPNAME ## pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);\
2149 static void OPNAME ## qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
2150 uint8_t full[24*17];\
2151 uint8_t halfH[272];\
2152 copy_block17(full, src, 24, stride, 17);\
2153 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2154 put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
2155 OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
2157 static void OPNAME ## qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
2158 uint8_t halfH[272];\
2159 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
2160 OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
2163 #define op_avg(a, b) a = (((a)+cm[((b) + 16)>>5]+1)>>1)
2164 #define op_avg_no_rnd(a, b) a = (((a)+cm[((b) + 15)>>5])>>1)
2165 #define op_put(a, b) a = cm[((b) + 16)>>5]
2166 #define op_put_no_rnd(a, b) a = cm[((b) + 15)>>5]
2168 QPEL_MC(0, put_
, _
, op_put
)
2169 QPEL_MC(1, put_no_rnd_
, _no_rnd_
, op_put_no_rnd
)
2170 QPEL_MC(0, avg_
, _
, op_avg
)
2171 //QPEL_MC(1, avg_no_rnd , _ , op_avg)
2173 #undef op_avg_no_rnd
2175 #undef op_put_no_rnd
2178 #define H264_LOWPASS(OPNAME, OP, OP2) \
2179 static av_unused void OPNAME ## h264_qpel2_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2181 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2185 OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));\
2186 OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]));\
2192 static av_unused void OPNAME ## h264_qpel2_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2194 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2198 const int srcB= src[-2*srcStride];\
2199 const int srcA= src[-1*srcStride];\
2200 const int src0= src[0 *srcStride];\
2201 const int src1= src[1 *srcStride];\
2202 const int src2= src[2 *srcStride];\
2203 const int src3= src[3 *srcStride];\
2204 const int src4= src[4 *srcStride];\
2205 OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
2206 OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
2212 static av_unused void OPNAME ## h264_qpel2_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2215 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2217 src -= 2*srcStride;\
2218 for(i=0; i<h+5; i++)\
2220 tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]);\
2221 tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]);\
2225 tmp -= tmpStride*(h+5-2);\
2228 const int tmpB= tmp[-2*tmpStride];\
2229 const int tmpA= tmp[-1*tmpStride];\
2230 const int tmp0= tmp[0 *tmpStride];\
2231 const int tmp1= tmp[1 *tmpStride];\
2232 const int tmp2= tmp[2 *tmpStride];\
2233 const int tmp3= tmp[3 *tmpStride];\
2234 const int tmp4= tmp[4 *tmpStride];\
2235 OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
2236 OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
2241 static void OPNAME ## h264_qpel4_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2243 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2247 OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));\
2248 OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]));\
2249 OP(dst[2], (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]));\
2250 OP(dst[3], (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]));\
2256 static void OPNAME ## h264_qpel4_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2258 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2262 const int srcB= src[-2*srcStride];\
2263 const int srcA= src[-1*srcStride];\
2264 const int src0= src[0 *srcStride];\
2265 const int src1= src[1 *srcStride];\
2266 const int src2= src[2 *srcStride];\
2267 const int src3= src[3 *srcStride];\
2268 const int src4= src[4 *srcStride];\
2269 const int src5= src[5 *srcStride];\
2270 const int src6= src[6 *srcStride];\
2271 OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
2272 OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
2273 OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));\
2274 OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));\
2280 static void OPNAME ## h264_qpel4_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2283 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2285 src -= 2*srcStride;\
2286 for(i=0; i<h+5; i++)\
2288 tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]);\
2289 tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]);\
2290 tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]);\
2291 tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]);\
2295 tmp -= tmpStride*(h+5-2);\
2298 const int tmpB= tmp[-2*tmpStride];\
2299 const int tmpA= tmp[-1*tmpStride];\
2300 const int tmp0= tmp[0 *tmpStride];\
2301 const int tmp1= tmp[1 *tmpStride];\
2302 const int tmp2= tmp[2 *tmpStride];\
2303 const int tmp3= tmp[3 *tmpStride];\
2304 const int tmp4= tmp[4 *tmpStride];\
2305 const int tmp5= tmp[5 *tmpStride];\
2306 const int tmp6= tmp[6 *tmpStride];\
2307 OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
2308 OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
2309 OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));\
2310 OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));\
2316 static void OPNAME ## h264_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2318 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2322 OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]));\
2323 OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]));\
2324 OP(dst[2], (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]));\
2325 OP(dst[3], (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]));\
2326 OP(dst[4], (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]));\
2327 OP(dst[5], (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]));\
2328 OP(dst[6], (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]));\
2329 OP(dst[7], (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]));\
2335 static void OPNAME ## h264_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2337 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2341 const int srcB= src[-2*srcStride];\
2342 const int srcA= src[-1*srcStride];\
2343 const int src0= src[0 *srcStride];\
2344 const int src1= src[1 *srcStride];\
2345 const int src2= src[2 *srcStride];\
2346 const int src3= src[3 *srcStride];\
2347 const int src4= src[4 *srcStride];\
2348 const int src5= src[5 *srcStride];\
2349 const int src6= src[6 *srcStride];\
2350 const int src7= src[7 *srcStride];\
2351 const int src8= src[8 *srcStride];\
2352 const int src9= src[9 *srcStride];\
2353 const int src10=src[10*srcStride];\
2354 OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
2355 OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
2356 OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));\
2357 OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));\
2358 OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*5 + (src2+src7));\
2359 OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*5 + (src3+src8));\
2360 OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*5 + (src4+src9));\
2361 OP(dst[7*dstStride], (src7+src8)*20 - (src6+src9)*5 + (src5+src10));\
2367 static void OPNAME ## h264_qpel8_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2370 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2372 src -= 2*srcStride;\
2373 for(i=0; i<h+5; i++)\
2375 tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]);\
2376 tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]);\
2377 tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]);\
2378 tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]);\
2379 tmp[4]= (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]);\
2380 tmp[5]= (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]);\
2381 tmp[6]= (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]);\
2382 tmp[7]= (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]);\
2386 tmp -= tmpStride*(h+5-2);\
2389 const int tmpB= tmp[-2*tmpStride];\
2390 const int tmpA= tmp[-1*tmpStride];\
2391 const int tmp0= tmp[0 *tmpStride];\
2392 const int tmp1= tmp[1 *tmpStride];\
2393 const int tmp2= tmp[2 *tmpStride];\
2394 const int tmp3= tmp[3 *tmpStride];\
2395 const int tmp4= tmp[4 *tmpStride];\
2396 const int tmp5= tmp[5 *tmpStride];\
2397 const int tmp6= tmp[6 *tmpStride];\
2398 const int tmp7= tmp[7 *tmpStride];\
2399 const int tmp8= tmp[8 *tmpStride];\
2400 const int tmp9= tmp[9 *tmpStride];\
2401 const int tmp10=tmp[10*tmpStride];\
2402 OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
2403 OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
2404 OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));\
2405 OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));\
2406 OP2(dst[4*dstStride], (tmp4+tmp5)*20 - (tmp3+tmp6)*5 + (tmp2+tmp7));\
2407 OP2(dst[5*dstStride], (tmp5+tmp6)*20 - (tmp4+tmp7)*5 + (tmp3+tmp8));\
2408 OP2(dst[6*dstStride], (tmp6+tmp7)*20 - (tmp5+tmp8)*5 + (tmp4+tmp9));\
2409 OP2(dst[7*dstStride], (tmp7+tmp8)*20 - (tmp6+tmp9)*5 + (tmp5+tmp10));\
2415 static void OPNAME ## h264_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2416 OPNAME ## h264_qpel8_v_lowpass(dst , src , dstStride, srcStride);\
2417 OPNAME ## h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);\
2418 src += 8*srcStride;\
2419 dst += 8*dstStride;\
2420 OPNAME ## h264_qpel8_v_lowpass(dst , src , dstStride, srcStride);\
2421 OPNAME ## h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);\
2424 static void OPNAME ## h264_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2425 OPNAME ## h264_qpel8_h_lowpass(dst , src , dstStride, srcStride);\
2426 OPNAME ## h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);\
2427 src += 8*srcStride;\
2428 dst += 8*dstStride;\
2429 OPNAME ## h264_qpel8_h_lowpass(dst , src , dstStride, srcStride);\
2430 OPNAME ## h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);\
2433 static void OPNAME ## h264_qpel16_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2434 OPNAME ## h264_qpel8_hv_lowpass(dst , tmp , src , dstStride, tmpStride, srcStride);\
2435 OPNAME ## h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);\
2436 src += 8*srcStride;\
2437 dst += 8*dstStride;\
2438 OPNAME ## h264_qpel8_hv_lowpass(dst , tmp , src , dstStride, tmpStride, srcStride);\
2439 OPNAME ## h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);\
2442 #define H264_MC(OPNAME, SIZE) \
2443 static void OPNAME ## h264_qpel ## SIZE ## _mc00_c (uint8_t *dst, uint8_t *src, int stride){\
2444 OPNAME ## pixels ## SIZE ## _c(dst, src, stride, SIZE);\
2447 static void OPNAME ## h264_qpel ## SIZE ## _mc10_c(uint8_t *dst, uint8_t *src, int stride){\
2448 uint8_t half[SIZE*SIZE];\
2449 put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);\
2450 OPNAME ## pixels ## SIZE ## _l2(dst, src, half, stride, stride, SIZE, SIZE);\
2453 static void OPNAME ## h264_qpel ## SIZE ## _mc20_c(uint8_t *dst, uint8_t *src, int stride){\
2454 OPNAME ## h264_qpel ## SIZE ## _h_lowpass(dst, src, stride, stride);\
2457 static void OPNAME ## h264_qpel ## SIZE ## _mc30_c(uint8_t *dst, uint8_t *src, int stride){\
2458 uint8_t half[SIZE*SIZE];\
2459 put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);\
2460 OPNAME ## pixels ## SIZE ## _l2(dst, src+1, half, stride, stride, SIZE, SIZE);\
2463 static void OPNAME ## h264_qpel ## SIZE ## _mc01_c(uint8_t *dst, uint8_t *src, int stride){\
2464 uint8_t full[SIZE*(SIZE+5)];\
2465 uint8_t * const full_mid= full + SIZE*2;\
2466 uint8_t half[SIZE*SIZE];\
2467 copy_block ## SIZE (full, src - stride*2, SIZE, stride, SIZE + 5);\
2468 put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);\
2469 OPNAME ## pixels ## SIZE ## _l2(dst, full_mid, half, stride, SIZE, SIZE, SIZE);\
2472 static void OPNAME ## h264_qpel ## SIZE ## _mc02_c(uint8_t *dst, uint8_t *src, int stride){\
2473 uint8_t full[SIZE*(SIZE+5)];\
2474 uint8_t * const full_mid= full + SIZE*2;\
2475 copy_block ## SIZE (full, src - stride*2, SIZE, stride, SIZE + 5);\
2476 OPNAME ## h264_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE);\
2479 static void OPNAME ## h264_qpel ## SIZE ## _mc03_c(uint8_t *dst, uint8_t *src, int stride){\
2480 uint8_t full[SIZE*(SIZE+5)];\
2481 uint8_t * const full_mid= full + SIZE*2;\
2482 uint8_t half[SIZE*SIZE];\
2483 copy_block ## SIZE (full, src - stride*2, SIZE, stride, SIZE + 5);\
2484 put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);\
2485 OPNAME ## pixels ## SIZE ## _l2(dst, full_mid+SIZE, half, stride, SIZE, SIZE, SIZE);\
2488 static void OPNAME ## h264_qpel ## SIZE ## _mc11_c(uint8_t *dst, uint8_t *src, int stride){\
2489 uint8_t full[SIZE*(SIZE+5)];\
2490 uint8_t * const full_mid= full + SIZE*2;\
2491 uint8_t halfH[SIZE*SIZE];\
2492 uint8_t halfV[SIZE*SIZE];\
2493 put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
2494 copy_block ## SIZE (full, src - stride*2, SIZE, stride, SIZE + 5);\
2495 put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2496 OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2499 static void OPNAME ## h264_qpel ## SIZE ## _mc31_c(uint8_t *dst, uint8_t *src, int stride){\
2500 uint8_t full[SIZE*(SIZE+5)];\
2501 uint8_t * const full_mid= full + SIZE*2;\
2502 uint8_t halfH[SIZE*SIZE];\
2503 uint8_t halfV[SIZE*SIZE];\
2504 put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
2505 copy_block ## SIZE (full, src - stride*2 + 1, SIZE, stride, SIZE + 5);\
2506 put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2507 OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2510 static void OPNAME ## h264_qpel ## SIZE ## _mc13_c(uint8_t *dst, uint8_t *src, int stride){\
2511 uint8_t full[SIZE*(SIZE+5)];\
2512 uint8_t * const full_mid= full + SIZE*2;\
2513 uint8_t halfH[SIZE*SIZE];\
2514 uint8_t halfV[SIZE*SIZE];\
2515 put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
2516 copy_block ## SIZE (full, src - stride*2, SIZE, stride, SIZE + 5);\
2517 put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2518 OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2521 static void OPNAME ## h264_qpel ## SIZE ## _mc33_c(uint8_t *dst, uint8_t *src, int stride){\
2522 uint8_t full[SIZE*(SIZE+5)];\
2523 uint8_t * const full_mid= full + SIZE*2;\
2524 uint8_t halfH[SIZE*SIZE];\
2525 uint8_t halfV[SIZE*SIZE];\
2526 put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
2527 copy_block ## SIZE (full, src - stride*2 + 1, SIZE, stride, SIZE + 5);\
2528 put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2529 OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2532 static void OPNAME ## h264_qpel ## SIZE ## _mc22_c(uint8_t *dst, uint8_t *src, int stride){\
2533 int16_t tmp[SIZE*(SIZE+5)];\
2534 OPNAME ## h264_qpel ## SIZE ## _hv_lowpass(dst, tmp, src, stride, SIZE, stride);\
2537 static void OPNAME ## h264_qpel ## SIZE ## _mc21_c(uint8_t *dst, uint8_t *src, int stride){\
2538 int16_t tmp[SIZE*(SIZE+5)];\
2539 uint8_t halfH[SIZE*SIZE];\
2540 uint8_t halfHV[SIZE*SIZE];\
2541 put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
2542 put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
2543 OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfHV, stride, SIZE, SIZE, SIZE);\
2546 static void OPNAME ## h264_qpel ## SIZE ## _mc23_c(uint8_t *dst, uint8_t *src, int stride){\
2547 int16_t tmp[SIZE*(SIZE+5)];\
2548 uint8_t halfH[SIZE*SIZE];\
2549 uint8_t halfHV[SIZE*SIZE];\
2550 put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
2551 put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
2552 OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfHV, stride, SIZE, SIZE, SIZE);\
2555 static void OPNAME ## h264_qpel ## SIZE ## _mc12_c(uint8_t *dst, uint8_t *src, int stride){\
2556 uint8_t full[SIZE*(SIZE+5)];\
2557 uint8_t * const full_mid= full + SIZE*2;\
2558 int16_t tmp[SIZE*(SIZE+5)];\
2559 uint8_t halfV[SIZE*SIZE];\
2560 uint8_t halfHV[SIZE*SIZE];\
2561 copy_block ## SIZE (full, src - stride*2, SIZE, stride, SIZE + 5);\
2562 put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2563 put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
2564 OPNAME ## pixels ## SIZE ## _l2(dst, halfV, halfHV, stride, SIZE, SIZE, SIZE);\
2567 static void OPNAME ## h264_qpel ## SIZE ## _mc32_c(uint8_t *dst, uint8_t *src, int stride){\
2568 uint8_t full[SIZE*(SIZE+5)];\
2569 uint8_t * const full_mid= full + SIZE*2;\
2570 int16_t tmp[SIZE*(SIZE+5)];\
2571 uint8_t halfV[SIZE*SIZE];\
2572 uint8_t halfHV[SIZE*SIZE];\
2573 copy_block ## SIZE (full, src - stride*2 + 1, SIZE, stride, SIZE + 5);\
2574 put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2575 put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
2576 OPNAME ## pixels ## SIZE ## _l2(dst, halfV, halfHV, stride, SIZE, SIZE, SIZE);\
2579 #define op_avg(a, b) a = (((a)+cm[((b) + 16)>>5]+1)>>1)
2580 //#define op_avg2(a, b) a = (((a)*w1+cm[((b) + 16)>>5]*w2 + o + 64)>>7)
2581 #define op_put(a, b) a = cm[((b) + 16)>>5]
2582 #define op2_avg(a, b) a = (((a)+cm[((b) + 512)>>10]+1)>>1)
2583 #define op2_put(a, b) a = cm[((b) + 512)>>10]
2585 H264_LOWPASS(put_
, op_put
, op2_put
)
2586 H264_LOWPASS(avg_
, op_avg
, op2_avg
)
2601 static void wmv2_mspel8_h_lowpass(uint8_t *dst
, uint8_t *src
, int dstStride
, int srcStride
, int h
){
2602 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
2606 dst
[0]= cm
[(9*(src
[0] + src
[1]) - (src
[-1] + src
[2]) + 8)>>4];
2607 dst
[1]= cm
[(9*(src
[1] + src
[2]) - (src
[ 0] + src
[3]) + 8)>>4];
2608 dst
[2]= cm
[(9*(src
[2] + src
[3]) - (src
[ 1] + src
[4]) + 8)>>4];
2609 dst
[3]= cm
[(9*(src
[3] + src
[4]) - (src
[ 2] + src
[5]) + 8)>>4];
2610 dst
[4]= cm
[(9*(src
[4] + src
[5]) - (src
[ 3] + src
[6]) + 8)>>4];
2611 dst
[5]= cm
[(9*(src
[5] + src
[6]) - (src
[ 4] + src
[7]) + 8)>>4];
2612 dst
[6]= cm
[(9*(src
[6] + src
[7]) - (src
[ 5] + src
[8]) + 8)>>4];
2613 dst
[7]= cm
[(9*(src
[7] + src
[8]) - (src
[ 6] + src
[9]) + 8)>>4];
2619 #if CONFIG_CAVS_DECODER
2621 void ff_put_cavs_qpel8_mc00_c(uint8_t *dst
, uint8_t *src
, int stride
) {
2622 put_pixels8_c(dst
, src
, stride
, 8);
2624 void ff_avg_cavs_qpel8_mc00_c(uint8_t *dst
, uint8_t *src
, int stride
) {
2625 avg_pixels8_c(dst
, src
, stride
, 8);
2627 void ff_put_cavs_qpel16_mc00_c(uint8_t *dst
, uint8_t *src
, int stride
) {
2628 put_pixels16_c(dst
, src
, stride
, 16);
2630 void ff_avg_cavs_qpel16_mc00_c(uint8_t *dst
, uint8_t *src
, int stride
) {
2631 avg_pixels16_c(dst
, src
, stride
, 16);
2633 #endif /* CONFIG_CAVS_DECODER */
2635 #if CONFIG_VC1_DECODER
2637 void ff_put_vc1_mspel_mc00_c(uint8_t *dst
, const uint8_t *src
, int stride
, int rnd
) {
2638 put_pixels8_c(dst
, src
, stride
, 8);
2640 void ff_avg_vc1_mspel_mc00_c(uint8_t *dst
, const uint8_t *src
, int stride
, int rnd
) {
2641 avg_pixels8_c(dst
, src
, stride
, 8);
2643 #endif /* CONFIG_VC1_DECODER */
2645 #if CONFIG_RV40_DECODER
2646 static void put_rv40_qpel16_mc33_c(uint8_t *dst
, uint8_t *src
, int stride
){
2647 put_pixels16_xy2_c(dst
, src
, stride
, 16);
2649 static void avg_rv40_qpel16_mc33_c(uint8_t *dst
, uint8_t *src
, int stride
){
2650 avg_pixels16_xy2_c(dst
, src
, stride
, 16);
2652 static void put_rv40_qpel8_mc33_c(uint8_t *dst
, uint8_t *src
, int stride
){
2653 put_pixels8_xy2_c(dst
, src
, stride
, 8);
2655 static void avg_rv40_qpel8_mc33_c(uint8_t *dst
, uint8_t *src
, int stride
){
2656 avg_pixels8_xy2_c(dst
, src
, stride
, 8);
2658 #endif /* CONFIG_RV40_DECODER */
2660 static void wmv2_mspel8_v_lowpass(uint8_t *dst
, uint8_t *src
, int dstStride
, int srcStride
, int w
){
2661 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
2665 const int src_1
= src
[ -srcStride
];
2666 const int src0
= src
[0 ];
2667 const int src1
= src
[ srcStride
];
2668 const int src2
= src
[2*srcStride
];
2669 const int src3
= src
[3*srcStride
];
2670 const int src4
= src
[4*srcStride
];
2671 const int src5
= src
[5*srcStride
];
2672 const int src6
= src
[6*srcStride
];
2673 const int src7
= src
[7*srcStride
];
2674 const int src8
= src
[8*srcStride
];
2675 const int src9
= src
[9*srcStride
];
2676 dst
[0*dstStride
]= cm
[(9*(src0
+ src1
) - (src_1
+ src2
) + 8)>>4];
2677 dst
[1*dstStride
]= cm
[(9*(src1
+ src2
) - (src0
+ src3
) + 8)>>4];
2678 dst
[2*dstStride
]= cm
[(9*(src2
+ src3
) - (src1
+ src4
) + 8)>>4];
2679 dst
[3*dstStride
]= cm
[(9*(src3
+ src4
) - (src2
+ src5
) + 8)>>4];
2680 dst
[4*dstStride
]= cm
[(9*(src4
+ src5
) - (src3
+ src6
) + 8)>>4];
2681 dst
[5*dstStride
]= cm
[(9*(src5
+ src6
) - (src4
+ src7
) + 8)>>4];
2682 dst
[6*dstStride
]= cm
[(9*(src6
+ src7
) - (src5
+ src8
) + 8)>>4];
2683 dst
[7*dstStride
]= cm
[(9*(src7
+ src8
) - (src6
+ src9
) + 8)>>4];
2689 static void put_mspel8_mc00_c (uint8_t *dst
, uint8_t *src
, int stride
){
2690 put_pixels8_c(dst
, src
, stride
, 8);
2693 static void put_mspel8_mc10_c(uint8_t *dst
, uint8_t *src
, int stride
){
2695 wmv2_mspel8_h_lowpass(half
, src
, 8, stride
, 8);
2696 put_pixels8_l2(dst
, src
, half
, stride
, stride
, 8, 8);
2699 static void put_mspel8_mc20_c(uint8_t *dst
, uint8_t *src
, int stride
){
2700 wmv2_mspel8_h_lowpass(dst
, src
, stride
, stride
, 8);
2703 static void put_mspel8_mc30_c(uint8_t *dst
, uint8_t *src
, int stride
){
2705 wmv2_mspel8_h_lowpass(half
, src
, 8, stride
, 8);
2706 put_pixels8_l2(dst
, src
+1, half
, stride
, stride
, 8, 8);
2709 static void put_mspel8_mc02_c(uint8_t *dst
, uint8_t *src
, int stride
){
2710 wmv2_mspel8_v_lowpass(dst
, src
, stride
, stride
, 8);
2713 static void put_mspel8_mc12_c(uint8_t *dst
, uint8_t *src
, int stride
){
2717 wmv2_mspel8_h_lowpass(halfH
, src
-stride
, 8, stride
, 11);
2718 wmv2_mspel8_v_lowpass(halfV
, src
, 8, stride
, 8);
2719 wmv2_mspel8_v_lowpass(halfHV
, halfH
+8, 8, 8, 8);
2720 put_pixels8_l2(dst
, halfV
, halfHV
, stride
, 8, 8, 8);
2722 static void put_mspel8_mc32_c(uint8_t *dst
, uint8_t *src
, int stride
){
2726 wmv2_mspel8_h_lowpass(halfH
, src
-stride
, 8, stride
, 11);
2727 wmv2_mspel8_v_lowpass(halfV
, src
+1, 8, stride
, 8);
2728 wmv2_mspel8_v_lowpass(halfHV
, halfH
+8, 8, 8, 8);
2729 put_pixels8_l2(dst
, halfV
, halfHV
, stride
, 8, 8, 8);
2731 static void put_mspel8_mc22_c(uint8_t *dst
, uint8_t *src
, int stride
){
2733 wmv2_mspel8_h_lowpass(halfH
, src
-stride
, 8, stride
, 11);
2734 wmv2_mspel8_v_lowpass(dst
, halfH
+8, stride
, 8, 8);
2737 static void h263_v_loop_filter_c(uint8_t *src
, int stride
, int qscale
){
2738 if(CONFIG_H263_DECODER
|| CONFIG_H263_ENCODER
) {
2740 const int strength
= ff_h263_loop_filter_strength
[qscale
];
2744 int p0
= src
[x
-2*stride
];
2745 int p1
= src
[x
-1*stride
];
2746 int p2
= src
[x
+0*stride
];
2747 int p3
= src
[x
+1*stride
];
2748 int d
= (p0
- p3
+ 4*(p2
- p1
)) / 8;
2750 if (d
<-2*strength
) d1
= 0;
2751 else if(d
<- strength
) d1
=-2*strength
- d
;
2752 else if(d
< strength
) d1
= d
;
2753 else if(d
< 2*strength
) d1
= 2*strength
- d
;
2758 if(p1
&256) p1
= ~(p1
>>31);
2759 if(p2
&256) p2
= ~(p2
>>31);
2761 src
[x
-1*stride
] = p1
;
2762 src
[x
+0*stride
] = p2
;
2766 d2
= av_clip((p0
-p3
)/4, -ad1
, ad1
);
2768 src
[x
-2*stride
] = p0
- d2
;
2769 src
[x
+ stride
] = p3
+ d2
;
2774 static void h263_h_loop_filter_c(uint8_t *src
, int stride
, int qscale
){
2775 if(CONFIG_H263_DECODER
|| CONFIG_H263_ENCODER
) {
2777 const int strength
= ff_h263_loop_filter_strength
[qscale
];
2781 int p0
= src
[y
*stride
-2];
2782 int p1
= src
[y
*stride
-1];
2783 int p2
= src
[y
*stride
+0];
2784 int p3
= src
[y
*stride
+1];
2785 int d
= (p0
- p3
+ 4*(p2
- p1
)) / 8;
2787 if (d
<-2*strength
) d1
= 0;
2788 else if(d
<- strength
) d1
=-2*strength
- d
;
2789 else if(d
< strength
) d1
= d
;
2790 else if(d
< 2*strength
) d1
= 2*strength
- d
;
2795 if(p1
&256) p1
= ~(p1
>>31);
2796 if(p2
&256) p2
= ~(p2
>>31);
2798 src
[y
*stride
-1] = p1
;
2799 src
[y
*stride
+0] = p2
;
2803 d2
= av_clip((p0
-p3
)/4, -ad1
, ad1
);
2805 src
[y
*stride
-2] = p0
- d2
;
2806 src
[y
*stride
+1] = p3
+ d2
;
2811 static void h261_loop_filter_c(uint8_t *src
, int stride
){
2816 temp
[x
] = 4*src
[x
];
2817 temp
[x
+ 7*8] = 4*src
[x
+ 7*stride
];
2821 xy
= y
* stride
+ x
;
2823 temp
[yz
] = src
[xy
- stride
] + 2*src
[xy
] + src
[xy
+ stride
];
2828 src
[ y
*stride
] = (temp
[ y
*8] + 2)>>2;
2829 src
[7+y
*stride
] = (temp
[7+y
*8] + 2)>>2;
2831 xy
= y
* stride
+ x
;
2833 src
[xy
] = (temp
[yz
-1] + 2*temp
[yz
] + temp
[yz
+1] + 8)>>4;
2838 static inline int pix_abs16_c(void *v
, uint8_t *pix1
, uint8_t *pix2
, int line_size
, int h
)
2844 s
+= abs(pix1
[0] - pix2
[0]);
2845 s
+= abs(pix1
[1] - pix2
[1]);
2846 s
+= abs(pix1
[2] - pix2
[2]);
2847 s
+= abs(pix1
[3] - pix2
[3]);
2848 s
+= abs(pix1
[4] - pix2
[4]);
2849 s
+= abs(pix1
[5] - pix2
[5]);
2850 s
+= abs(pix1
[6] - pix2
[6]);
2851 s
+= abs(pix1
[7] - pix2
[7]);
2852 s
+= abs(pix1
[8] - pix2
[8]);
2853 s
+= abs(pix1
[9] - pix2
[9]);
2854 s
+= abs(pix1
[10] - pix2
[10]);
2855 s
+= abs(pix1
[11] - pix2
[11]);
2856 s
+= abs(pix1
[12] - pix2
[12]);
2857 s
+= abs(pix1
[13] - pix2
[13]);
2858 s
+= abs(pix1
[14] - pix2
[14]);
2859 s
+= abs(pix1
[15] - pix2
[15]);
2866 static int pix_abs16_x2_c(void *v
, uint8_t *pix1
, uint8_t *pix2
, int line_size
, int h
)
2872 s
+= abs(pix1
[0] - avg2(pix2
[0], pix2
[1]));
2873 s
+= abs(pix1
[1] - avg2(pix2
[1], pix2
[2]));
2874 s
+= abs(pix1
[2] - avg2(pix2
[2], pix2
[3]));
2875 s
+= abs(pix1
[3] - avg2(pix2
[3], pix2
[4]));
2876 s
+= abs(pix1
[4] - avg2(pix2
[4], pix2
[5]));
2877 s
+= abs(pix1
[5] - avg2(pix2
[5], pix2
[6]));
2878 s
+= abs(pix1
[6] - avg2(pix2
[6], pix2
[7]));
2879 s
+= abs(pix1
[7] - avg2(pix2
[7], pix2
[8]));
2880 s
+= abs(pix1
[8] - avg2(pix2
[8], pix2
[9]));
2881 s
+= abs(pix1
[9] - avg2(pix2
[9], pix2
[10]));
2882 s
+= abs(pix1
[10] - avg2(pix2
[10], pix2
[11]));
2883 s
+= abs(pix1
[11] - avg2(pix2
[11], pix2
[12]));
2884 s
+= abs(pix1
[12] - avg2(pix2
[12], pix2
[13]));
2885 s
+= abs(pix1
[13] - avg2(pix2
[13], pix2
[14]));
2886 s
+= abs(pix1
[14] - avg2(pix2
[14], pix2
[15]));
2887 s
+= abs(pix1
[15] - avg2(pix2
[15], pix2
[16]));
2894 static int pix_abs16_y2_c(void *v
, uint8_t *pix1
, uint8_t *pix2
, int line_size
, int h
)
2897 uint8_t *pix3
= pix2
+ line_size
;
2901 s
+= abs(pix1
[0] - avg2(pix2
[0], pix3
[0]));
2902 s
+= abs(pix1
[1] - avg2(pix2
[1], pix3
[1]));
2903 s
+= abs(pix1
[2] - avg2(pix2
[2], pix3
[2]));
2904 s
+= abs(pix1
[3] - avg2(pix2
[3], pix3
[3]));
2905 s
+= abs(pix1
[4] - avg2(pix2
[4], pix3
[4]));
2906 s
+= abs(pix1
[5] - avg2(pix2
[5], pix3
[5]));
2907 s
+= abs(pix1
[6] - avg2(pix2
[6], pix3
[6]));
2908 s
+= abs(pix1
[7] - avg2(pix2
[7], pix3
[7]));
2909 s
+= abs(pix1
[8] - avg2(pix2
[8], pix3
[8]));
2910 s
+= abs(pix1
[9] - avg2(pix2
[9], pix3
[9]));
2911 s
+= abs(pix1
[10] - avg2(pix2
[10], pix3
[10]));
2912 s
+= abs(pix1
[11] - avg2(pix2
[11], pix3
[11]));
2913 s
+= abs(pix1
[12] - avg2(pix2
[12], pix3
[12]));
2914 s
+= abs(pix1
[13] - avg2(pix2
[13], pix3
[13]));
2915 s
+= abs(pix1
[14] - avg2(pix2
[14], pix3
[14]));
2916 s
+= abs(pix1
[15] - avg2(pix2
[15], pix3
[15]));
2924 static int pix_abs16_xy2_c(void *v
, uint8_t *pix1
, uint8_t *pix2
, int line_size
, int h
)
2927 uint8_t *pix3
= pix2
+ line_size
;
2931 s
+= abs(pix1
[0] - avg4(pix2
[0], pix2
[1], pix3
[0], pix3
[1]));
2932 s
+= abs(pix1
[1] - avg4(pix2
[1], pix2
[2], pix3
[1], pix3
[2]));
2933 s
+= abs(pix1
[2] - avg4(pix2
[2], pix2
[3], pix3
[2], pix3
[3]));
2934 s
+= abs(pix1
[3] - avg4(pix2
[3], pix2
[4], pix3
[3], pix3
[4]));
2935 s
+= abs(pix1
[4] - avg4(pix2
[4], pix2
[5], pix3
[4], pix3
[5]));
2936 s
+= abs(pix1
[5] - avg4(pix2
[5], pix2
[6], pix3
[5], pix3
[6]));
2937 s
+= abs(pix1
[6] - avg4(pix2
[6], pix2
[7], pix3
[6], pix3
[7]));
2938 s
+= abs(pix1
[7] - avg4(pix2
[7], pix2
[8], pix3
[7], pix3
[8]));
2939 s
+= abs(pix1
[8] - avg4(pix2
[8], pix2
[9], pix3
[8], pix3
[9]));
2940 s
+= abs(pix1
[9] - avg4(pix2
[9], pix2
[10], pix3
[9], pix3
[10]));
2941 s
+= abs(pix1
[10] - avg4(pix2
[10], pix2
[11], pix3
[10], pix3
[11]));
2942 s
+= abs(pix1
[11] - avg4(pix2
[11], pix2
[12], pix3
[11], pix3
[12]));
2943 s
+= abs(pix1
[12] - avg4(pix2
[12], pix2
[13], pix3
[12], pix3
[13]));
2944 s
+= abs(pix1
[13] - avg4(pix2
[13], pix2
[14], pix3
[13], pix3
[14]));
2945 s
+= abs(pix1
[14] - avg4(pix2
[14], pix2
[15], pix3
[14], pix3
[15]));
2946 s
+= abs(pix1
[15] - avg4(pix2
[15], pix2
[16], pix3
[15], pix3
[16]));
2954 static inline int pix_abs8_c(void *v
, uint8_t *pix1
, uint8_t *pix2
, int line_size
, int h
)
2960 s
+= abs(pix1
[0] - pix2
[0]);
2961 s
+= abs(pix1
[1] - pix2
[1]);
2962 s
+= abs(pix1
[2] - pix2
[2]);
2963 s
+= abs(pix1
[3] - pix2
[3]);
2964 s
+= abs(pix1
[4] - pix2
[4]);
2965 s
+= abs(pix1
[5] - pix2
[5]);
2966 s
+= abs(pix1
[6] - pix2
[6]);
2967 s
+= abs(pix1
[7] - pix2
[7]);
2974 static int pix_abs8_x2_c(void *v
, uint8_t *pix1
, uint8_t *pix2
, int line_size
, int h
)
2980 s
+= abs(pix1
[0] - avg2(pix2
[0], pix2
[1]));
2981 s
+= abs(pix1
[1] - avg2(pix2
[1], pix2
[2]));
2982 s
+= abs(pix1
[2] - avg2(pix2
[2], pix2
[3]));
2983 s
+= abs(pix1
[3] - avg2(pix2
[3], pix2
[4]));
2984 s
+= abs(pix1
[4] - avg2(pix2
[4], pix2
[5]));
2985 s
+= abs(pix1
[5] - avg2(pix2
[5], pix2
[6]));
2986 s
+= abs(pix1
[6] - avg2(pix2
[6], pix2
[7]));
2987 s
+= abs(pix1
[7] - avg2(pix2
[7], pix2
[8]));
2994 static int pix_abs8_y2_c(void *v
, uint8_t *pix1
, uint8_t *pix2
, int line_size
, int h
)
2997 uint8_t *pix3
= pix2
+ line_size
;
3001 s
+= abs(pix1
[0] - avg2(pix2
[0], pix3
[0]));
3002 s
+= abs(pix1
[1] - avg2(pix2
[1], pix3
[1]));
3003 s
+= abs(pix1
[2] - avg2(pix2
[2], pix3
[2]));
3004 s
+= abs(pix1
[3] - avg2(pix2
[3], pix3
[3]));
3005 s
+= abs(pix1
[4] - avg2(pix2
[4], pix3
[4]));
3006 s
+= abs(pix1
[5] - avg2(pix2
[5], pix3
[5]));
3007 s
+= abs(pix1
[6] - avg2(pix2
[6], pix3
[6]));
3008 s
+= abs(pix1
[7] - avg2(pix2
[7], pix3
[7]));
3016 static int pix_abs8_xy2_c(void *v
, uint8_t *pix1
, uint8_t *pix2
, int line_size
, int h
)
3019 uint8_t *pix3
= pix2
+ line_size
;
3023 s
+= abs(pix1
[0] - avg4(pix2
[0], pix2
[1], pix3
[0], pix3
[1]));
3024 s
+= abs(pix1
[1] - avg4(pix2
[1], pix2
[2], pix3
[1], pix3
[2]));
3025 s
+= abs(pix1
[2] - avg4(pix2
[2], pix2
[3], pix3
[2], pix3
[3]));
3026 s
+= abs(pix1
[3] - avg4(pix2
[3], pix2
[4], pix3
[3], pix3
[4]));
3027 s
+= abs(pix1
[4] - avg4(pix2
[4], pix2
[5], pix3
[4], pix3
[5]));
3028 s
+= abs(pix1
[5] - avg4(pix2
[5], pix2
[6], pix3
[5], pix3
[6]));
3029 s
+= abs(pix1
[6] - avg4(pix2
[6], pix2
[7], pix3
[6], pix3
[7]));
3030 s
+= abs(pix1
[7] - avg4(pix2
[7], pix2
[8], pix3
[7], pix3
[8]));
3038 static int nsse16_c(void *v
, uint8_t *s1
, uint8_t *s2
, int stride
, int h
){
3039 MpegEncContext
*c
= v
;
3045 for(x
=0; x
<16; x
++){
3046 score1
+= (s1
[x
] - s2
[x
])*(s1
[x
] - s2
[x
]);
3049 for(x
=0; x
<15; x
++){
3050 score2
+= FFABS( s1
[x
] - s1
[x
+stride
]
3051 - s1
[x
+1] + s1
[x
+1+stride
])
3052 -FFABS( s2
[x
] - s2
[x
+stride
]
3053 - s2
[x
+1] + s2
[x
+1+stride
]);
3060 if(c
) return score1
+ FFABS(score2
)*c
->avctx
->nsse_weight
;
3061 else return score1
+ FFABS(score2
)*8;
3064 static int nsse8_c(void *v
, uint8_t *s1
, uint8_t *s2
, int stride
, int h
){
3065 MpegEncContext
*c
= v
;
3072 score1
+= (s1
[x
] - s2
[x
])*(s1
[x
] - s2
[x
]);
3076 score2
+= FFABS( s1
[x
] - s1
[x
+stride
]
3077 - s1
[x
+1] + s1
[x
+1+stride
])
3078 -FFABS( s2
[x
] - s2
[x
+stride
]
3079 - s2
[x
+1] + s2
[x
+1+stride
]);
3086 if(c
) return score1
+ FFABS(score2
)*c
->avctx
->nsse_weight
;
3087 else return score1
+ FFABS(score2
)*8;
3090 static int try_8x8basis_c(int16_t rem
[64], int16_t weight
[64], int16_t basis
[64], int scale
){
3094 for(i
=0; i
<8*8; i
++){
3095 int b
= rem
[i
] + ((basis
[i
]*scale
+ (1<<(BASIS_SHIFT
- RECON_SHIFT
-1)))>>(BASIS_SHIFT
- RECON_SHIFT
));
3098 assert(-512<b
&& b
<512);
3100 sum
+= (w
*b
)*(w
*b
)>>4;
3105 static void add_8x8basis_c(int16_t rem
[64], int16_t basis
[64], int scale
){
3108 for(i
=0; i
<8*8; i
++){
3109 rem
[i
] += (basis
[i
]*scale
+ (1<<(BASIS_SHIFT
- RECON_SHIFT
-1)))>>(BASIS_SHIFT
- RECON_SHIFT
);
3114 * permutes an 8x8 block.
3115 * @param block the block which will be permuted according to the given permutation vector
3116 * @param permutation the permutation vector
3117 * @param last the last non zero coefficient in scantable order, used to speed the permutation up
3118 * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
3119 * (inverse) permutated to scantable order!
3121 void ff_block_permute(DCTELEM
*block
, uint8_t *permutation
, const uint8_t *scantable
, int last
)
3127 //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
3129 for(i
=0; i
<=last
; i
++){
3130 const int j
= scantable
[i
];
3135 for(i
=0; i
<=last
; i
++){
3136 const int j
= scantable
[i
];
3137 const int perm_j
= permutation
[j
];
3138 block
[perm_j
]= temp
[j
];
3142 static int zero_cmp(void *s
, uint8_t *a
, uint8_t *b
, int stride
, int h
){
3146 void ff_set_cmp(DSPContext
* c
, me_cmp_func
*cmp
, int type
){
3149 memset(cmp
, 0, sizeof(void*)*6);
3157 cmp
[i
]= c
->hadamard8_diff
[i
];
3163 cmp
[i
]= c
->dct_sad
[i
];
3166 cmp
[i
]= c
->dct264_sad
[i
];
3169 cmp
[i
]= c
->dct_max
[i
];
3172 cmp
[i
]= c
->quant_psnr
[i
];
3201 av_log(NULL
, AV_LOG_ERROR
,"internal error in cmp function selection\n");
3206 static void clear_block_c(DCTELEM
*block
)
3208 memset(block
, 0, sizeof(DCTELEM
)*64);
3212 * memset(blocks, 0, sizeof(DCTELEM)*6*64)
3214 static void clear_blocks_c(DCTELEM
*blocks
)
3216 memset(blocks
, 0, sizeof(DCTELEM
)*6*64);
3219 static void add_bytes_c(uint8_t *dst
, uint8_t *src
, int w
){
3221 for(i
=0; i
<=w
-sizeof(long); i
+=sizeof(long)){
3222 long a
= *(long*)(src
+i
);
3223 long b
= *(long*)(dst
+i
);
3224 *(long*)(dst
+i
) = ((a
&pb_7f
) + (b
&pb_7f
)) ^ ((a
^b
)&pb_80
);
3227 dst
[i
+0] += src
[i
+0];
3230 static void add_bytes_l2_c(uint8_t *dst
, uint8_t *src1
, uint8_t *src2
, int w
){
3232 for(i
=0; i
<=w
-sizeof(long); i
+=sizeof(long)){
3233 long a
= *(long*)(src1
+i
);
3234 long b
= *(long*)(src2
+i
);
3235 *(long*)(dst
+i
) = ((a
&pb_7f
) + (b
&pb_7f
)) ^ ((a
^b
)&pb_80
);
3238 dst
[i
] = src1
[i
]+src2
[i
];
3241 static void diff_bytes_c(uint8_t *dst
, uint8_t *src1
, uint8_t *src2
, int w
){
3243 #if !HAVE_FAST_UNALIGNED
3244 if((long)src2
& (sizeof(long)-1)){
3245 for(i
=0; i
+7<w
; i
+=8){
3246 dst
[i
+0] = src1
[i
+0]-src2
[i
+0];
3247 dst
[i
+1] = src1
[i
+1]-src2
[i
+1];
3248 dst
[i
+2] = src1
[i
+2]-src2
[i
+2];
3249 dst
[i
+3] = src1
[i
+3]-src2
[i
+3];
3250 dst
[i
+4] = src1
[i
+4]-src2
[i
+4];
3251 dst
[i
+5] = src1
[i
+5]-src2
[i
+5];
3252 dst
[i
+6] = src1
[i
+6]-src2
[i
+6];
3253 dst
[i
+7] = src1
[i
+7]-src2
[i
+7];
3257 for(i
=0; i
<=w
-sizeof(long); i
+=sizeof(long)){
3258 long a
= *(long*)(src1
+i
);
3259 long b
= *(long*)(src2
+i
);
3260 *(long*)(dst
+i
) = ((a
|pb_80
) - (b
&pb_7f
)) ^ ((a
^b
^pb_80
)&pb_80
);
3263 dst
[i
+0] = src1
[i
+0]-src2
[i
+0];
3266 static void add_hfyu_median_prediction_c(uint8_t *dst
, const uint8_t *src1
, const uint8_t *diff
, int w
, int *left
, int *left_top
){
3274 l
= mid_pred(l
, src1
[i
], (l
+ src1
[i
] - lt
)&0xFF) + diff
[i
];
3283 static void sub_hfyu_median_prediction_c(uint8_t *dst
, const uint8_t *src1
, const uint8_t *src2
, int w
, int *left
, int *left_top
){
3291 const int pred
= mid_pred(l
, src1
[i
], (l
+ src1
[i
] - lt
)&0xFF);
3301 static int add_hfyu_left_prediction_c(uint8_t *dst
, const uint8_t *src
, int w
, int acc
){
3304 for(i
=0; i
<w
-1; i
++){
3331 static void add_hfyu_left_prediction_bgr32_c(uint8_t *dst
, const uint8_t *src
, int w
, int *red
, int *green
, int *blue
, int *alpha
){
3361 #define BUTTERFLY2(o1,o2,i1,i2) \
3365 #define BUTTERFLY1(x,y) \
3374 #define BUTTERFLYA(x,y) (FFABS((x)+(y)) + FFABS((x)-(y)))
3376 static int hadamard8_diff8x8_c(/*MpegEncContext*/ void *s
, uint8_t *dst
, uint8_t *src
, int stride
, int h
){
3384 //FIXME try pointer walks
3385 BUTTERFLY2(temp
[8*i
+0], temp
[8*i
+1], src
[stride
*i
+0]-dst
[stride
*i
+0],src
[stride
*i
+1]-dst
[stride
*i
+1]);
3386 BUTTERFLY2(temp
[8*i
+2], temp
[8*i
+3], src
[stride
*i
+2]-dst
[stride
*i
+2],src
[stride
*i
+3]-dst
[stride
*i
+3]);
3387 BUTTERFLY2(temp
[8*i
+4], temp
[8*i
+5], src
[stride
*i
+4]-dst
[stride
*i
+4],src
[stride
*i
+5]-dst
[stride
*i
+5]);
3388 BUTTERFLY2(temp
[8*i
+6], temp
[8*i
+7], src
[stride
*i
+6]-dst
[stride
*i
+6],src
[stride
*i
+7]-dst
[stride
*i
+7]);
3390 BUTTERFLY1(temp
[8*i
+0], temp
[8*i
+2]);
3391 BUTTERFLY1(temp
[8*i
+1], temp
[8*i
+3]);
3392 BUTTERFLY1(temp
[8*i
+4], temp
[8*i
+6]);
3393 BUTTERFLY1(temp
[8*i
+5], temp
[8*i
+7]);
3395 BUTTERFLY1(temp
[8*i
+0], temp
[8*i
+4]);
3396 BUTTERFLY1(temp
[8*i
+1], temp
[8*i
+5]);
3397 BUTTERFLY1(temp
[8*i
+2], temp
[8*i
+6]);
3398 BUTTERFLY1(temp
[8*i
+3], temp
[8*i
+7]);
3402 BUTTERFLY1(temp
[8*0+i
], temp
[8*1+i
]);
3403 BUTTERFLY1(temp
[8*2+i
], temp
[8*3+i
]);
3404 BUTTERFLY1(temp
[8*4+i
], temp
[8*5+i
]);
3405 BUTTERFLY1(temp
[8*6+i
], temp
[8*7+i
]);
3407 BUTTERFLY1(temp
[8*0+i
], temp
[8*2+i
]);
3408 BUTTERFLY1(temp
[8*1+i
], temp
[8*3+i
]);
3409 BUTTERFLY1(temp
[8*4+i
], temp
[8*6+i
]);
3410 BUTTERFLY1(temp
[8*5+i
], temp
[8*7+i
]);
3413 BUTTERFLYA(temp
[8*0+i
], temp
[8*4+i
])
3414 +BUTTERFLYA(temp
[8*1+i
], temp
[8*5+i
])
3415 +BUTTERFLYA(temp
[8*2+i
], temp
[8*6+i
])
3416 +BUTTERFLYA(temp
[8*3+i
], temp
[8*7+i
]);
3422 printf("MAX:%d\n", maxi
);
3428 static int hadamard8_intra8x8_c(/*MpegEncContext*/ void *s
, uint8_t *src
, uint8_t *dummy
, int stride
, int h
){
3436 //FIXME try pointer walks
3437 BUTTERFLY2(temp
[8*i
+0], temp
[8*i
+1], src
[stride
*i
+0],src
[stride
*i
+1]);
3438 BUTTERFLY2(temp
[8*i
+2], temp
[8*i
+3], src
[stride
*i
+2],src
[stride
*i
+3]);
3439 BUTTERFLY2(temp
[8*i
+4], temp
[8*i
+5], src
[stride
*i
+4],src
[stride
*i
+5]);
3440 BUTTERFLY2(temp
[8*i
+6], temp
[8*i
+7], src
[stride
*i
+6],src
[stride
*i
+7]);
3442 BUTTERFLY1(temp
[8*i
+0], temp
[8*i
+2]);
3443 BUTTERFLY1(temp
[8*i
+1], temp
[8*i
+3]);
3444 BUTTERFLY1(temp
[8*i
+4], temp
[8*i
+6]);
3445 BUTTERFLY1(temp
[8*i
+5], temp
[8*i
+7]);
3447 BUTTERFLY1(temp
[8*i
+0], temp
[8*i
+4]);
3448 BUTTERFLY1(temp
[8*i
+1], temp
[8*i
+5]);
3449 BUTTERFLY1(temp
[8*i
+2], temp
[8*i
+6]);
3450 BUTTERFLY1(temp
[8*i
+3], temp
[8*i
+7]);
3454 BUTTERFLY1(temp
[8*0+i
], temp
[8*1+i
]);
3455 BUTTERFLY1(temp
[8*2+i
], temp
[8*3+i
]);
3456 BUTTERFLY1(temp
[8*4+i
], temp
[8*5+i
]);
3457 BUTTERFLY1(temp
[8*6+i
], temp
[8*7+i
]);
3459 BUTTERFLY1(temp
[8*0+i
], temp
[8*2+i
]);
3460 BUTTERFLY1(temp
[8*1+i
], temp
[8*3+i
]);
3461 BUTTERFLY1(temp
[8*4+i
], temp
[8*6+i
]);
3462 BUTTERFLY1(temp
[8*5+i
], temp
[8*7+i
]);
3465 BUTTERFLYA(temp
[8*0+i
], temp
[8*4+i
])
3466 +BUTTERFLYA(temp
[8*1+i
], temp
[8*5+i
])
3467 +BUTTERFLYA(temp
[8*2+i
], temp
[8*6+i
])
3468 +BUTTERFLYA(temp
[8*3+i
], temp
[8*7+i
]);
3471 sum
-= FFABS(temp
[8*0] + temp
[8*4]); // -mean
3476 static int dct_sad8x8_c(/*MpegEncContext*/ void *c
, uint8_t *src1
, uint8_t *src2
, int stride
, int h
){
3477 MpegEncContext
* const s
= (MpegEncContext
*)c
;
3478 LOCAL_ALIGNED_16(DCTELEM
, temp
, [64]);
3482 s
->dsp
.diff_pixels(temp
, src1
, src2
, stride
);
3484 return s
->dsp
.sum_abs_dctelem(temp
);
3489 const int s07 = SRC(0) + SRC(7);\
3490 const int s16 = SRC(1) + SRC(6);\
3491 const int s25 = SRC(2) + SRC(5);\
3492 const int s34 = SRC(3) + SRC(4);\
3493 const int a0 = s07 + s34;\
3494 const int a1 = s16 + s25;\
3495 const int a2 = s07 - s34;\
3496 const int a3 = s16 - s25;\
3497 const int d07 = SRC(0) - SRC(7);\
3498 const int d16 = SRC(1) - SRC(6);\
3499 const int d25 = SRC(2) - SRC(5);\
3500 const int d34 = SRC(3) - SRC(4);\
3501 const int a4 = d16 + d25 + (d07 + (d07>>1));\
3502 const int a5 = d07 - d34 - (d25 + (d25>>1));\
3503 const int a6 = d07 + d34 - (d16 + (d16>>1));\
3504 const int a7 = d16 - d25 + (d34 + (d34>>1));\
3506 DST(1, a4 + (a7>>2)) ;\
3507 DST(2, a2 + (a3>>1)) ;\
3508 DST(3, a5 + (a6>>2)) ;\
3510 DST(5, a6 - (a5>>2)) ;\
3511 DST(6, (a2>>1) - a3 ) ;\
3512 DST(7, (a4>>2) - a7 ) ;\
3515 static int dct264_sad8x8_c(/*MpegEncContext*/ void *c
, uint8_t *src1
, uint8_t *src2
, int stride
, int h
){
3516 MpegEncContext
* const s
= (MpegEncContext
*)c
;
3521 s
->dsp
.diff_pixels(dct
[0], src1
, src2
, stride
);
3523 #define SRC(x) dct[i][x]
3524 #define DST(x,v) dct[i][x]= v
3525 for( i
= 0; i
< 8; i
++ )
3530 #define SRC(x) dct[x][i]
3531 #define DST(x,v) sum += FFABS(v)
3532 for( i
= 0; i
< 8; i
++ )
3540 static int dct_max8x8_c(/*MpegEncContext*/ void *c
, uint8_t *src1
, uint8_t *src2
, int stride
, int h
){
3541 MpegEncContext
* const s
= (MpegEncContext
*)c
;
3542 LOCAL_ALIGNED_16(DCTELEM
, temp
, [64]);
3547 s
->dsp
.diff_pixels(temp
, src1
, src2
, stride
);
3551 sum
= FFMAX(sum
, FFABS(temp
[i
]));
3556 static int quant_psnr8x8_c(/*MpegEncContext*/ void *c
, uint8_t *src1
, uint8_t *src2
, int stride
, int h
){
3557 MpegEncContext
* const s
= (MpegEncContext
*)c
;
3558 LOCAL_ALIGNED_16(DCTELEM
, temp
, [64*2]);
3559 DCTELEM
* const bak
= temp
+64;
3565 s
->dsp
.diff_pixels(temp
, src1
, src2
, stride
);
3567 memcpy(bak
, temp
, 64*sizeof(DCTELEM
));
3569 s
->block_last_index
[0/*FIXME*/]= s
->fast_dct_quantize(s
, temp
, 0/*FIXME*/, s
->qscale
, &i
);
3570 s
->dct_unquantize_inter(s
, temp
, 0, s
->qscale
);
3571 ff_simple_idct(temp
); //FIXME
3574 sum
+= (temp
[i
]-bak
[i
])*(temp
[i
]-bak
[i
]);
3579 static int rd8x8_c(/*MpegEncContext*/ void *c
, uint8_t *src1
, uint8_t *src2
, int stride
, int h
){
3580 MpegEncContext
* const s
= (MpegEncContext
*)c
;
3581 const uint8_t *scantable
= s
->intra_scantable
.permutated
;
3582 LOCAL_ALIGNED_16(DCTELEM
, temp
, [64]);
3583 LOCAL_ALIGNED_16(uint8_t, lsrc1
, [64]);
3584 LOCAL_ALIGNED_16(uint8_t, lsrc2
, [64]);
3585 int i
, last
, run
, bits
, level
, distortion
, start_i
;
3586 const int esc_length
= s
->ac_esc_length
;
3588 uint8_t * last_length
;
3592 copy_block8(lsrc1
, src1
, 8, stride
, 8);
3593 copy_block8(lsrc2
, src2
, 8, stride
, 8);
3595 s
->dsp
.diff_pixels(temp
, lsrc1
, lsrc2
, 8);
3597 s
->block_last_index
[0/*FIXME*/]= last
= s
->fast_dct_quantize(s
, temp
, 0/*FIXME*/, s
->qscale
, &i
);
3603 length
= s
->intra_ac_vlc_length
;
3604 last_length
= s
->intra_ac_vlc_last_length
;
3605 bits
+= s
->luma_dc_vlc_length
[temp
[0] + 256]; //FIXME chroma
3608 length
= s
->inter_ac_vlc_length
;
3609 last_length
= s
->inter_ac_vlc_last_length
;
3614 for(i
=start_i
; i
<last
; i
++){
3615 int j
= scantable
[i
];
3620 if((level
&(~127)) == 0){
3621 bits
+= length
[UNI_AC_ENC_INDEX(run
, level
)];
3630 level
= temp
[i
] + 64;
3634 if((level
&(~127)) == 0){
3635 bits
+= last_length
[UNI_AC_ENC_INDEX(run
, level
)];
3643 s
->dct_unquantize_intra(s
, temp
, 0, s
->qscale
);
3645 s
->dct_unquantize_inter(s
, temp
, 0, s
->qscale
);
3648 s
->dsp
.idct_add(lsrc2
, 8, temp
);
3650 distortion
= s
->dsp
.sse
[1](NULL
, lsrc2
, lsrc1
, 8, 8);
3652 return distortion
+ ((bits
*s
->qscale
*s
->qscale
*109 + 64)>>7);
3655 static int bit8x8_c(/*MpegEncContext*/ void *c
, uint8_t *src1
, uint8_t *src2
, int stride
, int h
){
3656 MpegEncContext
* const s
= (MpegEncContext
*)c
;
3657 const uint8_t *scantable
= s
->intra_scantable
.permutated
;
3658 LOCAL_ALIGNED_16(DCTELEM
, temp
, [64]);
3659 int i
, last
, run
, bits
, level
, start_i
;
3660 const int esc_length
= s
->ac_esc_length
;
3662 uint8_t * last_length
;
3666 s
->dsp
.diff_pixels(temp
, src1
, src2
, stride
);
3668 s
->block_last_index
[0/*FIXME*/]= last
= s
->fast_dct_quantize(s
, temp
, 0/*FIXME*/, s
->qscale
, &i
);
3674 length
= s
->intra_ac_vlc_length
;
3675 last_length
= s
->intra_ac_vlc_last_length
;
3676 bits
+= s
->luma_dc_vlc_length
[temp
[0] + 256]; //FIXME chroma
3679 length
= s
->inter_ac_vlc_length
;
3680 last_length
= s
->inter_ac_vlc_last_length
;
3685 for(i
=start_i
; i
<last
; i
++){
3686 int j
= scantable
[i
];
3691 if((level
&(~127)) == 0){
3692 bits
+= length
[UNI_AC_ENC_INDEX(run
, level
)];
3701 level
= temp
[i
] + 64;
3705 if((level
&(~127)) == 0){
3706 bits
+= last_length
[UNI_AC_ENC_INDEX(run
, level
)];
3714 #define VSAD_INTRA(size) \
3715 static int vsad_intra##size##_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){ \
3719 for(y=1; y<h; y++){ \
3720 for(x=0; x<size; x+=4){ \
3721 score+= FFABS(s[x ] - s[x +stride]) + FFABS(s[x+1] - s[x+1+stride]) \
3722 +FFABS(s[x+2] - s[x+2+stride]) + FFABS(s[x+3] - s[x+3+stride]); \
3732 static int vsad16_c(/*MpegEncContext*/ void *c
, uint8_t *s1
, uint8_t *s2
, int stride
, int h
){
3737 for(x
=0; x
<16; x
++){
3738 score
+= FFABS(s1
[x
] - s2
[x
] - s1
[x
+stride
] + s2
[x
+stride
]);
3747 #define SQ(a) ((a)*(a))
3748 #define VSSE_INTRA(size) \
3749 static int vsse_intra##size##_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){ \
3753 for(y=1; y<h; y++){ \
3754 for(x=0; x<size; x+=4){ \
3755 score+= SQ(s[x ] - s[x +stride]) + SQ(s[x+1] - s[x+1+stride]) \
3756 +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]); \
3766 static int vsse16_c(/*MpegEncContext*/ void *c
, uint8_t *s1
, uint8_t *s2
, int stride
, int h
){
3771 for(x
=0; x
<16; x
++){
3772 score
+= SQ(s1
[x
] - s2
[x
] - s1
[x
+stride
] + s2
[x
+stride
]);
3781 static int ssd_int8_vs_int16_c(const int8_t *pix1
, const int16_t *pix2
,
3785 for(i
=0; i
<size
; i
++)
3786 score
+= (pix1
[i
]-pix2
[i
])*(pix1
[i
]-pix2
[i
]);
3790 WRAPPER8_16_SQ(hadamard8_diff8x8_c
, hadamard8_diff16_c
)
3791 WRAPPER8_16_SQ(hadamard8_intra8x8_c
, hadamard8_intra16_c
)
3792 WRAPPER8_16_SQ(dct_sad8x8_c
, dct_sad16_c
)
3794 WRAPPER8_16_SQ(dct264_sad8x8_c
, dct264_sad16_c
)
3796 WRAPPER8_16_SQ(dct_max8x8_c
, dct_max16_c
)
3797 WRAPPER8_16_SQ(quant_psnr8x8_c
, quant_psnr16_c
)
3798 WRAPPER8_16_SQ(rd8x8_c
, rd16_c
)
3799 WRAPPER8_16_SQ(bit8x8_c
, bit16_c
)
3803 static void vector_fmul_c(float *dst
, const float *src
, int len
){
3805 for(i
=0; i
<len
; i
++)
3809 static void vector_fmul_reverse_c(float *dst
, const float *src0
, const float *src1
, int len
){
3812 for(i
=0; i
<len
; i
++)
3813 dst
[i
] = src0
[i
] * src1
[-i
];
3816 static void vector_fmul_add_c(float *dst
, const float *src0
, const float *src1
, const float *src2
, int len
){
3818 for(i
=0; i
<len
; i
++)
3819 dst
[i
] = src0
[i
] * src1
[i
] + src2
[i
];
3822 void ff_vector_fmul_window_c(float *dst
, const float *src0
, const float *src1
, const float *win
, float add_bias
, int len
){
3827 for(i
=-len
, j
=len
-1; i
<0; i
++, j
--) {
3832 dst
[i
] = s0
*wj
- s1
*wi
+ add_bias
;
3833 dst
[j
] = s0
*wi
+ s1
*wj
+ add_bias
;
3837 static void vector_fmul_scalar_c(float *dst
, const float *src
, float mul
,
3841 for (i
= 0; i
< len
; i
++)
3842 dst
[i
] = src
[i
] * mul
;
3845 static void vector_fmul_sv_scalar_2_c(float *dst
, const float *src
,
3846 const float **sv
, float mul
, int len
)
3849 for (i
= 0; i
< len
; i
+= 2, sv
++) {
3850 dst
[i
] = src
[i
] * sv
[0][0] * mul
;
3851 dst
[i
+1] = src
[i
+1] * sv
[0][1] * mul
;
3855 static void vector_fmul_sv_scalar_4_c(float *dst
, const float *src
,
3856 const float **sv
, float mul
, int len
)
3859 for (i
= 0; i
< len
; i
+= 4, sv
++) {
3860 dst
[i
] = src
[i
] * sv
[0][0] * mul
;
3861 dst
[i
+1] = src
[i
+1] * sv
[0][1] * mul
;
3862 dst
[i
+2] = src
[i
+2] * sv
[0][2] * mul
;
3863 dst
[i
+3] = src
[i
+3] * sv
[0][3] * mul
;
3867 static void sv_fmul_scalar_2_c(float *dst
, const float **sv
, float mul
,
3871 for (i
= 0; i
< len
; i
+= 2, sv
++) {
3872 dst
[i
] = sv
[0][0] * mul
;
3873 dst
[i
+1] = sv
[0][1] * mul
;
3877 static void sv_fmul_scalar_4_c(float *dst
, const float **sv
, float mul
,
3881 for (i
= 0; i
< len
; i
+= 4, sv
++) {
3882 dst
[i
] = sv
[0][0] * mul
;
3883 dst
[i
+1] = sv
[0][1] * mul
;
3884 dst
[i
+2] = sv
[0][2] * mul
;
3885 dst
[i
+3] = sv
[0][3] * mul
;
3889 static void butterflies_float_c(float *restrict v1
, float *restrict v2
,
3893 for (i
= 0; i
< len
; i
++) {
3894 float t
= v1
[i
] - v2
[i
];
3900 static float scalarproduct_float_c(const float *v1
, const float *v2
, int len
)
3905 for (i
= 0; i
< len
; i
++)
3911 static void int32_to_float_fmul_scalar_c(float *dst
, const int *src
, float mul
, int len
){
3913 for(i
=0; i
<len
; i
++)
3914 dst
[i
] = src
[i
] * mul
;
3918 static inline uint32_t clipf_c_one(uint32_t a
, uint32_t mini
,
3919 uint32_t maxi
, uint32_t maxisign
)
3922 if(a
> mini
) return mini
;
3923 else if((a
^(1<<31)) > maxisign
) return maxi
;
3927 static void vector_clipf_c_opposite_sign(float *dst
, const float *src
, float *min
, float *max
, int len
){
3929 uint32_t mini
= *(uint32_t*)min
;
3930 uint32_t maxi
= *(uint32_t*)max
;
3931 uint32_t maxisign
= maxi
^ (1<<31);
3932 uint32_t *dsti
= (uint32_t*)dst
;
3933 const uint32_t *srci
= (const uint32_t*)src
;
3934 for(i
=0; i
<len
; i
+=8) {
3935 dsti
[i
+ 0] = clipf_c_one(srci
[i
+ 0], mini
, maxi
, maxisign
);
3936 dsti
[i
+ 1] = clipf_c_one(srci
[i
+ 1], mini
, maxi
, maxisign
);
3937 dsti
[i
+ 2] = clipf_c_one(srci
[i
+ 2], mini
, maxi
, maxisign
);
3938 dsti
[i
+ 3] = clipf_c_one(srci
[i
+ 3], mini
, maxi
, maxisign
);
3939 dsti
[i
+ 4] = clipf_c_one(srci
[i
+ 4], mini
, maxi
, maxisign
);
3940 dsti
[i
+ 5] = clipf_c_one(srci
[i
+ 5], mini
, maxi
, maxisign
);
3941 dsti
[i
+ 6] = clipf_c_one(srci
[i
+ 6], mini
, maxi
, maxisign
);
3942 dsti
[i
+ 7] = clipf_c_one(srci
[i
+ 7], mini
, maxi
, maxisign
);
3945 static void vector_clipf_c(float *dst
, const float *src
, float min
, float max
, int len
){
3947 if(min
< 0 && max
> 0) {
3948 vector_clipf_c_opposite_sign(dst
, src
, &min
, &max
, len
);
3950 for(i
=0; i
< len
; i
+=8) {
3951 dst
[i
] = av_clipf(src
[i
], min
, max
);
3952 dst
[i
+ 1] = av_clipf(src
[i
+ 1], min
, max
);
3953 dst
[i
+ 2] = av_clipf(src
[i
+ 2], min
, max
);
3954 dst
[i
+ 3] = av_clipf(src
[i
+ 3], min
, max
);
3955 dst
[i
+ 4] = av_clipf(src
[i
+ 4], min
, max
);
3956 dst
[i
+ 5] = av_clipf(src
[i
+ 5], min
, max
);
3957 dst
[i
+ 6] = av_clipf(src
[i
+ 6], min
, max
);
3958 dst
[i
+ 7] = av_clipf(src
[i
+ 7], min
, max
);
3963 static av_always_inline
int float_to_int16_one(const float *src
){
3964 int_fast32_t tmp
= *(const int32_t*)src
;
3966 tmp
= (0x43c0ffff - tmp
)>>31;
3967 // is this faster on some gcc/cpu combinations?
3968 // if(tmp > 0x43c0ffff) tmp = 0xFFFF;
3971 return tmp
- 0x8000;
3974 void ff_float_to_int16_c(int16_t *dst
, const float *src
, long len
){
3976 for(i
=0; i
<len
; i
++)
3977 dst
[i
] = float_to_int16_one(src
+i
);
3980 void ff_float_to_int16_interleave_c(int16_t *dst
, const float **src
, long len
, int channels
){
3983 for(i
=0; i
<len
; i
++){
3984 dst
[2*i
] = float_to_int16_one(src
[0]+i
);
3985 dst
[2*i
+1] = float_to_int16_one(src
[1]+i
);
3988 for(c
=0; c
<channels
; c
++)
3989 for(i
=0, j
=c
; i
<len
; i
++, j
+=channels
)
3990 dst
[j
] = float_to_int16_one(src
[c
]+i
);
3994 static int32_t scalarproduct_int16_c(int16_t * v1
, int16_t * v2
, int order
, int shift
)
3999 res
+= (*v1
++ * *v2
++) >> shift
;
4004 static int32_t scalarproduct_and_madd_int16_c(int16_t *v1
, int16_t *v2
, int16_t *v3
, int order
, int mul
)
4009 *v1
++ += mul
* *v3
++;
4015 #define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */
4016 #define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */
4017 #define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */
4018 #define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */
4019 #define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */
4020 #define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */
4021 #define W7 565 /* 2048*sqrt (2)*cos (7*pi/16) */
4023 static void wmv2_idct_row(short * b
)
4026 int a0
,a1
,a2
,a3
,a4
,a5
,a6
,a7
;
4028 a1
= W1
*b
[1]+W7
*b
[7];
4029 a7
= W7
*b
[1]-W1
*b
[7];
4030 a5
= W5
*b
[5]+W3
*b
[3];
4031 a3
= W3
*b
[5]-W5
*b
[3];
4032 a2
= W2
*b
[2]+W6
*b
[6];
4033 a6
= W6
*b
[2]-W2
*b
[6];
4034 a0
= W0
*b
[0]+W0
*b
[4];
4035 a4
= W0
*b
[0]-W0
*b
[4];
4037 s1
= (181*(a1
-a5
+a7
-a3
)+128)>>8;//1,3,5,7,
4038 s2
= (181*(a1
-a5
-a7
+a3
)+128)>>8;
4040 b
[0] = (a0
+a2
+a1
+a5
+ (1<<7))>>8;
4041 b
[1] = (a4
+a6
+s1
+ (1<<7))>>8;
4042 b
[2] = (a4
-a6
+s2
+ (1<<7))>>8;
4043 b
[3] = (a0
-a2
+a7
+a3
+ (1<<7))>>8;
4044 b
[4] = (a0
-a2
-a7
-a3
+ (1<<7))>>8;
4045 b
[5] = (a4
-a6
-s2
+ (1<<7))>>8;
4046 b
[6] = (a4
+a6
-s1
+ (1<<7))>>8;
4047 b
[7] = (a0
+a2
-a1
-a5
+ (1<<7))>>8;
4049 static void wmv2_idct_col(short * b
)
4052 int a0
,a1
,a2
,a3
,a4
,a5
,a6
,a7
;
4053 /*step 1, with extended precision*/
4054 a1
= (W1
*b
[8*1]+W7
*b
[8*7] + 4)>>3;
4055 a7
= (W7
*b
[8*1]-W1
*b
[8*7] + 4)>>3;
4056 a5
= (W5
*b
[8*5]+W3
*b
[8*3] + 4)>>3;
4057 a3
= (W3
*b
[8*5]-W5
*b
[8*3] + 4)>>3;
4058 a2
= (W2
*b
[8*2]+W6
*b
[8*6] + 4)>>3;
4059 a6
= (W6
*b
[8*2]-W2
*b
[8*6] + 4)>>3;
4060 a0
= (W0
*b
[8*0]+W0
*b
[8*4] )>>3;
4061 a4
= (W0
*b
[8*0]-W0
*b
[8*4] )>>3;
4063 s1
= (181*(a1
-a5
+a7
-a3
)+128)>>8;
4064 s2
= (181*(a1
-a5
-a7
+a3
)+128)>>8;
4066 b
[8*0] = (a0
+a2
+a1
+a5
+ (1<<13))>>14;
4067 b
[8*1] = (a4
+a6
+s1
+ (1<<13))>>14;
4068 b
[8*2] = (a4
-a6
+s2
+ (1<<13))>>14;
4069 b
[8*3] = (a0
-a2
+a7
+a3
+ (1<<13))>>14;
4071 b
[8*4] = (a0
-a2
-a7
-a3
+ (1<<13))>>14;
4072 b
[8*5] = (a4
-a6
-s2
+ (1<<13))>>14;
4073 b
[8*6] = (a4
+a6
-s1
+ (1<<13))>>14;
4074 b
[8*7] = (a0
+a2
-a1
-a5
+ (1<<13))>>14;
4076 void ff_wmv2_idct_c(short * block
){
4080 wmv2_idct_row(block
+i
);
4083 wmv2_idct_col(block
+i
);
4086 /* XXX: those functions should be suppressed ASAP when all IDCTs are
4088 static void ff_wmv2_idct_put_c(uint8_t *dest
, int line_size
, DCTELEM
*block
)
4090 ff_wmv2_idct_c(block
);
4091 put_pixels_clamped_c(block
, dest
, line_size
);
4093 static void ff_wmv2_idct_add_c(uint8_t *dest
, int line_size
, DCTELEM
*block
)
4095 ff_wmv2_idct_c(block
);
4096 add_pixels_clamped_c(block
, dest
, line_size
);
4098 static void ff_jref_idct_put(uint8_t *dest
, int line_size
, DCTELEM
*block
)
4101 put_pixels_clamped_c(block
, dest
, line_size
);
4103 static void ff_jref_idct_add(uint8_t *dest
, int line_size
, DCTELEM
*block
)
4106 add_pixels_clamped_c(block
, dest
, line_size
);
4109 static void ff_jref_idct4_put(uint8_t *dest
, int line_size
, DCTELEM
*block
)
4112 put_pixels_clamped4_c(block
, dest
, line_size
);
4114 static void ff_jref_idct4_add(uint8_t *dest
, int line_size
, DCTELEM
*block
)
4117 add_pixels_clamped4_c(block
, dest
, line_size
);
4120 static void ff_jref_idct2_put(uint8_t *dest
, int line_size
, DCTELEM
*block
)
4123 put_pixels_clamped2_c(block
, dest
, line_size
);
4125 static void ff_jref_idct2_add(uint8_t *dest
, int line_size
, DCTELEM
*block
)
4128 add_pixels_clamped2_c(block
, dest
, line_size
);
4131 static void ff_jref_idct1_put(uint8_t *dest
, int line_size
, DCTELEM
*block
)
4133 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
4135 dest
[0] = cm
[(block
[0] + 4)>>3];
4137 static void ff_jref_idct1_add(uint8_t *dest
, int line_size
, DCTELEM
*block
)
4139 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
4141 dest
[0] = cm
[dest
[0] + ((block
[0] + 4)>>3)];
4144 static void just_return(void *mem av_unused
, int stride av_unused
, int h av_unused
) { return; }
4146 /* init static data */
4147 av_cold
void dsputil_static_init(void)
4151 for(i
=0;i
<256;i
++) ff_cropTbl
[i
+ MAX_NEG_CROP
] = i
;
4152 for(i
=0;i
<MAX_NEG_CROP
;i
++) {
4154 ff_cropTbl
[i
+ MAX_NEG_CROP
+ 256] = 255;
4157 for(i
=0;i
<512;i
++) {
4158 ff_squareTbl
[i
] = (i
- 256) * (i
- 256);
4161 for(i
=0; i
<64; i
++) inv_zigzag_direct16
[ff_zigzag_direct
[i
]]= i
+1;
4164 int ff_check_alignment(void){
4165 static int did_fail
=0;
4166 DECLARE_ALIGNED(16, int, aligned
);
4168 if((intptr_t)&aligned
& 15){
4170 #if HAVE_MMX || HAVE_ALTIVEC
4171 av_log(NULL
, AV_LOG_ERROR
,
4172 "Compiler did not align stack variables. Libavcodec has been miscompiled\n"
4173 "and may be very slow or crash. This is not a bug in libavcodec,\n"
4174 "but in the compiler. You may try recompiling using gcc >= 4.2.\n"
4175 "Do not report crashes to FFmpeg developers.\n");
4184 av_cold
void dsputil_init(DSPContext
* c
, AVCodecContext
*avctx
)
4189 ff_check_alignment();
4192 if(avctx
->dct_algo
==FF_DCT_FASTINT
) {
4193 c
->fdct
= fdct_ifast
;
4194 c
->fdct248
= fdct_ifast248
;
4196 else if(avctx
->dct_algo
==FF_DCT_FAAN
) {
4197 c
->fdct
= ff_faandct
;
4198 c
->fdct248
= ff_faandct248
;
4201 c
->fdct
= ff_jpeg_fdct_islow
; //slow/accurate/default
4202 c
->fdct248
= ff_fdct248_islow
;
4204 #endif //CONFIG_ENCODERS
4206 if(avctx
->lowres
==1){
4207 if(avctx
->idct_algo
==FF_IDCT_INT
|| avctx
->idct_algo
==FF_IDCT_AUTO
|| !CONFIG_H264_DECODER
){
4208 c
->idct_put
= ff_jref_idct4_put
;
4209 c
->idct_add
= ff_jref_idct4_add
;
4211 c
->idct_put
= ff_h264_lowres_idct_put_c
;
4212 c
->idct_add
= ff_h264_lowres_idct_add_c
;
4214 c
->idct
= j_rev_dct4
;
4215 c
->idct_permutation_type
= FF_NO_IDCT_PERM
;
4216 }else if(avctx
->lowres
==2){
4217 c
->idct_put
= ff_jref_idct2_put
;
4218 c
->idct_add
= ff_jref_idct2_add
;
4219 c
->idct
= j_rev_dct2
;
4220 c
->idct_permutation_type
= FF_NO_IDCT_PERM
;
4221 }else if(avctx
->lowres
==3){
4222 c
->idct_put
= ff_jref_idct1_put
;
4223 c
->idct_add
= ff_jref_idct1_add
;
4224 c
->idct
= j_rev_dct1
;
4225 c
->idct_permutation_type
= FF_NO_IDCT_PERM
;
4227 if(avctx
->idct_algo
==FF_IDCT_INT
){
4228 c
->idct_put
= ff_jref_idct_put
;
4229 c
->idct_add
= ff_jref_idct_add
;
4230 c
->idct
= j_rev_dct
;
4231 c
->idct_permutation_type
= FF_LIBMPEG2_IDCT_PERM
;
4232 }else if((CONFIG_VP3_DECODER
|| CONFIG_VP5_DECODER
|| CONFIG_VP6_DECODER
) &&
4233 avctx
->idct_algo
==FF_IDCT_VP3
){
4234 c
->idct_put
= ff_vp3_idct_put_c
;
4235 c
->idct_add
= ff_vp3_idct_add_c
;
4236 c
->idct
= ff_vp3_idct_c
;
4237 c
->idct_permutation_type
= FF_NO_IDCT_PERM
;
4238 }else if(avctx
->idct_algo
==FF_IDCT_WMV2
){
4239 c
->idct_put
= ff_wmv2_idct_put_c
;
4240 c
->idct_add
= ff_wmv2_idct_add_c
;
4241 c
->idct
= ff_wmv2_idct_c
;
4242 c
->idct_permutation_type
= FF_NO_IDCT_PERM
;
4243 }else if(avctx
->idct_algo
==FF_IDCT_FAAN
){
4244 c
->idct_put
= ff_faanidct_put
;
4245 c
->idct_add
= ff_faanidct_add
;
4246 c
->idct
= ff_faanidct
;
4247 c
->idct_permutation_type
= FF_NO_IDCT_PERM
;
4248 }else if(CONFIG_EATGQ_DECODER
&& avctx
->idct_algo
==FF_IDCT_EA
) {
4249 c
->idct_put
= ff_ea_idct_put_c
;
4250 c
->idct_permutation_type
= FF_NO_IDCT_PERM
;
4251 }else if(CONFIG_BINK_DECODER
&& avctx
->idct_algo
==FF_IDCT_BINK
) {
4252 c
->idct
= ff_bink_idct_c
;
4253 c
->idct_add
= ff_bink_idct_add_c
;
4254 c
->idct_put
= ff_bink_idct_put_c
;
4255 c
->idct_permutation_type
= FF_NO_IDCT_PERM
;
4256 }else{ //accurate/default
4257 c
->idct_put
= ff_simple_idct_put
;
4258 c
->idct_add
= ff_simple_idct_add
;
4259 c
->idct
= ff_simple_idct
;
4260 c
->idct_permutation_type
= FF_NO_IDCT_PERM
;
4264 c
->get_pixels
= get_pixels_c
;
4265 c
->diff_pixels
= diff_pixels_c
;
4266 c
->put_pixels_clamped
= put_pixels_clamped_c
;
4267 c
->put_signed_pixels_clamped
= put_signed_pixels_clamped_c
;
4268 c
->put_pixels_nonclamped
= put_pixels_nonclamped_c
;
4269 c
->add_pixels_clamped
= add_pixels_clamped_c
;
4270 c
->add_pixels8
= add_pixels8_c
;
4271 c
->add_pixels4
= add_pixels4_c
;
4272 c
->sum_abs_dctelem
= sum_abs_dctelem_c
;
4275 c
->clear_block
= clear_block_c
;
4276 c
->clear_blocks
= clear_blocks_c
;
4277 c
->pix_sum
= pix_sum_c
;
4278 c
->pix_norm1
= pix_norm1_c
;
4280 c
->fill_block_tab
[0] = fill_block16_c
;
4281 c
->fill_block_tab
[1] = fill_block8_c
;
4282 c
->scale_block
= scale_block_c
;
4284 /* TODO [0] 16 [1] 8 */
4285 c
->pix_abs
[0][0] = pix_abs16_c
;
4286 c
->pix_abs
[0][1] = pix_abs16_x2_c
;
4287 c
->pix_abs
[0][2] = pix_abs16_y2_c
;
4288 c
->pix_abs
[0][3] = pix_abs16_xy2_c
;
4289 c
->pix_abs
[1][0] = pix_abs8_c
;
4290 c
->pix_abs
[1][1] = pix_abs8_x2_c
;
4291 c
->pix_abs
[1][2] = pix_abs8_y2_c
;
4292 c
->pix_abs
[1][3] = pix_abs8_xy2_c
;
4294 #define dspfunc(PFX, IDX, NUM) \
4295 c->PFX ## _pixels_tab[IDX][0] = PFX ## _pixels ## NUM ## _c; \
4296 c->PFX ## _pixels_tab[IDX][1] = PFX ## _pixels ## NUM ## _x2_c; \
4297 c->PFX ## _pixels_tab[IDX][2] = PFX ## _pixels ## NUM ## _y2_c; \
4298 c->PFX ## _pixels_tab[IDX][3] = PFX ## _pixels ## NUM ## _xy2_c
4300 dspfunc(put
, 0, 16);
4301 dspfunc(put_no_rnd
, 0, 16);
4303 dspfunc(put_no_rnd
, 1, 8);
4307 dspfunc(avg
, 0, 16);
4308 dspfunc(avg_no_rnd
, 0, 16);
4310 dspfunc(avg_no_rnd
, 1, 8);
4315 c
->put_no_rnd_pixels_l2
[0]= put_no_rnd_pixels16_l2_c
;
4316 c
->put_no_rnd_pixels_l2
[1]= put_no_rnd_pixels8_l2_c
;
4318 c
->put_tpel_pixels_tab
[ 0] = put_tpel_pixels_mc00_c
;
4319 c
->put_tpel_pixels_tab
[ 1] = put_tpel_pixels_mc10_c
;
4320 c
->put_tpel_pixels_tab
[ 2] = put_tpel_pixels_mc20_c
;
4321 c
->put_tpel_pixels_tab
[ 4] = put_tpel_pixels_mc01_c
;
4322 c
->put_tpel_pixels_tab
[ 5] = put_tpel_pixels_mc11_c
;
4323 c
->put_tpel_pixels_tab
[ 6] = put_tpel_pixels_mc21_c
;
4324 c
->put_tpel_pixels_tab
[ 8] = put_tpel_pixels_mc02_c
;
4325 c
->put_tpel_pixels_tab
[ 9] = put_tpel_pixels_mc12_c
;
4326 c
->put_tpel_pixels_tab
[10] = put_tpel_pixels_mc22_c
;
4328 c
->avg_tpel_pixels_tab
[ 0] = avg_tpel_pixels_mc00_c
;
4329 c
->avg_tpel_pixels_tab
[ 1] = avg_tpel_pixels_mc10_c
;
4330 c
->avg_tpel_pixels_tab
[ 2] = avg_tpel_pixels_mc20_c
;
4331 c
->avg_tpel_pixels_tab
[ 4] = avg_tpel_pixels_mc01_c
;
4332 c
->avg_tpel_pixels_tab
[ 5] = avg_tpel_pixels_mc11_c
;
4333 c
->avg_tpel_pixels_tab
[ 6] = avg_tpel_pixels_mc21_c
;
4334 c
->avg_tpel_pixels_tab
[ 8] = avg_tpel_pixels_mc02_c
;
4335 c
->avg_tpel_pixels_tab
[ 9] = avg_tpel_pixels_mc12_c
;
4336 c
->avg_tpel_pixels_tab
[10] = avg_tpel_pixels_mc22_c
;
4338 #define dspfunc(PFX, IDX, NUM) \
4339 c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_c; \
4340 c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_c; \
4341 c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_c; \
4342 c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_c; \
4343 c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_c; \
4344 c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_c; \
4345 c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_c; \
4346 c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_c; \
4347 c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_c; \
4348 c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_c; \
4349 c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_c; \
4350 c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_c; \
4351 c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_c; \
4352 c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_c; \
4353 c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_c; \
4354 c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_c
4356 dspfunc(put_qpel
, 0, 16);
4357 dspfunc(put_no_rnd_qpel
, 0, 16);
4359 dspfunc(avg_qpel
, 0, 16);
4360 /* dspfunc(avg_no_rnd_qpel, 0, 16); */
4362 dspfunc(put_qpel
, 1, 8);
4363 dspfunc(put_no_rnd_qpel
, 1, 8);
4365 dspfunc(avg_qpel
, 1, 8);
4366 /* dspfunc(avg_no_rnd_qpel, 1, 8); */
4368 dspfunc(put_h264_qpel
, 0, 16);
4369 dspfunc(put_h264_qpel
, 1, 8);
4370 dspfunc(put_h264_qpel
, 2, 4);
4371 dspfunc(put_h264_qpel
, 3, 2);
4372 dspfunc(avg_h264_qpel
, 0, 16);
4373 dspfunc(avg_h264_qpel
, 1, 8);
4374 dspfunc(avg_h264_qpel
, 2, 4);
4377 c
->put_h264_chroma_pixels_tab
[0]= put_h264_chroma_mc8_c
;
4378 c
->put_h264_chroma_pixels_tab
[1]= put_h264_chroma_mc4_c
;
4379 c
->put_h264_chroma_pixels_tab
[2]= put_h264_chroma_mc2_c
;
4380 c
->avg_h264_chroma_pixels_tab
[0]= avg_h264_chroma_mc8_c
;
4381 c
->avg_h264_chroma_pixels_tab
[1]= avg_h264_chroma_mc4_c
;
4382 c
->avg_h264_chroma_pixels_tab
[2]= avg_h264_chroma_mc2_c
;
4383 c
->put_no_rnd_vc1_chroma_pixels_tab
[0]= put_no_rnd_vc1_chroma_mc8_c
;
4384 c
->avg_no_rnd_vc1_chroma_pixels_tab
[0]= avg_no_rnd_vc1_chroma_mc8_c
;
4386 c
->draw_edges
= draw_edges_c
;
4388 #if CONFIG_CAVS_DECODER
4389 ff_cavsdsp_init(c
,avctx
);
4392 #if CONFIG_MLP_DECODER || CONFIG_TRUEHD_DECODER
4393 ff_mlp_init(c
, avctx
);
4395 #if CONFIG_VC1_DECODER
4396 ff_vc1dsp_init(c
,avctx
);
4398 #if CONFIG_WMV2_DECODER || CONFIG_VC1_DECODER
4399 ff_intrax8dsp_init(c
,avctx
);
4401 #if CONFIG_RV30_DECODER
4402 ff_rv30dsp_init(c
,avctx
);
4404 #if CONFIG_RV40_DECODER
4405 ff_rv40dsp_init(c
,avctx
);
4406 c
->put_rv40_qpel_pixels_tab
[0][15] = put_rv40_qpel16_mc33_c
;
4407 c
->avg_rv40_qpel_pixels_tab
[0][15] = avg_rv40_qpel16_mc33_c
;
4408 c
->put_rv40_qpel_pixels_tab
[1][15] = put_rv40_qpel8_mc33_c
;
4409 c
->avg_rv40_qpel_pixels_tab
[1][15] = avg_rv40_qpel8_mc33_c
;
4412 c
->put_mspel_pixels_tab
[0]= put_mspel8_mc00_c
;
4413 c
->put_mspel_pixels_tab
[1]= put_mspel8_mc10_c
;
4414 c
->put_mspel_pixels_tab
[2]= put_mspel8_mc20_c
;
4415 c
->put_mspel_pixels_tab
[3]= put_mspel8_mc30_c
;
4416 c
->put_mspel_pixels_tab
[4]= put_mspel8_mc02_c
;
4417 c
->put_mspel_pixels_tab
[5]= put_mspel8_mc12_c
;
4418 c
->put_mspel_pixels_tab
[6]= put_mspel8_mc22_c
;
4419 c
->put_mspel_pixels_tab
[7]= put_mspel8_mc32_c
;
4421 #define SET_CMP_FUNC(name) \
4422 c->name[0]= name ## 16_c;\
4423 c->name[1]= name ## 8x8_c;
4425 SET_CMP_FUNC(hadamard8_diff
)
4426 c
->hadamard8_diff
[4]= hadamard8_intra16_c
;
4427 c
->hadamard8_diff
[5]= hadamard8_intra8x8_c
;
4428 SET_CMP_FUNC(dct_sad
)
4429 SET_CMP_FUNC(dct_max
)
4431 SET_CMP_FUNC(dct264_sad
)
4433 c
->sad
[0]= pix_abs16_c
;
4434 c
->sad
[1]= pix_abs8_c
;
4438 SET_CMP_FUNC(quant_psnr
)
4441 c
->vsad
[0]= vsad16_c
;
4442 c
->vsad
[4]= vsad_intra16_c
;
4443 c
->vsad
[5]= vsad_intra8_c
;
4444 c
->vsse
[0]= vsse16_c
;
4445 c
->vsse
[4]= vsse_intra16_c
;
4446 c
->vsse
[5]= vsse_intra8_c
;
4447 c
->nsse
[0]= nsse16_c
;
4448 c
->nsse
[1]= nsse8_c
;
4450 ff_dsputil_init_dwt(c
);
4453 c
->ssd_int8_vs_int16
= ssd_int8_vs_int16_c
;
4455 c
->add_bytes
= add_bytes_c
;
4456 c
->add_bytes_l2
= add_bytes_l2_c
;
4457 c
->diff_bytes
= diff_bytes_c
;
4458 c
->add_hfyu_median_prediction
= add_hfyu_median_prediction_c
;
4459 c
->sub_hfyu_median_prediction
= sub_hfyu_median_prediction_c
;
4460 c
->add_hfyu_left_prediction
= add_hfyu_left_prediction_c
;
4461 c
->add_hfyu_left_prediction_bgr32
= add_hfyu_left_prediction_bgr32_c
;
4462 c
->bswap_buf
= bswap_buf
;
4463 #if CONFIG_PNG_DECODER
4464 c
->add_png_paeth_prediction
= ff_add_png_paeth_prediction
;
4467 if (CONFIG_H263_DECODER
|| CONFIG_H263_ENCODER
) {
4468 c
->h263_h_loop_filter
= h263_h_loop_filter_c
;
4469 c
->h263_v_loop_filter
= h263_v_loop_filter_c
;
4472 if (CONFIG_VP3_DECODER
) {
4473 c
->vp3_h_loop_filter
= ff_vp3_h_loop_filter_c
;
4474 c
->vp3_v_loop_filter
= ff_vp3_v_loop_filter_c
;
4476 if (CONFIG_VP6_DECODER
) {
4477 c
->vp6_filter_diag4
= ff_vp6_filter_diag4_c
;
4480 c
->h261_loop_filter
= h261_loop_filter_c
;
4482 c
->try_8x8basis
= try_8x8basis_c
;
4483 c
->add_8x8basis
= add_8x8basis_c
;
4485 #if CONFIG_VORBIS_DECODER
4486 c
->vorbis_inverse_coupling
= vorbis_inverse_coupling
;
4488 #if CONFIG_AC3_DECODER
4489 c
->ac3_downmix
= ff_ac3_downmix_c
;
4492 c
->lpc_compute_autocorr
= ff_lpc_compute_autocorr
;
4496 c
->vector_fmul
= vector_fmul_c
;
4497 c
->vector_fmul_reverse
= vector_fmul_reverse_c
;
4498 c
->vector_fmul_add
= vector_fmul_add_c
;
4499 c
->vector_fmul_window
= ff_vector_fmul_window_c
;
4500 //c->int32_to_float_fmul_scalar = int32_to_float_fmul_scalar_c;
4501 //c->vector_clipf = vector_clipf_c;
4502 //c->float_to_int16 = ff_float_to_int16_c;
4503 //c->float_to_int16_interleave = ff_float_to_int16_interleave_c;
4504 //c->scalarproduct_int16 = scalarproduct_int16_c;
4505 //c->scalarproduct_and_madd_int16 = scalarproduct_and_madd_int16_c;
4506 //c->scalarproduct_float = scalarproduct_float_c;
4507 //c->butterflies_float = butterflies_float_c;
4508 c
->vector_fmul_scalar
= vector_fmul_scalar_c
;
4510 c
->vector_fmul_sv_scalar
[0] = vector_fmul_sv_scalar_2_c
;
4511 c
->vector_fmul_sv_scalar
[1] = vector_fmul_sv_scalar_4_c
;
4513 c
->sv_fmul_scalar
[0] = sv_fmul_scalar_2_c
;
4514 c
->sv_fmul_scalar
[1] = sv_fmul_scalar_4_c
;
4516 c
->shrink
[0]= ff_img_copy_plane
;
4517 c
->shrink
[1]= ff_shrink22
;
4518 c
->shrink
[2]= ff_shrink44
;
4519 c
->shrink
[3]= ff_shrink88
;
4521 c
->prefetch
= just_return
;
4523 memset(c
->put_2tap_qpel_pixels_tab
, 0, sizeof(c
->put_2tap_qpel_pixels_tab
));
4524 memset(c
->avg_2tap_qpel_pixels_tab
, 0, sizeof(c
->avg_2tap_qpel_pixels_tab
));
4526 if (HAVE_MMX
) dsputil_init_mmx (c
, avctx
);
4527 if (ARCH_ARM
) dsputil_init_arm (c
, avctx
);
4528 if (CONFIG_MLIB
) dsputil_init_mlib (c
, avctx
);
4529 if (HAVE_VIS
) dsputil_init_vis (c
, avctx
);
4530 if (ARCH_ALPHA
) dsputil_init_alpha (c
, avctx
);
4531 if (ARCH_PPC
) dsputil_init_ppc (c
, avctx
);
4532 if (HAVE_MMI
) dsputil_init_mmi (c
, avctx
);
4533 if (ARCH_SH4
) dsputil_init_sh4 (c
, avctx
);
4534 if (ARCH_BFIN
) dsputil_init_bfin (c
, avctx
);
4536 for(i
=0; i
<64; i
++){
4537 if(!c
->put_2tap_qpel_pixels_tab
[0][i
])
4538 c
->put_2tap_qpel_pixels_tab
[0][i
]= c
->put_h264_qpel_pixels_tab
[0][i
];
4539 if(!c
->avg_2tap_qpel_pixels_tab
[0][i
])
4540 c
->avg_2tap_qpel_pixels_tab
[0][i
]= c
->avg_h264_qpel_pixels_tab
[0][i
];
4543 switch(c
->idct_permutation_type
){
4544 case FF_NO_IDCT_PERM
:
4546 c
->idct_permutation
[i
]= i
;
4548 case FF_LIBMPEG2_IDCT_PERM
:
4550 c
->idct_permutation
[i
]= (i
& 0x38) | ((i
& 6) >> 1) | ((i
& 1) << 2);
4552 case FF_SIMPLE_IDCT_PERM
:
4554 c
->idct_permutation
[i
]= simple_mmx_permutation
[i
];
4556 case FF_TRANSPOSE_IDCT_PERM
:
4558 c
->idct_permutation
[i
]= ((i
&7)<<3) | (i
>>3);
4560 case FF_PARTTRANS_IDCT_PERM
:
4562 c
->idct_permutation
[i
]= (i
&0x24) | ((i
&3)<<3) | ((i
>>3)&3);
4564 case FF_SSE2_IDCT_PERM
:
4566 c
->idct_permutation
[i
]= (i
&0x38) | idct_sse2_row_perm
[i
&7];
4569 av_log(avctx
, AV_LOG_ERROR
, "Internal error, IDCT permutation not set\n");