FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dsputil.c
Go to the documentation of this file.
1 /*
2  * DSP utils
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * gmc & q-pel & 32/64 bit based MC by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
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.
14  *
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.
19  *
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
23  */
24 
25 /**
26  * @file
27  * DSP utils
28  */
29 
30 #include "libavutil/attributes.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/internal.h"
33 #include "avcodec.h"
34 #include "copy_block.h"
35 #include "dct.h"
36 #include "dsputil.h"
37 #include "simple_idct.h"
38 #include "faandct.h"
39 #include "faanidct.h"
40 #include "imgconvert.h"
41 #include "mathops.h"
42 #include "mpegvideo.h"
43 #include "config.h"
44 #include "diracdsp.h"
45 
46 uint32_t ff_squareTbl[512] = {0, };
47 
48 #define BIT_DEPTH 16
49 #include "dsputil_template.c"
50 #undef BIT_DEPTH
51 
52 #define BIT_DEPTH 8
53 #include "dsputil_template.c"
54 
55 // 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size
56 #define pb_7f (~0UL/255 * 0x7f)
57 #define pb_80 (~0UL/255 * 0x80)
58 
59 /* Specific zigzag scan for 248 idct. NOTE that unlike the
60  specification, we interleave the fields */
61 const uint8_t ff_zigzag248_direct[64] = {
62  0, 8, 1, 9, 16, 24, 2, 10,
63  17, 25, 32, 40, 48, 56, 33, 41,
64  18, 26, 3, 11, 4, 12, 19, 27,
65  34, 42, 49, 57, 50, 58, 35, 43,
66  20, 28, 5, 13, 6, 14, 21, 29,
67  36, 44, 51, 59, 52, 60, 37, 45,
68  22, 30, 7, 15, 23, 31, 38, 46,
69  53, 61, 54, 62, 39, 47, 55, 63,
70 };
71 
72 /* not permutated inverse zigzag_direct + 1 for MMX quantizer */
73 DECLARE_ALIGNED(16, uint16_t, ff_inv_zigzag_direct16)[64];
74 
75 const uint8_t ff_alternate_horizontal_scan[64] = {
76  0, 1, 2, 3, 8, 9, 16, 17,
77  10, 11, 4, 5, 6, 7, 15, 14,
78  13, 12, 19, 18, 24, 25, 32, 33,
79  26, 27, 20, 21, 22, 23, 28, 29,
80  30, 31, 34, 35, 40, 41, 48, 49,
81  42, 43, 36, 37, 38, 39, 44, 45,
82  46, 47, 50, 51, 56, 57, 58, 59,
83  52, 53, 54, 55, 60, 61, 62, 63,
84 };
85 
86 const uint8_t ff_alternate_vertical_scan[64] = {
87  0, 8, 16, 24, 1, 9, 2, 10,
88  17, 25, 32, 40, 48, 56, 57, 49,
89  41, 33, 26, 18, 3, 11, 4, 12,
90  19, 27, 34, 42, 50, 58, 35, 43,
91  51, 59, 20, 28, 5, 13, 6, 14,
92  21, 29, 36, 44, 52, 60, 37, 45,
93  53, 61, 22, 30, 7, 15, 23, 31,
94  38, 46, 54, 62, 39, 47, 55, 63,
95 };
96 
97 /* Input permutation for the simple_idct_mmx */
98 static const uint8_t simple_mmx_permutation[64]={
99  0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
100  0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
101  0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
102  0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
103  0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
104  0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
105  0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
106  0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
107 };
108 
109 static const uint8_t idct_sse2_row_perm[8] = {0, 4, 1, 5, 2, 6, 3, 7};
110 
111 av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st,
112  const uint8_t *src_scantable)
113 {
114  int i;
115  int end;
116 
117  st->scantable= src_scantable;
118 
119  for(i=0; i<64; i++){
120  int j;
121  j = src_scantable[i];
122  st->permutated[i] = permutation[j];
123  }
124 
125  end=-1;
126  for(i=0; i<64; i++){
127  int j;
128  j = st->permutated[i];
129  if(j>end) end=j;
130  st->raster_end[i]= end;
131  }
132 }
133 
134 av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation,
135  int idct_permutation_type)
136 {
137  int i;
138 
139  switch(idct_permutation_type){
140  case FF_NO_IDCT_PERM:
141  for(i=0; i<64; i++)
142  idct_permutation[i]= i;
143  break;
144  case FF_LIBMPEG2_IDCT_PERM:
145  for(i=0; i<64; i++)
146  idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
147  break;
148  case FF_SIMPLE_IDCT_PERM:
149  for(i=0; i<64; i++)
150  idct_permutation[i]= simple_mmx_permutation[i];
151  break;
152  case FF_TRANSPOSE_IDCT_PERM:
153  for(i=0; i<64; i++)
154  idct_permutation[i]= ((i&7)<<3) | (i>>3);
155  break;
156  case FF_PARTTRANS_IDCT_PERM:
157  for(i=0; i<64; i++)
158  idct_permutation[i]= (i&0x24) | ((i&3)<<3) | ((i>>3)&3);
159  break;
160  case FF_SSE2_IDCT_PERM:
161  for(i=0; i<64; i++)
162  idct_permutation[i]= (i&0x38) | idct_sse2_row_perm[i&7];
163  break;
164  default:
165  av_log(NULL, AV_LOG_ERROR, "Internal error, IDCT permutation not set\n");
166  }
167 }
168 
169 static int pix_sum_c(uint8_t * pix, int line_size)
170 {
171  int s, i, j;
172 
173  s = 0;
174  for (i = 0; i < 16; i++) {
175  for (j = 0; j < 16; j += 8) {
176  s += pix[0];
177  s += pix[1];
178  s += pix[2];
179  s += pix[3];
180  s += pix[4];
181  s += pix[5];
182  s += pix[6];
183  s += pix[7];
184  pix += 8;
185  }
186  pix += line_size - 16;
187  }
188  return s;
189 }
190 
191 static int pix_norm1_c(uint8_t * pix, int line_size)
192 {
193  int s, i, j;
194  uint32_t *sq = ff_squareTbl + 256;
195 
196  s = 0;
197  for (i = 0; i < 16; i++) {
198  for (j = 0; j < 16; j += 8) {
199 #if 0
200  s += sq[pix[0]];
201  s += sq[pix[1]];
202  s += sq[pix[2]];
203  s += sq[pix[3]];
204  s += sq[pix[4]];
205  s += sq[pix[5]];
206  s += sq[pix[6]];
207  s += sq[pix[7]];
208 #else
209 #if HAVE_FAST_64BIT
210  register uint64_t x=*(uint64_t*)pix;
211  s += sq[x&0xff];
212  s += sq[(x>>8)&0xff];
213  s += sq[(x>>16)&0xff];
214  s += sq[(x>>24)&0xff];
215  s += sq[(x>>32)&0xff];
216  s += sq[(x>>40)&0xff];
217  s += sq[(x>>48)&0xff];
218  s += sq[(x>>56)&0xff];
219 #else
220  register uint32_t x=*(uint32_t*)pix;
221  s += sq[x&0xff];
222  s += sq[(x>>8)&0xff];
223  s += sq[(x>>16)&0xff];
224  s += sq[(x>>24)&0xff];
225  x=*(uint32_t*)(pix+4);
226  s += sq[x&0xff];
227  s += sq[(x>>8)&0xff];
228  s += sq[(x>>16)&0xff];
229  s += sq[(x>>24)&0xff];
230 #endif
231 #endif
232  pix += 8;
233  }
234  pix += line_size - 16;
235  }
236  return s;
237 }
238 
239 static void bswap_buf(uint32_t *dst, const uint32_t *src, int w){
240  int i;
241 
242  for(i=0; i+8<=w; i+=8){
243  dst[i+0]= av_bswap32(src[i+0]);
244  dst[i+1]= av_bswap32(src[i+1]);
245  dst[i+2]= av_bswap32(src[i+2]);
246  dst[i+3]= av_bswap32(src[i+3]);
247  dst[i+4]= av_bswap32(src[i+4]);
248  dst[i+5]= av_bswap32(src[i+5]);
249  dst[i+6]= av_bswap32(src[i+6]);
250  dst[i+7]= av_bswap32(src[i+7]);
251  }
252  for(;i<w; i++){
253  dst[i+0]= av_bswap32(src[i+0]);
254  }
255 }
256 
257 static void bswap16_buf(uint16_t *dst, const uint16_t *src, int len)
258 {
259  while (len--)
260  *dst++ = av_bswap16(*src++);
261 }
262 
263 static int sse4_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
264 {
265  int s, i;
266  uint32_t *sq = ff_squareTbl + 256;
267 
268  s = 0;
269  for (i = 0; i < h; i++) {
270  s += sq[pix1[0] - pix2[0]];
271  s += sq[pix1[1] - pix2[1]];
272  s += sq[pix1[2] - pix2[2]];
273  s += sq[pix1[3] - pix2[3]];
274  pix1 += line_size;
275  pix2 += line_size;
276  }
277  return s;
278 }
279 
280 static int sse8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
281 {
282  int s, i;
283  uint32_t *sq = ff_squareTbl + 256;
284 
285  s = 0;
286  for (i = 0; i < h; i++) {
287  s += sq[pix1[0] - pix2[0]];
288  s += sq[pix1[1] - pix2[1]];
289  s += sq[pix1[2] - pix2[2]];
290  s += sq[pix1[3] - pix2[3]];
291  s += sq[pix1[4] - pix2[4]];
292  s += sq[pix1[5] - pix2[5]];
293  s += sq[pix1[6] - pix2[6]];
294  s += sq[pix1[7] - pix2[7]];
295  pix1 += line_size;
296  pix2 += line_size;
297  }
298  return s;
299 }
300 
301 static int sse16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
302 {
303  int s, i;
304  uint32_t *sq = ff_squareTbl + 256;
305 
306  s = 0;
307  for (i = 0; i < h; i++) {
308  s += sq[pix1[ 0] - pix2[ 0]];
309  s += sq[pix1[ 1] - pix2[ 1]];
310  s += sq[pix1[ 2] - pix2[ 2]];
311  s += sq[pix1[ 3] - pix2[ 3]];
312  s += sq[pix1[ 4] - pix2[ 4]];
313  s += sq[pix1[ 5] - pix2[ 5]];
314  s += sq[pix1[ 6] - pix2[ 6]];
315  s += sq[pix1[ 7] - pix2[ 7]];
316  s += sq[pix1[ 8] - pix2[ 8]];
317  s += sq[pix1[ 9] - pix2[ 9]];
318  s += sq[pix1[10] - pix2[10]];
319  s += sq[pix1[11] - pix2[11]];
320  s += sq[pix1[12] - pix2[12]];
321  s += sq[pix1[13] - pix2[13]];
322  s += sq[pix1[14] - pix2[14]];
323  s += sq[pix1[15] - pix2[15]];
324 
325  pix1 += line_size;
326  pix2 += line_size;
327  }
328  return s;
329 }
330 
331 static void diff_pixels_c(int16_t *av_restrict block, const uint8_t *s1,
332  const uint8_t *s2, int stride){
333  int i;
334 
335  /* read the pixels */
336  for(i=0;i<8;i++) {
337  block[0] = s1[0] - s2[0];
338  block[1] = s1[1] - s2[1];
339  block[2] = s1[2] - s2[2];
340  block[3] = s1[3] - s2[3];
341  block[4] = s1[4] - s2[4];
342  block[5] = s1[5] - s2[5];
343  block[6] = s1[6] - s2[6];
344  block[7] = s1[7] - s2[7];
345  s1 += stride;
346  s2 += stride;
347  block += 8;
348  }
349 }
350 
351 static void put_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
352  int line_size)
353 {
354  int i;
355 
356  /* read the pixels */
357  for(i=0;i<8;i++) {
358  pixels[0] = av_clip_uint8(block[0]);
359  pixels[1] = av_clip_uint8(block[1]);
360  pixels[2] = av_clip_uint8(block[2]);
361  pixels[3] = av_clip_uint8(block[3]);
362  pixels[4] = av_clip_uint8(block[4]);
363  pixels[5] = av_clip_uint8(block[5]);
364  pixels[6] = av_clip_uint8(block[6]);
365  pixels[7] = av_clip_uint8(block[7]);
366 
367  pixels += line_size;
368  block += 8;
369  }
370 }
371 
372 static void put_pixels_clamped4_c(const int16_t *block, uint8_t *av_restrict pixels,
373  int line_size)
374 {
375  int i;
376 
377  /* read the pixels */
378  for(i=0;i<4;i++) {
379  pixels[0] = av_clip_uint8(block[0]);
380  pixels[1] = av_clip_uint8(block[1]);
381  pixels[2] = av_clip_uint8(block[2]);
382  pixels[3] = av_clip_uint8(block[3]);
383 
384  pixels += line_size;
385  block += 8;
386  }
387 }
388 
389 static void put_pixels_clamped2_c(const int16_t *block, uint8_t *av_restrict pixels,
390  int line_size)
391 {
392  int i;
393 
394  /* read the pixels */
395  for(i=0;i<2;i++) {
396  pixels[0] = av_clip_uint8(block[0]);
397  pixels[1] = av_clip_uint8(block[1]);
398 
399  pixels += line_size;
400  block += 8;
401  }
402 }
403 
404 static void put_signed_pixels_clamped_c(const int16_t *block,
405  uint8_t *av_restrict pixels,
406  int line_size)
407 {
408  int i, j;
409 
410  for (i = 0; i < 8; i++) {
411  for (j = 0; j < 8; j++) {
412  if (*block < -128)
413  *pixels = 0;
414  else if (*block > 127)
415  *pixels = 255;
416  else
417  *pixels = (uint8_t)(*block + 128);
418  block++;
419  pixels++;
420  }
421  pixels += (line_size - 8);
422  }
423 }
424 
425 static void add_pixels8_c(uint8_t *av_restrict pixels,
426  int16_t *block,
427  int line_size)
428 {
429  int i;
430 
431  for(i=0;i<8;i++) {
432  pixels[0] += block[0];
433  pixels[1] += block[1];
434  pixels[2] += block[2];
435  pixels[3] += block[3];
436  pixels[4] += block[4];
437  pixels[5] += block[5];
438  pixels[6] += block[6];
439  pixels[7] += block[7];
440  pixels += line_size;
441  block += 8;
442  }
443 }
444 
445 static void add_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
446  int line_size)
447 {
448  int i;
449 
450  /* read the pixels */
451  for(i=0;i<8;i++) {
452  pixels[0] = av_clip_uint8(pixels[0] + block[0]);
453  pixels[1] = av_clip_uint8(pixels[1] + block[1]);
454  pixels[2] = av_clip_uint8(pixels[2] + block[2]);
455  pixels[3] = av_clip_uint8(pixels[3] + block[3]);
456  pixels[4] = av_clip_uint8(pixels[4] + block[4]);
457  pixels[5] = av_clip_uint8(pixels[5] + block[5]);
458  pixels[6] = av_clip_uint8(pixels[6] + block[6]);
459  pixels[7] = av_clip_uint8(pixels[7] + block[7]);
460  pixels += line_size;
461  block += 8;
462  }
463 }
464 
465 static void add_pixels_clamped4_c(const int16_t *block, uint8_t *av_restrict pixels,
466  int line_size)
467 {
468  int i;
469 
470  /* read the pixels */
471  for(i=0;i<4;i++) {
472  pixels[0] = av_clip_uint8(pixels[0] + block[0]);
473  pixels[1] = av_clip_uint8(pixels[1] + block[1]);
474  pixels[2] = av_clip_uint8(pixels[2] + block[2]);
475  pixels[3] = av_clip_uint8(pixels[3] + block[3]);
476  pixels += line_size;
477  block += 8;
478  }
479 }
480 
481 static void add_pixels_clamped2_c(const int16_t *block, uint8_t *av_restrict pixels,
482  int line_size)
483 {
484  int i;
485 
486  /* read the pixels */
487  for(i=0;i<2;i++) {
488  pixels[0] = av_clip_uint8(pixels[0] + block[0]);
489  pixels[1] = av_clip_uint8(pixels[1] + block[1]);
490  pixels += line_size;
491  block += 8;
492  }
493 }
494 
495 static int sum_abs_dctelem_c(int16_t *block)
496 {
497  int sum=0, i;
498  for(i=0; i<64; i++)
499  sum+= FFABS(block[i]);
500  return sum;
501 }
502 
503 static void fill_block16_c(uint8_t *block, uint8_t value, int line_size, int h)
504 {
505  int i;
506 
507  for (i = 0; i < h; i++) {
508  memset(block, value, 16);
509  block += line_size;
510  }
511 }
512 
513 static void fill_block8_c(uint8_t *block, uint8_t value, int line_size, int h)
514 {
515  int i;
516 
517  for (i = 0; i < h; i++) {
518  memset(block, value, 8);
519  block += line_size;
520  }
521 }
522 
523 #define avg2(a,b) ((a+b+1)>>1)
524 #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
525 
526 static void gmc1_c(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder)
527 {
528  const int A=(16-x16)*(16-y16);
529  const int B=( x16)*(16-y16);
530  const int C=(16-x16)*( y16);
531  const int D=( x16)*( y16);
532  int i;
533 
534  for(i=0; i<h; i++)
535  {
536  dst[0]= (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + rounder)>>8;
537  dst[1]= (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + rounder)>>8;
538  dst[2]= (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + rounder)>>8;
539  dst[3]= (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + rounder)>>8;
540  dst[4]= (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + rounder)>>8;
541  dst[5]= (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + rounder)>>8;
542  dst[6]= (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + rounder)>>8;
543  dst[7]= (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + rounder)>>8;
544  dst+= stride;
545  src+= stride;
546  }
547 }
548 
549 void ff_gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
550  int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height)
551 {
552  int y, vx, vy;
553  const int s= 1<<shift;
554 
555  width--;
556  height--;
557 
558  for(y=0; y<h; y++){
559  int x;
560 
561  vx= ox;
562  vy= oy;
563  for(x=0; x<8; x++){ //XXX FIXME optimize
564  int src_x, src_y, frac_x, frac_y, index;
565 
566  src_x= vx>>16;
567  src_y= vy>>16;
568  frac_x= src_x&(s-1);
569  frac_y= src_y&(s-1);
570  src_x>>=shift;
571  src_y>>=shift;
572 
573  if((unsigned)src_x < width){
574  if((unsigned)src_y < height){
575  index= src_x + src_y*stride;
576  dst[y*stride + x]= ( ( src[index ]*(s-frac_x)
577  + src[index +1]* frac_x )*(s-frac_y)
578  + ( src[index+stride ]*(s-frac_x)
579  + src[index+stride+1]* frac_x )* frac_y
580  + r)>>(shift*2);
581  }else{
582  index= src_x + av_clip(src_y, 0, height)*stride;
583  dst[y*stride + x]= ( ( src[index ]*(s-frac_x)
584  + src[index +1]* frac_x )*s
585  + r)>>(shift*2);
586  }
587  }else{
588  if((unsigned)src_y < height){
589  index= av_clip(src_x, 0, width) + src_y*stride;
590  dst[y*stride + x]= ( ( src[index ]*(s-frac_y)
591  + src[index+stride ]* frac_y )*s
592  + r)>>(shift*2);
593  }else{
594  index= av_clip(src_x, 0, width) + av_clip(src_y, 0, height)*stride;
595  dst[y*stride + x]= src[index ];
596  }
597  }
598 
599  vx+= dxx;
600  vy+= dyx;
601  }
602  ox += dxy;
603  oy += dyy;
604  }
605 }
606 
607 static inline void put_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
608  switch(width){
609  case 2: put_pixels2_8_c (dst, src, stride, height); break;
610  case 4: put_pixels4_8_c (dst, src, stride, height); break;
611  case 8: put_pixels8_8_c (dst, src, stride, height); break;
612  case 16:put_pixels16_8_c(dst, src, stride, height); break;
613  }
614 }
615 
616 static inline void put_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
617  int i,j;
618  for (i=0; i < height; i++) {
619  for (j=0; j < width; j++) {
620  dst[j] = (683*(2*src[j] + src[j+1] + 1)) >> 11;
621  }
622  src += stride;
623  dst += stride;
624  }
625 }
626 
627 static inline void put_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
628  int i,j;
629  for (i=0; i < height; i++) {
630  for (j=0; j < width; j++) {
631  dst[j] = (683*(src[j] + 2*src[j+1] + 1)) >> 11;
632  }
633  src += stride;
634  dst += stride;
635  }
636 }
637 
638 static inline void put_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
639  int i,j;
640  for (i=0; i < height; i++) {
641  for (j=0; j < width; j++) {
642  dst[j] = (683*(2*src[j] + src[j+stride] + 1)) >> 11;
643  }
644  src += stride;
645  dst += stride;
646  }
647 }
648 
649 static inline void put_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
650  int i,j;
651  for (i=0; i < height; i++) {
652  for (j=0; j < width; j++) {
653  dst[j] = (2731*(4*src[j] + 3*src[j+1] + 3*src[j+stride] + 2*src[j+stride+1] + 6)) >> 15;
654  }
655  src += stride;
656  dst += stride;
657  }
658 }
659 
660 static inline void put_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
661  int i,j;
662  for (i=0; i < height; i++) {
663  for (j=0; j < width; j++) {
664  dst[j] = (2731*(3*src[j] + 2*src[j+1] + 4*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
665  }
666  src += stride;
667  dst += stride;
668  }
669 }
670 
671 static inline void put_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
672  int i,j;
673  for (i=0; i < height; i++) {
674  for (j=0; j < width; j++) {
675  dst[j] = (683*(src[j] + 2*src[j+stride] + 1)) >> 11;
676  }
677  src += stride;
678  dst += stride;
679  }
680 }
681 
682 static inline void put_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
683  int i,j;
684  for (i=0; i < height; i++) {
685  for (j=0; j < width; j++) {
686  dst[j] = (2731*(3*src[j] + 4*src[j+1] + 2*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
687  }
688  src += stride;
689  dst += stride;
690  }
691 }
692 
693 static inline void put_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
694  int i,j;
695  for (i=0; i < height; i++) {
696  for (j=0; j < width; j++) {
697  dst[j] = (2731*(2*src[j] + 3*src[j+1] + 3*src[j+stride] + 4*src[j+stride+1] + 6)) >> 15;
698  }
699  src += stride;
700  dst += stride;
701  }
702 }
703 
704 static inline void avg_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
705  switch(width){
706  case 2: avg_pixels2_8_c (dst, src, stride, height); break;
707  case 4: avg_pixels4_8_c (dst, src, stride, height); break;
708  case 8: avg_pixels8_8_c (dst, src, stride, height); break;
709  case 16:avg_pixels16_8_c(dst, src, stride, height); break;
710  }
711 }
712 
713 static inline void avg_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
714  int i,j;
715  for (i=0; i < height; i++) {
716  for (j=0; j < width; j++) {
717  dst[j] = (dst[j] + ((683*(2*src[j] + src[j+1] + 1)) >> 11) + 1) >> 1;
718  }
719  src += stride;
720  dst += stride;
721  }
722 }
723 
724 static inline void avg_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
725  int i,j;
726  for (i=0; i < height; i++) {
727  for (j=0; j < width; j++) {
728  dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+1] + 1)) >> 11) + 1) >> 1;
729  }
730  src += stride;
731  dst += stride;
732  }
733 }
734 
735 static inline void avg_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
736  int i,j;
737  for (i=0; i < height; i++) {
738  for (j=0; j < width; j++) {
739  dst[j] = (dst[j] + ((683*(2*src[j] + src[j+stride] + 1)) >> 11) + 1) >> 1;
740  }
741  src += stride;
742  dst += stride;
743  }
744 }
745 
746 static inline void avg_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
747  int i,j;
748  for (i=0; i < height; i++) {
749  for (j=0; j < width; j++) {
750  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;
751  }
752  src += stride;
753  dst += stride;
754  }
755 }
756 
757 static inline void avg_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
758  int i,j;
759  for (i=0; i < height; i++) {
760  for (j=0; j < width; j++) {
761  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;
762  }
763  src += stride;
764  dst += stride;
765  }
766 }
767 
768 static inline void avg_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
769  int i,j;
770  for (i=0; i < height; i++) {
771  for (j=0; j < width; j++) {
772  dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+stride] + 1)) >> 11) + 1) >> 1;
773  }
774  src += stride;
775  dst += stride;
776  }
777 }
778 
779 static inline void avg_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
780  int i,j;
781  for (i=0; i < height; i++) {
782  for (j=0; j < width; j++) {
783  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;
784  }
785  src += stride;
786  dst += stride;
787  }
788 }
789 
790 static inline void avg_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
791  int i,j;
792  for (i=0; i < height; i++) {
793  for (j=0; j < width; j++) {
794  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;
795  }
796  src += stride;
797  dst += stride;
798  }
799 }
800 
801 #define QPEL_MC(r, OPNAME, RND, OP) \
802 static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
803  const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
804  int i;\
805  for(i=0; i<h; i++)\
806  {\
807  OP(dst[0], (src[0]+src[1])*20 - (src[0]+src[2])*6 + (src[1]+src[3])*3 - (src[2]+src[4]));\
808  OP(dst[1], (src[1]+src[2])*20 - (src[0]+src[3])*6 + (src[0]+src[4])*3 - (src[1]+src[5]));\
809  OP(dst[2], (src[2]+src[3])*20 - (src[1]+src[4])*6 + (src[0]+src[5])*3 - (src[0]+src[6]));\
810  OP(dst[3], (src[3]+src[4])*20 - (src[2]+src[5])*6 + (src[1]+src[6])*3 - (src[0]+src[7]));\
811  OP(dst[4], (src[4]+src[5])*20 - (src[3]+src[6])*6 + (src[2]+src[7])*3 - (src[1]+src[8]));\
812  OP(dst[5], (src[5]+src[6])*20 - (src[4]+src[7])*6 + (src[3]+src[8])*3 - (src[2]+src[8]));\
813  OP(dst[6], (src[6]+src[7])*20 - (src[5]+src[8])*6 + (src[4]+src[8])*3 - (src[3]+src[7]));\
814  OP(dst[7], (src[7]+src[8])*20 - (src[6]+src[8])*6 + (src[5]+src[7])*3 - (src[4]+src[6]));\
815  dst+=dstStride;\
816  src+=srcStride;\
817  }\
818 }\
819 \
820 static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
821  const int w=8;\
822  const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
823  int i;\
824  for(i=0; i<w; i++)\
825  {\
826  const int src0= src[0*srcStride];\
827  const int src1= src[1*srcStride];\
828  const int src2= src[2*srcStride];\
829  const int src3= src[3*srcStride];\
830  const int src4= src[4*srcStride];\
831  const int src5= src[5*srcStride];\
832  const int src6= src[6*srcStride];\
833  const int src7= src[7*srcStride];\
834  const int src8= src[8*srcStride];\
835  OP(dst[0*dstStride], (src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4));\
836  OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5));\
837  OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6));\
838  OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7));\
839  OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8));\
840  OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8));\
841  OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7));\
842  OP(dst[7*dstStride], (src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6));\
843  dst++;\
844  src++;\
845  }\
846 }\
847 \
848 static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
849  const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
850  int i;\
851  \
852  for(i=0; i<h; i++)\
853  {\
854  OP(dst[ 0], (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]));\
855  OP(dst[ 1], (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]));\
856  OP(dst[ 2], (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]));\
857  OP(dst[ 3], (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]));\
858  OP(dst[ 4], (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]));\
859  OP(dst[ 5], (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9]));\
860  OP(dst[ 6], (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10]));\
861  OP(dst[ 7], (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11]));\
862  OP(dst[ 8], (src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12]));\
863  OP(dst[ 9], (src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13]));\
864  OP(dst[10], (src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14]));\
865  OP(dst[11], (src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15]));\
866  OP(dst[12], (src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16]));\
867  OP(dst[13], (src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16]));\
868  OP(dst[14], (src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15]));\
869  OP(dst[15], (src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14]));\
870  dst+=dstStride;\
871  src+=srcStride;\
872  }\
873 }\
874 \
875 static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
876  const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
877  int i;\
878  const int w=16;\
879  for(i=0; i<w; i++)\
880  {\
881  const int src0= src[0*srcStride];\
882  const int src1= src[1*srcStride];\
883  const int src2= src[2*srcStride];\
884  const int src3= src[3*srcStride];\
885  const int src4= src[4*srcStride];\
886  const int src5= src[5*srcStride];\
887  const int src6= src[6*srcStride];\
888  const int src7= src[7*srcStride];\
889  const int src8= src[8*srcStride];\
890  const int src9= src[9*srcStride];\
891  const int src10= src[10*srcStride];\
892  const int src11= src[11*srcStride];\
893  const int src12= src[12*srcStride];\
894  const int src13= src[13*srcStride];\
895  const int src14= src[14*srcStride];\
896  const int src15= src[15*srcStride];\
897  const int src16= src[16*srcStride];\
898  OP(dst[ 0*dstStride], (src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 ));\
899  OP(dst[ 1*dstStride], (src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 ));\
900  OP(dst[ 2*dstStride], (src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 ));\
901  OP(dst[ 3*dstStride], (src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 ));\
902  OP(dst[ 4*dstStride], (src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 ));\
903  OP(dst[ 5*dstStride], (src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 ));\
904  OP(dst[ 6*dstStride], (src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10));\
905  OP(dst[ 7*dstStride], (src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11));\
906  OP(dst[ 8*dstStride], (src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12));\
907  OP(dst[ 9*dstStride], (src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13));\
908  OP(dst[10*dstStride], (src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14));\
909  OP(dst[11*dstStride], (src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15));\
910  OP(dst[12*dstStride], (src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16));\
911  OP(dst[13*dstStride], (src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16));\
912  OP(dst[14*dstStride], (src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15));\
913  OP(dst[15*dstStride], (src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14));\
914  dst++;\
915  src++;\
916  }\
917 }\
918 \
919 static void OPNAME ## qpel8_mc10_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
920 {\
921  uint8_t half[64];\
922  put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
923  OPNAME ## pixels8_l2_8(dst, src, half, stride, stride, 8, 8);\
924 }\
925 \
926 static void OPNAME ## qpel8_mc20_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
927 {\
928  OPNAME ## mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);\
929 }\
930 \
931 static void OPNAME ## qpel8_mc30_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
932 {\
933  uint8_t half[64];\
934  put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
935  OPNAME ## pixels8_l2_8(dst, src+1, half, stride, stride, 8, 8);\
936 }\
937 \
938 static void OPNAME ## qpel8_mc01_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
939 {\
940  uint8_t full[16*9];\
941  uint8_t half[64];\
942  copy_block9(full, src, 16, stride, 9);\
943  put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
944  OPNAME ## pixels8_l2_8(dst, full, half, stride, 16, 8, 8);\
945 }\
946 \
947 static void OPNAME ## qpel8_mc02_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
948 {\
949  uint8_t full[16*9];\
950  copy_block9(full, src, 16, stride, 9);\
951  OPNAME ## mpeg4_qpel8_v_lowpass(dst, full, stride, 16);\
952 }\
953 \
954 static void OPNAME ## qpel8_mc03_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
955 {\
956  uint8_t full[16*9];\
957  uint8_t half[64];\
958  copy_block9(full, src, 16, stride, 9);\
959  put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
960  OPNAME ## pixels8_l2_8(dst, full+16, half, stride, 16, 8, 8);\
961 }\
962 void ff_ ## OPNAME ## qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
963 {\
964  uint8_t full[16*9];\
965  uint8_t halfH[72];\
966  uint8_t halfV[64];\
967  uint8_t halfHV[64];\
968  copy_block9(full, src, 16, stride, 9);\
969  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
970  put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
971  put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
972  OPNAME ## pixels8_l4_8(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
973 }\
974 static void OPNAME ## qpel8_mc11_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
975 {\
976  uint8_t full[16*9];\
977  uint8_t halfH[72];\
978  uint8_t halfHV[64];\
979  copy_block9(full, src, 16, stride, 9);\
980  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
981  put ## RND ## pixels8_l2_8(halfH, halfH, full, 8, 8, 16, 9);\
982  put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
983  OPNAME ## pixels8_l2_8(dst, halfH, halfHV, stride, 8, 8, 8);\
984 }\
985 void ff_ ## OPNAME ## qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
986 {\
987  uint8_t full[16*9];\
988  uint8_t halfH[72];\
989  uint8_t halfV[64];\
990  uint8_t halfHV[64];\
991  copy_block9(full, src, 16, stride, 9);\
992  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
993  put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
994  put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
995  OPNAME ## pixels8_l4_8(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
996 }\
997 static void OPNAME ## qpel8_mc31_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
998 {\
999  uint8_t full[16*9];\
1000  uint8_t halfH[72];\
1001  uint8_t halfHV[64];\
1002  copy_block9(full, src, 16, stride, 9);\
1003  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1004  put ## RND ## pixels8_l2_8(halfH, halfH, full+1, 8, 8, 16, 9);\
1005  put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1006  OPNAME ## pixels8_l2_8(dst, halfH, halfHV, stride, 8, 8, 8);\
1007 }\
1008 void ff_ ## OPNAME ## qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1009 {\
1010  uint8_t full[16*9];\
1011  uint8_t halfH[72];\
1012  uint8_t halfV[64];\
1013  uint8_t halfHV[64];\
1014  copy_block9(full, src, 16, stride, 9);\
1015  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1016  put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1017  put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1018  OPNAME ## pixels8_l4_8(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1019 }\
1020 static void OPNAME ## qpel8_mc13_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1021 {\
1022  uint8_t full[16*9];\
1023  uint8_t halfH[72];\
1024  uint8_t halfHV[64];\
1025  copy_block9(full, src, 16, stride, 9);\
1026  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1027  put ## RND ## pixels8_l2_8(halfH, halfH, full, 8, 8, 16, 9);\
1028  put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1029  OPNAME ## pixels8_l2_8(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1030 }\
1031 void ff_ ## OPNAME ## qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1032 {\
1033  uint8_t full[16*9];\
1034  uint8_t halfH[72];\
1035  uint8_t halfV[64];\
1036  uint8_t halfHV[64];\
1037  copy_block9(full, src, 16, stride, 9);\
1038  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full , 8, 16, 9);\
1039  put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1040  put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1041  OPNAME ## pixels8_l4_8(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1042 }\
1043 static void OPNAME ## qpel8_mc33_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1044 {\
1045  uint8_t full[16*9];\
1046  uint8_t halfH[72];\
1047  uint8_t halfHV[64];\
1048  copy_block9(full, src, 16, stride, 9);\
1049  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1050  put ## RND ## pixels8_l2_8(halfH, halfH, full+1, 8, 8, 16, 9);\
1051  put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1052  OPNAME ## pixels8_l2_8(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1053 }\
1054 static void OPNAME ## qpel8_mc21_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1055 {\
1056  uint8_t halfH[72];\
1057  uint8_t halfHV[64];\
1058  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1059  put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1060  OPNAME ## pixels8_l2_8(dst, halfH, halfHV, stride, 8, 8, 8);\
1061 }\
1062 static void OPNAME ## qpel8_mc23_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1063 {\
1064  uint8_t halfH[72];\
1065  uint8_t halfHV[64];\
1066  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1067  put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1068  OPNAME ## pixels8_l2_8(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1069 }\
1070 void ff_ ## OPNAME ## qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1071 {\
1072  uint8_t full[16*9];\
1073  uint8_t halfH[72];\
1074  uint8_t halfV[64];\
1075  uint8_t halfHV[64];\
1076  copy_block9(full, src, 16, stride, 9);\
1077  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1078  put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1079  put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1080  OPNAME ## pixels8_l2_8(dst, halfV, halfHV, stride, 8, 8, 8);\
1081 }\
1082 static void OPNAME ## qpel8_mc12_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1083 {\
1084  uint8_t full[16*9];\
1085  uint8_t halfH[72];\
1086  copy_block9(full, src, 16, stride, 9);\
1087  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1088  put ## RND ## pixels8_l2_8(halfH, halfH, full, 8, 8, 16, 9);\
1089  OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1090 }\
1091 void ff_ ## OPNAME ## qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1092 {\
1093  uint8_t full[16*9];\
1094  uint8_t halfH[72];\
1095  uint8_t halfV[64];\
1096  uint8_t halfHV[64];\
1097  copy_block9(full, src, 16, stride, 9);\
1098  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1099  put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1100  put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1101  OPNAME ## pixels8_l2_8(dst, halfV, halfHV, stride, 8, 8, 8);\
1102 }\
1103 static void OPNAME ## qpel8_mc32_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1104 {\
1105  uint8_t full[16*9];\
1106  uint8_t halfH[72];\
1107  copy_block9(full, src, 16, stride, 9);\
1108  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1109  put ## RND ## pixels8_l2_8(halfH, halfH, full+1, 8, 8, 16, 9);\
1110  OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1111 }\
1112 static void OPNAME ## qpel8_mc22_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1113 {\
1114  uint8_t halfH[72];\
1115  put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1116  OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1117 }\
1118 \
1119 static void OPNAME ## qpel16_mc10_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1120 {\
1121  uint8_t half[256];\
1122  put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
1123  OPNAME ## pixels16_l2_8(dst, src, half, stride, stride, 16, 16);\
1124 }\
1125 \
1126 static void OPNAME ## qpel16_mc20_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1127 {\
1128  OPNAME ## mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);\
1129 }\
1130 \
1131 static void OPNAME ## qpel16_mc30_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1132 {\
1133  uint8_t half[256];\
1134  put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
1135  OPNAME ## pixels16_l2_8(dst, src+1, half, stride, stride, 16, 16);\
1136 }\
1137 \
1138 static void OPNAME ## qpel16_mc01_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1139 {\
1140  uint8_t full[24*17];\
1141  uint8_t half[256];\
1142  copy_block17(full, src, 24, stride, 17);\
1143  put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
1144  OPNAME ## pixels16_l2_8(dst, full, half, stride, 24, 16, 16);\
1145 }\
1146 \
1147 static void OPNAME ## qpel16_mc02_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1148 {\
1149  uint8_t full[24*17];\
1150  copy_block17(full, src, 24, stride, 17);\
1151  OPNAME ## mpeg4_qpel16_v_lowpass(dst, full, stride, 24);\
1152 }\
1153 \
1154 static void OPNAME ## qpel16_mc03_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1155 {\
1156  uint8_t full[24*17];\
1157  uint8_t half[256];\
1158  copy_block17(full, src, 24, stride, 17);\
1159  put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
1160  OPNAME ## pixels16_l2_8(dst, full+24, half, stride, 24, 16, 16);\
1161 }\
1162 void ff_ ## OPNAME ## qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1163 {\
1164  uint8_t full[24*17];\
1165  uint8_t halfH[272];\
1166  uint8_t halfV[256];\
1167  uint8_t halfHV[256];\
1168  copy_block17(full, src, 24, stride, 17);\
1169  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1170  put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1171  put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1172  OPNAME ## pixels16_l4_8(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1173 }\
1174 static void OPNAME ## qpel16_mc11_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1175 {\
1176  uint8_t full[24*17];\
1177  uint8_t halfH[272];\
1178  uint8_t halfHV[256];\
1179  copy_block17(full, src, 24, stride, 17);\
1180  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1181  put ## RND ## pixels16_l2_8(halfH, halfH, full, 16, 16, 24, 17);\
1182  put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1183  OPNAME ## pixels16_l2_8(dst, halfH, halfHV, stride, 16, 16, 16);\
1184 }\
1185 void ff_ ## OPNAME ## qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1186 {\
1187  uint8_t full[24*17];\
1188  uint8_t halfH[272];\
1189  uint8_t halfV[256];\
1190  uint8_t halfHV[256];\
1191  copy_block17(full, src, 24, stride, 17);\
1192  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1193  put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1194  put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1195  OPNAME ## pixels16_l4_8(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1196 }\
1197 static void OPNAME ## qpel16_mc31_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1198 {\
1199  uint8_t full[24*17];\
1200  uint8_t halfH[272];\
1201  uint8_t halfHV[256];\
1202  copy_block17(full, src, 24, stride, 17);\
1203  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1204  put ## RND ## pixels16_l2_8(halfH, halfH, full+1, 16, 16, 24, 17);\
1205  put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1206  OPNAME ## pixels16_l2_8(dst, halfH, halfHV, stride, 16, 16, 16);\
1207 }\
1208 void ff_ ## OPNAME ## qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1209 {\
1210  uint8_t full[24*17];\
1211  uint8_t halfH[272];\
1212  uint8_t halfV[256];\
1213  uint8_t halfHV[256];\
1214  copy_block17(full, src, 24, stride, 17);\
1215  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1216  put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1217  put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1218  OPNAME ## pixels16_l4_8(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1219 }\
1220 static void OPNAME ## qpel16_mc13_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1221 {\
1222  uint8_t full[24*17];\
1223  uint8_t halfH[272];\
1224  uint8_t halfHV[256];\
1225  copy_block17(full, src, 24, stride, 17);\
1226  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1227  put ## RND ## pixels16_l2_8(halfH, halfH, full, 16, 16, 24, 17);\
1228  put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1229  OPNAME ## pixels16_l2_8(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1230 }\
1231 void ff_ ## OPNAME ## qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1232 {\
1233  uint8_t full[24*17];\
1234  uint8_t halfH[272];\
1235  uint8_t halfV[256];\
1236  uint8_t halfHV[256];\
1237  copy_block17(full, src, 24, stride, 17);\
1238  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full , 16, 24, 17);\
1239  put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1240  put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1241  OPNAME ## pixels16_l4_8(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1242 }\
1243 static void OPNAME ## qpel16_mc33_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1244 {\
1245  uint8_t full[24*17];\
1246  uint8_t halfH[272];\
1247  uint8_t halfHV[256];\
1248  copy_block17(full, src, 24, stride, 17);\
1249  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1250  put ## RND ## pixels16_l2_8(halfH, halfH, full+1, 16, 16, 24, 17);\
1251  put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1252  OPNAME ## pixels16_l2_8(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1253 }\
1254 static void OPNAME ## qpel16_mc21_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1255 {\
1256  uint8_t halfH[272];\
1257  uint8_t halfHV[256];\
1258  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1259  put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1260  OPNAME ## pixels16_l2_8(dst, halfH, halfHV, stride, 16, 16, 16);\
1261 }\
1262 static void OPNAME ## qpel16_mc23_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1263 {\
1264  uint8_t halfH[272];\
1265  uint8_t halfHV[256];\
1266  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1267  put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1268  OPNAME ## pixels16_l2_8(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1269 }\
1270 void ff_ ## OPNAME ## qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1271 {\
1272  uint8_t full[24*17];\
1273  uint8_t halfH[272];\
1274  uint8_t halfV[256];\
1275  uint8_t halfHV[256];\
1276  copy_block17(full, src, 24, stride, 17);\
1277  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1278  put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1279  put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1280  OPNAME ## pixels16_l2_8(dst, halfV, halfHV, stride, 16, 16, 16);\
1281 }\
1282 static void OPNAME ## qpel16_mc12_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1283 {\
1284  uint8_t full[24*17];\
1285  uint8_t halfH[272];\
1286  copy_block17(full, src, 24, stride, 17);\
1287  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1288  put ## RND ## pixels16_l2_8(halfH, halfH, full, 16, 16, 24, 17);\
1289  OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1290 }\
1291 void ff_ ## OPNAME ## qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1292 {\
1293  uint8_t full[24*17];\
1294  uint8_t halfH[272];\
1295  uint8_t halfV[256];\
1296  uint8_t halfHV[256];\
1297  copy_block17(full, src, 24, stride, 17);\
1298  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1299  put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1300  put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1301  OPNAME ## pixels16_l2_8(dst, halfV, halfHV, stride, 16, 16, 16);\
1302 }\
1303 static void OPNAME ## qpel16_mc32_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1304 {\
1305  uint8_t full[24*17];\
1306  uint8_t halfH[272];\
1307  copy_block17(full, src, 24, stride, 17);\
1308  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1309  put ## RND ## pixels16_l2_8(halfH, halfH, full+1, 16, 16, 24, 17);\
1310  OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1311 }\
1312 static void OPNAME ## qpel16_mc22_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)\
1313 {\
1314  uint8_t halfH[272];\
1315  put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1316  OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1317 }
1318 
1319 #define op_avg(a, b) a = (((a)+cm[((b) + 16)>>5]+1)>>1)
1320 #define op_avg_no_rnd(a, b) a = (((a)+cm[((b) + 15)>>5])>>1)
1321 #define op_put(a, b) a = cm[((b) + 16)>>5]
1322 #define op_put_no_rnd(a, b) a = cm[((b) + 15)>>5]
1323 
1324 QPEL_MC(0, put_ , _ , op_put)
1325 QPEL_MC(1, put_no_rnd_, _no_rnd_, op_put_no_rnd)
1326 QPEL_MC(0, avg_ , _ , op_avg)
1327 //QPEL_MC(1, avg_no_rnd , _ , op_avg)
1328 #undef op_avg
1329 #undef op_avg_no_rnd
1330 #undef op_put
1331 #undef op_put_no_rnd
1332 
1333 void ff_put_pixels8x8_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1334 {
1335  put_pixels8_8_c(dst, src, stride, 8);
1336 }
1337 void ff_avg_pixels8x8_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1338 {
1339  avg_pixels8_8_c(dst, src, stride, 8);
1340 }
1341 void ff_put_pixels16x16_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1342 {
1343  put_pixels16_8_c(dst, src, stride, 16);
1344 }
1345 void ff_avg_pixels16x16_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1346 {
1347  avg_pixels16_8_c(dst, src, stride, 16);
1348 }
1349 
1350 #define put_qpel8_mc00_c ff_put_pixels8x8_c
1351 #define avg_qpel8_mc00_c ff_avg_pixels8x8_c
1352 #define put_qpel16_mc00_c ff_put_pixels16x16_c
1353 #define avg_qpel16_mc00_c ff_avg_pixels16x16_c
1354 #define put_no_rnd_qpel8_mc00_c ff_put_pixels8x8_c
1355 #define put_no_rnd_qpel16_mc00_c ff_put_pixels16x16_c
1356 
1357 static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
1358  const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
1359  int i;
1360 
1361  for(i=0; i<h; i++){
1362  dst[0]= cm[(9*(src[0] + src[1]) - (src[-1] + src[2]) + 8)>>4];
1363  dst[1]= cm[(9*(src[1] + src[2]) - (src[ 0] + src[3]) + 8)>>4];
1364  dst[2]= cm[(9*(src[2] + src[3]) - (src[ 1] + src[4]) + 8)>>4];
1365  dst[3]= cm[(9*(src[3] + src[4]) - (src[ 2] + src[5]) + 8)>>4];
1366  dst[4]= cm[(9*(src[4] + src[5]) - (src[ 3] + src[6]) + 8)>>4];
1367  dst[5]= cm[(9*(src[5] + src[6]) - (src[ 4] + src[7]) + 8)>>4];
1368  dst[6]= cm[(9*(src[6] + src[7]) - (src[ 5] + src[8]) + 8)>>4];
1369  dst[7]= cm[(9*(src[7] + src[8]) - (src[ 6] + src[9]) + 8)>>4];
1370  dst+=dstStride;
1371  src+=srcStride;
1372  }
1373 }
1374 
1375 #if CONFIG_RV40_DECODER
1376 void ff_put_rv40_qpel16_mc33_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1377 {
1378  put_pixels16_xy2_8_c(dst, src, stride, 16);
1379 }
1380 void ff_avg_rv40_qpel16_mc33_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1381 {
1382  avg_pixels16_xy2_8_c(dst, src, stride, 16);
1383 }
1384 void ff_put_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1385 {
1386  put_pixels8_xy2_8_c(dst, src, stride, 8);
1387 }
1388 void ff_avg_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1389 {
1390  avg_pixels8_xy2_8_c(dst, src, stride, 8);
1391 }
1392 #endif /* CONFIG_RV40_DECODER */
1393 
1394 #if CONFIG_DIRAC_DECODER
1395 #define DIRAC_MC(OPNAME)\
1396 void ff_ ## OPNAME ## _dirac_pixels8_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
1397 {\
1398  OPNAME ## _pixels8_8_c(dst, src[0], stride, h);\
1399 }\
1400 void ff_ ## OPNAME ## _dirac_pixels16_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
1401 {\
1402  OPNAME ## _pixels16_8_c(dst, src[0], stride, h);\
1403 }\
1404 void ff_ ## OPNAME ## _dirac_pixels32_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
1405 {\
1406  OPNAME ## _pixels16_8_c(dst , src[0] , stride, h);\
1407  OPNAME ## _pixels16_8_c(dst+16, src[0]+16, stride, h);\
1408 }\
1409 void ff_ ## OPNAME ## _dirac_pixels8_l2_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
1410 {\
1411  OPNAME ## _pixels8_l2_8(dst, src[0], src[1], stride, stride, stride, h);\
1412 }\
1413 void ff_ ## OPNAME ## _dirac_pixels16_l2_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
1414 {\
1415  OPNAME ## _pixels16_l2_8(dst, src[0], src[1], stride, stride, stride, h);\
1416 }\
1417 void ff_ ## OPNAME ## _dirac_pixels32_l2_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
1418 {\
1419  OPNAME ## _pixels16_l2_8(dst , src[0] , src[1] , stride, stride, stride, h);\
1420  OPNAME ## _pixels16_l2_8(dst+16, src[0]+16, src[1]+16, stride, stride, stride, h);\
1421 }\
1422 void ff_ ## OPNAME ## _dirac_pixels8_l4_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
1423 {\
1424  OPNAME ## _pixels8_l4_8(dst, src[0], src[1], src[2], src[3], stride, stride, stride, stride, stride, h);\
1425 }\
1426 void ff_ ## OPNAME ## _dirac_pixels16_l4_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
1427 {\
1428  OPNAME ## _pixels16_l4_8(dst, src[0], src[1], src[2], src[3], stride, stride, stride, stride, stride, h);\
1429 }\
1430 void ff_ ## OPNAME ## _dirac_pixels32_l4_c(uint8_t *dst, const uint8_t *src[5], int stride, int h)\
1431 {\
1432  OPNAME ## _pixels16_l4_8(dst , src[0] , src[1] , src[2] , src[3] , stride, stride, stride, stride, stride, h);\
1433  OPNAME ## _pixels16_l4_8(dst+16, src[0]+16, src[1]+16, src[2]+16, src[3]+16, stride, stride, stride, stride, stride, h);\
1434 }
1435 DIRAC_MC(put)
1436 DIRAC_MC(avg)
1437 #endif
1438 
1439 static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
1440  const uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
1441  int i;
1442 
1443  for(i=0; i<w; i++){
1444  const int src_1= src[ -srcStride];
1445  const int src0 = src[0 ];
1446  const int src1 = src[ srcStride];
1447  const int src2 = src[2*srcStride];
1448  const int src3 = src[3*srcStride];
1449  const int src4 = src[4*srcStride];
1450  const int src5 = src[5*srcStride];
1451  const int src6 = src[6*srcStride];
1452  const int src7 = src[7*srcStride];
1453  const int src8 = src[8*srcStride];
1454  const int src9 = src[9*srcStride];
1455  dst[0*dstStride]= cm[(9*(src0 + src1) - (src_1 + src2) + 8)>>4];
1456  dst[1*dstStride]= cm[(9*(src1 + src2) - (src0 + src3) + 8)>>4];
1457  dst[2*dstStride]= cm[(9*(src2 + src3) - (src1 + src4) + 8)>>4];
1458  dst[3*dstStride]= cm[(9*(src3 + src4) - (src2 + src5) + 8)>>4];
1459  dst[4*dstStride]= cm[(9*(src4 + src5) - (src3 + src6) + 8)>>4];
1460  dst[5*dstStride]= cm[(9*(src5 + src6) - (src4 + src7) + 8)>>4];
1461  dst[6*dstStride]= cm[(9*(src6 + src7) - (src5 + src8) + 8)>>4];
1462  dst[7*dstStride]= cm[(9*(src7 + src8) - (src6 + src9) + 8)>>4];
1463  src++;
1464  dst++;
1465  }
1466 }
1467 
1468 static void put_mspel8_mc10_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1469 {
1470  uint8_t half[64];
1471  wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
1472  put_pixels8_l2_8(dst, src, half, stride, stride, 8, 8);
1473 }
1474 
1475 static void put_mspel8_mc20_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1476 {
1477  wmv2_mspel8_h_lowpass(dst, src, stride, stride, 8);
1478 }
1479 
1480 static void put_mspel8_mc30_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1481 {
1482  uint8_t half[64];
1483  wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
1484  put_pixels8_l2_8(dst, src+1, half, stride, stride, 8, 8);
1485 }
1486 
1487 static void put_mspel8_mc02_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1488 {
1489  wmv2_mspel8_v_lowpass(dst, src, stride, stride, 8);
1490 }
1491 
1492 static void put_mspel8_mc12_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1493 {
1494  uint8_t halfH[88];
1495  uint8_t halfV[64];
1496  uint8_t halfHV[64];
1497  wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
1498  wmv2_mspel8_v_lowpass(halfV, src, 8, stride, 8);
1499  wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
1500  put_pixels8_l2_8(dst, halfV, halfHV, stride, 8, 8, 8);
1501 }
1502 static void put_mspel8_mc32_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1503 {
1504  uint8_t halfH[88];
1505  uint8_t halfV[64];
1506  uint8_t halfHV[64];
1507  wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
1508  wmv2_mspel8_v_lowpass(halfV, src+1, 8, stride, 8);
1509  wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
1510  put_pixels8_l2_8(dst, halfV, halfHV, stride, 8, 8, 8);
1511 }
1512 static void put_mspel8_mc22_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride)
1513 {
1514  uint8_t halfH[88];
1515  wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
1516  wmv2_mspel8_v_lowpass(dst, halfH+8, stride, 8, 8);
1517 }
1518 
1519 static void h263_v_loop_filter_c(uint8_t *src, int stride, int qscale){
1520  if(CONFIG_H263_DECODER || CONFIG_H263_ENCODER) {
1521  int x;
1522  const int strength= ff_h263_loop_filter_strength[qscale];
1523 
1524  for(x=0; x<8; x++){
1525  int d1, d2, ad1;
1526  int p0= src[x-2*stride];
1527  int p1= src[x-1*stride];
1528  int p2= src[x+0*stride];
1529  int p3= src[x+1*stride];
1530  int d = (p0 - p3 + 4*(p2 - p1)) / 8;
1531 
1532  if (d<-2*strength) d1= 0;
1533  else if(d<- strength) d1=-2*strength - d;
1534  else if(d< strength) d1= d;
1535  else if(d< 2*strength) d1= 2*strength - d;
1536  else d1= 0;
1537 
1538  p1 += d1;
1539  p2 -= d1;
1540  if(p1&256) p1= ~(p1>>31);
1541  if(p2&256) p2= ~(p2>>31);
1542 
1543  src[x-1*stride] = p1;
1544  src[x+0*stride] = p2;
1545 
1546  ad1= FFABS(d1)>>1;
1547 
1548  d2= av_clip((p0-p3)/4, -ad1, ad1);
1549 
1550  src[x-2*stride] = p0 - d2;
1551  src[x+ stride] = p3 + d2;
1552  }
1553  }
1554 }
1555 
1556 static void h263_h_loop_filter_c(uint8_t *src, int stride, int qscale){
1557  if(CONFIG_H263_DECODER || CONFIG_H263_ENCODER) {
1558  int y;
1559  const int strength= ff_h263_loop_filter_strength[qscale];
1560 
1561  for(y=0; y<8; y++){
1562  int d1, d2, ad1;
1563  int p0= src[y*stride-2];
1564  int p1= src[y*stride-1];
1565  int p2= src[y*stride+0];
1566  int p3= src[y*stride+1];
1567  int d = (p0 - p3 + 4*(p2 - p1)) / 8;
1568 
1569  if (d<-2*strength) d1= 0;
1570  else if(d<- strength) d1=-2*strength - d;
1571  else if(d< strength) d1= d;
1572  else if(d< 2*strength) d1= 2*strength - d;
1573  else d1= 0;
1574 
1575  p1 += d1;
1576  p2 -= d1;
1577  if(p1&256) p1= ~(p1>>31);
1578  if(p2&256) p2= ~(p2>>31);
1579 
1580  src[y*stride-1] = p1;
1581  src[y*stride+0] = p2;
1582 
1583  ad1= FFABS(d1)>>1;
1584 
1585  d2= av_clip((p0-p3)/4, -ad1, ad1);
1586 
1587  src[y*stride-2] = p0 - d2;
1588  src[y*stride+1] = p3 + d2;
1589  }
1590  }
1591 }
1592 
1593 static inline int pix_abs16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1594 {
1595  int s, i;
1596 
1597  s = 0;
1598  for(i=0;i<h;i++) {
1599  s += abs(pix1[0] - pix2[0]);
1600  s += abs(pix1[1] - pix2[1]);
1601  s += abs(pix1[2] - pix2[2]);
1602  s += abs(pix1[3] - pix2[3]);
1603  s += abs(pix1[4] - pix2[4]);
1604  s += abs(pix1[5] - pix2[5]);
1605  s += abs(pix1[6] - pix2[6]);
1606  s += abs(pix1[7] - pix2[7]);
1607  s += abs(pix1[8] - pix2[8]);
1608  s += abs(pix1[9] - pix2[9]);
1609  s += abs(pix1[10] - pix2[10]);
1610  s += abs(pix1[11] - pix2[11]);
1611  s += abs(pix1[12] - pix2[12]);
1612  s += abs(pix1[13] - pix2[13]);
1613  s += abs(pix1[14] - pix2[14]);
1614  s += abs(pix1[15] - pix2[15]);
1615  pix1 += line_size;
1616  pix2 += line_size;
1617  }
1618  return s;
1619 }
1620 
1621 static int pix_abs16_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1622 {
1623  int s, i;
1624 
1625  s = 0;
1626  for(i=0;i<h;i++) {
1627  s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
1628  s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
1629  s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
1630  s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
1631  s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
1632  s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
1633  s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
1634  s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
1635  s += abs(pix1[8] - avg2(pix2[8], pix2[9]));
1636  s += abs(pix1[9] - avg2(pix2[9], pix2[10]));
1637  s += abs(pix1[10] - avg2(pix2[10], pix2[11]));
1638  s += abs(pix1[11] - avg2(pix2[11], pix2[12]));
1639  s += abs(pix1[12] - avg2(pix2[12], pix2[13]));
1640  s += abs(pix1[13] - avg2(pix2[13], pix2[14]));
1641  s += abs(pix1[14] - avg2(pix2[14], pix2[15]));
1642  s += abs(pix1[15] - avg2(pix2[15], pix2[16]));
1643  pix1 += line_size;
1644  pix2 += line_size;
1645  }
1646  return s;
1647 }
1648 
1649 static int pix_abs16_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1650 {
1651  int s, i;
1652  uint8_t *pix3 = pix2 + line_size;
1653 
1654  s = 0;
1655  for(i=0;i<h;i++) {
1656  s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
1657  s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
1658  s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
1659  s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
1660  s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
1661  s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
1662  s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
1663  s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
1664  s += abs(pix1[8] - avg2(pix2[8], pix3[8]));
1665  s += abs(pix1[9] - avg2(pix2[9], pix3[9]));
1666  s += abs(pix1[10] - avg2(pix2[10], pix3[10]));
1667  s += abs(pix1[11] - avg2(pix2[11], pix3[11]));
1668  s += abs(pix1[12] - avg2(pix2[12], pix3[12]));
1669  s += abs(pix1[13] - avg2(pix2[13], pix3[13]));
1670  s += abs(pix1[14] - avg2(pix2[14], pix3[14]));
1671  s += abs(pix1[15] - avg2(pix2[15], pix3[15]));
1672  pix1 += line_size;
1673  pix2 += line_size;
1674  pix3 += line_size;
1675  }
1676  return s;
1677 }
1678 
1679 static int pix_abs16_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1680 {
1681  int s, i;
1682  uint8_t *pix3 = pix2 + line_size;
1683 
1684  s = 0;
1685  for(i=0;i<h;i++) {
1686  s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
1687  s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
1688  s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
1689  s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
1690  s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
1691  s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
1692  s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
1693  s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
1694  s += abs(pix1[8] - avg4(pix2[8], pix2[9], pix3[8], pix3[9]));
1695  s += abs(pix1[9] - avg4(pix2[9], pix2[10], pix3[9], pix3[10]));
1696  s += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));
1697  s += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));
1698  s += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));
1699  s += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));
1700  s += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));
1701  s += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));
1702  pix1 += line_size;
1703  pix2 += line_size;
1704  pix3 += line_size;
1705  }
1706  return s;
1707 }
1708 
1709 static inline int pix_abs8_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1710 {
1711  int s, i;
1712 
1713  s = 0;
1714  for(i=0;i<h;i++) {
1715  s += abs(pix1[0] - pix2[0]);
1716  s += abs(pix1[1] - pix2[1]);
1717  s += abs(pix1[2] - pix2[2]);
1718  s += abs(pix1[3] - pix2[3]);
1719  s += abs(pix1[4] - pix2[4]);
1720  s += abs(pix1[5] - pix2[5]);
1721  s += abs(pix1[6] - pix2[6]);
1722  s += abs(pix1[7] - pix2[7]);
1723  pix1 += line_size;
1724  pix2 += line_size;
1725  }
1726  return s;
1727 }
1728 
1729 static int pix_abs8_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1730 {
1731  int s, i;
1732 
1733  s = 0;
1734  for(i=0;i<h;i++) {
1735  s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
1736  s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
1737  s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
1738  s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
1739  s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
1740  s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
1741  s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
1742  s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
1743  pix1 += line_size;
1744  pix2 += line_size;
1745  }
1746  return s;
1747 }
1748 
1749 static int pix_abs8_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1750 {
1751  int s, i;
1752  uint8_t *pix3 = pix2 + line_size;
1753 
1754  s = 0;
1755  for(i=0;i<h;i++) {
1756  s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
1757  s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
1758  s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
1759  s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
1760  s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
1761  s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
1762  s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
1763  s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
1764  pix1 += line_size;
1765  pix2 += line_size;
1766  pix3 += line_size;
1767  }
1768  return s;
1769 }
1770 
1771 static int pix_abs8_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1772 {
1773  int s, i;
1774  uint8_t *pix3 = pix2 + line_size;
1775 
1776  s = 0;
1777  for(i=0;i<h;i++) {
1778  s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
1779  s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
1780  s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
1781  s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
1782  s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
1783  s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
1784  s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
1785  s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
1786  pix1 += line_size;
1787  pix2 += line_size;
1788  pix3 += line_size;
1789  }
1790  return s;
1791 }
1792 
1793 static int nsse16_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
1794  MpegEncContext *c = v;
1795  int score1=0;
1796  int score2=0;
1797  int x,y;
1798 
1799  for(y=0; y<h; y++){
1800  for(x=0; x<16; x++){
1801  score1+= (s1[x ] - s2[x ])*(s1[x ] - s2[x ]);
1802  }
1803  if(y+1<h){
1804  for(x=0; x<15; x++){
1805  score2+= FFABS( s1[x ] - s1[x +stride]
1806  - s1[x+1] + s1[x+1+stride])
1807  -FFABS( s2[x ] - s2[x +stride]
1808  - s2[x+1] + s2[x+1+stride]);
1809  }
1810  }
1811  s1+= stride;
1812  s2+= stride;
1813  }
1814 
1815  if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
1816  else return score1 + FFABS(score2)*8;
1817 }
1818 
1819 static int nsse8_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
1820  MpegEncContext *c = v;
1821  int score1=0;
1822  int score2=0;
1823  int x,y;
1824 
1825  for(y=0; y<h; y++){
1826  for(x=0; x<8; x++){
1827  score1+= (s1[x ] - s2[x ])*(s1[x ] - s2[x ]);
1828  }
1829  if(y+1<h){
1830  for(x=0; x<7; x++){
1831  score2+= FFABS( s1[x ] - s1[x +stride]
1832  - s1[x+1] + s1[x+1+stride])
1833  -FFABS( s2[x ] - s2[x +stride]
1834  - s2[x+1] + s2[x+1+stride]);
1835  }
1836  }
1837  s1+= stride;
1838  s2+= stride;
1839  }
1840 
1841  if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
1842  else return score1 + FFABS(score2)*8;
1843 }
1844 
1845 static int try_8x8basis_c(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale){
1846  int i;
1847  unsigned int sum=0;
1848 
1849  for(i=0; i<8*8; i++){
1850  int b= rem[i] + ((basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT));
1851  int w= weight[i];
1852  b>>= RECON_SHIFT;
1853  av_assert2(-512<b && b<512);
1854 
1855  sum += (w*b)*(w*b)>>4;
1856  }
1857  return sum>>2;
1858 }
1859 
1860 static void add_8x8basis_c(int16_t rem[64], int16_t basis[64], int scale){
1861  int i;
1862 
1863  for(i=0; i<8*8; i++){
1864  rem[i] += (basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT);
1865  }
1866 }
1867 
1868 static int zero_cmp(void *s, uint8_t *a, uint8_t *b, int stride, int h){
1869  return 0;
1870 }
1871 
1872 void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type){
1873  int i;
1874 
1875  memset(cmp, 0, sizeof(void*)*6);
1876 
1877  for(i=0; i<6; i++){
1878  switch(type&0xFF){
1879  case FF_CMP_SAD:
1880  cmp[i]= c->sad[i];
1881  break;
1882  case FF_CMP_SATD:
1883  cmp[i]= c->hadamard8_diff[i];
1884  break;
1885  case FF_CMP_SSE:
1886  cmp[i]= c->sse[i];
1887  break;
1888  case FF_CMP_DCT:
1889  cmp[i]= c->dct_sad[i];
1890  break;
1891  case FF_CMP_DCT264:
1892  cmp[i]= c->dct264_sad[i];
1893  break;
1894  case FF_CMP_DCTMAX:
1895  cmp[i]= c->dct_max[i];
1896  break;
1897  case FF_CMP_PSNR:
1898  cmp[i]= c->quant_psnr[i];
1899  break;
1900  case FF_CMP_BIT:
1901  cmp[i]= c->bit[i];
1902  break;
1903  case FF_CMP_RD:
1904  cmp[i]= c->rd[i];
1905  break;
1906  case FF_CMP_VSAD:
1907  cmp[i]= c->vsad[i];
1908  break;
1909  case FF_CMP_VSSE:
1910  cmp[i]= c->vsse[i];
1911  break;
1912  case FF_CMP_ZERO:
1913  cmp[i]= zero_cmp;
1914  break;
1915  case FF_CMP_NSSE:
1916  cmp[i]= c->nsse[i];
1917  break;
1918 #if CONFIG_DWT
1919  case FF_CMP_W53:
1920  cmp[i]= c->w53[i];
1921  break;
1922  case FF_CMP_W97:
1923  cmp[i]= c->w97[i];
1924  break;
1925 #endif
1926  default:
1927  av_log(NULL, AV_LOG_ERROR,"internal error in cmp function selection\n");
1928  }
1929  }
1930 }
1931 
1932 static void add_bytes_c(uint8_t *dst, uint8_t *src, int w){
1933  long i;
1934  for(i=0; i<=w-sizeof(long); i+=sizeof(long)){
1935  long a = *(long*)(src+i);
1936  long b = *(long*)(dst+i);
1937  *(long*)(dst+i) = ((a&pb_7f) + (b&pb_7f)) ^ ((a^b)&pb_80);
1938  }
1939  for(; i<w; i++)
1940  dst[i+0] += src[i+0];
1941 }
1942 
1943 static void diff_bytes_c(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int w){
1944  long i;
1945 #if !HAVE_FAST_UNALIGNED
1946  if((long)src2 & (sizeof(long)-1)){
1947  for(i=0; i+7<w; i+=8){
1948  dst[i+0] = src1[i+0]-src2[i+0];
1949  dst[i+1] = src1[i+1]-src2[i+1];
1950  dst[i+2] = src1[i+2]-src2[i+2];
1951  dst[i+3] = src1[i+3]-src2[i+3];
1952  dst[i+4] = src1[i+4]-src2[i+4];
1953  dst[i+5] = src1[i+5]-src2[i+5];
1954  dst[i+6] = src1[i+6]-src2[i+6];
1955  dst[i+7] = src1[i+7]-src2[i+7];
1956  }
1957  }else
1958 #endif
1959  for(i=0; i<=w-sizeof(long); i+=sizeof(long)){
1960  long a = *(long*)(src1+i);
1961  long b = *(long*)(src2+i);
1962  *(long*)(dst+i) = ((a|pb_80) - (b&pb_7f)) ^ ((a^b^pb_80)&pb_80);
1963  }
1964  for(; i<w; i++)
1965  dst[i+0] = src1[i+0]-src2[i+0];
1966 }
1967 
1968 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){
1969  int i;
1970  uint8_t l, lt;
1971 
1972  l= *left;
1973  lt= *left_top;
1974 
1975  for(i=0; i<w; i++){
1976  l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i];
1977  lt= src1[i];
1978  dst[i]= l;
1979  }
1980 
1981  *left= l;
1982  *left_top= lt;
1983 }
1984 
1985 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){
1986  int i;
1987  uint8_t l, lt;
1988 
1989  l= *left;
1990  lt= *left_top;
1991 
1992  for(i=0; i<w; i++){
1993  const int pred= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF);
1994  lt= src1[i];
1995  l= src2[i];
1996  dst[i]= l - pred;
1997  }
1998 
1999  *left= l;
2000  *left_top= lt;
2001 }
2002 
2003 static int add_hfyu_left_prediction_c(uint8_t *dst, const uint8_t *src, int w, int acc){
2004  int i;
2005 
2006  for(i=0; i<w-1; i++){
2007  acc+= src[i];
2008  dst[i]= acc;
2009  i++;
2010  acc+= src[i];
2011  dst[i]= acc;
2012  }
2013 
2014  for(; i<w; i++){
2015  acc+= src[i];
2016  dst[i]= acc;
2017  }
2018 
2019  return acc;
2020 }
2021 
2022 #if HAVE_BIGENDIAN
2023 #define B 3
2024 #define G 2
2025 #define R 1
2026 #define A 0
2027 #else
2028 #define B 0
2029 #define G 1
2030 #define R 2
2031 #define A 3
2032 #endif
2033 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){
2034  int i;
2035  int r,g,b,a;
2036  r= *red;
2037  g= *green;
2038  b= *blue;
2039  a= *alpha;
2040 
2041  for(i=0; i<w; i++){
2042  b+= src[4*i+B];
2043  g+= src[4*i+G];
2044  r+= src[4*i+R];
2045  a+= src[4*i+A];
2046 
2047  dst[4*i+B]= b;
2048  dst[4*i+G]= g;
2049  dst[4*i+R]= r;
2050  dst[4*i+A]= a;
2051  }
2052 
2053  *red= r;
2054  *green= g;
2055  *blue= b;
2056  *alpha= a;
2057 }
2058 #undef B
2059 #undef G
2060 #undef R
2061 #undef A
2062 
2063 #define BUTTERFLY2(o1,o2,i1,i2) \
2064 o1= (i1)+(i2);\
2065 o2= (i1)-(i2);
2066 
2067 #define BUTTERFLY1(x,y) \
2068 {\
2069  int a,b;\
2070  a= x;\
2071  b= y;\
2072  x= a+b;\
2073  y= a-b;\
2074 }
2075 
2076 #define BUTTERFLYA(x,y) (FFABS((x)+(y)) + FFABS((x)-(y)))
2077 
2078 static int hadamard8_diff8x8_c(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h){
2079  int i;
2080  int temp[64];
2081  int sum=0;
2082 
2083  av_assert2(h==8);
2084 
2085  for(i=0; i<8; i++){
2086  //FIXME try pointer walks
2087  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]);
2088  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]);
2089  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]);
2090  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]);
2091 
2092  BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
2093  BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
2094  BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
2095  BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
2096 
2097  BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
2098  BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
2099  BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
2100  BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
2101  }
2102 
2103  for(i=0; i<8; i++){
2104  BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
2105  BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
2106  BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
2107  BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
2108 
2109  BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
2110  BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
2111  BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
2112  BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
2113 
2114  sum +=
2115  BUTTERFLYA(temp[8*0+i], temp[8*4+i])
2116  +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
2117  +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
2118  +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
2119  }
2120  return sum;
2121 }
2122 
2123 static int hadamard8_intra8x8_c(/*MpegEncContext*/ void *s, uint8_t *src, uint8_t *dummy, int stride, int h){
2124  int i;
2125  int temp[64];
2126  int sum=0;
2127 
2128  av_assert2(h==8);
2129 
2130  for(i=0; i<8; i++){
2131  //FIXME try pointer walks
2132  BUTTERFLY2(temp[8*i+0], temp[8*i+1], src[stride*i+0],src[stride*i+1]);
2133  BUTTERFLY2(temp[8*i+2], temp[8*i+3], src[stride*i+2],src[stride*i+3]);
2134  BUTTERFLY2(temp[8*i+4], temp[8*i+5], src[stride*i+4],src[stride*i+5]);
2135  BUTTERFLY2(temp[8*i+6], temp[8*i+7], src[stride*i+6],src[stride*i+7]);
2136 
2137  BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
2138  BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
2139  BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
2140  BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
2141 
2142  BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
2143  BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
2144  BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
2145  BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
2146  }
2147 
2148  for(i=0; i<8; i++){
2149  BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
2150  BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
2151  BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
2152  BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
2153 
2154  BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
2155  BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
2156  BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
2157  BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
2158 
2159  sum +=
2160  BUTTERFLYA(temp[8*0+i], temp[8*4+i])
2161  +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
2162  +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
2163  +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
2164  }
2165 
2166  sum -= FFABS(temp[8*0] + temp[8*4]); // -mean
2167 
2168  return sum;
2169 }
2170 
2171 static int dct_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2172  MpegEncContext * const s= (MpegEncContext *)c;
2173  LOCAL_ALIGNED_16(int16_t, temp, [64]);
2174 
2175  av_assert2(h==8);
2176 
2177  s->dsp.diff_pixels(temp, src1, src2, stride);
2178  s->dsp.fdct(temp);
2179  return s->dsp.sum_abs_dctelem(temp);
2180 }
2181 
2182 #if CONFIG_GPL
2183 #define DCT8_1D {\
2184  const int s07 = SRC(0) + SRC(7);\
2185  const int s16 = SRC(1) + SRC(6);\
2186  const int s25 = SRC(2) + SRC(5);\
2187  const int s34 = SRC(3) + SRC(4);\
2188  const int a0 = s07 + s34;\
2189  const int a1 = s16 + s25;\
2190  const int a2 = s07 - s34;\
2191  const int a3 = s16 - s25;\
2192  const int d07 = SRC(0) - SRC(7);\
2193  const int d16 = SRC(1) - SRC(6);\
2194  const int d25 = SRC(2) - SRC(5);\
2195  const int d34 = SRC(3) - SRC(4);\
2196  const int a4 = d16 + d25 + (d07 + (d07>>1));\
2197  const int a5 = d07 - d34 - (d25 + (d25>>1));\
2198  const int a6 = d07 + d34 - (d16 + (d16>>1));\
2199  const int a7 = d16 - d25 + (d34 + (d34>>1));\
2200  DST(0, a0 + a1 ) ;\
2201  DST(1, a4 + (a7>>2)) ;\
2202  DST(2, a2 + (a3>>1)) ;\
2203  DST(3, a5 + (a6>>2)) ;\
2204  DST(4, a0 - a1 ) ;\
2205  DST(5, a6 - (a5>>2)) ;\
2206  DST(6, (a2>>1) - a3 ) ;\
2207  DST(7, (a4>>2) - a7 ) ;\
2208 }
2209 
2210 static int dct264_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2211  MpegEncContext * const s= (MpegEncContext *)c;
2212  int16_t dct[8][8];
2213  int i;
2214  int sum=0;
2215 
2216  s->dsp.diff_pixels(dct[0], src1, src2, stride);
2217 
2218 #define SRC(x) dct[i][x]
2219 #define DST(x,v) dct[i][x]= v
2220  for( i = 0; i < 8; i++ )
2221  DCT8_1D
2222 #undef SRC
2223 #undef DST
2224 
2225 #define SRC(x) dct[x][i]
2226 #define DST(x,v) sum += FFABS(v)
2227  for( i = 0; i < 8; i++ )
2228  DCT8_1D
2229 #undef SRC
2230 #undef DST
2231  return sum;
2232 }
2233 #endif
2234 
2235 static int dct_max8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2236  MpegEncContext * const s= (MpegEncContext *)c;
2237  LOCAL_ALIGNED_16(int16_t, temp, [64]);
2238  int sum=0, i;
2239 
2240  av_assert2(h==8);
2241 
2242  s->dsp.diff_pixels(temp, src1, src2, stride);
2243  s->dsp.fdct(temp);
2244 
2245  for(i=0; i<64; i++)
2246  sum= FFMAX(sum, FFABS(temp[i]));
2247 
2248  return sum;
2249 }
2250 
2251 static int quant_psnr8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2252  MpegEncContext * const s= (MpegEncContext *)c;
2253  LOCAL_ALIGNED_16(int16_t, temp, [64*2]);
2254  int16_t * const bak = temp+64;
2255  int sum=0, i;
2256 
2257  av_assert2(h==8);
2258  s->mb_intra=0;
2259 
2260  s->dsp.diff_pixels(temp, src1, src2, stride);
2261 
2262  memcpy(bak, temp, 64*sizeof(int16_t));
2263 
2264  s->block_last_index[0/*FIXME*/]= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
2265  s->dct_unquantize_inter(s, temp, 0, s->qscale);
2266  ff_simple_idct_8(temp); //FIXME
2267 
2268  for(i=0; i<64; i++)
2269  sum+= (temp[i]-bak[i])*(temp[i]-bak[i]);
2270 
2271  return sum;
2272 }
2273 
2274 static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2275  MpegEncContext * const s= (MpegEncContext *)c;
2276  const uint8_t *scantable= s->intra_scantable.permutated;
2277  LOCAL_ALIGNED_16(int16_t, temp, [64]);
2278  LOCAL_ALIGNED_16(uint8_t, lsrc1, [64]);
2279  LOCAL_ALIGNED_16(uint8_t, lsrc2, [64]);
2280  int i, last, run, bits, level, distortion, start_i;
2281  const int esc_length= s->ac_esc_length;
2282  uint8_t * length;
2283  uint8_t * last_length;
2284 
2285  av_assert2(h==8);
2286 
2287  copy_block8(lsrc1, src1, 8, stride, 8);
2288  copy_block8(lsrc2, src2, 8, stride, 8);
2289 
2290  s->dsp.diff_pixels(temp, lsrc1, lsrc2, 8);
2291 
2292  s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
2293 
2294  bits=0;
2295 
2296  if (s->mb_intra) {
2297  start_i = 1;
2298  length = s->intra_ac_vlc_length;
2299  last_length= s->intra_ac_vlc_last_length;
2300  bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
2301  } else {
2302  start_i = 0;
2303  length = s->inter_ac_vlc_length;
2304  last_length= s->inter_ac_vlc_last_length;
2305  }
2306 
2307  if(last>=start_i){
2308  run=0;
2309  for(i=start_i; i<last; i++){
2310  int j= scantable[i];
2311  level= temp[j];
2312 
2313  if(level){
2314  level+=64;
2315  if((level&(~127)) == 0){
2316  bits+= length[UNI_AC_ENC_INDEX(run, level)];
2317  }else
2318  bits+= esc_length;
2319  run=0;
2320  }else
2321  run++;
2322  }
2323  i= scantable[last];
2324 
2325  level= temp[i] + 64;
2326 
2327  av_assert2(level - 64);
2328 
2329  if((level&(~127)) == 0){
2330  bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
2331  }else
2332  bits+= esc_length;
2333 
2334  }
2335 
2336  if(last>=0){
2337  if(s->mb_intra)
2338  s->dct_unquantize_intra(s, temp, 0, s->qscale);
2339  else
2340  s->dct_unquantize_inter(s, temp, 0, s->qscale);
2341  }
2342 
2343  s->dsp.idct_add(lsrc2, 8, temp);
2344 
2345  distortion= s->dsp.sse[1](NULL, lsrc2, lsrc1, 8, 8);
2346 
2347  return distortion + ((bits*s->qscale*s->qscale*109 + 64)>>7);
2348 }
2349 
2350 static int bit8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2351  MpegEncContext * const s= (MpegEncContext *)c;
2352  const uint8_t *scantable= s->intra_scantable.permutated;
2353  LOCAL_ALIGNED_16(int16_t, temp, [64]);
2354  int i, last, run, bits, level, start_i;
2355  const int esc_length= s->ac_esc_length;
2356  uint8_t * length;
2357  uint8_t * last_length;
2358 
2359  av_assert2(h==8);
2360 
2361  s->dsp.diff_pixels(temp, src1, src2, stride);
2362 
2363  s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
2364 
2365  bits=0;
2366 
2367  if (s->mb_intra) {
2368  start_i = 1;
2369  length = s->intra_ac_vlc_length;
2370  last_length= s->intra_ac_vlc_last_length;
2371  bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
2372  } else {
2373  start_i = 0;
2374  length = s->inter_ac_vlc_length;
2375  last_length= s->inter_ac_vlc_last_length;
2376  }
2377 
2378  if(last>=start_i){
2379  run=0;
2380  for(i=start_i; i<last; i++){
2381  int j= scantable[i];
2382  level= temp[j];
2383 
2384  if(level){
2385  level+=64;
2386  if((level&(~127)) == 0){
2387  bits+= length[UNI_AC_ENC_INDEX(run, level)];
2388  }else
2389  bits+= esc_length;
2390  run=0;
2391  }else
2392  run++;
2393  }
2394  i= scantable[last];
2395 
2396  level= temp[i] + 64;
2397 
2398  av_assert2(level - 64);
2399 
2400  if((level&(~127)) == 0){
2401  bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
2402  }else
2403  bits+= esc_length;
2404  }
2405 
2406  return bits;
2407 }
2408 
2409 #define VSAD_INTRA(size) \
2410 static int vsad_intra##size##_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){ \
2411  int score=0; \
2412  int x,y; \
2413  \
2414  for(y=1; y<h; y++){ \
2415  for(x=0; x<size; x+=4){ \
2416  score+= FFABS(s[x ] - s[x +stride]) + FFABS(s[x+1] - s[x+1+stride]) \
2417  +FFABS(s[x+2] - s[x+2+stride]) + FFABS(s[x+3] - s[x+3+stride]); \
2418  } \
2419  s+= stride; \
2420  } \
2421  \
2422  return score; \
2423 }
2424 VSAD_INTRA(8)
2425 VSAD_INTRA(16)
2426 
2427 static int vsad16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
2428  int score=0;
2429  int x,y;
2430 
2431  for(y=1; y<h; y++){
2432  for(x=0; x<16; x++){
2433  score+= FFABS(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
2434  }
2435  s1+= stride;
2436  s2+= stride;
2437  }
2438 
2439  return score;
2440 }
2441 
2442 #define SQ(a) ((a)*(a))
2443 #define VSSE_INTRA(size) \
2444 static int vsse_intra##size##_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){ \
2445  int score=0; \
2446  int x,y; \
2447  \
2448  for(y=1; y<h; y++){ \
2449  for(x=0; x<size; x+=4){ \
2450  score+= SQ(s[x ] - s[x +stride]) + SQ(s[x+1] - s[x+1+stride]) \
2451  +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]); \
2452  } \
2453  s+= stride; \
2454  } \
2455  \
2456  return score; \
2457 }
2458 VSSE_INTRA(8)
2459 VSSE_INTRA(16)
2460 
2461 static int vsse16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
2462  int score=0;
2463  int x,y;
2464 
2465  for(y=1; y<h; y++){
2466  for(x=0; x<16; x++){
2467  score+= SQ(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
2468  }
2469  s1+= stride;
2470  s2+= stride;
2471  }
2472 
2473  return score;
2474 }
2475 
2476 static int ssd_int8_vs_int16_c(const int8_t *pix1, const int16_t *pix2,
2477  int size){
2478  int score=0;
2479  int i;
2480  for(i=0; i<size; i++)
2481  score += (pix1[i]-pix2[i])*(pix1[i]-pix2[i]);
2482  return score;
2483 }
2484 
2485 #define WRAPPER8_16_SQ(name8, name16)\
2486 static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride, int h){\
2487  int score=0;\
2488  score +=name8(s, dst , src , stride, 8);\
2489  score +=name8(s, dst+8 , src+8 , stride, 8);\
2490  if(h==16){\
2491  dst += 8*stride;\
2492  src += 8*stride;\
2493  score +=name8(s, dst , src , stride, 8);\
2494  score +=name8(s, dst+8 , src+8 , stride, 8);\
2495  }\
2496  return score;\
2497 }
2498 
2499 WRAPPER8_16_SQ(hadamard8_diff8x8_c, hadamard8_diff16_c)
2500 WRAPPER8_16_SQ(hadamard8_intra8x8_c, hadamard8_intra16_c)
2501 WRAPPER8_16_SQ(dct_sad8x8_c, dct_sad16_c)
2502 #if CONFIG_GPL
2503 WRAPPER8_16_SQ(dct264_sad8x8_c, dct264_sad16_c)
2504 #endif
2505 WRAPPER8_16_SQ(dct_max8x8_c, dct_max16_c)
2506 WRAPPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c)
2507 WRAPPER8_16_SQ(rd8x8_c, rd16_c)
2508 WRAPPER8_16_SQ(bit8x8_c, bit16_c)
2509 
2510 static inline uint32_t clipf_c_one(uint32_t a, uint32_t mini,
2511  uint32_t maxi, uint32_t maxisign)
2512 {
2513 
2514  if(a > mini) return mini;
2515  else if((a^(1U<<31)) > maxisign) return maxi;
2516  else return a;
2517 }
2518 
2519 static void vector_clipf_c_opposite_sign(float *dst, const float *src, float *min, float *max, int len){
2520  int i;
2521  uint32_t mini = *(uint32_t*)min;
2522  uint32_t maxi = *(uint32_t*)max;
2523  uint32_t maxisign = maxi ^ (1U<<31);
2524  uint32_t *dsti = (uint32_t*)dst;
2525  const uint32_t *srci = (const uint32_t*)src;
2526  for(i=0; i<len; i+=8) {
2527  dsti[i + 0] = clipf_c_one(srci[i + 0], mini, maxi, maxisign);
2528  dsti[i + 1] = clipf_c_one(srci[i + 1], mini, maxi, maxisign);
2529  dsti[i + 2] = clipf_c_one(srci[i + 2], mini, maxi, maxisign);
2530  dsti[i + 3] = clipf_c_one(srci[i + 3], mini, maxi, maxisign);
2531  dsti[i + 4] = clipf_c_one(srci[i + 4], mini, maxi, maxisign);
2532  dsti[i + 5] = clipf_c_one(srci[i + 5], mini, maxi, maxisign);
2533  dsti[i + 6] = clipf_c_one(srci[i + 6], mini, maxi, maxisign);
2534  dsti[i + 7] = clipf_c_one(srci[i + 7], mini, maxi, maxisign);
2535  }
2536 }
2537 static void vector_clipf_c(float *dst, const float *src, float min, float max, int len){
2538  int i;
2539  if(min < 0 && max > 0) {
2540  vector_clipf_c_opposite_sign(dst, src, &min, &max, len);
2541  } else {
2542  for(i=0; i < len; i+=8) {
2543  dst[i ] = av_clipf(src[i ], min, max);
2544  dst[i + 1] = av_clipf(src[i + 1], min, max);
2545  dst[i + 2] = av_clipf(src[i + 2], min, max);
2546  dst[i + 3] = av_clipf(src[i + 3], min, max);
2547  dst[i + 4] = av_clipf(src[i + 4], min, max);
2548  dst[i + 5] = av_clipf(src[i + 5], min, max);
2549  dst[i + 6] = av_clipf(src[i + 6], min, max);
2550  dst[i + 7] = av_clipf(src[i + 7], min, max);
2551  }
2552  }
2553 }
2554 
2555 static int32_t scalarproduct_int16_c(const int16_t * v1, const int16_t * v2, int order)
2556 {
2557  int res = 0;
2558 
2559  while (order--)
2560  res += *v1++ * *v2++;
2561 
2562  return res;
2563 }
2564 
2565 static int32_t scalarproduct_and_madd_int16_c(int16_t *v1, const int16_t *v2, const int16_t *v3, int order, int mul)
2566 {
2567  int res = 0;
2568  while (order--) {
2569  res += *v1 * *v2++;
2570  *v1++ += mul * *v3++;
2571  }
2572  return res;
2573 }
2574 
2575 static void apply_window_int16_c(int16_t *output, const int16_t *input,
2576  const int16_t *window, unsigned int len)
2577 {
2578  int i;
2579  int len2 = len >> 1;
2580 
2581  for (i = 0; i < len2; i++) {
2582  int16_t w = window[i];
2583  output[i] = (MUL16(input[i], w) + (1 << 14)) >> 15;
2584  output[len-i-1] = (MUL16(input[len-i-1], w) + (1 << 14)) >> 15;
2585  }
2586 }
2587 
2588 static void vector_clip_int32_c(int32_t *dst, const int32_t *src, int32_t min,
2589  int32_t max, unsigned int len)
2590 {
2591  do {
2592  *dst++ = av_clip(*src++, min, max);
2593  *dst++ = av_clip(*src++, min, max);
2594  *dst++ = av_clip(*src++, min, max);
2595  *dst++ = av_clip(*src++, min, max);
2596  *dst++ = av_clip(*src++, min, max);
2597  *dst++ = av_clip(*src++, min, max);
2598  *dst++ = av_clip(*src++, min, max);
2599  *dst++ = av_clip(*src++, min, max);
2600  len -= 8;
2601  } while (len > 0);
2602 }
2603 
2604 static void jref_idct_put(uint8_t *dest, int line_size, int16_t *block)
2605 {
2606  ff_j_rev_dct (block);
2607  put_pixels_clamped_c(block, dest, line_size);
2608 }
2609 static void jref_idct_add(uint8_t *dest, int line_size, int16_t *block)
2610 {
2611  ff_j_rev_dct (block);
2612  add_pixels_clamped_c(block, dest, line_size);
2613 }
2614 
2615 static void ff_jref_idct4_put(uint8_t *dest, int line_size, int16_t *block)
2616 {
2617  ff_j_rev_dct4 (block);
2618  put_pixels_clamped4_c(block, dest, line_size);
2619 }
2620 static void ff_jref_idct4_add(uint8_t *dest, int line_size, int16_t *block)
2621 {
2622  ff_j_rev_dct4 (block);
2623  add_pixels_clamped4_c(block, dest, line_size);
2624 }
2625 
2626 static void ff_jref_idct2_put(uint8_t *dest, int line_size, int16_t *block)
2627 {
2628  ff_j_rev_dct2 (block);
2629  put_pixels_clamped2_c(block, dest, line_size);
2630 }
2631 static void ff_jref_idct2_add(uint8_t *dest, int line_size, int16_t *block)
2632 {
2633  ff_j_rev_dct2 (block);
2634  add_pixels_clamped2_c(block, dest, line_size);
2635 }
2636 
2637 static void ff_jref_idct1_put(uint8_t *dest, int line_size, int16_t *block)
2638 {
2639  dest[0] = av_clip_uint8((block[0] + 4)>>3);
2640 }
2641 static void ff_jref_idct1_add(uint8_t *dest, int line_size, int16_t *block)
2642 {
2643  dest[0] = av_clip_uint8(dest[0] + ((block[0] + 4)>>3));
2644 }
2645 
2646 /* init static data */
2647 av_cold void ff_dsputil_static_init(void)
2648 {
2649  int i;
2650 
2651  for(i=0;i<512;i++) {
2652  ff_squareTbl[i] = (i - 256) * (i - 256);
2653  }
2654 
2655  for(i=0; i<64; i++) ff_inv_zigzag_direct16[ff_zigzag_direct[i]]= i+1;
2656 }
2657 
2658 int ff_check_alignment(void){
2659  static int did_fail=0;
2660  LOCAL_ALIGNED_16(int, aligned, [4]);
2661 
2662  if((intptr_t)aligned & 15){
2663  if(!did_fail){
2664 #if HAVE_MMX || HAVE_ALTIVEC
2665  av_log(NULL, AV_LOG_ERROR,
2666  "Compiler did not align stack variables. Libavcodec has been miscompiled\n"
2667  "and may be very slow or crash. This is not a bug in libavcodec,\n"
2668  "but in the compiler. You may try recompiling using gcc >= 4.2.\n"
2669  "Do not report crashes to FFmpeg developers.\n");
2670 #endif
2671  did_fail=1;
2672  }
2673  return -1;
2674  }
2675  return 0;
2676 }
2677 
2678 av_cold void ff_dsputil_init(DSPContext* c, AVCodecContext *avctx)
2679 {
2680  ff_check_alignment();
2681 
2682 #if CONFIG_ENCODERS
2683  if (avctx->bits_per_raw_sample == 10) {
2684  c->fdct = ff_jpeg_fdct_islow_10;
2685  c->fdct248 = ff_fdct248_islow_10;
2686  } else {
2687  if(avctx->dct_algo==FF_DCT_FASTINT) {
2688  c->fdct = ff_fdct_ifast;
2689  c->fdct248 = ff_fdct_ifast248;
2690  }
2691  else if(avctx->dct_algo==FF_DCT_FAAN) {
2692  c->fdct = ff_faandct;
2693  c->fdct248 = ff_faandct248;
2694  }
2695  else {
2696  c->fdct = ff_jpeg_fdct_islow_8; //slow/accurate/default
2697  c->fdct248 = ff_fdct248_islow_8;
2698  }
2699  }
2700 #endif //CONFIG_ENCODERS
2701 
2702  if(avctx->lowres==1){
2703  c->idct_put= ff_jref_idct4_put;
2704  c->idct_add= ff_jref_idct4_add;
2705  c->idct = ff_j_rev_dct4;
2706  c->idct_permutation_type= FF_NO_IDCT_PERM;
2707  }else if(avctx->lowres==2){
2708  c->idct_put= ff_jref_idct2_put;
2709  c->idct_add= ff_jref_idct2_add;
2710  c->idct = ff_j_rev_dct2;
2711  c->idct_permutation_type= FF_NO_IDCT_PERM;
2712  }else if(avctx->lowres==3){
2713  c->idct_put= ff_jref_idct1_put;
2714  c->idct_add= ff_jref_idct1_add;
2715  c->idct = ff_j_rev_dct1;
2716  c->idct_permutation_type= FF_NO_IDCT_PERM;
2717  }else{
2718  if (avctx->bits_per_raw_sample == 10) {
2719  c->idct_put = ff_simple_idct_put_10;
2720  c->idct_add = ff_simple_idct_add_10;
2721  c->idct = ff_simple_idct_10;
2722  c->idct_permutation_type = FF_NO_IDCT_PERM;
2723  } else {
2724  if(avctx->idct_algo==FF_IDCT_INT){
2725  c->idct_put= jref_idct_put;
2726  c->idct_add= jref_idct_add;
2727  c->idct = ff_j_rev_dct;
2728  c->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
2729  }else if(avctx->idct_algo==FF_IDCT_FAAN){
2730  c->idct_put= ff_faanidct_put;
2731  c->idct_add= ff_faanidct_add;
2732  c->idct = ff_faanidct;
2733  c->idct_permutation_type= FF_NO_IDCT_PERM;
2734  }else{ //accurate/default
2735  c->idct_put = ff_simple_idct_put_8;
2736  c->idct_add = ff_simple_idct_add_8;
2737  c->idct = ff_simple_idct_8;
2738  c->idct_permutation_type= FF_NO_IDCT_PERM;
2739  }
2740  }
2741  }
2742 
2743  c->diff_pixels = diff_pixels_c;
2744  c->put_pixels_clamped = put_pixels_clamped_c;
2745  c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
2746  c->add_pixels_clamped = add_pixels_clamped_c;
2747  c->sum_abs_dctelem = sum_abs_dctelem_c;
2748  c->gmc1 = gmc1_c;
2749  c->gmc = ff_gmc_c;
2750  c->pix_sum = pix_sum_c;
2751  c->pix_norm1 = pix_norm1_c;
2752 
2753  c->fill_block_tab[0] = fill_block16_c;
2754  c->fill_block_tab[1] = fill_block8_c;
2755 
2756  /* TODO [0] 16 [1] 8 */
2757  c->pix_abs[0][0] = pix_abs16_c;
2758  c->pix_abs[0][1] = pix_abs16_x2_c;
2759  c->pix_abs[0][2] = pix_abs16_y2_c;
2760  c->pix_abs[0][3] = pix_abs16_xy2_c;
2761  c->pix_abs[1][0] = pix_abs8_c;
2762  c->pix_abs[1][1] = pix_abs8_x2_c;
2763  c->pix_abs[1][2] = pix_abs8_y2_c;
2764  c->pix_abs[1][3] = pix_abs8_xy2_c;
2765 
2766  c->put_tpel_pixels_tab[ 0] = put_tpel_pixels_mc00_c;
2767  c->put_tpel_pixels_tab[ 1] = put_tpel_pixels_mc10_c;
2768  c->put_tpel_pixels_tab[ 2] = put_tpel_pixels_mc20_c;
2769  c->put_tpel_pixels_tab[ 4] = put_tpel_pixels_mc01_c;
2770  c->put_tpel_pixels_tab[ 5] = put_tpel_pixels_mc11_c;
2771  c->put_tpel_pixels_tab[ 6] = put_tpel_pixels_mc21_c;
2772  c->put_tpel_pixels_tab[ 8] = put_tpel_pixels_mc02_c;
2773  c->put_tpel_pixels_tab[ 9] = put_tpel_pixels_mc12_c;
2774  c->put_tpel_pixels_tab[10] = put_tpel_pixels_mc22_c;
2775 
2776  c->avg_tpel_pixels_tab[ 0] = avg_tpel_pixels_mc00_c;
2777  c->avg_tpel_pixels_tab[ 1] = avg_tpel_pixels_mc10_c;
2778  c->avg_tpel_pixels_tab[ 2] = avg_tpel_pixels_mc20_c;
2779  c->avg_tpel_pixels_tab[ 4] = avg_tpel_pixels_mc01_c;
2780  c->avg_tpel_pixels_tab[ 5] = avg_tpel_pixels_mc11_c;
2781  c->avg_tpel_pixels_tab[ 6] = avg_tpel_pixels_mc21_c;
2782  c->avg_tpel_pixels_tab[ 8] = avg_tpel_pixels_mc02_c;
2783  c->avg_tpel_pixels_tab[ 9] = avg_tpel_pixels_mc12_c;
2784  c->avg_tpel_pixels_tab[10] = avg_tpel_pixels_mc22_c;
2785 
2786 #define dspfunc(PFX, IDX, NUM) \
2787  c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_c; \
2788  c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_c; \
2789  c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_c; \
2790  c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_c; \
2791  c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_c; \
2792  c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_c; \
2793  c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_c; \
2794  c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_c; \
2795  c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_c; \
2796  c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_c; \
2797  c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_c; \
2798  c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_c; \
2799  c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_c; \
2800  c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_c; \
2801  c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_c; \
2802  c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_c
2803 
2804  dspfunc(put_qpel, 0, 16);
2805  dspfunc(put_no_rnd_qpel, 0, 16);
2806 
2807  dspfunc(avg_qpel, 0, 16);
2808  /* dspfunc(avg_no_rnd_qpel, 0, 16); */
2809 
2810  dspfunc(put_qpel, 1, 8);
2811  dspfunc(put_no_rnd_qpel, 1, 8);
2812 
2813  dspfunc(avg_qpel, 1, 8);
2814  /* dspfunc(avg_no_rnd_qpel, 1, 8); */
2815 
2816 #undef dspfunc
2817 
2818  c->put_mspel_pixels_tab[0]= ff_put_pixels8x8_c;
2819  c->put_mspel_pixels_tab[1]= put_mspel8_mc10_c;
2820  c->put_mspel_pixels_tab[2]= put_mspel8_mc20_c;
2821  c->put_mspel_pixels_tab[3]= put_mspel8_mc30_c;
2822  c->put_mspel_pixels_tab[4]= put_mspel8_mc02_c;
2823  c->put_mspel_pixels_tab[5]= put_mspel8_mc12_c;
2824  c->put_mspel_pixels_tab[6]= put_mspel8_mc22_c;
2825  c->put_mspel_pixels_tab[7]= put_mspel8_mc32_c;
2826 
2827 #define SET_CMP_FUNC(name) \
2828  c->name[0]= name ## 16_c;\
2829  c->name[1]= name ## 8x8_c;
2830 
2831  SET_CMP_FUNC(hadamard8_diff)
2832  c->hadamard8_diff[4]= hadamard8_intra16_c;
2833  c->hadamard8_diff[5]= hadamard8_intra8x8_c;
2834  SET_CMP_FUNC(dct_sad)
2835  SET_CMP_FUNC(dct_max)
2836 #if CONFIG_GPL
2837  SET_CMP_FUNC(dct264_sad)
2838 #endif
2839  c->sad[0]= pix_abs16_c;
2840  c->sad[1]= pix_abs8_c;
2841  c->sse[0]= sse16_c;
2842  c->sse[1]= sse8_c;
2843  c->sse[2]= sse4_c;
2844  SET_CMP_FUNC(quant_psnr)
2845  SET_CMP_FUNC(rd)
2846  SET_CMP_FUNC(bit)
2847  c->vsad[0]= vsad16_c;
2848  c->vsad[4]= vsad_intra16_c;
2849  c->vsad[5]= vsad_intra8_c;
2850  c->vsse[0]= vsse16_c;
2851  c->vsse[4]= vsse_intra16_c;
2852  c->vsse[5]= vsse_intra8_c;
2853  c->nsse[0]= nsse16_c;
2854  c->nsse[1]= nsse8_c;
2855 #if CONFIG_SNOW_DECODER || CONFIG_SNOW_ENCODER
2856  ff_dsputil_init_dwt(c);
2857 #endif
2858 
2859  c->ssd_int8_vs_int16 = ssd_int8_vs_int16_c;
2860 
2861  c->add_bytes= add_bytes_c;
2862  c->diff_bytes= diff_bytes_c;
2863  c->add_hfyu_median_prediction= add_hfyu_median_prediction_c;
2864  c->sub_hfyu_median_prediction= sub_hfyu_median_prediction_c;
2865  c->add_hfyu_left_prediction = add_hfyu_left_prediction_c;
2866  c->add_hfyu_left_prediction_bgr32 = add_hfyu_left_prediction_bgr32_c;
2867  c->bswap_buf= bswap_buf;
2868  c->bswap16_buf = bswap16_buf;
2869 
2870  if (CONFIG_H263_DECODER || CONFIG_H263_ENCODER) {
2871  c->h263_h_loop_filter= h263_h_loop_filter_c;
2872  c->h263_v_loop_filter= h263_v_loop_filter_c;
2873  }
2874 
2875  c->try_8x8basis= try_8x8basis_c;
2876  c->add_8x8basis= add_8x8basis_c;
2877 
2878  c->vector_clipf = vector_clipf_c;
2879  c->scalarproduct_int16 = scalarproduct_int16_c;
2880  c->scalarproduct_and_madd_int16 = scalarproduct_and_madd_int16_c;
2881  c->apply_window_int16 = apply_window_int16_c;
2882  c->vector_clip_int32 = vector_clip_int32_c;
2883 
2884  c->shrink[0]= av_image_copy_plane;
2885  c->shrink[1]= ff_shrink22;
2886  c->shrink[2]= ff_shrink44;
2887  c->shrink[3]= ff_shrink88;
2888 
2889  c->add_pixels8 = add_pixels8_c;
2890 
2891 #undef FUNC
2892 #undef FUNCC
2893 #define FUNC(f, depth) f ## _ ## depth
2894 #define FUNCC(f, depth) f ## _ ## depth ## _c
2895 
2896  c->draw_edges = FUNCC(draw_edges, 8);
2897  c->clear_block = FUNCC(clear_block, 8);
2898  c->clear_blocks = FUNCC(clear_blocks, 8);
2899 
2900 #define BIT_DEPTH_FUNCS(depth) \
2901  c->get_pixels = FUNCC(get_pixels, depth);
2902 
2903  switch (avctx->bits_per_raw_sample) {
2904  case 9:
2905  case 10:
2906  case 12:
2907  case 14:
2908  BIT_DEPTH_FUNCS(16);
2909  break;
2910  default:
2911  if(avctx->bits_per_raw_sample<=8 || avctx->codec_type != AVMEDIA_TYPE_VIDEO) {
2912  BIT_DEPTH_FUNCS(8);
2913  }
2914  break;
2915  }
2916 
2917 
2918  if (HAVE_MMX) ff_dsputil_init_mmx (c, avctx);
2919  if (ARCH_ARM) ff_dsputil_init_arm (c, avctx);
2920  if (HAVE_VIS) ff_dsputil_init_vis (c, avctx);
2921  if (ARCH_ALPHA) ff_dsputil_init_alpha (c, avctx);
2922  if (ARCH_PPC) ff_dsputil_init_ppc (c, avctx);
2923  if (ARCH_SH4) ff_dsputil_init_sh4 (c, avctx);
2924  if (ARCH_BFIN) ff_dsputil_init_bfin (c, avctx);
2925 
2926  ff_init_scantable_permutation(c->idct_permutation,
2927  c->idct_permutation_type);
2928 }
2929 
2930 av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx)
2931 {
2932  ff_dsputil_init(c, avctx);
2933 }
2934 
2935 av_cold void avpriv_dsputil_init(DSPContext *c, AVCodecContext *avctx)
2936 {
2937  ff_dsputil_init(c, avctx);
2938 }
Generated on Wed Jul 10 2013 23:47:57 for FFmpeg by   doxygen 1.8.2