build: Generalize yasm/nasm-related variable names
[ffmpeg.git] / libavcodec / vc1dsp.c
1 /*
2  * VC-1 and WMV3 decoder - DSP functions
3  * Copyright (c) 2006 Konstantin Shishkov
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * VC-1 and WMV3 decoder
25  */
26
27 #include "libavutil/common.h"
28 #include "h264chroma.h"
29 #include "qpeldsp.h"
30 #include "vc1dsp.h"
31 #include "startcode.h"
32
33 /* Apply overlap transform to horizontal edge */
34 static void vc1_v_overlap_c(uint8_t *src, int stride)
35 {
36     int i;
37     int a, b, c, d;
38     int d1, d2;
39     int rnd = 1;
40     for (i = 0; i < 8; i++) {
41         a  = src[-2 * stride];
42         b  = src[-stride];
43         c  = src[0];
44         d  = src[stride];
45         d1 = (a - d + 3 + rnd) >> 3;
46         d2 = (a - d + b - c + 4 - rnd) >> 3;
47
48         src[-2 * stride] = a - d1;
49         src[-stride]     = av_clip_uint8(b - d2);
50         src[0]           = av_clip_uint8(c + d2);
51         src[stride]      = d + d1;
52         src++;
53         rnd = !rnd;
54     }
55 }
56
57 /* Apply overlap transform to vertical edge */
58 static void vc1_h_overlap_c(uint8_t *src, int stride)
59 {
60     int i;
61     int a, b, c, d;
62     int d1, d2;
63     int rnd = 1;
64     for (i = 0; i < 8; i++) {
65         a  = src[-2];
66         b  = src[-1];
67         c  = src[0];
68         d  = src[1];
69         d1 = (a - d + 3 + rnd) >> 3;
70         d2 = (a - d + b - c + 4 - rnd) >> 3;
71
72         src[-2] = a - d1;
73         src[-1] = av_clip_uint8(b - d2);
74         src[0]  = av_clip_uint8(c + d2);
75         src[1]  = d + d1;
76         src    += stride;
77         rnd     = !rnd;
78     }
79 }
80
81 static void vc1_v_s_overlap_c(int16_t *top, int16_t *bottom)
82 {
83     int i;
84     int a, b, c, d;
85     int d1, d2;
86     int rnd1 = 4, rnd2 = 3;
87     for (i = 0; i < 8; i++) {
88         a  = top[48];
89         b  = top[56];
90         c  = bottom[0];
91         d  = bottom[8];
92         d1 = a - d;
93         d2 = a - d + b - c;
94
95         top[48]   = ((a << 3) - d1 + rnd1) >> 3;
96         top[56]   = ((b << 3) - d2 + rnd2) >> 3;
97         bottom[0] = ((c << 3) + d2 + rnd1) >> 3;
98         bottom[8] = ((d << 3) + d1 + rnd2) >> 3;
99
100         bottom++;
101         top++;
102         rnd2 = 7 - rnd2;
103         rnd1 = 7 - rnd1;
104     }
105 }
106
107 static void vc1_h_s_overlap_c(int16_t *left, int16_t *right)
108 {
109     int i;
110     int a, b, c, d;
111     int d1, d2;
112     int rnd1 = 4, rnd2 = 3;
113     for (i = 0; i < 8; i++) {
114         a  = left[6];
115         b  = left[7];
116         c  = right[0];
117         d  = right[1];
118         d1 = a - d;
119         d2 = a - d + b - c;
120
121         left[6]  = ((a << 3) - d1 + rnd1) >> 3;
122         left[7]  = ((b << 3) - d2 + rnd2) >> 3;
123         right[0] = ((c << 3) + d2 + rnd1) >> 3;
124         right[1] = ((d << 3) + d1 + rnd2) >> 3;
125
126         right += 8;
127         left  += 8;
128         rnd2   = 7 - rnd2;
129         rnd1   = 7 - rnd1;
130     }
131 }
132
133 /**
134  * VC-1 in-loop deblocking filter for one line
135  * @param src source block type
136  * @param stride block stride
137  * @param pq block quantizer
138  * @return whether other 3 pairs should be filtered or not
139  * @see 8.6
140  */
141 static av_always_inline int vc1_filter_line(uint8_t *src, int stride, int pq)
142 {
143     int a0 = (2 * (src[-2 * stride] - src[1 * stride]) -
144               5 * (src[-1 * stride] - src[0 * stride]) + 4) >> 3;
145     int a0_sign = a0 >> 31;        /* Store sign */
146
147     a0 = (a0 ^ a0_sign) - a0_sign; /* a0 = FFABS(a0); */
148     if (a0 < pq) {
149         int a1 = FFABS((2 * (src[-4 * stride] - src[-1 * stride]) -
150                         5 * (src[-3 * stride] - src[-2 * stride]) + 4) >> 3);
151         int a2 = FFABS((2 * (src[ 0 * stride] - src[ 3 * stride]) -
152                         5 * (src[ 1 * stride] - src[ 2 * stride]) + 4) >> 3);
153         if (a1 < a0 || a2 < a0) {
154             int clip      = src[-1 * stride] - src[0 * stride];
155             int clip_sign = clip >> 31;
156
157             clip = ((clip ^ clip_sign) - clip_sign) >> 1;
158             if (clip) {
159                 int a3     = FFMIN(a1, a2);
160                 int d      = 5 * (a3 - a0);
161                 int d_sign = (d >> 31);
162
163                 d       = ((d ^ d_sign) - d_sign) >> 3;
164                 d_sign ^= a0_sign;
165
166                 if (d_sign ^ clip_sign)
167                     d = 0;
168                 else {
169                     d = FFMIN(d, clip);
170                     d = (d ^ d_sign) - d_sign; /* Restore sign */
171                     src[-1 * stride] = av_clip_uint8(src[-1 * stride] - d);
172                     src[ 0 * stride] = av_clip_uint8(src[ 0 * stride] + d);
173                 }
174                 return 1;
175             }
176         }
177     }
178     return 0;
179 }
180
181 /**
182  * VC-1 in-loop deblocking filter
183  * @param src source block type
184  * @param step distance between horizontally adjacent elements
185  * @param stride distance between vertically adjacent elements
186  * @param len edge length to filter (4 or 8 pixels)
187  * @param pq block quantizer
188  * @see 8.6
189  */
190 static inline void vc1_loop_filter(uint8_t *src, int step, int stride,
191                                    int len, int pq)
192 {
193     int i;
194     int filt3;
195
196     for (i = 0; i < len; i += 4) {
197         filt3 = vc1_filter_line(src + 2 * step, stride, pq);
198         if (filt3) {
199             vc1_filter_line(src + 0 * step, stride, pq);
200             vc1_filter_line(src + 1 * step, stride, pq);
201             vc1_filter_line(src + 3 * step, stride, pq);
202         }
203         src += step * 4;
204     }
205 }
206
207 static void vc1_v_loop_filter4_c(uint8_t *src, int stride, int pq)
208 {
209     vc1_loop_filter(src, 1, stride, 4, pq);
210 }
211
212 static void vc1_h_loop_filter4_c(uint8_t *src, int stride, int pq)
213 {
214     vc1_loop_filter(src, stride, 1, 4, pq);
215 }
216
217 static void vc1_v_loop_filter8_c(uint8_t *src, int stride, int pq)
218 {
219     vc1_loop_filter(src, 1, stride, 8, pq);
220 }
221
222 static void vc1_h_loop_filter8_c(uint8_t *src, int stride, int pq)
223 {
224     vc1_loop_filter(src, stride, 1, 8, pq);
225 }
226
227 static void vc1_v_loop_filter16_c(uint8_t *src, int stride, int pq)
228 {
229     vc1_loop_filter(src, 1, stride, 16, pq);
230 }
231
232 static void vc1_h_loop_filter16_c(uint8_t *src, int stride, int pq)
233 {
234     vc1_loop_filter(src, stride, 1, 16, pq);
235 }
236
237 /* Do inverse transform on 8x8 block */
238 static void vc1_inv_trans_8x8_dc_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
239 {
240     int i;
241     int dc = block[0];
242
243     dc = (3 * dc +  1) >> 1;
244     dc = (3 * dc + 16) >> 5;
245
246     for (i = 0; i < 8; i++) {
247         dest[0] = av_clip_uint8(dest[0] + dc);
248         dest[1] = av_clip_uint8(dest[1] + dc);
249         dest[2] = av_clip_uint8(dest[2] + dc);
250         dest[3] = av_clip_uint8(dest[3] + dc);
251         dest[4] = av_clip_uint8(dest[4] + dc);
252         dest[5] = av_clip_uint8(dest[5] + dc);
253         dest[6] = av_clip_uint8(dest[6] + dc);
254         dest[7] = av_clip_uint8(dest[7] + dc);
255         dest += stride;
256     }
257 }
258
259 static void vc1_inv_trans_8x8_c(int16_t block[64])
260 {
261     int i;
262     register int t1, t2, t3, t4, t5, t6, t7, t8;
263     int16_t *src, *dst, temp[64];
264
265     src = block;
266     dst = temp;
267     for (i = 0; i < 8; i++) {
268         t1 = 12 * (src[ 0] + src[32]) + 4;
269         t2 = 12 * (src[ 0] - src[32]) + 4;
270         t3 = 16 * src[16] +  6 * src[48];
271         t4 =  6 * src[16] - 16 * src[48];
272
273         t5 = t1 + t3;
274         t6 = t2 + t4;
275         t7 = t2 - t4;
276         t8 = t1 - t3;
277
278         t1 = 16 * src[ 8] + 15 * src[24] +  9 * src[40] +  4 * src[56];
279         t2 = 15 * src[ 8] -  4 * src[24] - 16 * src[40] -  9 * src[56];
280         t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
281         t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
282
283         dst[0] = (t5 + t1) >> 3;
284         dst[1] = (t6 + t2) >> 3;
285         dst[2] = (t7 + t3) >> 3;
286         dst[3] = (t8 + t4) >> 3;
287         dst[4] = (t8 - t4) >> 3;
288         dst[5] = (t7 - t3) >> 3;
289         dst[6] = (t6 - t2) >> 3;
290         dst[7] = (t5 - t1) >> 3;
291
292         src += 1;
293         dst += 8;
294     }
295
296     src = temp;
297     dst = block;
298     for (i = 0; i < 8; i++) {
299         t1 = 12 * (src[ 0] + src[32]) + 64;
300         t2 = 12 * (src[ 0] - src[32]) + 64;
301         t3 = 16 * src[16] +  6 * src[48];
302         t4 =  6 * src[16] - 16 * src[48];
303
304         t5 = t1 + t3;
305         t6 = t2 + t4;
306         t7 = t2 - t4;
307         t8 = t1 - t3;
308
309         t1 = 16 * src[ 8] + 15 * src[24] +  9 * src[40] +  4 * src[56];
310         t2 = 15 * src[ 8] -  4 * src[24] - 16 * src[40] -  9 * src[56];
311         t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
312         t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
313
314         dst[ 0] = (t5 + t1) >> 7;
315         dst[ 8] = (t6 + t2) >> 7;
316         dst[16] = (t7 + t3) >> 7;
317         dst[24] = (t8 + t4) >> 7;
318         dst[32] = (t8 - t4 + 1) >> 7;
319         dst[40] = (t7 - t3 + 1) >> 7;
320         dst[48] = (t6 - t2 + 1) >> 7;
321         dst[56] = (t5 - t1 + 1) >> 7;
322
323         src++;
324         dst++;
325     }
326 }
327
328 /* Do inverse transform on 8x4 part of block */
329 static void vc1_inv_trans_8x4_dc_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
330 {
331     int i;
332     int dc = block[0];
333
334     dc =  (3 * dc +  1) >> 1;
335     dc = (17 * dc + 64) >> 7;
336
337     for (i = 0; i < 4; i++) {
338         dest[0] = av_clip_uint8(dest[0] + dc);
339         dest[1] = av_clip_uint8(dest[1] + dc);
340         dest[2] = av_clip_uint8(dest[2] + dc);
341         dest[3] = av_clip_uint8(dest[3] + dc);
342         dest[4] = av_clip_uint8(dest[4] + dc);
343         dest[5] = av_clip_uint8(dest[5] + dc);
344         dest[6] = av_clip_uint8(dest[6] + dc);
345         dest[7] = av_clip_uint8(dest[7] + dc);
346         dest += stride;
347     }
348 }
349
350 static void vc1_inv_trans_8x4_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
351 {
352     int i;
353     register int t1, t2, t3, t4, t5, t6, t7, t8;
354     int16_t *src, *dst;
355
356     src = block;
357     dst = block;
358
359     for (i = 0; i < 4; i++) {
360         t1 = 12 * (src[0] + src[4]) + 4;
361         t2 = 12 * (src[0] - src[4]) + 4;
362         t3 = 16 * src[2] +  6 * src[6];
363         t4 =  6 * src[2] - 16 * src[6];
364
365         t5 = t1 + t3;
366         t6 = t2 + t4;
367         t7 = t2 - t4;
368         t8 = t1 - t3;
369
370         t1 = 16 * src[1] + 15 * src[3] +  9 * src[5] +  4 * src[7];
371         t2 = 15 * src[1] -  4 * src[3] - 16 * src[5] -  9 * src[7];
372         t3 =  9 * src[1] - 16 * src[3] +  4 * src[5] + 15 * src[7];
373         t4 =  4 * src[1] -  9 * src[3] + 15 * src[5] - 16 * src[7];
374
375         dst[0] = (t5 + t1) >> 3;
376         dst[1] = (t6 + t2) >> 3;
377         dst[2] = (t7 + t3) >> 3;
378         dst[3] = (t8 + t4) >> 3;
379         dst[4] = (t8 - t4) >> 3;
380         dst[5] = (t7 - t3) >> 3;
381         dst[6] = (t6 - t2) >> 3;
382         dst[7] = (t5 - t1) >> 3;
383
384         src += 8;
385         dst += 8;
386     }
387
388     src = block;
389     for (i = 0; i < 8; i++) {
390         t1 = 17 * (src[ 0] + src[16]) + 64;
391         t2 = 17 * (src[ 0] - src[16]) + 64;
392         t3 = 22 * src[ 8] + 10 * src[24];
393         t4 = 22 * src[24] - 10 * src[ 8];
394
395         dest[0 * stride] = av_clip_uint8(dest[0 * stride] + ((t1 + t3) >> 7));
396         dest[1 * stride] = av_clip_uint8(dest[1 * stride] + ((t2 - t4) >> 7));
397         dest[2 * stride] = av_clip_uint8(dest[2 * stride] + ((t2 + t4) >> 7));
398         dest[3 * stride] = av_clip_uint8(dest[3 * stride] + ((t1 - t3) >> 7));
399
400         src++;
401         dest++;
402     }
403 }
404
405 /* Do inverse transform on 4x8 parts of block */
406 static void vc1_inv_trans_4x8_dc_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
407 {
408     int i;
409     int dc = block[0];
410
411     dc = (17 * dc +  4) >> 3;
412     dc = (12 * dc + 64) >> 7;
413
414     for (i = 0; i < 8; i++) {
415         dest[0] = av_clip_uint8(dest[0] + dc);
416         dest[1] = av_clip_uint8(dest[1] + dc);
417         dest[2] = av_clip_uint8(dest[2] + dc);
418         dest[3] = av_clip_uint8(dest[3] + dc);
419         dest += stride;
420     }
421 }
422
423 static void vc1_inv_trans_4x8_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
424 {
425     int i;
426     register int t1, t2, t3, t4, t5, t6, t7, t8;
427     int16_t *src, *dst;
428
429     src = block;
430     dst = block;
431
432     for (i = 0; i < 8; i++) {
433         t1 = 17 * (src[0] + src[2]) + 4;
434         t2 = 17 * (src[0] - src[2]) + 4;
435         t3 = 22 * src[1] + 10 * src[3];
436         t4 = 22 * src[3] - 10 * src[1];
437
438         dst[0] = (t1 + t3) >> 3;
439         dst[1] = (t2 - t4) >> 3;
440         dst[2] = (t2 + t4) >> 3;
441         dst[3] = (t1 - t3) >> 3;
442
443         src += 8;
444         dst += 8;
445     }
446
447     src = block;
448     for (i = 0; i < 4; i++) {
449         t1 = 12 * (src[ 0] + src[32]) + 64;
450         t2 = 12 * (src[ 0] - src[32]) + 64;
451         t3 = 16 * src[16] +  6 * src[48];
452         t4 =  6 * src[16] - 16 * src[48];
453
454         t5 = t1 + t3;
455         t6 = t2 + t4;
456         t7 = t2 - t4;
457         t8 = t1 - t3;
458
459         t1 = 16 * src[ 8] + 15 * src[24] +  9 * src[40] +  4 * src[56];
460         t2 = 15 * src[ 8] -  4 * src[24] - 16 * src[40] -  9 * src[56];
461         t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
462         t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
463
464         dest[0 * stride] = av_clip_uint8(dest[0 * stride] + ((t5 + t1)     >> 7));
465         dest[1 * stride] = av_clip_uint8(dest[1 * stride] + ((t6 + t2)     >> 7));
466         dest[2 * stride] = av_clip_uint8(dest[2 * stride] + ((t7 + t3)     >> 7));
467         dest[3 * stride] = av_clip_uint8(dest[3 * stride] + ((t8 + t4)     >> 7));
468         dest[4 * stride] = av_clip_uint8(dest[4 * stride] + ((t8 - t4 + 1) >> 7));
469         dest[5 * stride] = av_clip_uint8(dest[5 * stride] + ((t7 - t3 + 1) >> 7));
470         dest[6 * stride] = av_clip_uint8(dest[6 * stride] + ((t6 - t2 + 1) >> 7));
471         dest[7 * stride] = av_clip_uint8(dest[7 * stride] + ((t5 - t1 + 1) >> 7));
472
473         src++;
474         dest++;
475     }
476 }
477
478 /* Do inverse transform on 4x4 part of block */
479 static void vc1_inv_trans_4x4_dc_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
480 {
481     int i;
482     int dc = block[0];
483
484     dc = (17 * dc +  4) >> 3;
485     dc = (17 * dc + 64) >> 7;
486
487     for (i = 0; i < 4; i++) {
488         dest[0] = av_clip_uint8(dest[0] + dc);
489         dest[1] = av_clip_uint8(dest[1] + dc);
490         dest[2] = av_clip_uint8(dest[2] + dc);
491         dest[3] = av_clip_uint8(dest[3] + dc);
492         dest += stride;
493     }
494 }
495
496 static void vc1_inv_trans_4x4_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
497 {
498     int i;
499     register int t1, t2, t3, t4;
500     int16_t *src, *dst;
501
502     src = block;
503     dst = block;
504     for (i = 0; i < 4; i++) {
505         t1 = 17 * (src[0] + src[2]) + 4;
506         t2 = 17 * (src[0] - src[2]) + 4;
507         t3 = 22 * src[1] + 10 * src[3];
508         t4 = 22 * src[3] - 10 * src[1];
509
510         dst[0] = (t1 + t3) >> 3;
511         dst[1] = (t2 - t4) >> 3;
512         dst[2] = (t2 + t4) >> 3;
513         dst[3] = (t1 - t3) >> 3;
514
515         src += 8;
516         dst += 8;
517     }
518
519     src = block;
520     for (i = 0; i < 4; i++) {
521         t1 = 17 * (src[0] + src[16]) + 64;
522         t2 = 17 * (src[0] - src[16]) + 64;
523         t3 = 22 * src[8] + 10 * src[24];
524         t4 = 22 * src[24] - 10 * src[8];
525
526         dest[0 * stride] = av_clip_uint8(dest[0 * stride] + ((t1 + t3) >> 7));
527         dest[1 * stride] = av_clip_uint8(dest[1 * stride] + ((t2 - t4) >> 7));
528         dest[2 * stride] = av_clip_uint8(dest[2 * stride] + ((t2 + t4) >> 7));
529         dest[3 * stride] = av_clip_uint8(dest[3 * stride] + ((t1 - t3) >> 7));
530
531         src++;
532         dest++;
533     }
534 }
535
536 /* motion compensation functions */
537
538 /* Filter in case of 2 filters */
539 #define VC1_MSPEL_FILTER_16B(DIR, TYPE)                                       \
540 static av_always_inline int vc1_mspel_ ## DIR ## _filter_16bits(const TYPE *src, \
541                                                                 int stride,   \
542                                                                 int mode)     \
543 {                                                                             \
544     switch(mode) {                                                            \
545     case 0: /* no shift - should not occur */                                 \
546         return 0;                                                             \
547     case 1: /* 1/4 shift */                                                   \
548         return -4 * src[-stride] + 53 * src[0] +                              \
549                18 * src[stride]  -  3 * src[stride * 2];                      \
550     case 2: /* 1/2 shift */                                                   \
551         return -1 * src[-stride] +  9 * src[0] +                              \
552                 9 * src[stride]  -  1 * src[stride * 2];                      \
553     case 3: /* 3/4 shift */                                                   \
554         return -3 * src[-stride] + 18 * src[0] +                              \
555                53 * src[stride]  -  4 * src[stride * 2];                      \
556     }                                                                         \
557     return 0; /* should not occur */                                          \
558 }
559
560 VC1_MSPEL_FILTER_16B(ver, uint8_t)
561 VC1_MSPEL_FILTER_16B(hor, int16_t)
562
563 /* Filter used to interpolate fractional pel values */
564 static av_always_inline int vc1_mspel_filter(const uint8_t *src, int stride,
565                                              int mode, int r)
566 {
567     switch (mode) {
568     case 0: // no shift
569         return src[0];
570     case 1: // 1/4 shift
571         return (-4 * src[-stride] + 53 * src[0] +
572                 18 * src[stride]  -  3 * src[stride * 2] + 32 - r) >> 6;
573     case 2: // 1/2 shift
574         return (-1 * src[-stride] +  9 * src[0] +
575                  9 * src[stride]  -  1 * src[stride * 2] + 8 - r) >> 4;
576     case 3: // 3/4 shift
577         return (-3 * src[-stride] + 18 * src[0] +
578                 53 * src[stride]  -  4 * src[stride * 2] + 32 - r) >> 6;
579     }
580     return 0; // should not occur
581 }
582
583 /* Function used to do motion compensation with bicubic interpolation */
584 #define VC1_MSPEL_MC(OP, OPNAME)                                              \
585 static av_always_inline void OPNAME ## vc1_mspel_mc(uint8_t *dst,             \
586                                                     const uint8_t *src,       \
587                                                     int stride,               \
588                                                     int hmode,                \
589                                                     int vmode,                \
590                                                     int rnd)                  \
591 {                                                                             \
592     int i, j;                                                                 \
593                                                                               \
594     if (vmode) { /* Horizontal filter to apply */                             \
595         int r;                                                                \
596                                                                               \
597         if (hmode) { /* Vertical filter to apply, output to tmp */            \
598             static const int shift_value[] = { 0, 5, 1, 5 };                  \
599             int shift = (shift_value[hmode] + shift_value[vmode]) >> 1;       \
600             int16_t tmp[11 * 8], *tptr = tmp;                                 \
601                                                                               \
602             r = (1 << (shift - 1)) + rnd - 1;                                 \
603                                                                               \
604             src -= 1;                                                         \
605             for (j = 0; j < 8; j++) {                                         \
606                 for (i = 0; i < 11; i++)                                      \
607                     tptr[i] = (vc1_mspel_ver_filter_16bits(src + i, stride, vmode) + r) >> shift; \
608                 src  += stride;                                               \
609                 tptr += 11;                                                   \
610             }                                                                 \
611                                                                               \
612             r    = 64 - rnd;                                                  \
613             tptr = tmp + 1;                                                   \
614             for (j = 0; j < 8; j++) {                                         \
615                 for (i = 0; i < 8; i++)                                       \
616                     OP(dst[i], (vc1_mspel_hor_filter_16bits(tptr + i, 1, hmode) + r) >> 7); \
617                 dst  += stride;                                               \
618                 tptr += 11;                                                   \
619             }                                                                 \
620                                                                               \
621             return;                                                           \
622         } else { /* No horizontal filter, output 8 lines to dst */            \
623             r = 1 - rnd;                                                      \
624                                                                               \
625             for (j = 0; j < 8; j++) {                                         \
626                 for (i = 0; i < 8; i++)                                       \
627                     OP(dst[i], vc1_mspel_filter(src + i, stride, vmode, r));  \
628                 src += stride;                                                \
629                 dst += stride;                                                \
630             }                                                                 \
631             return;                                                           \
632         }                                                                     \
633     }                                                                         \
634                                                                               \
635     /* Horizontal mode with no vertical mode */                               \
636     for (j = 0; j < 8; j++) {                                                 \
637         for (i = 0; i < 8; i++)                                               \
638             OP(dst[i], vc1_mspel_filter(src + i, 1, hmode, rnd));             \
639         dst += stride;                                                        \
640         src += stride;                                                        \
641     }                                                                         \
642 }
643
644 #define op_put(a, b) a = av_clip_uint8(b)
645 #define op_avg(a, b) a = (a + av_clip_uint8(b) + 1) >> 1
646
647 VC1_MSPEL_MC(op_put, put_)
648 VC1_MSPEL_MC(op_avg, avg_)
649
650 /* pixel functions - really are entry points to vc1_mspel_mc */
651
652 #define PUT_VC1_MSPEL(a, b)                                                   \
653 static void put_vc1_mspel_mc ## a ## b ## _c(uint8_t *dst,                    \
654                                              const uint8_t *src,              \
655                                              ptrdiff_t stride, int rnd)       \
656 {                                                                             \
657     put_vc1_mspel_mc(dst, src, stride, a, b, rnd);                            \
658 }                                                                             \
659 static void avg_vc1_mspel_mc ## a ## b ## _c(uint8_t *dst,                    \
660                                              const uint8_t *src,              \
661                                              ptrdiff_t stride, int rnd)       \
662 {                                                                             \
663     avg_vc1_mspel_mc(dst, src, stride, a, b, rnd);                            \
664 }
665
666 PUT_VC1_MSPEL(1, 0)
667 PUT_VC1_MSPEL(2, 0)
668 PUT_VC1_MSPEL(3, 0)
669
670 PUT_VC1_MSPEL(0, 1)
671 PUT_VC1_MSPEL(1, 1)
672 PUT_VC1_MSPEL(2, 1)
673 PUT_VC1_MSPEL(3, 1)
674
675 PUT_VC1_MSPEL(0, 2)
676 PUT_VC1_MSPEL(1, 2)
677 PUT_VC1_MSPEL(2, 2)
678 PUT_VC1_MSPEL(3, 2)
679
680 PUT_VC1_MSPEL(0, 3)
681 PUT_VC1_MSPEL(1, 3)
682 PUT_VC1_MSPEL(2, 3)
683 PUT_VC1_MSPEL(3, 3)
684
685
686 static void put_vc1_mspel_mc00_c(uint8_t *dst, const uint8_t *src,
687                                  ptrdiff_t stride, int rnd)
688 {
689     ff_put_pixels8x8_c(dst, src, stride);
690 }
691
692 static void avg_vc1_mspel_mc00_c(uint8_t *dst, const uint8_t *src,
693                                  ptrdiff_t stride, int rnd)
694 {
695     ff_avg_pixels8x8_c(dst, src, stride);
696 }
697
698 #define chroma_mc(a) \
699     ((A * src[a] + B * src[a + 1] + \
700       C * src[stride + a] + D * src[stride + a + 1] + 32 - 4) >> 6)
701 static void put_no_rnd_vc1_chroma_mc8_c(uint8_t *dst /* align 8 */,
702                                         uint8_t *src /* align 1 */,
703                                         ptrdiff_t stride, int h, int x, int y)
704 {
705     const int A = (8 - x) * (8 - y);
706     const int B =     (x) * (8 - y);
707     const int C = (8 - x) *     (y);
708     const int D =     (x) *     (y);
709     int i;
710
711     assert(x < 8 && y < 8 && x >= 0 && y >= 0);
712
713     for (i = 0; i < h; i++) {
714         dst[0] = chroma_mc(0);
715         dst[1] = chroma_mc(1);
716         dst[2] = chroma_mc(2);
717         dst[3] = chroma_mc(3);
718         dst[4] = chroma_mc(4);
719         dst[5] = chroma_mc(5);
720         dst[6] = chroma_mc(6);
721         dst[7] = chroma_mc(7);
722         dst += stride;
723         src += stride;
724     }
725 }
726
727 static void put_no_rnd_vc1_chroma_mc4_c(uint8_t *dst, uint8_t *src,
728                                         ptrdiff_t stride, int h, int x, int y)
729 {
730     const int A = (8 - x) * (8 - y);
731     const int B =     (x) * (8 - y);
732     const int C = (8 - x) *     (y);
733     const int D =     (x) *     (y);
734     int i;
735
736     assert(x < 8 && y < 8 && x >= 0 && y >= 0);
737
738     for (i = 0; i < h; i++) {
739         dst[0] = chroma_mc(0);
740         dst[1] = chroma_mc(1);
741         dst[2] = chroma_mc(2);
742         dst[3] = chroma_mc(3);
743         dst += stride;
744         src += stride;
745     }
746 }
747
748 #define avg2(a, b) (((a) + (b) + 1) >> 1)
749 static void avg_no_rnd_vc1_chroma_mc8_c(uint8_t *dst /* align 8 */,
750                                         uint8_t *src /* align 1 */,
751                                         ptrdiff_t stride, int h, int x, int y)
752 {
753     const int A = (8 - x) * (8 - y);
754     const int B =     (x) * (8 - y);
755     const int C = (8 - x) *     (y);
756     const int D =     (x) *     (y);
757     int i;
758
759     assert(x < 8 && y < 8 && x >= 0 && y >= 0);
760
761     for (i = 0; i < h; i++) {
762         dst[0] = avg2(dst[0], chroma_mc(0));
763         dst[1] = avg2(dst[1], chroma_mc(1));
764         dst[2] = avg2(dst[2], chroma_mc(2));
765         dst[3] = avg2(dst[3], chroma_mc(3));
766         dst[4] = avg2(dst[4], chroma_mc(4));
767         dst[5] = avg2(dst[5], chroma_mc(5));
768         dst[6] = avg2(dst[6], chroma_mc(6));
769         dst[7] = avg2(dst[7], chroma_mc(7));
770         dst += stride;
771         src += stride;
772     }
773 }
774
775 static void avg_no_rnd_vc1_chroma_mc4_c(uint8_t *dst /* align 8 */,
776                                         uint8_t *src /* align 1 */,
777                                         ptrdiff_t stride, int h, int x, int y)
778 {
779     const int A = (8 - x) * (8 - y);
780     const int B = (    x) * (8 - y);
781     const int C = (8 - x) * (    y);
782     const int D = (    x) * (    y);
783     int i;
784
785     assert(x < 8 && y < 8 && x >= 0 && y >= 0);
786
787     for (i = 0; i < h; i++) {
788         dst[0] = avg2(dst[0], chroma_mc(0));
789         dst[1] = avg2(dst[1], chroma_mc(1));
790         dst[2] = avg2(dst[2], chroma_mc(2));
791         dst[3] = avg2(dst[3], chroma_mc(3));
792         dst += stride;
793         src += stride;
794     }
795 }
796
797 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
798
799 static void sprite_h_c(uint8_t *dst, const uint8_t *src, int offset,
800                        int advance, int count)
801 {
802     while (count--) {
803         int a = src[(offset >> 16)];
804         int b = src[(offset >> 16) + 1];
805         *dst++  = a + ((b - a) * (offset & 0xFFFF) >> 16);
806         offset += advance;
807     }
808 }
809
810 static av_always_inline void sprite_v_template(uint8_t *dst,
811                                                const uint8_t *src1a,
812                                                const uint8_t *src1b,
813                                                int offset1,
814                                                int two_sprites,
815                                                const uint8_t *src2a,
816                                                const uint8_t *src2b,
817                                                int offset2,
818                                                int alpha, int scaled,
819                                                int width)
820 {
821     int a1, b1, a2, b2;
822     while (width--) {
823         a1 = *src1a++;
824         if (scaled) {
825             b1 = *src1b++;
826             a1 = a1 + ((b1 - a1) * offset1 >> 16);
827         }
828         if (two_sprites) {
829             a2 = *src2a++;
830             if (scaled > 1) {
831                 b2 = *src2b++;
832                 a2 = a2 + ((b2 - a2) * offset2 >> 16);
833             }
834             a1 = a1 + ((a2 - a1) * alpha >> 16);
835         }
836         *dst++ = a1;
837     }
838 }
839
840 static void sprite_v_single_c(uint8_t *dst, const uint8_t *src1a,
841                               const uint8_t *src1b,
842                               int offset, int width)
843 {
844     sprite_v_template(dst, src1a, src1b, offset, 0, NULL, NULL, 0, 0, 1, width);
845 }
846
847 static void sprite_v_double_noscale_c(uint8_t *dst, const uint8_t *src1a,
848                                       const uint8_t *src2a,
849                                       int alpha, int width)
850 {
851     sprite_v_template(dst, src1a, NULL, 0, 1, src2a, NULL, 0, alpha, 0, width);
852 }
853
854 static void sprite_v_double_onescale_c(uint8_t *dst,
855                                        const uint8_t *src1a,
856                                        const uint8_t *src1b,
857                                        int offset1,
858                                        const uint8_t *src2a,
859                                        int alpha, int width)
860 {
861     sprite_v_template(dst, src1a, src1b, offset1, 1, src2a, NULL, 0, alpha, 1,
862                       width);
863 }
864
865 static void sprite_v_double_twoscale_c(uint8_t *dst,
866                                        const uint8_t *src1a,
867                                        const uint8_t *src1b,
868                                        int offset1,
869                                        const uint8_t *src2a,
870                                        const uint8_t *src2b,
871                                        int offset2,
872                                        int alpha,
873                                        int width)
874 {
875     sprite_v_template(dst, src1a, src1b, offset1, 1, src2a, src2b, offset2,
876                       alpha, 2, width);
877 }
878
879 #endif /* CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER */
880
881 av_cold void ff_vc1dsp_init(VC1DSPContext *dsp)
882 {
883     dsp->vc1_inv_trans_8x8    = vc1_inv_trans_8x8_c;
884     dsp->vc1_inv_trans_4x8    = vc1_inv_trans_4x8_c;
885     dsp->vc1_inv_trans_8x4    = vc1_inv_trans_8x4_c;
886     dsp->vc1_inv_trans_4x4    = vc1_inv_trans_4x4_c;
887     dsp->vc1_inv_trans_8x8_dc = vc1_inv_trans_8x8_dc_c;
888     dsp->vc1_inv_trans_4x8_dc = vc1_inv_trans_4x8_dc_c;
889     dsp->vc1_inv_trans_8x4_dc = vc1_inv_trans_8x4_dc_c;
890     dsp->vc1_inv_trans_4x4_dc = vc1_inv_trans_4x4_dc_c;
891
892     dsp->vc1_h_overlap        = vc1_h_overlap_c;
893     dsp->vc1_v_overlap        = vc1_v_overlap_c;
894     dsp->vc1_h_s_overlap      = vc1_h_s_overlap_c;
895     dsp->vc1_v_s_overlap      = vc1_v_s_overlap_c;
896
897     dsp->vc1_v_loop_filter4   = vc1_v_loop_filter4_c;
898     dsp->vc1_h_loop_filter4   = vc1_h_loop_filter4_c;
899     dsp->vc1_v_loop_filter8   = vc1_v_loop_filter8_c;
900     dsp->vc1_h_loop_filter8   = vc1_h_loop_filter8_c;
901     dsp->vc1_v_loop_filter16  = vc1_v_loop_filter16_c;
902     dsp->vc1_h_loop_filter16  = vc1_h_loop_filter16_c;
903
904     dsp->put_vc1_mspel_pixels_tab[0]  = put_vc1_mspel_mc00_c;
905     dsp->put_vc1_mspel_pixels_tab[1]  = put_vc1_mspel_mc10_c;
906     dsp->put_vc1_mspel_pixels_tab[2]  = put_vc1_mspel_mc20_c;
907     dsp->put_vc1_mspel_pixels_tab[3]  = put_vc1_mspel_mc30_c;
908     dsp->put_vc1_mspel_pixels_tab[4]  = put_vc1_mspel_mc01_c;
909     dsp->put_vc1_mspel_pixels_tab[5]  = put_vc1_mspel_mc11_c;
910     dsp->put_vc1_mspel_pixels_tab[6]  = put_vc1_mspel_mc21_c;
911     dsp->put_vc1_mspel_pixels_tab[7]  = put_vc1_mspel_mc31_c;
912     dsp->put_vc1_mspel_pixels_tab[8]  = put_vc1_mspel_mc02_c;
913     dsp->put_vc1_mspel_pixels_tab[9]  = put_vc1_mspel_mc12_c;
914     dsp->put_vc1_mspel_pixels_tab[10] = put_vc1_mspel_mc22_c;
915     dsp->put_vc1_mspel_pixels_tab[11] = put_vc1_mspel_mc32_c;
916     dsp->put_vc1_mspel_pixels_tab[12] = put_vc1_mspel_mc03_c;
917     dsp->put_vc1_mspel_pixels_tab[13] = put_vc1_mspel_mc13_c;
918     dsp->put_vc1_mspel_pixels_tab[14] = put_vc1_mspel_mc23_c;
919     dsp->put_vc1_mspel_pixels_tab[15] = put_vc1_mspel_mc33_c;
920
921     dsp->avg_vc1_mspel_pixels_tab[0]  = avg_vc1_mspel_mc00_c;
922     dsp->avg_vc1_mspel_pixels_tab[1]  = avg_vc1_mspel_mc10_c;
923     dsp->avg_vc1_mspel_pixels_tab[2]  = avg_vc1_mspel_mc20_c;
924     dsp->avg_vc1_mspel_pixels_tab[3]  = avg_vc1_mspel_mc30_c;
925     dsp->avg_vc1_mspel_pixels_tab[4]  = avg_vc1_mspel_mc01_c;
926     dsp->avg_vc1_mspel_pixels_tab[5]  = avg_vc1_mspel_mc11_c;
927     dsp->avg_vc1_mspel_pixels_tab[6]  = avg_vc1_mspel_mc21_c;
928     dsp->avg_vc1_mspel_pixels_tab[7]  = avg_vc1_mspel_mc31_c;
929     dsp->avg_vc1_mspel_pixels_tab[8]  = avg_vc1_mspel_mc02_c;
930     dsp->avg_vc1_mspel_pixels_tab[9]  = avg_vc1_mspel_mc12_c;
931     dsp->avg_vc1_mspel_pixels_tab[10] = avg_vc1_mspel_mc22_c;
932     dsp->avg_vc1_mspel_pixels_tab[11] = avg_vc1_mspel_mc32_c;
933     dsp->avg_vc1_mspel_pixels_tab[12] = avg_vc1_mspel_mc03_c;
934     dsp->avg_vc1_mspel_pixels_tab[13] = avg_vc1_mspel_mc13_c;
935     dsp->avg_vc1_mspel_pixels_tab[14] = avg_vc1_mspel_mc23_c;
936     dsp->avg_vc1_mspel_pixels_tab[15] = avg_vc1_mspel_mc33_c;
937
938     dsp->put_no_rnd_vc1_chroma_pixels_tab[0] = put_no_rnd_vc1_chroma_mc8_c;
939     dsp->avg_no_rnd_vc1_chroma_pixels_tab[0] = avg_no_rnd_vc1_chroma_mc8_c;
940     dsp->put_no_rnd_vc1_chroma_pixels_tab[1] = put_no_rnd_vc1_chroma_mc4_c;
941     dsp->avg_no_rnd_vc1_chroma_pixels_tab[1] = avg_no_rnd_vc1_chroma_mc4_c;
942
943 #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
944     dsp->sprite_h                 = sprite_h_c;
945     dsp->sprite_v_single          = sprite_v_single_c;
946     dsp->sprite_v_double_noscale  = sprite_v_double_noscale_c;
947     dsp->sprite_v_double_onescale = sprite_v_double_onescale_c;
948     dsp->sprite_v_double_twoscale = sprite_v_double_twoscale_c;
949 #endif /* CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER */
950
951     dsp->startcode_find_candidate = ff_startcode_find_candidate_c;
952
953     if (ARCH_AARCH64)
954         ff_vc1dsp_init_aarch64(dsp);
955     if (ARCH_ARM)
956         ff_vc1dsp_init_arm(dsp);
957     if (ARCH_PPC)
958         ff_vc1dsp_init_ppc(dsp);
959     if (ARCH_X86)
960         ff_vc1dsp_init_x86(dsp);
961 }