2 * VP9 compatible video decoder
4 * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
5 * Copyright (C) 2013 Clément Bœsch <u pkh me>
7 * This file is part of Libav.
9 * Libav is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * Libav is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with Libav; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #include "libavutil/common.h"
25 #include "libavutil/intreadwrite.h"
30 // FIXME see whether we can merge parts of this (perhaps at least 4x4 and 8x8)
31 // back with h264pred.[ch]
33 static void vert_4x4_c(uint8_t *dst, ptrdiff_t stride,
34 const uint8_t *left, const uint8_t *top)
36 unsigned p4 = AV_RN32A(top);
38 AV_WN32A(dst + stride * 0, p4);
39 AV_WN32A(dst + stride * 1, p4);
40 AV_WN32A(dst + stride * 2, p4);
41 AV_WN32A(dst + stride * 3, p4);
44 static void vert_8x8_c(uint8_t *dst, ptrdiff_t stride,
45 const uint8_t *left, const uint8_t *top)
47 uint64_t p8 = AV_RN64A(top);
50 for (y = 0; y < 8; y++) {
56 static void vert_16x16_c(uint8_t *dst, ptrdiff_t stride,
57 const uint8_t *left, const uint8_t *top)
59 uint64_t p8a = AV_RN64A(top + 0), p8b = AV_RN64A(top + 8);
62 for (y = 0; y < 16; y++) {
63 AV_WN64A(dst + 0, p8a);
64 AV_WN64A(dst + 8, p8b);
69 static void vert_32x32_c(uint8_t *dst, ptrdiff_t stride,
70 const uint8_t *left, const uint8_t *top)
72 uint64_t p8a = AV_RN64A(top + 0), p8b = AV_RN64A(top + 8),
73 p8c = AV_RN64A(top + 16), p8d = AV_RN64A(top + 24);
76 for (y = 0; y < 32; y++) {
77 AV_WN64A(dst + 0, p8a);
78 AV_WN64A(dst + 8, p8b);
79 AV_WN64A(dst + 16, p8c);
80 AV_WN64A(dst + 24, p8d);
85 static void hor_4x4_c(uint8_t *dst, ptrdiff_t stride,
86 const uint8_t *left, const uint8_t *top)
88 AV_WN32A(dst + stride * 0, left[0] * 0x01010101U);
89 AV_WN32A(dst + stride * 1, left[1] * 0x01010101U);
90 AV_WN32A(dst + stride * 2, left[2] * 0x01010101U);
91 AV_WN32A(dst + stride * 3, left[3] * 0x01010101U);
94 static void hor_8x8_c(uint8_t *dst, ptrdiff_t stride,
95 const uint8_t *left, const uint8_t *top)
99 for (y = 0; y < 8; y++) {
100 AV_WN64A(dst, left[y] * 0x0101010101010101ULL);
105 static void hor_16x16_c(uint8_t *dst, ptrdiff_t stride,
106 const uint8_t *left, const uint8_t *top)
110 for (y = 0; y < 16; y++) {
111 uint64_t p8 = left[y] * 0x0101010101010101ULL;
113 AV_WN64A(dst + 0, p8);
114 AV_WN64A(dst + 8, p8);
119 static void hor_32x32_c(uint8_t *dst, ptrdiff_t stride,
120 const uint8_t *left, const uint8_t *top)
124 for (y = 0; y < 32; y++) {
125 uint64_t p8 = left[y] * 0x0101010101010101ULL;
127 AV_WN64A(dst + 0, p8);
128 AV_WN64A(dst + 8, p8);
129 AV_WN64A(dst + 16, p8);
130 AV_WN64A(dst + 24, p8);
135 static void tm_4x4_c(uint8_t *dst, ptrdiff_t stride,
136 const uint8_t *left, const uint8_t *top)
140 for (y = 0; y < 4; y++) {
141 int l_m_tl = left[y] - tl;
143 dst[0] = av_clip_uint8(top[0] + l_m_tl);
144 dst[1] = av_clip_uint8(top[1] + l_m_tl);
145 dst[2] = av_clip_uint8(top[2] + l_m_tl);
146 dst[3] = av_clip_uint8(top[3] + l_m_tl);
151 static void tm_8x8_c(uint8_t *dst, ptrdiff_t stride,
152 const uint8_t *left, const uint8_t *top)
156 for (y = 0; y < 8; y++) {
157 int l_m_tl = left[y] - tl;
159 dst[0] = av_clip_uint8(top[0] + l_m_tl);
160 dst[1] = av_clip_uint8(top[1] + l_m_tl);
161 dst[2] = av_clip_uint8(top[2] + l_m_tl);
162 dst[3] = av_clip_uint8(top[3] + l_m_tl);
163 dst[4] = av_clip_uint8(top[4] + l_m_tl);
164 dst[5] = av_clip_uint8(top[5] + l_m_tl);
165 dst[6] = av_clip_uint8(top[6] + l_m_tl);
166 dst[7] = av_clip_uint8(top[7] + l_m_tl);
171 static void tm_16x16_c(uint8_t *dst, ptrdiff_t stride,
172 const uint8_t *left, const uint8_t *top)
176 for (y = 0; y < 16; y++) {
177 int l_m_tl = left[y] - tl;
179 dst[0] = av_clip_uint8(top[0] + l_m_tl);
180 dst[1] = av_clip_uint8(top[1] + l_m_tl);
181 dst[2] = av_clip_uint8(top[2] + l_m_tl);
182 dst[3] = av_clip_uint8(top[3] + l_m_tl);
183 dst[4] = av_clip_uint8(top[4] + l_m_tl);
184 dst[5] = av_clip_uint8(top[5] + l_m_tl);
185 dst[6] = av_clip_uint8(top[6] + l_m_tl);
186 dst[7] = av_clip_uint8(top[7] + l_m_tl);
187 dst[8] = av_clip_uint8(top[8] + l_m_tl);
188 dst[9] = av_clip_uint8(top[9] + l_m_tl);
189 dst[10] = av_clip_uint8(top[10] + l_m_tl);
190 dst[11] = av_clip_uint8(top[11] + l_m_tl);
191 dst[12] = av_clip_uint8(top[12] + l_m_tl);
192 dst[13] = av_clip_uint8(top[13] + l_m_tl);
193 dst[14] = av_clip_uint8(top[14] + l_m_tl);
194 dst[15] = av_clip_uint8(top[15] + l_m_tl);
199 static void tm_32x32_c(uint8_t *dst, ptrdiff_t stride,
200 const uint8_t *left, const uint8_t *top)
204 for (y = 0; y < 32; y++) {
205 int l_m_tl = left[y] - tl;
207 dst[0] = av_clip_uint8(top[0] + l_m_tl);
208 dst[1] = av_clip_uint8(top[1] + l_m_tl);
209 dst[2] = av_clip_uint8(top[2] + l_m_tl);
210 dst[3] = av_clip_uint8(top[3] + l_m_tl);
211 dst[4] = av_clip_uint8(top[4] + l_m_tl);
212 dst[5] = av_clip_uint8(top[5] + l_m_tl);
213 dst[6] = av_clip_uint8(top[6] + l_m_tl);
214 dst[7] = av_clip_uint8(top[7] + l_m_tl);
215 dst[8] = av_clip_uint8(top[8] + l_m_tl);
216 dst[9] = av_clip_uint8(top[9] + l_m_tl);
217 dst[10] = av_clip_uint8(top[10] + l_m_tl);
218 dst[11] = av_clip_uint8(top[11] + l_m_tl);
219 dst[12] = av_clip_uint8(top[12] + l_m_tl);
220 dst[13] = av_clip_uint8(top[13] + l_m_tl);
221 dst[14] = av_clip_uint8(top[14] + l_m_tl);
222 dst[15] = av_clip_uint8(top[15] + l_m_tl);
223 dst[16] = av_clip_uint8(top[16] + l_m_tl);
224 dst[17] = av_clip_uint8(top[17] + l_m_tl);
225 dst[18] = av_clip_uint8(top[18] + l_m_tl);
226 dst[19] = av_clip_uint8(top[19] + l_m_tl);
227 dst[20] = av_clip_uint8(top[20] + l_m_tl);
228 dst[21] = av_clip_uint8(top[21] + l_m_tl);
229 dst[22] = av_clip_uint8(top[22] + l_m_tl);
230 dst[23] = av_clip_uint8(top[23] + l_m_tl);
231 dst[24] = av_clip_uint8(top[24] + l_m_tl);
232 dst[25] = av_clip_uint8(top[25] + l_m_tl);
233 dst[26] = av_clip_uint8(top[26] + l_m_tl);
234 dst[27] = av_clip_uint8(top[27] + l_m_tl);
235 dst[28] = av_clip_uint8(top[28] + l_m_tl);
236 dst[29] = av_clip_uint8(top[29] + l_m_tl);
237 dst[30] = av_clip_uint8(top[30] + l_m_tl);
238 dst[31] = av_clip_uint8(top[31] + l_m_tl);
243 static void dc_4x4_c(uint8_t *dst, ptrdiff_t stride,
244 const uint8_t *left, const uint8_t *top)
246 unsigned dc = 0x01010101U *
247 ((left[0] + left[1] + left[2] + left[3] +
248 top[0] + top[1] + top[2] + top[3] + 4) >> 3);
250 AV_WN32A(dst + stride * 0, dc);
251 AV_WN32A(dst + stride * 1, dc);
252 AV_WN32A(dst + stride * 2, dc);
253 AV_WN32A(dst + stride * 3, dc);
256 static void dc_8x8_c(uint8_t *dst, ptrdiff_t stride,
257 const uint8_t *left, const uint8_t *top)
259 uint64_t dc = 0x0101010101010101ULL *
260 ((left[0] + left[1] + left[2] + left[3] +
261 left[4] + left[5] + left[6] + left[7] +
262 top[0] + top[1] + top[2] + top[3] +
263 top[4] + top[5] + top[6] + top[7] + 8) >> 4);
266 for (y = 0; y < 8; y++) {
272 static void dc_16x16_c(uint8_t *dst, ptrdiff_t stride,
273 const uint8_t *left, const uint8_t *top)
275 uint64_t dc = 0x0101010101010101ULL *
276 ((left[0] + left[1] + left[2] + left[3] +
277 left[4] + left[5] + left[6] + left[7] +
278 left[8] + left[9] + left[10] + left[11] +
279 left[12] + left[13] + left[14] + left[15] +
280 top[0] + top[1] + top[2] + top[3] +
281 top[4] + top[5] + top[6] + top[7] +
282 top[8] + top[9] + top[10] + top[11] +
283 top[12] + top[13] + top[14] + top[15] + 16) >> 5);
286 for (y = 0; y < 16; y++) {
287 AV_WN64A(dst + 0, dc);
288 AV_WN64A(dst + 8, dc);
293 static void dc_32x32_c(uint8_t *dst, ptrdiff_t stride,
294 const uint8_t *left, const uint8_t *top)
296 uint64_t dc = 0x0101010101010101ULL *
297 ((left[0] + left[1] + left[2] + left[3] +
298 left[4] + left[5] + left[6] + left[7] +
299 left[8] + left[9] + left[10] + left[11] +
300 left[12] + left[13] + left[14] + left[15] +
301 left[16] + left[17] + left[18] + left[19] +
302 left[20] + left[21] + left[22] + left[23] +
303 left[24] + left[25] + left[26] + left[27] +
304 left[28] + left[29] + left[30] + left[31] +
305 top[0] + top[1] + top[2] + top[3] +
306 top[4] + top[5] + top[6] + top[7] +
307 top[8] + top[9] + top[10] + top[11] +
308 top[12] + top[13] + top[14] + top[15] +
309 top[16] + top[17] + top[18] + top[19] +
310 top[20] + top[21] + top[22] + top[23] +
311 top[24] + top[25] + top[26] + top[27] +
312 top[28] + top[29] + top[30] + top[31] + 32) >> 6);
315 for (y = 0; y < 32; y++) {
316 AV_WN64A(dst + 0, dc);
317 AV_WN64A(dst + 8, dc);
318 AV_WN64A(dst + 16, dc);
319 AV_WN64A(dst + 24, dc);
324 static void dc_left_4x4_c(uint8_t *dst, ptrdiff_t stride,
325 const uint8_t *left, const uint8_t *top)
327 unsigned dc = 0x01010101U *
328 ((left[0] + left[1] + left[2] + left[3] + 2) >> 2);
330 AV_WN32A(dst + stride * 0, dc);
331 AV_WN32A(dst + stride * 1, dc);
332 AV_WN32A(dst + stride * 2, dc);
333 AV_WN32A(dst + stride * 3, dc);
336 static void dc_left_8x8_c(uint8_t *dst, ptrdiff_t stride,
337 const uint8_t *left, const uint8_t *top)
339 uint64_t dc = 0x0101010101010101ULL *
340 ((left[0] + left[1] + left[2] + left[3] +
341 left[4] + left[5] + left[6] + left[7] + 4) >> 3);
344 for (y = 0; y < 8; y++) {
350 static void dc_left_16x16_c(uint8_t *dst, ptrdiff_t stride,
351 const uint8_t *left, const uint8_t *top)
353 uint64_t dc = 0x0101010101010101ULL *
354 ((left[0] + left[1] + left[2] + left[3] +
355 left[4] + left[5] + left[6] + left[7] +
356 left[8] + left[9] + left[10] + left[11] +
357 left[12] + left[13] + left[14] + left[15] + 8) >> 4);
360 for (y = 0; y < 16; y++) {
361 AV_WN64A(dst + 0, dc);
362 AV_WN64A(dst + 8, dc);
367 static void dc_left_32x32_c(uint8_t *dst, ptrdiff_t stride,
368 const uint8_t *left, const uint8_t *top)
370 uint64_t dc = 0x0101010101010101ULL *
371 ((left[0] + left[1] + left[2] + left[3] +
372 left[4] + left[5] + left[6] + left[7] +
373 left[8] + left[9] + left[10] + left[11] +
374 left[12] + left[13] + left[14] + left[15] +
375 left[16] + left[17] + left[18] + left[19] +
376 left[20] + left[21] + left[22] + left[23] +
377 left[24] + left[25] + left[26] + left[27] +
378 left[28] + left[29] + left[30] + left[31] + 16) >> 5);
381 for (y = 0; y < 32; y++) {
382 AV_WN64A(dst + 0, dc);
383 AV_WN64A(dst + 8, dc);
384 AV_WN64A(dst + 16, dc);
385 AV_WN64A(dst + 24, dc);
390 static void dc_top_4x4_c(uint8_t *dst, ptrdiff_t stride,
391 const uint8_t *left, const uint8_t *top)
393 unsigned dc = 0x01010101U * ((top[0] + top[1] + top[2] + top[3] + 2) >> 2);
395 AV_WN32A(dst + stride * 0, dc);
396 AV_WN32A(dst + stride * 1, dc);
397 AV_WN32A(dst + stride * 2, dc);
398 AV_WN32A(dst + stride * 3, dc);
401 static void dc_top_8x8_c(uint8_t *dst, ptrdiff_t stride,
402 const uint8_t *left, const uint8_t *top)
404 uint64_t dc = 0x0101010101010101ULL *
405 ((top[0] + top[1] + top[2] + top[3] +
406 top[4] + top[5] + top[6] + top[7] + 4) >> 3);
409 for (y = 0; y < 8; y++) {
415 static void dc_top_16x16_c(uint8_t *dst, ptrdiff_t stride,
416 const uint8_t *left, const uint8_t *top)
418 uint64_t dc = 0x0101010101010101ULL *
419 ((top[0] + top[1] + top[2] + top[3] +
420 top[4] + top[5] + top[6] + top[7] +
421 top[8] + top[9] + top[10] + top[11] +
422 top[12] + top[13] + top[14] + top[15] + 8) >> 4);
425 for (y = 0; y < 16; y++) {
426 AV_WN64A(dst + 0, dc);
427 AV_WN64A(dst + 8, dc);
432 static void dc_top_32x32_c(uint8_t *dst, ptrdiff_t stride,
433 const uint8_t *left, const uint8_t *top)
435 uint64_t dc = 0x0101010101010101ULL *
436 ((top[0] + top[1] + top[2] + top[3] +
437 top[4] + top[5] + top[6] + top[7] +
438 top[8] + top[9] + top[10] + top[11] +
439 top[12] + top[13] + top[14] + top[15] +
440 top[16] + top[17] + top[18] + top[19] +
441 top[20] + top[21] + top[22] + top[23] +
442 top[24] + top[25] + top[26] + top[27] +
443 top[28] + top[29] + top[30] + top[31] + 16) >> 5);
446 for (y = 0; y < 32; y++) {
447 AV_WN64A(dst + 0, dc);
448 AV_WN64A(dst + 8, dc);
449 AV_WN64A(dst + 16, dc);
450 AV_WN64A(dst + 24, dc);
455 static void dc_128_4x4_c(uint8_t *dst, ptrdiff_t stride,
456 const uint8_t *left, const uint8_t *top)
458 AV_WN32A(dst + stride * 0, 0x80808080U);
459 AV_WN32A(dst + stride * 1, 0x80808080U);
460 AV_WN32A(dst + stride * 2, 0x80808080U);
461 AV_WN32A(dst + stride * 3, 0x80808080U);
464 static void dc_128_8x8_c(uint8_t *dst, ptrdiff_t stride,
465 const uint8_t *left, const uint8_t *top)
469 for (y = 0; y < 8; y++) {
470 AV_WN64A(dst, 0x8080808080808080ULL);
475 static void dc_128_16x16_c(uint8_t *dst, ptrdiff_t stride,
476 const uint8_t *left, const uint8_t *top)
480 for (y = 0; y < 16; y++) {
481 AV_WN64A(dst + 0, 0x8080808080808080ULL);
482 AV_WN64A(dst + 8, 0x8080808080808080ULL);
487 static void dc_128_32x32_c(uint8_t *dst, ptrdiff_t stride,
488 const uint8_t *left, const uint8_t *top)
492 for (y = 0; y < 32; y++) {
493 AV_WN64A(dst + 0, 0x8080808080808080ULL);
494 AV_WN64A(dst + 8, 0x8080808080808080ULL);
495 AV_WN64A(dst + 16, 0x8080808080808080ULL);
496 AV_WN64A(dst + 24, 0x8080808080808080ULL);
501 static void dc_127_4x4_c(uint8_t *dst, ptrdiff_t stride,
502 const uint8_t *left, const uint8_t *top)
504 AV_WN32A(dst + stride * 0, 0x7F7F7F7FU);
505 AV_WN32A(dst + stride * 1, 0x7F7F7F7FU);
506 AV_WN32A(dst + stride * 2, 0x7F7F7F7FU);
507 AV_WN32A(dst + stride * 3, 0x7F7F7F7FU);
510 static void dc_127_8x8_c(uint8_t *dst, ptrdiff_t stride,
511 const uint8_t *left, const uint8_t *top)
515 for (y = 0; y < 8; y++) {
516 AV_WN64A(dst, 0x7F7F7F7F7F7F7F7FULL);
521 static void dc_127_16x16_c(uint8_t *dst, ptrdiff_t stride,
522 const uint8_t *left, const uint8_t *top)
526 for (y = 0; y < 16; y++) {
527 AV_WN64A(dst + 0, 0x7F7F7F7F7F7F7F7FULL);
528 AV_WN64A(dst + 8, 0x7F7F7F7F7F7F7F7FULL);
533 static void dc_127_32x32_c(uint8_t *dst, ptrdiff_t stride,
534 const uint8_t *left, const uint8_t *top)
538 for (y = 0; y < 32; y++) {
539 AV_WN64A(dst + 0, 0x7F7F7F7F7F7F7F7FULL);
540 AV_WN64A(dst + 8, 0x7F7F7F7F7F7F7F7FULL);
541 AV_WN64A(dst + 16, 0x7F7F7F7F7F7F7F7FULL);
542 AV_WN64A(dst + 24, 0x7F7F7F7F7F7F7F7FULL);
547 static void dc_129_4x4_c(uint8_t *dst, ptrdiff_t stride,
548 const uint8_t *left, const uint8_t *top)
550 AV_WN32A(dst + stride * 0, 0x81818181U);
551 AV_WN32A(dst + stride * 1, 0x81818181U);
552 AV_WN32A(dst + stride * 2, 0x81818181U);
553 AV_WN32A(dst + stride * 3, 0x81818181U);
556 static void dc_129_8x8_c(uint8_t *dst, ptrdiff_t stride,
557 const uint8_t *left, const uint8_t *top)
561 for (y = 0; y < 8; y++) {
562 AV_WN64A(dst, 0x8181818181818181ULL);
567 static void dc_129_16x16_c(uint8_t *dst, ptrdiff_t stride,
568 const uint8_t *left, const uint8_t *top)
572 for (y = 0; y < 16; y++) {
573 AV_WN64A(dst + 0, 0x8181818181818181ULL);
574 AV_WN64A(dst + 8, 0x8181818181818181ULL);
579 static void dc_129_32x32_c(uint8_t *dst, ptrdiff_t stride,
580 const uint8_t *left, const uint8_t *top)
584 for (y = 0; y < 32; y++) {
585 AV_WN64A(dst + 0, 0x8181818181818181ULL);
586 AV_WN64A(dst + 8, 0x8181818181818181ULL);
587 AV_WN64A(dst + 16, 0x8181818181818181ULL);
588 AV_WN64A(dst + 24, 0x8181818181818181ULL);
593 #define DST(x, y) dst[(x) + (y) * stride]
595 static void diag_downleft_4x4_c(uint8_t *dst, ptrdiff_t stride,
596 const uint8_t *left, const uint8_t *top)
598 int a0 = top[0], a1 = top[1], a2 = top[2], a3 = top[3],
599 a4 = top[4], a5 = top[5], a6 = top[6], a7 = top[7];
601 DST(0, 0) = (a0 + a1 * 2 + a2 + 2) >> 2;
603 DST(0, 1) = (a1 + a2 * 2 + a3 + 2) >> 2;
606 DST(0, 2) = (a2 + a3 * 2 + a4 + 2) >> 2;
610 DST(0, 3) = (a3 + a4 * 2 + a5 + 2) >> 2;
613 DST(1, 3) = (a4 + a5 * 2 + a6 + 2) >> 2;
615 DST(2, 3) = (a5 + a6 * 2 + a7 + 2) >> 2;
616 DST(3, 3) = a7; // note: this is different from vp8 and such
619 #define def_diag_downleft(size) \
620 static void diag_downleft_ ## size ## x ## size ## _c(uint8_t *dst, \
622 const uint8_t *left, \
623 const uint8_t *top) \
626 uint8_t v[size - 1]; \
628 for (i = 0; i < size - 2; i++) \
629 v[i] = (top[i] + top[i + 1] * 2 + top[i + 2] + 2) >> 2; \
630 v[size - 2] = (top[size - 2] + top[size - 1] * 3 + 2) >> 2; \
632 for (j = 0; j < size; j++) { \
633 memcpy(dst + j * stride, v + j, size - 1 - j); \
634 memset(dst + j * stride + size - 1 - j, top[size - 1], j + 1); \
639 def_diag_downleft(16)
640 def_diag_downleft(32)
642 static void diag_downright_4x4_c(uint8_t *dst, ptrdiff_t stride,
643 const uint8_t *left, const uint8_t *top)
645 int tl = top[-1], a0 = top[0], a1 = top[1], a2 = top[2], a3 = top[3],
646 l0 = left[0], l1 = left[1], l2 = left[2], l3 = left[3];
648 DST(0, 3) = (l1 + l2 * 2 + l3 + 2) >> 2;
650 DST(1, 3) = (l0 + l1 * 2 + l2 + 2) >> 2;
653 DST(2, 3) = (tl + l0 * 2 + l1 + 2) >> 2;
657 DST(3, 3) = (l0 + tl * 2 + a0 + 2) >> 2;
660 DST(3, 2) = (tl + a0 * 2 + a1 + 2) >> 2;
662 DST(3, 1) = (a0 + a1 * 2 + a2 + 2) >> 2;
663 DST(3, 0) = (a1 + a2 * 2 + a3 + 2) >> 2;
666 #define def_diag_downright(size) \
667 static void diag_downright_ ## size ## x ## size ## _c(uint8_t *dst, \
669 const uint8_t *left, \
670 const uint8_t *top) \
673 uint8_t v[size + size - 1]; \
675 for (i = 0; i < size - 2; i++) { \
676 v[i] = (left[size - 1 - i] + \
677 left[size - 2 - i] * 2 + \
678 left[size - 3 - i] + 2) >> 2; \
679 v[size + 1 + i] = (top[i] + \
681 top[i + 2] + 2) >> 2; \
683 v[size - 2] = (left[1] + left[0] * 2 + top[-1] + 2) >> 2; \
684 v[size - 1] = (left[0] + top[-1] * 2 + top[0] + 2) >> 2; \
685 v[size] = (top[-1] + top[0] * 2 + top[1] + 2) >> 2; \
687 for (j = 0; j < size; j++) \
688 memcpy(dst + j * stride, v + size - 1 - j, size); \
691 def_diag_downright(8)
692 def_diag_downright(16)
693 def_diag_downright(32)
695 static void vert_right_4x4_c(uint8_t *dst, ptrdiff_t stride,
696 const uint8_t *left, const uint8_t *top)
698 int tl = top[-1], a0 = top[0], a1 = top[1], a2 = top[2], a3 = top[3],
699 l0 = left[0], l1 = left[1], l2 = left[2];
701 DST(0, 3) = (l0 + l1 * 2 + l2 + 2) >> 2;
702 DST(0, 2) = (tl + l0 * 2 + l1 + 2) >> 2;
704 DST(1, 2) = (tl + a0 + 1) >> 1;
706 DST(1, 3) = (l0 + tl * 2 + a0 + 2) >> 2;
708 DST(2, 2) = (a0 + a1 + 1) >> 1;
710 DST(2, 3) = (tl + a0 * 2 + a1 + 2) >> 2;
712 DST(3, 2) = (a1 + a2 + 1) >> 1;
714 DST(3, 3) = (a0 + a1 * 2 + a2 + 2) >> 2;
715 DST(3, 0) = (a2 + a3 + 1) >> 1;
716 DST(3, 1) = (a1 + a2 * 2 + a3 + 2) >> 2;
719 #define def_vert_right(size) \
720 static void vert_right_ ## size ## x ## size ## _c(uint8_t *dst, \
722 const uint8_t *left, \
723 const uint8_t *top) \
726 uint8_t ve[size + size / 2 - 1], vo[size + size / 2 - 1]; \
728 for (i = 0; i < size / 2 - 2; i++) { \
729 vo[i] = (left[size - 4 - i * 2] + \
730 left[size - 3 - i * 2] * 2 + \
731 left[size - 2 - i * 2] + 2) >> 2; \
732 ve[i] = (left[size - 5 - i * 2] + \
733 left[size - 4 - i * 2] * 2 + \
734 left[size - 3 - i * 2] + 2) >> 2; \
736 vo[size / 2 - 2] = (left[0] + left[1] * 2 + left[2] + 2) >> 2; \
737 ve[size / 2 - 2] = (top[-1] + left[0] * 2 + left[1] + 2) >> 2; \
739 ve[size / 2 - 1] = (top[-1] + top[0] + 1) >> 1; \
740 vo[size / 2 - 1] = (left[0] + top[-1] * 2 + top[0] + 2) >> 2; \
741 for (i = 0; i < size - 1; i++) { \
742 ve[size / 2 + i] = (top[i] + top[i + 1] + 1) >> 1; \
743 vo[size / 2 + i] = (top[i - 1] + top[i] * 2 + top[i + 1] + 2) >> 2; \
746 for (j = 0; j < size / 2; j++) { \
747 memcpy(dst + j * 2 * stride, ve + size / 2 - 1 - j, size); \
748 memcpy(dst + (j * 2 + 1) * stride, vo + size / 2 - 1 - j, size); \
756 static void hor_down_4x4_c(uint8_t *dst, ptrdiff_t stride,
757 const uint8_t *left, const uint8_t *top)
759 int l0 = left[0], l1 = left[1], l2 = left[2], l3 = left[3],
760 tl = top[-1], a0 = top[0], a1 = top[1], a2 = top[2];
762 DST(2, 0) = (tl + a0 * 2 + a1 + 2) >> 2;
763 DST(3, 0) = (a0 + a1 * 2 + a2 + 2) >> 2;
765 DST(2, 1) = (tl + l0 + 1) >> 1;
767 DST(3, 1) = (a0 + tl * 2 + l0 + 2) >> 2;
769 DST(2, 2) = (l0 + l1 + 1) >> 1;
771 DST(3, 2) = (tl + l0 * 2 + l1 + 2) >> 2;
773 DST(2, 3) = (l1 + l2 + 1) >> 1;
775 DST(3, 3) = (l0 + l1 * 2 + l2 + 2) >> 2;
776 DST(0, 3) = (l2 + l3 + 1) >> 1;
777 DST(1, 3) = (l1 + l2 * 2 + l3 + 2) >> 2;
780 #define def_hor_down(size) \
781 static void hor_down_ ## size ## x ## size ## _c(uint8_t *dst, \
783 const uint8_t *left, \
784 const uint8_t *top) \
787 uint8_t v[size * 3 - 2]; \
789 for (i = 0; i < size - 2; i++) { \
790 v[i * 2] = (left[size - 2 - i] + \
791 left[size - 1 - i] + 1) >> 1; \
792 v[i * 2 + 1] = (left[size - 3 - i] + \
793 left[size - 2 - i] * 2 + \
794 left[size - 1 - i] + 2) >> 2; \
795 v[size * 2 + i] = (top[i - 1] + \
797 top[i + 1] + 2) >> 2; \
799 v[size * 2 - 2] = (top[-1] + left[0] + 1) >> 1; \
800 v[size * 2 - 4] = (left[0] + left[1] + 1) >> 1; \
801 v[size * 2 - 1] = (top[0] + top[-1] * 2 + left[0] + 2) >> 2; \
802 v[size * 2 - 3] = (top[-1] + left[0] * 2 + left[1] + 2) >> 2; \
804 for (j = 0; j < size; j++) \
805 memcpy(dst + j * stride, v + size * 2 - 2 - j * 2, size); \
812 static void vert_left_4x4_c(uint8_t *dst, ptrdiff_t stride,
813 const uint8_t *left, const uint8_t *top)
815 int a0 = top[0], a1 = top[1], a2 = top[2], a3 = top[3],
816 a4 = top[4], a5 = top[5], a6 = top[6];
818 DST(0, 0) = (a0 + a1 + 1) >> 1;
819 DST(0, 1) = (a0 + a1 * 2 + a2 + 2) >> 2;
821 DST(0, 2) = (a1 + a2 + 1) >> 1;
823 DST(0, 3) = (a1 + a2 * 2 + a3 + 2) >> 2;
825 DST(1, 2) = (a2 + a3 + 1) >> 1;
827 DST(1, 3) = (a2 + a3 * 2 + a4 + 2) >> 2;
829 DST(2, 2) = (a3 + a4 + 1) >> 1;
831 DST(2, 3) = (a3 + a4 * 2 + a5 + 2) >> 2;
832 DST(3, 2) = (a4 + a5 + 1) >> 1;
833 DST(3, 3) = (a4 + a5 * 2 + a6 + 2) >> 2;
836 #define def_vert_left(size) \
837 static void vert_left_ ## size ## x ## size ## _c(uint8_t *dst, \
839 const uint8_t *left, \
840 const uint8_t *top) \
843 uint8_t ve[size - 1], vo[size - 1]; \
845 for (i = 0; i < size - 2; i++) { \
846 ve[i] = (top[i] + top[i + 1] + 1) >> 1; \
847 vo[i] = (top[i] + top[i + 1] * 2 + top[i + 2] + 2) >> 2; \
849 ve[size - 2] = (top[size - 2] + top[size - 1] + 1) >> 1; \
850 vo[size - 2] = (top[size - 2] + top[size - 1] * 3 + 2) >> 2; \
852 for (j = 0; j < size / 2; j++) { \
853 memcpy(dst + j * 2 * stride, ve + j, size - (j + 1)); \
854 memset(dst + j * 2 * stride + size - j - 1, \
855 top[size - 1], j + 1); \
856 memcpy(dst + (j * 2 + 1) * stride, vo + j, size - (j + 1)); \
857 memset(dst + (j * 2 + 1) * stride + size - j - 1, \
858 top[size - 1], j + 1); \
866 static void hor_up_4x4_c(uint8_t *dst, ptrdiff_t stride,
867 const uint8_t *left, const uint8_t *top)
869 int l0 = left[0], l1 = left[1], l2 = left[2], l3 = left[3];
871 DST(0, 0) = (l0 + l1 + 1) >> 1;
872 DST(1, 0) = (l0 + l1 * 2 + l2 + 2) >> 2;
874 DST(2, 0) = (l1 + l2 + 1) >> 1;
876 DST(3, 0) = (l1 + l2 * 2 + l3 + 2) >> 2;
878 DST(2, 1) = (l2 + l3 + 1) >> 1;
880 DST(3, 1) = (l2 + l3 * 3 + 2) >> 2;
889 #define def_hor_up(size) \
890 static void hor_up_ ## size ## x ## size ## _c(uint8_t *dst, \
892 const uint8_t *left, \
893 const uint8_t *top) \
896 uint8_t v[size * 2 - 2]; \
898 for (i = 0; i < size - 2; i++) { \
899 v[i * 2] = (left[i] + left[i + 1] + 1) >> 1; \
900 v[i * 2 + 1] = (left[i] + left[i + 1] * 2 + left[i + 2] + 2) >> 2; \
902 v[size * 2 - 4] = (left[size - 2] + left[size - 1] + 1) >> 1; \
903 v[size * 2 - 3] = (left[size - 2] + left[size - 1] * 3 + 2) >> 2; \
905 for (j = 0; j < size / 2; j++) \
906 memcpy(dst + j * stride, v + j * 2, size); \
907 for (j = size / 2; j < size; j++) { \
908 memcpy(dst + j * stride, v + j * 2, size * 2 - 2 - j * 2); \
909 memset(dst + j * stride + size * 2 - 2 - j * 2, left[size - 1], \
920 static av_cold void vp9dsp_intrapred_init(VP9DSPContext *dsp)
922 #define init_intra_pred(tx, sz) \
923 dsp->intra_pred[tx][VERT_PRED] = vert_ ## sz ## _c; \
924 dsp->intra_pred[tx][HOR_PRED] = hor_ ## sz ## _c; \
925 dsp->intra_pred[tx][DC_PRED] = dc_ ## sz ## _c; \
926 dsp->intra_pred[tx][DIAG_DOWN_LEFT_PRED] = diag_downleft_ ## sz ## _c; \
927 dsp->intra_pred[tx][DIAG_DOWN_RIGHT_PRED] = diag_downright_ ## sz ## _c; \
928 dsp->intra_pred[tx][VERT_RIGHT_PRED] = vert_right_ ## sz ## _c; \
929 dsp->intra_pred[tx][HOR_DOWN_PRED] = hor_down_ ## sz ## _c; \
930 dsp->intra_pred[tx][VERT_LEFT_PRED] = vert_left_ ## sz ## _c; \
931 dsp->intra_pred[tx][HOR_UP_PRED] = hor_up_ ## sz ## _c; \
932 dsp->intra_pred[tx][TM_VP8_PRED] = tm_ ## sz ## _c; \
933 dsp->intra_pred[tx][LEFT_DC_PRED] = dc_left_ ## sz ## _c; \
934 dsp->intra_pred[tx][TOP_DC_PRED] = dc_top_ ## sz ## _c; \
935 dsp->intra_pred[tx][DC_128_PRED] = dc_128_ ## sz ## _c; \
936 dsp->intra_pred[tx][DC_127_PRED] = dc_127_ ## sz ## _c; \
937 dsp->intra_pred[tx][DC_129_PRED] = dc_129_ ## sz ## _c
939 init_intra_pred(TX_4X4, 4x4);
940 init_intra_pred(TX_8X8, 8x8);
941 init_intra_pred(TX_16X16, 16x16);
942 init_intra_pred(TX_32X32, 32x32);
944 #undef init_intra_pred
947 #define itxfm_wrapper(type_a, type_b, sz, bits) \
949 type_a ## _ ## type_b ## _ ## sz ## x ## sz ## _add_c(uint8_t *dst, \
955 int16_t tmp[sz * sz], out[sz]; \
956 for (i = 0; i < sz; i++) \
957 type_a ## sz ## _1d(tmp + i * sz, block + i, sz, 0); \
958 memset(block, 0, sz * sz * sizeof(*block)); \
959 for (i = 0; i < sz; i++) { \
960 type_b ## sz ## _1d(out, tmp + i, sz, 1); \
961 for (j = 0; j < sz; j++) \
963 av_clip_uint8(dst[j * stride] + \
964 (bits ? (out[j] + (1 << (bits - 1))) >> bits \
970 #define itxfm_wrap(sz, bits) \
971 itxfm_wrapper(idct, idct, sz, bits) \
972 itxfm_wrapper(iadst, idct, sz, bits) \
973 itxfm_wrapper(idct, iadst, sz, bits) \
974 itxfm_wrapper(iadst, iadst, sz, bits)
976 #define IN(x) in[x * stride]
978 static av_always_inline void idct4_1d(int16_t *out, const int16_t *in,
979 ptrdiff_t stride, int pass)
983 t0 = ((IN(0) + IN(2)) * 11585 + (1 << 13)) >> 14;
984 t1 = ((IN(0) - IN(2)) * 11585 + (1 << 13)) >> 14;
985 t2 = (IN(1) * 6270 - IN(3) * 15137 + (1 << 13)) >> 14;
986 t3 = (IN(1) * 15137 + IN(3) * 6270 + (1 << 13)) >> 14;
994 static av_always_inline void iadst4_1d(int16_t *out, const int16_t *in,
995 ptrdiff_t stride, int pass)
999 t0 = 5283 * IN(0) + 15212 * IN(2) + 9929 * IN(3);
1000 t1 = 9929 * IN(0) - 5283 * IN(2) - 15212 * IN(3);
1001 t2 = 13377 * (IN(0) - IN(2) + IN(3));
1004 out[0] = (t0 + t3 + (1 << 13)) >> 14;
1005 out[1] = (t1 + t3 + (1 << 13)) >> 14;
1006 out[2] = (t2 + (1 << 13)) >> 14;
1007 out[3] = (t0 + t1 - t3 + (1 << 13)) >> 14;
1012 static av_always_inline void idct8_1d(int16_t *out, const int16_t *in,
1013 ptrdiff_t stride, int pass)
1015 int t0, t0a, t1, t1a, t2, t2a, t3, t3a, t4, t4a, t5, t5a, t6, t6a, t7, t7a;
1017 t0a = ((IN(0) + IN(4)) * 11585 + (1 << 13)) >> 14;
1018 t1a = ((IN(0) - IN(4)) * 11585 + (1 << 13)) >> 14;
1019 t2a = (IN(2) * 6270 - IN(6) * 15137 + (1 << 13)) >> 14;
1020 t3a = (IN(2) * 15137 + IN(6) * 6270 + (1 << 13)) >> 14;
1021 t4a = (IN(1) * 3196 - IN(7) * 16069 + (1 << 13)) >> 14;
1022 t5a = (IN(5) * 13623 - IN(3) * 9102 + (1 << 13)) >> 14;
1023 t6a = (IN(5) * 9102 + IN(3) * 13623 + (1 << 13)) >> 14;
1024 t7a = (IN(1) * 16069 + IN(7) * 3196 + (1 << 13)) >> 14;
1035 t5 = ((t6a - t5a) * 11585 + (1 << 13)) >> 14;
1036 t6 = ((t6a + t5a) * 11585 + (1 << 13)) >> 14;
1048 static av_always_inline void iadst8_1d(int16_t *out, const int16_t *in,
1049 ptrdiff_t stride, int pass)
1051 int t0, t0a, t1, t1a, t2, t2a, t3, t3a, t4, t4a, t5, t5a, t6, t6a, t7, t7a;
1053 t0a = 16305 * IN(7) + 1606 * IN(0);
1054 t1a = 1606 * IN(7) - 16305 * IN(0);
1055 t2a = 14449 * IN(5) + 7723 * IN(2);
1056 t3a = 7723 * IN(5) - 14449 * IN(2);
1057 t4a = 10394 * IN(3) + 12665 * IN(4);
1058 t5a = 12665 * IN(3) - 10394 * IN(4);
1059 t6a = 4756 * IN(1) + 15679 * IN(6);
1060 t7a = 15679 * IN(1) - 4756 * IN(6);
1062 t0 = (t0a + t4a + (1 << 13)) >> 14;
1063 t1 = (t1a + t5a + (1 << 13)) >> 14;
1064 t2 = (t2a + t6a + (1 << 13)) >> 14;
1065 t3 = (t3a + t7a + (1 << 13)) >> 14;
1066 t4 = (t0a - t4a + (1 << 13)) >> 14;
1067 t5 = (t1a - t5a + (1 << 13)) >> 14;
1068 t6 = (t2a - t6a + (1 << 13)) >> 14;
1069 t7 = (t3a - t7a + (1 << 13)) >> 14;
1071 t4a = 15137 * t4 + 6270 * t5;
1072 t5a = 6270 * t4 - 15137 * t5;
1073 t6a = 15137 * t7 - 6270 * t6;
1074 t7a = 6270 * t7 + 15137 * t6;
1077 out[7] = -(t1 + t3);
1081 out[1] = -((t4a + t6a + (1 << 13)) >> 14);
1082 out[6] = (t5a + t7a + (1 << 13)) >> 14;
1083 t6 = (t4a - t6a + (1 << 13)) >> 14;
1084 t7 = (t5a - t7a + (1 << 13)) >> 14;
1086 out[3] = -(((t2 + t3) * 11585 + (1 << 13)) >> 14);
1087 out[4] = ((t2 - t3) * 11585 + (1 << 13)) >> 14;
1088 out[2] = ((t6 + t7) * 11585 + (1 << 13)) >> 14;
1089 out[5] = -(((t6 - t7) * 11585 + (1 << 13)) >> 14);
1094 static av_always_inline void idct16_1d(int16_t *out, const int16_t *in,
1095 ptrdiff_t stride, int pass)
1097 int t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15;
1098 int t0a, t1a, t2a, t3a, t4a, t5a, t6a, t7a;
1099 int t8a, t9a, t10a, t11a, t12a, t13a, t14a, t15a;
1101 t0a = ((IN(0) + IN(8)) * 11585 + (1 << 13)) >> 14;
1102 t1a = ((IN(0) - IN(8)) * 11585 + (1 << 13)) >> 14;
1103 t2a = (IN(4) * 6270 - IN(12) * 15137 + (1 << 13)) >> 14;
1104 t3a = (IN(4) * 15137 + IN(12) * 6270 + (1 << 13)) >> 14;
1105 t4a = (IN(2) * 3196 - IN(14) * 16069 + (1 << 13)) >> 14;
1106 t7a = (IN(2) * 16069 + IN(14) * 3196 + (1 << 13)) >> 14;
1107 t5a = (IN(10) * 13623 - IN(6) * 9102 + (1 << 13)) >> 14;
1108 t6a = (IN(10) * 9102 + IN(6) * 13623 + (1 << 13)) >> 14;
1109 t8a = (IN(1) * 1606 - IN(15) * 16305 + (1 << 13)) >> 14;
1110 t15a = (IN(1) * 16305 + IN(15) * 1606 + (1 << 13)) >> 14;
1111 t9a = (IN(9) * 12665 - IN(7) * 10394 + (1 << 13)) >> 14;
1112 t14a = (IN(9) * 10394 + IN(7) * 12665 + (1 << 13)) >> 14;
1113 t10a = (IN(5) * 7723 - IN(11) * 14449 + (1 << 13)) >> 14;
1114 t13a = (IN(5) * 14449 + IN(11) * 7723 + (1 << 13)) >> 14;
1115 t11a = (IN(13) * 15679 - IN(3) * 4756 + (1 << 13)) >> 14;
1116 t12a = (IN(13) * 4756 + IN(3) * 15679 + (1 << 13)) >> 14;
1135 t5a = ((t6 - t5) * 11585 + (1 << 13)) >> 14;
1136 t6a = ((t6 + t5) * 11585 + (1 << 13)) >> 14;
1137 t9a = (t14 * 6270 - t9 * 15137 + (1 << 13)) >> 14;
1138 t14a = (t14 * 15137 + t9 * 6270 + (1 << 13)) >> 14;
1139 t10a = (-(t13 * 15137 + t10 * 6270) + (1 << 13)) >> 14;
1140 t13a = (t13 * 6270 - t10 * 15137 + (1 << 13)) >> 14;
1159 t10a = ((t13 - t10) * 11585 + (1 << 13)) >> 14;
1160 t13a = ((t13 + t10) * 11585 + (1 << 13)) >> 14;
1161 t11 = ((t12a - t11a) * 11585 + (1 << 13)) >> 14;
1162 t12 = ((t12a + t11a) * 11585 + (1 << 13)) >> 14;
1164 out[0] = t0a + t15a;
1166 out[2] = t2a + t13a;
1174 out[10] = t5 - t10a;
1176 out[12] = t3a - t12;
1177 out[13] = t2a - t13a;
1178 out[14] = t1a - t14;
1179 out[15] = t0a - t15a;
1182 static av_always_inline void iadst16_1d(int16_t *out, const int16_t *in,
1183 ptrdiff_t stride, int pass)
1185 int t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15;
1186 int t0a, t1a, t2a, t3a, t4a, t5a, t6a, t7a;
1187 int t8a, t9a, t10a, t11a, t12a, t13a, t14a, t15a;
1189 t0 = IN(15) * 16364 + IN(0) * 804;
1190 t1 = IN(15) * 804 - IN(0) * 16364;
1191 t2 = IN(13) * 15893 + IN(2) * 3981;
1192 t3 = IN(13) * 3981 - IN(2) * 15893;
1193 t4 = IN(11) * 14811 + IN(4) * 7005;
1194 t5 = IN(11) * 7005 - IN(4) * 14811;
1195 t6 = IN(9) * 13160 + IN(6) * 9760;
1196 t7 = IN(9) * 9760 - IN(6) * 13160;
1197 t8 = IN(7) * 11003 + IN(8) * 12140;
1198 t9 = IN(7) * 12140 - IN(8) * 11003;
1199 t10 = IN(5) * 8423 + IN(10) * 14053;
1200 t11 = IN(5) * 14053 - IN(10) * 8423;
1201 t12 = IN(3) * 5520 + IN(12) * 15426;
1202 t13 = IN(3) * 15426 - IN(12) * 5520;
1203 t14 = IN(1) * 2404 + IN(14) * 16207;
1204 t15 = IN(1) * 16207 - IN(14) * 2404;
1206 t0a = (t0 + t8 + (1 << 13)) >> 14;
1207 t1a = (t1 + t9 + (1 << 13)) >> 14;
1208 t2a = (t2 + t10 + (1 << 13)) >> 14;
1209 t3a = (t3 + t11 + (1 << 13)) >> 14;
1210 t4a = (t4 + t12 + (1 << 13)) >> 14;
1211 t5a = (t5 + t13 + (1 << 13)) >> 14;
1212 t6a = (t6 + t14 + (1 << 13)) >> 14;
1213 t7a = (t7 + t15 + (1 << 13)) >> 14;
1214 t8a = (t0 - t8 + (1 << 13)) >> 14;
1215 t9a = (t1 - t9 + (1 << 13)) >> 14;
1216 t10a = (t2 - t10 + (1 << 13)) >> 14;
1217 t11a = (t3 - t11 + (1 << 13)) >> 14;
1218 t12a = (t4 - t12 + (1 << 13)) >> 14;
1219 t13a = (t5 - t13 + (1 << 13)) >> 14;
1220 t14a = (t6 - t14 + (1 << 13)) >> 14;
1221 t15a = (t7 - t15 + (1 << 13)) >> 14;
1223 t8 = t8a * 16069 + t9a * 3196;
1224 t9 = t8a * 3196 - t9a * 16069;
1225 t10 = t10a * 9102 + t11a * 13623;
1226 t11 = t10a * 13623 - t11a * 9102;
1227 t12 = t13a * 16069 - t12a * 3196;
1228 t13 = t13a * 3196 + t12a * 16069;
1229 t14 = t15a * 9102 - t14a * 13623;
1230 t15 = t15a * 13623 + t14a * 9102;
1240 t8a = (t8 + t12 + (1 << 13)) >> 14;
1241 t9a = (t9 + t13 + (1 << 13)) >> 14;
1242 t10a = (t10 + t14 + (1 << 13)) >> 14;
1243 t11a = (t11 + t15 + (1 << 13)) >> 14;
1244 t12a = (t8 - t12 + (1 << 13)) >> 14;
1245 t13a = (t9 - t13 + (1 << 13)) >> 14;
1246 t14a = (t10 - t14 + (1 << 13)) >> 14;
1247 t15a = (t11 - t15 + (1 << 13)) >> 14;
1249 t4a = t4 * 15137 + t5 * 6270;
1250 t5a = t4 * 6270 - t5 * 15137;
1251 t6a = t7 * 15137 - t6 * 6270;
1252 t7a = t7 * 6270 + t6 * 15137;
1253 t12 = t12a * 15137 + t13a * 6270;
1254 t13 = t12a * 6270 - t13a * 15137;
1255 t14 = t15a * 15137 - t14a * 6270;
1256 t15 = t15a * 6270 + t14a * 15137;
1259 out[15] = -(t1 + t3);
1262 out[3] = -((t4a + t6a + (1 << 13)) >> 14);
1263 out[12] = (t5a + t7a + (1 << 13)) >> 14;
1264 t6 = (t4a - t6a + (1 << 13)) >> 14;
1265 t7 = (t5a - t7a + (1 << 13)) >> 14;
1266 out[1] = -(t8a + t10a);
1267 out[14] = t9a + t11a;
1270 out[2] = (t12 + t14 + (1 << 13)) >> 14;
1271 out[13] = -((t13 + t15 + (1 << 13)) >> 14);
1272 t14a = (t12 - t14 + (1 << 13)) >> 14;
1273 t15a = (t13 - t15 + (1 << 13)) >> 14;
1275 out[7] = ((t2a + t3a) * -11585 + (1 << 13)) >> 14;
1276 out[8] = ((t2a - t3a) * 11585 + (1 << 13)) >> 14;
1277 out[4] = ((t7 + t6) * 11585 + (1 << 13)) >> 14;
1278 out[11] = ((t7 - t6) * 11585 + (1 << 13)) >> 14;
1279 out[6] = ((t11 + t10) * 11585 + (1 << 13)) >> 14;
1280 out[9] = ((t11 - t10) * 11585 + (1 << 13)) >> 14;
1281 out[5] = ((t14a + t15a) * -11585 + (1 << 13)) >> 14;
1282 out[10] = ((t14a - t15a) * 11585 + (1 << 13)) >> 14;
1287 static av_always_inline void idct32_1d(int16_t *out, const int16_t *in,
1288 ptrdiff_t stride, int pass)
1290 int t0a = ((IN(0) + IN(16)) * 11585 + (1 << 13)) >> 14;
1291 int t1a = ((IN(0) - IN(16)) * 11585 + (1 << 13)) >> 14;
1292 int t2a = (IN(8) * 6270 - IN(24) * 15137 + (1 << 13)) >> 14;
1293 int t3a = (IN(8) * 15137 + IN(24) * 6270 + (1 << 13)) >> 14;
1294 int t4a = (IN(4) * 3196 - IN(28) * 16069 + (1 << 13)) >> 14;
1295 int t7a = (IN(4) * 16069 + IN(28) * 3196 + (1 << 13)) >> 14;
1296 int t5a = (IN(20) * 13623 - IN(12) * 9102 + (1 << 13)) >> 14;
1297 int t6a = (IN(20) * 9102 + IN(12) * 13623 + (1 << 13)) >> 14;
1298 int t8a = (IN(2) * 1606 - IN(30) * 16305 + (1 << 13)) >> 14;
1299 int t15a = (IN(2) * 16305 + IN(30) * 1606 + (1 << 13)) >> 14;
1300 int t9a = (IN(18) * 12665 - IN(14) * 10394 + (1 << 13)) >> 14;
1301 int t14a = (IN(18) * 10394 + IN(14) * 12665 + (1 << 13)) >> 14;
1302 int t10a = (IN(10) * 7723 - IN(22) * 14449 + (1 << 13)) >> 14;
1303 int t13a = (IN(10) * 14449 + IN(22) * 7723 + (1 << 13)) >> 14;
1304 int t11a = (IN(26) * 15679 - IN(6) * 4756 + (1 << 13)) >> 14;
1305 int t12a = (IN(26) * 4756 + IN(6) * 15679 + (1 << 13)) >> 14;
1306 int t16a = (IN(1) * 804 - IN(31) * 16364 + (1 << 13)) >> 14;
1307 int t31a = (IN(1) * 16364 + IN(31) * 804 + (1 << 13)) >> 14;
1308 int t17a = (IN(17) * 12140 - IN(15) * 11003 + (1 << 13)) >> 14;
1309 int t30a = (IN(17) * 11003 + IN(15) * 12140 + (1 << 13)) >> 14;
1310 int t18a = (IN(9) * 7005 - IN(23) * 14811 + (1 << 13)) >> 14;
1311 int t29a = (IN(9) * 14811 + IN(23) * 7005 + (1 << 13)) >> 14;
1312 int t19a = (IN(25) * 15426 - IN(7) * 5520 + (1 << 13)) >> 14;
1313 int t28a = (IN(25) * 5520 + IN(7) * 15426 + (1 << 13)) >> 14;
1314 int t20a = (IN(5) * 3981 - IN(27) * 15893 + (1 << 13)) >> 14;
1315 int t27a = (IN(5) * 15893 + IN(27) * 3981 + (1 << 13)) >> 14;
1316 int t21a = (IN(21) * 14053 - IN(11) * 8423 + (1 << 13)) >> 14;
1317 int t26a = (IN(21) * 8423 + IN(11) * 14053 + (1 << 13)) >> 14;
1318 int t22a = (IN(13) * 9760 - IN(19) * 13160 + (1 << 13)) >> 14;
1319 int t25a = (IN(13) * 13160 + IN(19) * 9760 + (1 << 13)) >> 14;
1320 int t23a = (IN(29) * 16207 - IN(3) * 2404 + (1 << 13)) >> 14;
1321 int t24a = (IN(29) * 2404 + IN(3) * 16207 + (1 << 13)) >> 14;
1333 int t10 = t11a - t10a;
1334 int t11 = t11a + t10a;
1335 int t12 = t12a + t13a;
1336 int t13 = t12a - t13a;
1337 int t14 = t15a - t14a;
1338 int t15 = t15a + t14a;
1339 int t16 = t16a + t17a;
1340 int t17 = t16a - t17a;
1341 int t18 = t19a - t18a;
1342 int t19 = t19a + t18a;
1343 int t20 = t20a + t21a;
1344 int t21 = t20a - t21a;
1345 int t22 = t23a - t22a;
1346 int t23 = t23a + t22a;
1347 int t24 = t24a + t25a;
1348 int t25 = t24a - t25a;
1349 int t26 = t27a - t26a;
1350 int t27 = t27a + t26a;
1351 int t28 = t28a + t29a;
1352 int t29 = t28a - t29a;
1353 int t30 = t31a - t30a;
1354 int t31 = t31a + t30a;
1356 t5a = ((t6 - t5) * 11585 + (1 << 13)) >> 14;
1357 t6a = ((t6 + t5) * 11585 + (1 << 13)) >> 14;
1358 t9a = (t14 * 6270 - t9 * 15137 + (1 << 13)) >> 14;
1359 t14a = (t14 * 15137 + t9 * 6270 + (1 << 13)) >> 14;
1360 t10a = (-(t13 * 15137 + t10 * 6270) + (1 << 13)) >> 14;
1361 t13a = (t13 * 6270 - t10 * 15137 + (1 << 13)) >> 14;
1362 t17a = (t30 * 3196 - t17 * 16069 + (1 << 13)) >> 14;
1363 t30a = (t30 * 16069 + t17 * 3196 + (1 << 13)) >> 14;
1364 t18a = (-(t29 * 16069 + t18 * 3196) + (1 << 13)) >> 14;
1365 t29a = (t29 * 3196 - t18 * 16069 + (1 << 13)) >> 14;
1366 t21a = (t26 * 13623 - t21 * 9102 + (1 << 13)) >> 14;
1367 t26a = (t26 * 9102 + t21 * 13623 + (1 << 13)) >> 14;
1368 t22a = (-(t25 * 9102 + t22 * 13623) + (1 << 13)) >> 14;
1369 t25a = (t25 * 13623 - t22 * 9102 + (1 << 13)) >> 14;
1404 t10a = ((t13 - t10) * 11585 + (1 << 13)) >> 14;
1405 t13a = ((t13 + t10) * 11585 + (1 << 13)) >> 14;
1406 t11 = ((t12a - t11a) * 11585 + (1 << 13)) >> 14;
1407 t12 = ((t12a + t11a) * 11585 + (1 << 13)) >> 14;
1408 t18a = (t29 * 6270 - t18 * 15137 + (1 << 13)) >> 14;
1409 t29a = (t29 * 15137 + t18 * 6270 + (1 << 13)) >> 14;
1410 t19 = (t28a * 6270 - t19a * 15137 + (1 << 13)) >> 14;
1411 t28 = (t28a * 15137 + t19a * 6270 + (1 << 13)) >> 14;
1412 t20 = (-(t27a * 15137 + t20a * 6270) + (1 << 13)) >> 14;
1413 t27 = (t27a * 6270 - t20a * 15137 + (1 << 13)) >> 14;
1414 t21a = (-(t26 * 15137 + t21 * 6270) + (1 << 13)) >> 14;
1415 t26a = (t26 * 6270 - t21 * 15137 + (1 << 13)) >> 14;
1450 t20 = ((t27a - t20a) * 11585 + (1 << 13)) >> 14;
1451 t27 = ((t27a + t20a) * 11585 + (1 << 13)) >> 14;
1452 t21a = ((t26 - t21) * 11585 + (1 << 13)) >> 14;
1453 t26a = ((t26 + t21) * 11585 + (1 << 13)) >> 14;
1454 t22 = ((t25a - t22a) * 11585 + (1 << 13)) >> 14;
1455 t25 = ((t25a + t22a) * 11585 + (1 << 13)) >> 14;
1456 t23a = ((t24 - t23) * 11585 + (1 << 13)) >> 14;
1457 t24a = ((t24 + t23) * 11585 + (1 << 13)) >> 14;
1464 out[5] = t5a + t26a;
1469 out[10] = t10 + t21a;
1470 out[11] = t11a + t20;
1471 out[12] = t12a + t19a;
1472 out[13] = t13 + t18;
1473 out[14] = t14a + t17a;
1474 out[15] = t15 + t16;
1475 out[16] = t15 - t16;
1476 out[17] = t14a - t17a;
1477 out[18] = t13 - t18;
1478 out[19] = t12a - t19a;
1479 out[20] = t11a - t20;
1480 out[21] = t10 - t21a;
1481 out[22] = t9a - t22;
1482 out[23] = t8 - t23a;
1483 out[24] = t7 - t24a;
1484 out[25] = t6a - t25;
1485 out[26] = t5a - t26a;
1487 out[28] = t3 - t28a;
1489 out[30] = t1 - t30a;
1493 itxfm_wrapper(idct, idct, 32, 6)
1495 static av_always_inline void iwht4_1d(int16_t *out, const int16_t *in,
1496 ptrdiff_t stride, int pass)
1498 int t0, t1, t2, t3, t4;
1514 t4 = (t0 - t3) >> 1;
1526 itxfm_wrapper(iwht, iwht, 4, 0)
1529 #undef itxfm_wrapper
1532 static av_cold void vp9dsp_itxfm_init(VP9DSPContext *dsp)
1534 #define init_itxfm(tx, sz) \
1535 dsp->itxfm_add[tx][DCT_DCT] = idct_idct_ ## sz ## _add_c; \
1536 dsp->itxfm_add[tx][DCT_ADST] = iadst_idct_ ## sz ## _add_c; \
1537 dsp->itxfm_add[tx][ADST_DCT] = idct_iadst_ ## sz ## _add_c; \
1538 dsp->itxfm_add[tx][ADST_ADST] = iadst_iadst_ ## sz ## _add_c
1540 #define init_idct(tx, nm) \
1541 dsp->itxfm_add[tx][DCT_DCT] = \
1542 dsp->itxfm_add[tx][ADST_DCT] = \
1543 dsp->itxfm_add[tx][DCT_ADST] = \
1544 dsp->itxfm_add[tx][ADST_ADST] = nm ## _add_c
1546 init_itxfm(TX_4X4, 4x4);
1547 init_itxfm(TX_8X8, 8x8);
1548 init_itxfm(TX_16X16, 16x16);
1549 init_idct(TX_32X32, idct_idct_32x32);
1550 init_idct(4 /* lossless */, iwht_iwht_4x4);
1556 static av_always_inline void loop_filter(uint8_t *dst, ptrdiff_t stride,
1557 int E, int I, int H,
1558 ptrdiff_t stridea, ptrdiff_t strideb,
1563 for (i = 0; i < 8; i++, dst += stridea) {
1565 int p3 = dst[strideb * -4], p2 = dst[strideb * -3];
1566 int p1 = dst[strideb * -2], p0 = dst[strideb * -1];
1567 int q0 = dst[strideb * +0], q1 = dst[strideb * +1];
1568 int q2 = dst[strideb * +2], q3 = dst[strideb * +3];
1570 int fm = FFABS(p3 - p2) <= I && FFABS(p2 - p1) <= I &&
1571 FFABS(p1 - p0) <= I && FFABS(q1 - q0) <= I &&
1572 FFABS(q2 - q1) <= I && FFABS(q3 - q2) <= I &&
1573 FFABS(p0 - q0) * 2 + (FFABS(p1 - q1) >> 1) <= E;
1574 int flat8out, flat8in;
1580 p7 = dst[strideb * -8];
1581 p6 = dst[strideb * -7];
1582 p5 = dst[strideb * -6];
1583 p4 = dst[strideb * -5];
1584 q4 = dst[strideb * +4];
1585 q5 = dst[strideb * +5];
1586 q6 = dst[strideb * +6];
1587 q7 = dst[strideb * +7];
1589 flat8out = FFABS(p7 - p0) <= 1 && FFABS(p6 - p0) <= 1 &&
1590 FFABS(p5 - p0) <= 1 && FFABS(p4 - p0) <= 1 &&
1591 FFABS(q4 - q0) <= 1 && FFABS(q5 - q0) <= 1 &&
1592 FFABS(q6 - q0) <= 1 && FFABS(q7 - q0) <= 1;
1596 flat8in = FFABS(p3 - p0) <= 1 && FFABS(p2 - p0) <= 1 &&
1597 FFABS(p1 - p0) <= 1 && FFABS(q1 - q0) <= 1 &&
1598 FFABS(q2 - q0) <= 1 && FFABS(q3 - q0) <= 1;
1600 if (wd >= 16 && flat8out && flat8in) {
1601 dst[strideb * -7] = (p7 + p7 + p7 + p7 + p7 + p7 + p7 + p6 * 2 +
1602 p5 + p4 + p3 + p2 + p1 + p0 + q0 + 8) >> 4;
1603 dst[strideb * -6] = (p7 + p7 + p7 + p7 + p7 + p7 + p6 + p5 * 2 +
1604 p4 + p3 + p2 + p1 + p0 + q0 + q1 + 8) >> 4;
1605 dst[strideb * -5] = (p7 + p7 + p7 + p7 + p7 + p6 + p5 + p4 * 2 +
1606 p3 + p2 + p1 + p0 + q0 + q1 + q2 + 8) >> 4;
1607 dst[strideb * -4] = (p7 + p7 + p7 + p7 + p6 + p5 + p4 + p3 * 2 +
1608 p2 + p1 + p0 + q0 + q1 + q2 + q3 + 8) >> 4;
1609 dst[strideb * -3] = (p7 + p7 + p7 + p6 + p5 + p4 + p3 + p2 * 2 +
1610 p1 + p0 + q0 + q1 + q2 + q3 + q4 + 8) >> 4;
1611 dst[strideb * -2] = (p7 + p7 + p6 + p5 + p4 + p3 + p2 + p1 * 2 +
1612 p0 + q0 + q1 + q2 + q3 + q4 + q5 + 8) >> 4;
1613 dst[strideb * -1] = (p7 + p6 + p5 + p4 + p3 + p2 + p1 + p0 * 2 +
1614 q0 + q1 + q2 + q3 + q4 + q5 + q6 + 8) >> 4;
1615 dst[strideb * +0] = (p6 + p5 + p4 + p3 + p2 + p1 + p0 + q0 * 2 +
1616 q1 + q2 + q3 + q4 + q5 + q6 + q7 + 8) >> 4;
1617 dst[strideb * +1] = (p5 + p4 + p3 + p2 + p1 + p0 + q0 + q1 * 2 +
1618 q2 + q3 + q4 + q5 + q6 + q7 + q7 + 8) >> 4;
1619 dst[strideb * +2] = (p4 + p3 + p2 + p1 + p0 + q0 + q1 + q2 * 2 +
1620 q3 + q4 + q5 + q6 + q7 + q7 + q7 + 8) >> 4;
1621 dst[strideb * +3] = (p3 + p2 + p1 + p0 + q0 + q1 + q2 + q3 * 2 +
1622 q4 + q5 + q6 + q7 + q7 + q7 + q7 + 8) >> 4;
1623 dst[strideb * +4] = (p2 + p1 + p0 + q0 + q1 + q2 + q3 + q4 * 2 +
1624 q5 + q6 + q7 + q7 + q7 + q7 + q7 + 8) >> 4;
1625 dst[strideb * +5] = (p1 + p0 + q0 + q1 + q2 + q3 + q4 + q5 * 2 +
1626 q6 + q7 + q7 + q7 + q7 + q7 + q7 + 8) >> 4;
1627 dst[strideb * +6] = (p0 + q0 + q1 + q2 + q3 + q4 + q5 + q6 * 2 +
1628 q7 + q7 + q7 + q7 + q7 + q7 + q7 + 8) >> 4;
1629 } else if (wd >= 8 && flat8in) {
1630 dst[strideb * -3] = (p3 + p3 + p3 + 2 * p2 + p1 + p0 + q0 + 4) >> 3;
1631 dst[strideb * -2] = (p3 + p3 + p2 + 2 * p1 + p0 + q0 + q1 + 4) >> 3;
1632 dst[strideb * -1] = (p3 + p2 + p1 + 2 * p0 + q0 + q1 + q2 + 4) >> 3;
1633 dst[strideb * +0] = (p2 + p1 + p0 + 2 * q0 + q1 + q2 + q3 + 4) >> 3;
1634 dst[strideb * +1] = (p1 + p0 + q0 + 2 * q1 + q2 + q3 + q3 + 4) >> 3;
1635 dst[strideb * +2] = (p0 + q0 + q1 + 2 * q2 + q3 + q3 + q3 + 4) >> 3;
1637 int hev = FFABS(p1 - p0) > H || FFABS(q1 - q0) > H;
1640 int f = av_clip_int8(3 * (q0 - p0) + av_clip_int8(p1 - q1));
1641 int f1 = FFMIN(f + 4, 127) >> 3;
1642 int f2 = FFMIN(f + 3, 127) >> 3;
1644 dst[strideb * -1] = av_clip_uint8(p0 + f2);
1645 dst[strideb * +0] = av_clip_uint8(q0 - f1);
1647 int f = av_clip_int8(3 * (q0 - p0));
1648 int f1 = FFMIN(f + 4, 127) >> 3;
1649 int f2 = FFMIN(f + 3, 127) >> 3;
1651 dst[strideb * -1] = av_clip_uint8(p0 + f2);
1652 dst[strideb * +0] = av_clip_uint8(q0 - f1);
1655 dst[strideb * -2] = av_clip_uint8(p1 + f);
1656 dst[strideb * +1] = av_clip_uint8(q1 - f);
1662 #define lf_8_fn(dir, wd, stridea, strideb) \
1663 static void loop_filter_ ## dir ## _ ## wd ## _8_c(uint8_t *dst, \
1665 int E, int I, int H) \
1667 loop_filter(dst, stride, E, I, H, stridea, strideb, wd); \
1670 #define lf_8_fns(wd) \
1671 lf_8_fn(h, wd, stride, 1) \
1672 lf_8_fn(v, wd, 1, stride)
1681 #define lf_16_fn(dir, stridea) \
1682 static void loop_filter_ ## dir ## _16_16_c(uint8_t *dst, \
1684 int E, int I, int H) \
1686 loop_filter_ ## dir ## _16_8_c(dst, stride, E, I, H); \
1687 loop_filter_ ## dir ## _16_8_c(dst + 8 * stridea, stride, E, I, H); \
1695 #define lf_mix_fn(dir, wd1, wd2, stridea) \
1696 static void loop_filter_ ## dir ## _ ## wd1 ## wd2 ## _16_c(uint8_t *dst, \
1701 loop_filter_ ## dir ## _ ## wd1 ## _8_c(dst, stride, E & 0xff, \
1702 I & 0xff, H & 0xff); \
1703 loop_filter_ ## dir ## _ ## wd2 ## _8_c(dst + 8 * stridea, stride, \
1704 E >> 8, I >> 8, H >> 8); \
1707 #define lf_mix_fns(wd1, wd2) \
1708 lf_mix_fn(h, wd1, wd2, stride) \
1709 lf_mix_fn(v, wd1, wd2, 1)
1719 static av_cold void vp9dsp_loopfilter_init(VP9DSPContext *dsp)
1721 dsp->loop_filter_8[0][0] = loop_filter_h_4_8_c;
1722 dsp->loop_filter_8[0][1] = loop_filter_v_4_8_c;
1723 dsp->loop_filter_8[1][0] = loop_filter_h_8_8_c;
1724 dsp->loop_filter_8[1][1] = loop_filter_v_8_8_c;
1725 dsp->loop_filter_8[2][0] = loop_filter_h_16_8_c;
1726 dsp->loop_filter_8[2][1] = loop_filter_v_16_8_c;
1728 dsp->loop_filter_16[0] = loop_filter_h_16_16_c;
1729 dsp->loop_filter_16[1] = loop_filter_v_16_16_c;
1731 dsp->loop_filter_mix2[0][0][0] = loop_filter_h_44_16_c;
1732 dsp->loop_filter_mix2[0][0][1] = loop_filter_v_44_16_c;
1733 dsp->loop_filter_mix2[0][1][0] = loop_filter_h_48_16_c;
1734 dsp->loop_filter_mix2[0][1][1] = loop_filter_v_48_16_c;
1735 dsp->loop_filter_mix2[1][0][0] = loop_filter_h_84_16_c;
1736 dsp->loop_filter_mix2[1][0][1] = loop_filter_v_84_16_c;
1737 dsp->loop_filter_mix2[1][1][0] = loop_filter_h_88_16_c;
1738 dsp->loop_filter_mix2[1][1][1] = loop_filter_v_88_16_c;
1741 static av_always_inline void copy_c(uint8_t *dst, const uint8_t *src,
1742 ptrdiff_t dst_stride,
1743 ptrdiff_t src_stride,
1747 memcpy(dst, src, w);
1754 static av_always_inline void avg_c(uint8_t *dst, const uint8_t *src,
1755 ptrdiff_t dst_stride,
1756 ptrdiff_t src_stride,
1762 for (x = 0; x < w; x += 4)
1763 AV_WN32A(&dst[x], rnd_avg32(AV_RN32A(&dst[x]), AV_RN32(&src[x])));
1770 #define fpel_fn(type, sz) \
1771 static void type ## sz ## _c(uint8_t *dst, const uint8_t *src, \
1772 ptrdiff_t dst_stride, \
1773 ptrdiff_t src_stride, \
1774 int h, int mx, int my) \
1776 type ## _c(dst, src, dst_stride, src_stride, sz, h); \
1779 #define copy_avg_fn(sz) \
1792 static const int8_t vp9_subpel_filters[3][15][8] = {
1793 [FILTER_8TAP_REGULAR] = {
1794 { 0, 1, -5, 126, 8, -3, 1, 0 },
1795 { -1, 3, -10, 122, 18, -6, 2, 0 },
1796 { -1, 4, -13, 118, 27, -9, 3, -1 },
1797 { -1, 4, -16, 112, 37, -11, 4, -1 },
1798 { -1, 5, -18, 105, 48, -14, 4, -1 },
1799 { -1, 5, -19, 97, 58, -16, 5, -1 },
1800 { -1, 6, -19, 88, 68, -18, 5, -1 },
1801 { -1, 6, -19, 78, 78, -19, 6, -1 },
1802 { -1, 5, -18, 68, 88, -19, 6, -1 },
1803 { -1, 5, -16, 58, 97, -19, 5, -1 },
1804 { -1, 4, -14, 48, 105, -18, 5, -1 },
1805 { -1, 4, -11, 37, 112, -16, 4, -1 },
1806 { -1, 3, -9, 27, 118, -13, 4, -1 },
1807 { 0, 2, -6, 18, 122, -10, 3, -1 },
1808 { 0, 1, -3, 8, 126, -5, 1, 0 },
1809 }, [FILTER_8TAP_SHARP] = {
1810 { -1, 3, -7, 127, 8, -3, 1, 0 },
1811 { -2, 5, -13, 125, 17, -6, 3, -1 },
1812 { -3, 7, -17, 121, 27, -10, 5, -2 },
1813 { -4, 9, -20, 115, 37, -13, 6, -2 },
1814 { -4, 10, -23, 108, 48, -16, 8, -3 },
1815 { -4, 10, -24, 100, 59, -19, 9, -3 },
1816 { -4, 11, -24, 90, 70, -21, 10, -4 },
1817 { -4, 11, -23, 80, 80, -23, 11, -4 },
1818 { -4, 10, -21, 70, 90, -24, 11, -4 },
1819 { -3, 9, -19, 59, 100, -24, 10, -4 },
1820 { -3, 8, -16, 48, 108, -23, 10, -4 },
1821 { -2, 6, -13, 37, 115, -20, 9, -4 },
1822 { -2, 5, -10, 27, 121, -17, 7, -3 },
1823 { -1, 3, -6, 17, 125, -13, 5, -2 },
1824 { 0, 1, -3, 8, 127, -7, 3, -1 },
1825 }, [FILTER_8TAP_SMOOTH] = {
1826 { -3, -1, 32, 64, 38, 1, -3, 0 },
1827 { -2, -2, 29, 63, 41, 2, -3, 0 },
1828 { -2, -2, 26, 63, 43, 4, -4, 0 },
1829 { -2, -3, 24, 62, 46, 5, -4, 0 },
1830 { -2, -3, 21, 60, 49, 7, -4, 0 },
1831 { -1, -4, 18, 59, 51, 9, -4, 0 },
1832 { -1, -4, 16, 57, 53, 12, -4, -1 },
1833 { -1, -4, 14, 55, 55, 14, -4, -1 },
1834 { -1, -4, 12, 53, 57, 16, -4, -1 },
1835 { 0, -4, 9, 51, 59, 18, -4, -1 },
1836 { 0, -4, 7, 49, 60, 21, -3, -2 },
1837 { 0, -4, 5, 46, 62, 24, -3, -2 },
1838 { 0, -4, 4, 43, 63, 26, -2, -2 },
1839 { 0, -3, 2, 41, 63, 29, -2, -2 },
1840 { 0, -3, 1, 38, 64, 32, -1, -3 },
1844 #define FILTER_8TAP(src, x, F, stride) \
1845 av_clip_uint8((F[0] * src[x + -3 * stride] + \
1846 F[1] * src[x + -2 * stride] + \
1847 F[2] * src[x + -1 * stride] + \
1848 F[3] * src[x + +0 * stride] + \
1849 F[4] * src[x + +1 * stride] + \
1850 F[5] * src[x + +2 * stride] + \
1851 F[6] * src[x + +3 * stride] + \
1852 F[7] * src[x + +4 * stride] + 64) >> 7)
1854 static av_always_inline void do_8tap_1d_c(uint8_t *dst, const uint8_t *src,
1855 ptrdiff_t dst_stride,
1856 ptrdiff_t src_stride,
1857 int w, int h, ptrdiff_t ds,
1858 const int8_t *filter, int avg)
1863 for (x = 0; x < w; x++)
1865 dst[x] = (dst[x] + FILTER_8TAP(src, x, filter, ds) + 1) >> 1;
1867 dst[x] = FILTER_8TAP(src, x, filter, ds);
1874 #define filter_8tap_1d_fn(opn, opa, dir, ds) \
1875 static av_noinline void opn ## _8tap_1d_ ## dir ## _c(uint8_t *dst, \
1876 const uint8_t *src, \
1877 ptrdiff_t dst_stride, \
1878 ptrdiff_t src_stride, \
1880 const int8_t *filter) \
1882 do_8tap_1d_c(dst, src, dst_stride, src_stride, w, h, ds, filter, opa); \
1885 filter_8tap_1d_fn(put, 0, v, src_stride)
1886 filter_8tap_1d_fn(put, 0, h, 1)
1887 filter_8tap_1d_fn(avg, 1, v, src_stride)
1888 filter_8tap_1d_fn(avg, 1, h, 1)
1890 #undef filter_8tap_1d_fn
1892 static av_always_inline void do_8tap_2d_c(uint8_t *dst, const uint8_t *src,
1893 ptrdiff_t dst_stride,
1894 ptrdiff_t src_stride,
1895 int w, int h, const int8_t *filterx,
1896 const int8_t *filtery, int avg)
1899 uint8_t tmp[64 * 71], *tmp_ptr = tmp;
1901 src -= src_stride * 3;
1905 for (x = 0; x < w; x++)
1906 tmp_ptr[x] = FILTER_8TAP(src, x, filterx, 1);
1912 tmp_ptr = tmp + 64 * 3;
1916 for (x = 0; x < w; x++)
1918 dst[x] = (dst[x] + FILTER_8TAP(tmp_ptr, x, filtery, 64) + 1) >> 1;
1920 dst[x] = FILTER_8TAP(tmp_ptr, x, filtery, 64);
1927 #define filter_8tap_2d_fn(opn, opa) \
1928 static av_noinline void opn ## _8tap_2d_hv_c(uint8_t *dst, \
1929 const uint8_t *src, \
1930 ptrdiff_t dst_stride, \
1931 ptrdiff_t src_stride, \
1933 const int8_t *filterx, \
1934 const int8_t *filtery) \
1936 do_8tap_2d_c(dst, src, dst_stride, src_stride, \
1937 w, h, filterx, filtery, opa); \
1940 filter_8tap_2d_fn(put, 0)
1941 filter_8tap_2d_fn(avg, 1)
1943 #undef filter_8tap_2d_fn
1947 #define filter_fn_1d(sz, dir, dir_m, type, type_idx, avg) \
1949 avg ## _8tap_ ## type ## _ ## sz ## dir ## _c(uint8_t *dst, \
1950 const uint8_t *src, \
1951 ptrdiff_t dst_stride, \
1952 ptrdiff_t src_stride, \
1953 int h, int mx, int my) \
1955 avg ## _8tap_1d_ ## dir ## _c(dst, src, dst_stride, src_stride, sz, h, \
1956 vp9_subpel_filters[type_idx][dir_m - 1]); \
1959 #define filter_fn_2d(sz, type, type_idx, avg) \
1960 static void avg ## _8tap_ ## type ## _ ## sz ## hv_c(uint8_t *dst, \
1961 const uint8_t *src, \
1962 ptrdiff_t dst_stride, \
1963 ptrdiff_t src_stride, \
1964 int h, int mx, int my) \
1966 avg ## _8tap_2d_hv_c(dst, src, dst_stride, src_stride, sz, h, \
1967 vp9_subpel_filters[type_idx][mx - 1], \
1968 vp9_subpel_filters[type_idx][my - 1]); \
1971 #define FILTER_BILIN(src, x, mxy, stride) \
1972 (src[x] + ((mxy * (src[x + stride] - src[x]) + 8) >> 4))
1974 static av_always_inline void do_bilin_1d_c(uint8_t *dst,
1976 ptrdiff_t dst_stride,
1977 ptrdiff_t src_stride,
1978 int w, int h, ptrdiff_t ds,
1984 for (x = 0; x < w; x++)
1986 dst[x] = (dst[x] + FILTER_BILIN(src, x, mxy, ds) + 1) >> 1;
1988 dst[x] = FILTER_BILIN(src, x, mxy, ds);
1995 #define bilin_1d_fn(opn, opa, dir, ds) \
1996 static av_noinline void opn ## _bilin_1d_ ## dir ## _c(uint8_t *dst, \
1997 const uint8_t *src, \
1998 ptrdiff_t dst_stride, \
1999 ptrdiff_t src_stride, \
2000 int w, int h, int mxy) \
2002 do_bilin_1d_c(dst, src, dst_stride, src_stride, w, h, ds, mxy, opa); \
2005 bilin_1d_fn(put, 0, v, src_stride)
2006 bilin_1d_fn(put, 0, h, 1)
2007 bilin_1d_fn(avg, 1, v, src_stride)
2008 bilin_1d_fn(avg, 1, h, 1)
2012 static av_always_inline void do_bilin_2d_c(uint8_t *dst,
2014 ptrdiff_t dst_stride,
2015 ptrdiff_t src_stride,
2016 int w, int h, int mx, int my,
2019 uint8_t tmp[64 * 65], *tmp_ptr = tmp;
2025 for (x = 0; x < w; x++)
2026 tmp_ptr[x] = FILTER_BILIN(src, x, mx, 1);
2036 for (x = 0; x < w; x++)
2038 dst[x] = (dst[x] + FILTER_BILIN(tmp_ptr, x, my, 64) + 1) >> 1;
2040 dst[x] = FILTER_BILIN(tmp_ptr, x, my, 64);
2047 #define bilin_2d_fn(opn, opa) \
2048 static av_noinline void opn ## _bilin_2d_hv_c(uint8_t *dst, \
2049 const uint8_t *src, \
2050 ptrdiff_t dst_stride, \
2051 ptrdiff_t src_stride, \
2055 do_bilin_2d_c(dst, src, dst_stride, src_stride, w, h, mx, my, opa); \
2065 #define bilinf_fn_1d(sz, dir, dir_m, avg) \
2066 static void avg ## _bilin_ ## sz ## dir ## _c(uint8_t *dst, \
2067 const uint8_t *src, \
2068 ptrdiff_t dst_stride, \
2069 ptrdiff_t src_stride, \
2070 int h, int mx, int my) \
2072 avg ## _bilin_1d_ ## dir ## _c(dst, src, dst_stride, src_stride, \
2076 #define bilinf_fn_2d(sz, avg) \
2077 static void avg ## _bilin_ ## sz ## hv_c(uint8_t *dst, \
2078 const uint8_t *src, \
2079 ptrdiff_t dst_stride, \
2080 ptrdiff_t src_stride, \
2081 int h, int mx, int my) \
2083 avg ## _bilin_2d_hv_c(dst, src, dst_stride, src_stride, \
2087 #define filter_fn(sz, avg) \
2088 filter_fn_1d(sz, h, mx, regular, FILTER_8TAP_REGULAR, avg) \
2089 filter_fn_1d(sz, v, my, regular, FILTER_8TAP_REGULAR, avg) \
2090 filter_fn_2d(sz, regular, FILTER_8TAP_REGULAR, avg) \
2091 filter_fn_1d(sz, h, mx, smooth, FILTER_8TAP_SMOOTH, avg) \
2092 filter_fn_1d(sz, v, my, smooth, FILTER_8TAP_SMOOTH, avg) \
2093 filter_fn_2d(sz, smooth, FILTER_8TAP_SMOOTH, avg) \
2094 filter_fn_1d(sz, h, mx, sharp, FILTER_8TAP_SHARP, avg) \
2095 filter_fn_1d(sz, v, my, sharp, FILTER_8TAP_SHARP, avg) \
2096 filter_fn_2d(sz, sharp, FILTER_8TAP_SHARP, avg) \
2097 bilinf_fn_1d(sz, h, mx, avg) \
2098 bilinf_fn_1d(sz, v, my, avg) \
2099 bilinf_fn_2d(sz, avg)
2101 #define filter_fn_set(avg) \
2102 filter_fn(64, avg) \
2103 filter_fn(32, avg) \
2104 filter_fn(16, avg) \
2112 #undef filter_fn_set
2118 static av_cold void vp9dsp_mc_init(VP9DSPContext *dsp)
2120 #define init_fpel(idx1, idx2, sz, type) \
2121 dsp->mc[idx1][FILTER_8TAP_SMOOTH][idx2][0][0] = type ## sz ## _c; \
2122 dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = type ## sz ## _c; \
2123 dsp->mc[idx1][FILTER_8TAP_SHARP][idx2][0][0] = type ## sz ## _c; \
2124 dsp->mc[idx1][FILTER_BILINEAR][idx2][0][0] = type ## sz ## _c
2126 #define init_copy_avg(idx, sz) \
2127 init_fpel(idx, 0, sz, copy); \
2128 init_fpel(idx, 1, sz, avg)
2130 init_copy_avg(0, 64);
2131 init_copy_avg(1, 32);
2132 init_copy_avg(2, 16);
2133 init_copy_avg(3, 8);
2134 init_copy_avg(4, 4);
2136 #undef init_copy_avg
2139 #define init_subpel1(idx1, idx2, idxh, idxv, sz, dir, type) \
2140 dsp->mc[idx1][FILTER_8TAP_SMOOTH][idx2][idxh][idxv] = type ## _8tap_smooth_ ## sz ## dir ## _c; \
2141 dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][idxh][idxv] = type ## _8tap_regular_ ## sz ## dir ## _c; \
2142 dsp->mc[idx1][FILTER_8TAP_SHARP][idx2][idxh][idxv] = type ## _8tap_sharp_ ## sz ## dir ## _c; \
2143 dsp->mc[idx1][FILTER_BILINEAR][idx2][idxh][idxv] = type ## _bilin_ ## sz ## dir ## _c
2145 #define init_subpel2(idx, idxh, idxv, dir, type) \
2146 init_subpel1(0, idx, idxh, idxv, 64, dir, type); \
2147 init_subpel1(1, idx, idxh, idxv, 32, dir, type); \
2148 init_subpel1(2, idx, idxh, idxv, 16, dir, type); \
2149 init_subpel1(3, idx, idxh, idxv, 8, dir, type); \
2150 init_subpel1(4, idx, idxh, idxv, 4, dir, type)
2152 #define init_subpel3(idx, type) \
2153 init_subpel2(idx, 1, 1, hv, type); \
2154 init_subpel2(idx, 0, 1, v, type); \
2155 init_subpel2(idx, 1, 0, h, type)
2157 init_subpel3(0, put);
2158 init_subpel3(1, avg);
2165 av_cold void ff_vp9dsp_init(VP9DSPContext *dsp)
2167 vp9dsp_intrapred_init(dsp);
2168 vp9dsp_itxfm_init(dsp);
2169 vp9dsp_loopfilter_init(dsp);
2170 vp9dsp_mc_init(dsp);
2173 ff_vp9dsp_init_x86(dsp);