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, has_dconly) \
949 type_a ## _ ## type_b ## _ ## sz ## x ## sz ## _add_c(uint8_t *dst, \
955 int16_t tmp[sz * sz], out[sz]; \
957 if (has_dconly && eob == 1) { \
958 const int t = (((block[0] * 11585 + (1 << 13)) >> 14) \
959 * 11585 + (1 << 13)) >> 14; \
961 for (i = 0; i < sz; i++) { \
962 for (j = 0; j < sz; j++) \
964 av_clip_uint8(dst[j * stride] + \
965 (bits ? (t + (1 << (bits - 1))) >> bits \
972 for (i = 0; i < sz; i++) \
973 type_a ## sz ## _1d(tmp + i * sz, block + i, sz, 0); \
974 memset(block, 0, sz * sz * sizeof(*block)); \
975 for (i = 0; i < sz; i++) { \
976 type_b ## sz ## _1d(out, tmp + i, sz, 1); \
977 for (j = 0; j < sz; j++) \
979 av_clip_uint8(dst[j * stride] + \
980 (bits ? (out[j] + (1 << (bits - 1))) >> bits \
986 #define itxfm_wrap(sz, bits) \
987 itxfm_wrapper(idct, idct, sz, bits, 1) \
988 itxfm_wrapper(iadst, idct, sz, bits, 0) \
989 itxfm_wrapper(idct, iadst, sz, bits, 0) \
990 itxfm_wrapper(iadst, iadst, sz, bits, 0)
992 #define IN(x) in[x * stride]
994 static av_always_inline void idct4_1d(int16_t *out, const int16_t *in,
995 ptrdiff_t stride, int pass)
999 t0 = ((IN(0) + IN(2)) * 11585 + (1 << 13)) >> 14;
1000 t1 = ((IN(0) - IN(2)) * 11585 + (1 << 13)) >> 14;
1001 t2 = (IN(1) * 6270 - IN(3) * 15137 + (1 << 13)) >> 14;
1002 t3 = (IN(1) * 15137 + IN(3) * 6270 + (1 << 13)) >> 14;
1010 static av_always_inline void iadst4_1d(int16_t *out, const int16_t *in,
1011 ptrdiff_t stride, int pass)
1015 t0 = 5283 * IN(0) + 15212 * IN(2) + 9929 * IN(3);
1016 t1 = 9929 * IN(0) - 5283 * IN(2) - 15212 * IN(3);
1017 t2 = 13377 * (IN(0) - IN(2) + IN(3));
1020 out[0] = (t0 + t3 + (1 << 13)) >> 14;
1021 out[1] = (t1 + t3 + (1 << 13)) >> 14;
1022 out[2] = (t2 + (1 << 13)) >> 14;
1023 out[3] = (t0 + t1 - t3 + (1 << 13)) >> 14;
1028 static av_always_inline void idct8_1d(int16_t *out, const int16_t *in,
1029 ptrdiff_t stride, int pass)
1031 int t0, t0a, t1, t1a, t2, t2a, t3, t3a, t4, t4a, t5, t5a, t6, t6a, t7, t7a;
1033 t0a = ((IN(0) + IN(4)) * 11585 + (1 << 13)) >> 14;
1034 t1a = ((IN(0) - IN(4)) * 11585 + (1 << 13)) >> 14;
1035 t2a = (IN(2) * 6270 - IN(6) * 15137 + (1 << 13)) >> 14;
1036 t3a = (IN(2) * 15137 + IN(6) * 6270 + (1 << 13)) >> 14;
1037 t4a = (IN(1) * 3196 - IN(7) * 16069 + (1 << 13)) >> 14;
1038 t5a = (IN(5) * 13623 - IN(3) * 9102 + (1 << 13)) >> 14;
1039 t6a = (IN(5) * 9102 + IN(3) * 13623 + (1 << 13)) >> 14;
1040 t7a = (IN(1) * 16069 + IN(7) * 3196 + (1 << 13)) >> 14;
1051 t5 = ((t6a - t5a) * 11585 + (1 << 13)) >> 14;
1052 t6 = ((t6a + t5a) * 11585 + (1 << 13)) >> 14;
1064 static av_always_inline void iadst8_1d(int16_t *out, const int16_t *in,
1065 ptrdiff_t stride, int pass)
1067 int t0, t0a, t1, t1a, t2, t2a, t3, t3a, t4, t4a, t5, t5a, t6, t6a, t7, t7a;
1069 t0a = 16305 * IN(7) + 1606 * IN(0);
1070 t1a = 1606 * IN(7) - 16305 * IN(0);
1071 t2a = 14449 * IN(5) + 7723 * IN(2);
1072 t3a = 7723 * IN(5) - 14449 * IN(2);
1073 t4a = 10394 * IN(3) + 12665 * IN(4);
1074 t5a = 12665 * IN(3) - 10394 * IN(4);
1075 t6a = 4756 * IN(1) + 15679 * IN(6);
1076 t7a = 15679 * IN(1) - 4756 * IN(6);
1078 t0 = (t0a + t4a + (1 << 13)) >> 14;
1079 t1 = (t1a + t5a + (1 << 13)) >> 14;
1080 t2 = (t2a + t6a + (1 << 13)) >> 14;
1081 t3 = (t3a + t7a + (1 << 13)) >> 14;
1082 t4 = (t0a - t4a + (1 << 13)) >> 14;
1083 t5 = (t1a - t5a + (1 << 13)) >> 14;
1084 t6 = (t2a - t6a + (1 << 13)) >> 14;
1085 t7 = (t3a - t7a + (1 << 13)) >> 14;
1087 t4a = 15137 * t4 + 6270 * t5;
1088 t5a = 6270 * t4 - 15137 * t5;
1089 t6a = 15137 * t7 - 6270 * t6;
1090 t7a = 6270 * t7 + 15137 * t6;
1093 out[7] = -(t1 + t3);
1097 out[1] = -((t4a + t6a + (1 << 13)) >> 14);
1098 out[6] = (t5a + t7a + (1 << 13)) >> 14;
1099 t6 = (t4a - t6a + (1 << 13)) >> 14;
1100 t7 = (t5a - t7a + (1 << 13)) >> 14;
1102 out[3] = -(((t2 + t3) * 11585 + (1 << 13)) >> 14);
1103 out[4] = ((t2 - t3) * 11585 + (1 << 13)) >> 14;
1104 out[2] = ((t6 + t7) * 11585 + (1 << 13)) >> 14;
1105 out[5] = -(((t6 - t7) * 11585 + (1 << 13)) >> 14);
1110 static av_always_inline void idct16_1d(int16_t *out, const int16_t *in,
1111 ptrdiff_t stride, int pass)
1113 int t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15;
1114 int t0a, t1a, t2a, t3a, t4a, t5a, t6a, t7a;
1115 int t8a, t9a, t10a, t11a, t12a, t13a, t14a, t15a;
1117 t0a = ((IN(0) + IN(8)) * 11585 + (1 << 13)) >> 14;
1118 t1a = ((IN(0) - IN(8)) * 11585 + (1 << 13)) >> 14;
1119 t2a = (IN(4) * 6270 - IN(12) * 15137 + (1 << 13)) >> 14;
1120 t3a = (IN(4) * 15137 + IN(12) * 6270 + (1 << 13)) >> 14;
1121 t4a = (IN(2) * 3196 - IN(14) * 16069 + (1 << 13)) >> 14;
1122 t7a = (IN(2) * 16069 + IN(14) * 3196 + (1 << 13)) >> 14;
1123 t5a = (IN(10) * 13623 - IN(6) * 9102 + (1 << 13)) >> 14;
1124 t6a = (IN(10) * 9102 + IN(6) * 13623 + (1 << 13)) >> 14;
1125 t8a = (IN(1) * 1606 - IN(15) * 16305 + (1 << 13)) >> 14;
1126 t15a = (IN(1) * 16305 + IN(15) * 1606 + (1 << 13)) >> 14;
1127 t9a = (IN(9) * 12665 - IN(7) * 10394 + (1 << 13)) >> 14;
1128 t14a = (IN(9) * 10394 + IN(7) * 12665 + (1 << 13)) >> 14;
1129 t10a = (IN(5) * 7723 - IN(11) * 14449 + (1 << 13)) >> 14;
1130 t13a = (IN(5) * 14449 + IN(11) * 7723 + (1 << 13)) >> 14;
1131 t11a = (IN(13) * 15679 - IN(3) * 4756 + (1 << 13)) >> 14;
1132 t12a = (IN(13) * 4756 + IN(3) * 15679 + (1 << 13)) >> 14;
1151 t5a = ((t6 - t5) * 11585 + (1 << 13)) >> 14;
1152 t6a = ((t6 + t5) * 11585 + (1 << 13)) >> 14;
1153 t9a = (t14 * 6270 - t9 * 15137 + (1 << 13)) >> 14;
1154 t14a = (t14 * 15137 + t9 * 6270 + (1 << 13)) >> 14;
1155 t10a = (-(t13 * 15137 + t10 * 6270) + (1 << 13)) >> 14;
1156 t13a = (t13 * 6270 - t10 * 15137 + (1 << 13)) >> 14;
1175 t10a = ((t13 - t10) * 11585 + (1 << 13)) >> 14;
1176 t13a = ((t13 + t10) * 11585 + (1 << 13)) >> 14;
1177 t11 = ((t12a - t11a) * 11585 + (1 << 13)) >> 14;
1178 t12 = ((t12a + t11a) * 11585 + (1 << 13)) >> 14;
1180 out[0] = t0a + t15a;
1182 out[2] = t2a + t13a;
1190 out[10] = t5 - t10a;
1192 out[12] = t3a - t12;
1193 out[13] = t2a - t13a;
1194 out[14] = t1a - t14;
1195 out[15] = t0a - t15a;
1198 static av_always_inline void iadst16_1d(int16_t *out, const int16_t *in,
1199 ptrdiff_t stride, int pass)
1201 int t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15;
1202 int t0a, t1a, t2a, t3a, t4a, t5a, t6a, t7a;
1203 int t8a, t9a, t10a, t11a, t12a, t13a, t14a, t15a;
1205 t0 = IN(15) * 16364 + IN(0) * 804;
1206 t1 = IN(15) * 804 - IN(0) * 16364;
1207 t2 = IN(13) * 15893 + IN(2) * 3981;
1208 t3 = IN(13) * 3981 - IN(2) * 15893;
1209 t4 = IN(11) * 14811 + IN(4) * 7005;
1210 t5 = IN(11) * 7005 - IN(4) * 14811;
1211 t6 = IN(9) * 13160 + IN(6) * 9760;
1212 t7 = IN(9) * 9760 - IN(6) * 13160;
1213 t8 = IN(7) * 11003 + IN(8) * 12140;
1214 t9 = IN(7) * 12140 - IN(8) * 11003;
1215 t10 = IN(5) * 8423 + IN(10) * 14053;
1216 t11 = IN(5) * 14053 - IN(10) * 8423;
1217 t12 = IN(3) * 5520 + IN(12) * 15426;
1218 t13 = IN(3) * 15426 - IN(12) * 5520;
1219 t14 = IN(1) * 2404 + IN(14) * 16207;
1220 t15 = IN(1) * 16207 - IN(14) * 2404;
1222 t0a = (t0 + t8 + (1 << 13)) >> 14;
1223 t1a = (t1 + t9 + (1 << 13)) >> 14;
1224 t2a = (t2 + t10 + (1 << 13)) >> 14;
1225 t3a = (t3 + t11 + (1 << 13)) >> 14;
1226 t4a = (t4 + t12 + (1 << 13)) >> 14;
1227 t5a = (t5 + t13 + (1 << 13)) >> 14;
1228 t6a = (t6 + t14 + (1 << 13)) >> 14;
1229 t7a = (t7 + t15 + (1 << 13)) >> 14;
1230 t8a = (t0 - t8 + (1 << 13)) >> 14;
1231 t9a = (t1 - t9 + (1 << 13)) >> 14;
1232 t10a = (t2 - t10 + (1 << 13)) >> 14;
1233 t11a = (t3 - t11 + (1 << 13)) >> 14;
1234 t12a = (t4 - t12 + (1 << 13)) >> 14;
1235 t13a = (t5 - t13 + (1 << 13)) >> 14;
1236 t14a = (t6 - t14 + (1 << 13)) >> 14;
1237 t15a = (t7 - t15 + (1 << 13)) >> 14;
1239 t8 = t8a * 16069 + t9a * 3196;
1240 t9 = t8a * 3196 - t9a * 16069;
1241 t10 = t10a * 9102 + t11a * 13623;
1242 t11 = t10a * 13623 - t11a * 9102;
1243 t12 = t13a * 16069 - t12a * 3196;
1244 t13 = t13a * 3196 + t12a * 16069;
1245 t14 = t15a * 9102 - t14a * 13623;
1246 t15 = t15a * 13623 + t14a * 9102;
1256 t8a = (t8 + t12 + (1 << 13)) >> 14;
1257 t9a = (t9 + t13 + (1 << 13)) >> 14;
1258 t10a = (t10 + t14 + (1 << 13)) >> 14;
1259 t11a = (t11 + t15 + (1 << 13)) >> 14;
1260 t12a = (t8 - t12 + (1 << 13)) >> 14;
1261 t13a = (t9 - t13 + (1 << 13)) >> 14;
1262 t14a = (t10 - t14 + (1 << 13)) >> 14;
1263 t15a = (t11 - t15 + (1 << 13)) >> 14;
1265 t4a = t4 * 15137 + t5 * 6270;
1266 t5a = t4 * 6270 - t5 * 15137;
1267 t6a = t7 * 15137 - t6 * 6270;
1268 t7a = t7 * 6270 + t6 * 15137;
1269 t12 = t12a * 15137 + t13a * 6270;
1270 t13 = t12a * 6270 - t13a * 15137;
1271 t14 = t15a * 15137 - t14a * 6270;
1272 t15 = t15a * 6270 + t14a * 15137;
1275 out[15] = -(t1 + t3);
1278 out[3] = -((t4a + t6a + (1 << 13)) >> 14);
1279 out[12] = (t5a + t7a + (1 << 13)) >> 14;
1280 t6 = (t4a - t6a + (1 << 13)) >> 14;
1281 t7 = (t5a - t7a + (1 << 13)) >> 14;
1282 out[1] = -(t8a + t10a);
1283 out[14] = t9a + t11a;
1286 out[2] = (t12 + t14 + (1 << 13)) >> 14;
1287 out[13] = -((t13 + t15 + (1 << 13)) >> 14);
1288 t14a = (t12 - t14 + (1 << 13)) >> 14;
1289 t15a = (t13 - t15 + (1 << 13)) >> 14;
1291 out[7] = ((t2a + t3a) * -11585 + (1 << 13)) >> 14;
1292 out[8] = ((t2a - t3a) * 11585 + (1 << 13)) >> 14;
1293 out[4] = ((t7 + t6) * 11585 + (1 << 13)) >> 14;
1294 out[11] = ((t7 - t6) * 11585 + (1 << 13)) >> 14;
1295 out[6] = ((t11 + t10) * 11585 + (1 << 13)) >> 14;
1296 out[9] = ((t11 - t10) * 11585 + (1 << 13)) >> 14;
1297 out[5] = ((t14a + t15a) * -11585 + (1 << 13)) >> 14;
1298 out[10] = ((t14a - t15a) * 11585 + (1 << 13)) >> 14;
1303 static av_always_inline void idct32_1d(int16_t *out, const int16_t *in,
1304 ptrdiff_t stride, int pass)
1306 int t0a = ((IN(0) + IN(16)) * 11585 + (1 << 13)) >> 14;
1307 int t1a = ((IN(0) - IN(16)) * 11585 + (1 << 13)) >> 14;
1308 int t2a = (IN(8) * 6270 - IN(24) * 15137 + (1 << 13)) >> 14;
1309 int t3a = (IN(8) * 15137 + IN(24) * 6270 + (1 << 13)) >> 14;
1310 int t4a = (IN(4) * 3196 - IN(28) * 16069 + (1 << 13)) >> 14;
1311 int t7a = (IN(4) * 16069 + IN(28) * 3196 + (1 << 13)) >> 14;
1312 int t5a = (IN(20) * 13623 - IN(12) * 9102 + (1 << 13)) >> 14;
1313 int t6a = (IN(20) * 9102 + IN(12) * 13623 + (1 << 13)) >> 14;
1314 int t8a = (IN(2) * 1606 - IN(30) * 16305 + (1 << 13)) >> 14;
1315 int t15a = (IN(2) * 16305 + IN(30) * 1606 + (1 << 13)) >> 14;
1316 int t9a = (IN(18) * 12665 - IN(14) * 10394 + (1 << 13)) >> 14;
1317 int t14a = (IN(18) * 10394 + IN(14) * 12665 + (1 << 13)) >> 14;
1318 int t10a = (IN(10) * 7723 - IN(22) * 14449 + (1 << 13)) >> 14;
1319 int t13a = (IN(10) * 14449 + IN(22) * 7723 + (1 << 13)) >> 14;
1320 int t11a = (IN(26) * 15679 - IN(6) * 4756 + (1 << 13)) >> 14;
1321 int t12a = (IN(26) * 4756 + IN(6) * 15679 + (1 << 13)) >> 14;
1322 int t16a = (IN(1) * 804 - IN(31) * 16364 + (1 << 13)) >> 14;
1323 int t31a = (IN(1) * 16364 + IN(31) * 804 + (1 << 13)) >> 14;
1324 int t17a = (IN(17) * 12140 - IN(15) * 11003 + (1 << 13)) >> 14;
1325 int t30a = (IN(17) * 11003 + IN(15) * 12140 + (1 << 13)) >> 14;
1326 int t18a = (IN(9) * 7005 - IN(23) * 14811 + (1 << 13)) >> 14;
1327 int t29a = (IN(9) * 14811 + IN(23) * 7005 + (1 << 13)) >> 14;
1328 int t19a = (IN(25) * 15426 - IN(7) * 5520 + (1 << 13)) >> 14;
1329 int t28a = (IN(25) * 5520 + IN(7) * 15426 + (1 << 13)) >> 14;
1330 int t20a = (IN(5) * 3981 - IN(27) * 15893 + (1 << 13)) >> 14;
1331 int t27a = (IN(5) * 15893 + IN(27) * 3981 + (1 << 13)) >> 14;
1332 int t21a = (IN(21) * 14053 - IN(11) * 8423 + (1 << 13)) >> 14;
1333 int t26a = (IN(21) * 8423 + IN(11) * 14053 + (1 << 13)) >> 14;
1334 int t22a = (IN(13) * 9760 - IN(19) * 13160 + (1 << 13)) >> 14;
1335 int t25a = (IN(13) * 13160 + IN(19) * 9760 + (1 << 13)) >> 14;
1336 int t23a = (IN(29) * 16207 - IN(3) * 2404 + (1 << 13)) >> 14;
1337 int t24a = (IN(29) * 2404 + IN(3) * 16207 + (1 << 13)) >> 14;
1349 int t10 = t11a - t10a;
1350 int t11 = t11a + t10a;
1351 int t12 = t12a + t13a;
1352 int t13 = t12a - t13a;
1353 int t14 = t15a - t14a;
1354 int t15 = t15a + t14a;
1355 int t16 = t16a + t17a;
1356 int t17 = t16a - t17a;
1357 int t18 = t19a - t18a;
1358 int t19 = t19a + t18a;
1359 int t20 = t20a + t21a;
1360 int t21 = t20a - t21a;
1361 int t22 = t23a - t22a;
1362 int t23 = t23a + t22a;
1363 int t24 = t24a + t25a;
1364 int t25 = t24a - t25a;
1365 int t26 = t27a - t26a;
1366 int t27 = t27a + t26a;
1367 int t28 = t28a + t29a;
1368 int t29 = t28a - t29a;
1369 int t30 = t31a - t30a;
1370 int t31 = t31a + t30a;
1372 t5a = ((t6 - t5) * 11585 + (1 << 13)) >> 14;
1373 t6a = ((t6 + t5) * 11585 + (1 << 13)) >> 14;
1374 t9a = (t14 * 6270 - t9 * 15137 + (1 << 13)) >> 14;
1375 t14a = (t14 * 15137 + t9 * 6270 + (1 << 13)) >> 14;
1376 t10a = (-(t13 * 15137 + t10 * 6270) + (1 << 13)) >> 14;
1377 t13a = (t13 * 6270 - t10 * 15137 + (1 << 13)) >> 14;
1378 t17a = (t30 * 3196 - t17 * 16069 + (1 << 13)) >> 14;
1379 t30a = (t30 * 16069 + t17 * 3196 + (1 << 13)) >> 14;
1380 t18a = (-(t29 * 16069 + t18 * 3196) + (1 << 13)) >> 14;
1381 t29a = (t29 * 3196 - t18 * 16069 + (1 << 13)) >> 14;
1382 t21a = (t26 * 13623 - t21 * 9102 + (1 << 13)) >> 14;
1383 t26a = (t26 * 9102 + t21 * 13623 + (1 << 13)) >> 14;
1384 t22a = (-(t25 * 9102 + t22 * 13623) + (1 << 13)) >> 14;
1385 t25a = (t25 * 13623 - t22 * 9102 + (1 << 13)) >> 14;
1420 t10a = ((t13 - t10) * 11585 + (1 << 13)) >> 14;
1421 t13a = ((t13 + t10) * 11585 + (1 << 13)) >> 14;
1422 t11 = ((t12a - t11a) * 11585 + (1 << 13)) >> 14;
1423 t12 = ((t12a + t11a) * 11585 + (1 << 13)) >> 14;
1424 t18a = (t29 * 6270 - t18 * 15137 + (1 << 13)) >> 14;
1425 t29a = (t29 * 15137 + t18 * 6270 + (1 << 13)) >> 14;
1426 t19 = (t28a * 6270 - t19a * 15137 + (1 << 13)) >> 14;
1427 t28 = (t28a * 15137 + t19a * 6270 + (1 << 13)) >> 14;
1428 t20 = (-(t27a * 15137 + t20a * 6270) + (1 << 13)) >> 14;
1429 t27 = (t27a * 6270 - t20a * 15137 + (1 << 13)) >> 14;
1430 t21a = (-(t26 * 15137 + t21 * 6270) + (1 << 13)) >> 14;
1431 t26a = (t26 * 6270 - t21 * 15137 + (1 << 13)) >> 14;
1466 t20 = ((t27a - t20a) * 11585 + (1 << 13)) >> 14;
1467 t27 = ((t27a + t20a) * 11585 + (1 << 13)) >> 14;
1468 t21a = ((t26 - t21) * 11585 + (1 << 13)) >> 14;
1469 t26a = ((t26 + t21) * 11585 + (1 << 13)) >> 14;
1470 t22 = ((t25a - t22a) * 11585 + (1 << 13)) >> 14;
1471 t25 = ((t25a + t22a) * 11585 + (1 << 13)) >> 14;
1472 t23a = ((t24 - t23) * 11585 + (1 << 13)) >> 14;
1473 t24a = ((t24 + t23) * 11585 + (1 << 13)) >> 14;
1480 out[5] = t5a + t26a;
1485 out[10] = t10 + t21a;
1486 out[11] = t11a + t20;
1487 out[12] = t12a + t19a;
1488 out[13] = t13 + t18;
1489 out[14] = t14a + t17a;
1490 out[15] = t15 + t16;
1491 out[16] = t15 - t16;
1492 out[17] = t14a - t17a;
1493 out[18] = t13 - t18;
1494 out[19] = t12a - t19a;
1495 out[20] = t11a - t20;
1496 out[21] = t10 - t21a;
1497 out[22] = t9a - t22;
1498 out[23] = t8 - t23a;
1499 out[24] = t7 - t24a;
1500 out[25] = t6a - t25;
1501 out[26] = t5a - t26a;
1503 out[28] = t3 - t28a;
1505 out[30] = t1 - t30a;
1509 itxfm_wrapper(idct, idct, 32, 6, 1)
1511 static av_always_inline void iwht4_1d(int16_t *out, const int16_t *in,
1512 ptrdiff_t stride, int pass)
1514 int t0, t1, t2, t3, t4;
1530 t4 = (t0 - t3) >> 1;
1542 itxfm_wrapper(iwht, iwht, 4, 0, 0)
1545 #undef itxfm_wrapper
1548 static av_cold void vp9dsp_itxfm_init(VP9DSPContext *dsp)
1550 #define init_itxfm(tx, sz) \
1551 dsp->itxfm_add[tx][DCT_DCT] = idct_idct_ ## sz ## _add_c; \
1552 dsp->itxfm_add[tx][DCT_ADST] = iadst_idct_ ## sz ## _add_c; \
1553 dsp->itxfm_add[tx][ADST_DCT] = idct_iadst_ ## sz ## _add_c; \
1554 dsp->itxfm_add[tx][ADST_ADST] = iadst_iadst_ ## sz ## _add_c
1556 #define init_idct(tx, nm) \
1557 dsp->itxfm_add[tx][DCT_DCT] = \
1558 dsp->itxfm_add[tx][ADST_DCT] = \
1559 dsp->itxfm_add[tx][DCT_ADST] = \
1560 dsp->itxfm_add[tx][ADST_ADST] = nm ## _add_c
1562 init_itxfm(TX_4X4, 4x4);
1563 init_itxfm(TX_8X8, 8x8);
1564 init_itxfm(TX_16X16, 16x16);
1565 init_idct(TX_32X32, idct_idct_32x32);
1566 init_idct(4 /* lossless */, iwht_iwht_4x4);
1572 static av_always_inline void loop_filter(uint8_t *dst, ptrdiff_t stride,
1573 int E, int I, int H,
1574 ptrdiff_t stridea, ptrdiff_t strideb,
1579 for (i = 0; i < 8; i++, dst += stridea) {
1581 int p3 = dst[strideb * -4], p2 = dst[strideb * -3];
1582 int p1 = dst[strideb * -2], p0 = dst[strideb * -1];
1583 int q0 = dst[strideb * +0], q1 = dst[strideb * +1];
1584 int q2 = dst[strideb * +2], q3 = dst[strideb * +3];
1586 int fm = FFABS(p3 - p2) <= I && FFABS(p2 - p1) <= I &&
1587 FFABS(p1 - p0) <= I && FFABS(q1 - q0) <= I &&
1588 FFABS(q2 - q1) <= I && FFABS(q3 - q2) <= I &&
1589 FFABS(p0 - q0) * 2 + (FFABS(p1 - q1) >> 1) <= E;
1590 int flat8out, flat8in;
1596 p7 = dst[strideb * -8];
1597 p6 = dst[strideb * -7];
1598 p5 = dst[strideb * -6];
1599 p4 = dst[strideb * -5];
1600 q4 = dst[strideb * +4];
1601 q5 = dst[strideb * +5];
1602 q6 = dst[strideb * +6];
1603 q7 = dst[strideb * +7];
1605 flat8out = FFABS(p7 - p0) <= 1 && FFABS(p6 - p0) <= 1 &&
1606 FFABS(p5 - p0) <= 1 && FFABS(p4 - p0) <= 1 &&
1607 FFABS(q4 - q0) <= 1 && FFABS(q5 - q0) <= 1 &&
1608 FFABS(q6 - q0) <= 1 && FFABS(q7 - q0) <= 1;
1612 flat8in = FFABS(p3 - p0) <= 1 && FFABS(p2 - p0) <= 1 &&
1613 FFABS(p1 - p0) <= 1 && FFABS(q1 - q0) <= 1 &&
1614 FFABS(q2 - q0) <= 1 && FFABS(q3 - q0) <= 1;
1616 if (wd >= 16 && flat8out && flat8in) {
1617 dst[strideb * -7] = (p7 + p7 + p7 + p7 + p7 + p7 + p7 + p6 * 2 +
1618 p5 + p4 + p3 + p2 + p1 + p0 + q0 + 8) >> 4;
1619 dst[strideb * -6] = (p7 + p7 + p7 + p7 + p7 + p7 + p6 + p5 * 2 +
1620 p4 + p3 + p2 + p1 + p0 + q0 + q1 + 8) >> 4;
1621 dst[strideb * -5] = (p7 + p7 + p7 + p7 + p7 + p6 + p5 + p4 * 2 +
1622 p3 + p2 + p1 + p0 + q0 + q1 + q2 + 8) >> 4;
1623 dst[strideb * -4] = (p7 + p7 + p7 + p7 + p6 + p5 + p4 + p3 * 2 +
1624 p2 + p1 + p0 + q0 + q1 + q2 + q3 + 8) >> 4;
1625 dst[strideb * -3] = (p7 + p7 + p7 + p6 + p5 + p4 + p3 + p2 * 2 +
1626 p1 + p0 + q0 + q1 + q2 + q3 + q4 + 8) >> 4;
1627 dst[strideb * -2] = (p7 + p7 + p6 + p5 + p4 + p3 + p2 + p1 * 2 +
1628 p0 + q0 + q1 + q2 + q3 + q4 + q5 + 8) >> 4;
1629 dst[strideb * -1] = (p7 + p6 + p5 + p4 + p3 + p2 + p1 + p0 * 2 +
1630 q0 + q1 + q2 + q3 + q4 + q5 + q6 + 8) >> 4;
1631 dst[strideb * +0] = (p6 + p5 + p4 + p3 + p2 + p1 + p0 + q0 * 2 +
1632 q1 + q2 + q3 + q4 + q5 + q6 + q7 + 8) >> 4;
1633 dst[strideb * +1] = (p5 + p4 + p3 + p2 + p1 + p0 + q0 + q1 * 2 +
1634 q2 + q3 + q4 + q5 + q6 + q7 + q7 + 8) >> 4;
1635 dst[strideb * +2] = (p4 + p3 + p2 + p1 + p0 + q0 + q1 + q2 * 2 +
1636 q3 + q4 + q5 + q6 + q7 + q7 + q7 + 8) >> 4;
1637 dst[strideb * +3] = (p3 + p2 + p1 + p0 + q0 + q1 + q2 + q3 * 2 +
1638 q4 + q5 + q6 + q7 + q7 + q7 + q7 + 8) >> 4;
1639 dst[strideb * +4] = (p2 + p1 + p0 + q0 + q1 + q2 + q3 + q4 * 2 +
1640 q5 + q6 + q7 + q7 + q7 + q7 + q7 + 8) >> 4;
1641 dst[strideb * +5] = (p1 + p0 + q0 + q1 + q2 + q3 + q4 + q5 * 2 +
1642 q6 + q7 + q7 + q7 + q7 + q7 + q7 + 8) >> 4;
1643 dst[strideb * +6] = (p0 + q0 + q1 + q2 + q3 + q4 + q5 + q6 * 2 +
1644 q7 + q7 + q7 + q7 + q7 + q7 + q7 + 8) >> 4;
1645 } else if (wd >= 8 && flat8in) {
1646 dst[strideb * -3] = (p3 + p3 + p3 + 2 * p2 + p1 + p0 + q0 + 4) >> 3;
1647 dst[strideb * -2] = (p3 + p3 + p2 + 2 * p1 + p0 + q0 + q1 + 4) >> 3;
1648 dst[strideb * -1] = (p3 + p2 + p1 + 2 * p0 + q0 + q1 + q2 + 4) >> 3;
1649 dst[strideb * +0] = (p2 + p1 + p0 + 2 * q0 + q1 + q2 + q3 + 4) >> 3;
1650 dst[strideb * +1] = (p1 + p0 + q0 + 2 * q1 + q2 + q3 + q3 + 4) >> 3;
1651 dst[strideb * +2] = (p0 + q0 + q1 + 2 * q2 + q3 + q3 + q3 + 4) >> 3;
1653 int hev = FFABS(p1 - p0) > H || FFABS(q1 - q0) > H;
1656 int f = av_clip_int8(3 * (q0 - p0) + av_clip_int8(p1 - q1));
1657 int f1 = FFMIN(f + 4, 127) >> 3;
1658 int f2 = FFMIN(f + 3, 127) >> 3;
1660 dst[strideb * -1] = av_clip_uint8(p0 + f2);
1661 dst[strideb * +0] = av_clip_uint8(q0 - f1);
1663 int f = av_clip_int8(3 * (q0 - p0));
1664 int f1 = FFMIN(f + 4, 127) >> 3;
1665 int f2 = FFMIN(f + 3, 127) >> 3;
1667 dst[strideb * -1] = av_clip_uint8(p0 + f2);
1668 dst[strideb * +0] = av_clip_uint8(q0 - f1);
1671 dst[strideb * -2] = av_clip_uint8(p1 + f);
1672 dst[strideb * +1] = av_clip_uint8(q1 - f);
1678 #define lf_8_fn(dir, wd, stridea, strideb) \
1679 static void loop_filter_ ## dir ## _ ## wd ## _8_c(uint8_t *dst, \
1681 int E, int I, int H) \
1683 loop_filter(dst, stride, E, I, H, stridea, strideb, wd); \
1686 #define lf_8_fns(wd) \
1687 lf_8_fn(h, wd, stride, 1) \
1688 lf_8_fn(v, wd, 1, stride)
1697 #define lf_16_fn(dir, stridea) \
1698 static void loop_filter_ ## dir ## _16_16_c(uint8_t *dst, \
1700 int E, int I, int H) \
1702 loop_filter_ ## dir ## _16_8_c(dst, stride, E, I, H); \
1703 loop_filter_ ## dir ## _16_8_c(dst + 8 * stridea, stride, E, I, H); \
1711 #define lf_mix_fn(dir, wd1, wd2, stridea) \
1712 static void loop_filter_ ## dir ## _ ## wd1 ## wd2 ## _16_c(uint8_t *dst, \
1717 loop_filter_ ## dir ## _ ## wd1 ## _8_c(dst, stride, E & 0xff, \
1718 I & 0xff, H & 0xff); \
1719 loop_filter_ ## dir ## _ ## wd2 ## _8_c(dst + 8 * stridea, stride, \
1720 E >> 8, I >> 8, H >> 8); \
1723 #define lf_mix_fns(wd1, wd2) \
1724 lf_mix_fn(h, wd1, wd2, stride) \
1725 lf_mix_fn(v, wd1, wd2, 1)
1735 static av_cold void vp9dsp_loopfilter_init(VP9DSPContext *dsp)
1737 dsp->loop_filter_8[0][0] = loop_filter_h_4_8_c;
1738 dsp->loop_filter_8[0][1] = loop_filter_v_4_8_c;
1739 dsp->loop_filter_8[1][0] = loop_filter_h_8_8_c;
1740 dsp->loop_filter_8[1][1] = loop_filter_v_8_8_c;
1741 dsp->loop_filter_8[2][0] = loop_filter_h_16_8_c;
1742 dsp->loop_filter_8[2][1] = loop_filter_v_16_8_c;
1744 dsp->loop_filter_16[0] = loop_filter_h_16_16_c;
1745 dsp->loop_filter_16[1] = loop_filter_v_16_16_c;
1747 dsp->loop_filter_mix2[0][0][0] = loop_filter_h_44_16_c;
1748 dsp->loop_filter_mix2[0][0][1] = loop_filter_v_44_16_c;
1749 dsp->loop_filter_mix2[0][1][0] = loop_filter_h_48_16_c;
1750 dsp->loop_filter_mix2[0][1][1] = loop_filter_v_48_16_c;
1751 dsp->loop_filter_mix2[1][0][0] = loop_filter_h_84_16_c;
1752 dsp->loop_filter_mix2[1][0][1] = loop_filter_v_84_16_c;
1753 dsp->loop_filter_mix2[1][1][0] = loop_filter_h_88_16_c;
1754 dsp->loop_filter_mix2[1][1][1] = loop_filter_v_88_16_c;
1757 static av_always_inline void copy_c(uint8_t *dst, ptrdiff_t dst_stride,
1758 const uint8_t *src, ptrdiff_t src_stride,
1762 memcpy(dst, src, w);
1769 static av_always_inline void avg_c(uint8_t *dst, ptrdiff_t dst_stride,
1770 const uint8_t *src, ptrdiff_t src_stride,
1776 for (x = 0; x < w; x += 4)
1777 AV_WN32A(&dst[x], rnd_avg32(AV_RN32A(&dst[x]), AV_RN32(&src[x])));
1784 #define fpel_fn(type, sz) \
1785 static void type ## sz ## _c(uint8_t *dst, ptrdiff_t dst_stride, \
1786 const uint8_t *src, ptrdiff_t src_stride, \
1787 int h, int mx, int my) \
1789 type ## _c(dst, dst_stride, src, src_stride, sz, h); \
1792 #define copy_avg_fn(sz) \
1805 const DECLARE_ALIGNED(8, int8_t, ff_vp9_subpel_filters)[3][15][8] = {
1806 [FILTER_8TAP_REGULAR] = {
1807 { 0, 1, -5, 126, 8, -3, 1, 0 },
1808 { -1, 3, -10, 122, 18, -6, 2, 0 },
1809 { -1, 4, -13, 118, 27, -9, 3, -1 },
1810 { -1, 4, -16, 112, 37, -11, 4, -1 },
1811 { -1, 5, -18, 105, 48, -14, 4, -1 },
1812 { -1, 5, -19, 97, 58, -16, 5, -1 },
1813 { -1, 6, -19, 88, 68, -18, 5, -1 },
1814 { -1, 6, -19, 78, 78, -19, 6, -1 },
1815 { -1, 5, -18, 68, 88, -19, 6, -1 },
1816 { -1, 5, -16, 58, 97, -19, 5, -1 },
1817 { -1, 4, -14, 48, 105, -18, 5, -1 },
1818 { -1, 4, -11, 37, 112, -16, 4, -1 },
1819 { -1, 3, -9, 27, 118, -13, 4, -1 },
1820 { 0, 2, -6, 18, 122, -10, 3, -1 },
1821 { 0, 1, -3, 8, 126, -5, 1, 0 },
1822 }, [FILTER_8TAP_SHARP] = {
1823 { -1, 3, -7, 127, 8, -3, 1, 0 },
1824 { -2, 5, -13, 125, 17, -6, 3, -1 },
1825 { -3, 7, -17, 121, 27, -10, 5, -2 },
1826 { -4, 9, -20, 115, 37, -13, 6, -2 },
1827 { -4, 10, -23, 108, 48, -16, 8, -3 },
1828 { -4, 10, -24, 100, 59, -19, 9, -3 },
1829 { -4, 11, -24, 90, 70, -21, 10, -4 },
1830 { -4, 11, -23, 80, 80, -23, 11, -4 },
1831 { -4, 10, -21, 70, 90, -24, 11, -4 },
1832 { -3, 9, -19, 59, 100, -24, 10, -4 },
1833 { -3, 8, -16, 48, 108, -23, 10, -4 },
1834 { -2, 6, -13, 37, 115, -20, 9, -4 },
1835 { -2, 5, -10, 27, 121, -17, 7, -3 },
1836 { -1, 3, -6, 17, 125, -13, 5, -2 },
1837 { 0, 1, -3, 8, 127, -7, 3, -1 },
1838 }, [FILTER_8TAP_SMOOTH] = {
1839 { -3, -1, 32, 64, 38, 1, -3, 0 },
1840 { -2, -2, 29, 63, 41, 2, -3, 0 },
1841 { -2, -2, 26, 63, 43, 4, -4, 0 },
1842 { -2, -3, 24, 62, 46, 5, -4, 0 },
1843 { -2, -3, 21, 60, 49, 7, -4, 0 },
1844 { -1, -4, 18, 59, 51, 9, -4, 0 },
1845 { -1, -4, 16, 57, 53, 12, -4, -1 },
1846 { -1, -4, 14, 55, 55, 14, -4, -1 },
1847 { -1, -4, 12, 53, 57, 16, -4, -1 },
1848 { 0, -4, 9, 51, 59, 18, -4, -1 },
1849 { 0, -4, 7, 49, 60, 21, -3, -2 },
1850 { 0, -4, 5, 46, 62, 24, -3, -2 },
1851 { 0, -4, 4, 43, 63, 26, -2, -2 },
1852 { 0, -3, 2, 41, 63, 29, -2, -2 },
1853 { 0, -3, 1, 38, 64, 32, -1, -3 },
1857 #define FILTER_8TAP(src, x, F, stride) \
1858 av_clip_uint8((F[0] * src[x + -3 * stride] + \
1859 F[1] * src[x + -2 * stride] + \
1860 F[2] * src[x + -1 * stride] + \
1861 F[3] * src[x + +0 * stride] + \
1862 F[4] * src[x + +1 * stride] + \
1863 F[5] * src[x + +2 * stride] + \
1864 F[6] * src[x + +3 * stride] + \
1865 F[7] * src[x + +4 * stride] + 64) >> 7)
1867 static av_always_inline void do_8tap_1d_c(uint8_t *dst, ptrdiff_t dst_stride,
1868 const uint8_t *src, ptrdiff_t src_stride,
1869 int w, int h, ptrdiff_t ds,
1870 const int8_t *filter, int avg)
1875 for (x = 0; x < w; x++)
1877 dst[x] = (dst[x] + FILTER_8TAP(src, x, filter, ds) + 1) >> 1;
1879 dst[x] = FILTER_8TAP(src, x, filter, ds);
1886 #define filter_8tap_1d_fn(opn, opa, dir, ds) \
1887 static av_noinline void opn ## _8tap_1d_ ## dir ## _c(uint8_t *dst, \
1888 ptrdiff_t dst_stride, \
1889 const uint8_t *src, \
1890 ptrdiff_t src_stride, \
1892 const int8_t *filter) \
1894 do_8tap_1d_c(dst, dst_stride, src, src_stride, w, h, ds, filter, opa); \
1897 filter_8tap_1d_fn(put, 0, v, src_stride)
1898 filter_8tap_1d_fn(put, 0, h, 1)
1899 filter_8tap_1d_fn(avg, 1, v, src_stride)
1900 filter_8tap_1d_fn(avg, 1, h, 1)
1902 #undef filter_8tap_1d_fn
1904 static av_always_inline void do_8tap_2d_c(uint8_t *dst, ptrdiff_t dst_stride,
1905 const uint8_t *src, ptrdiff_t src_stride,
1906 int w, int h, const int8_t *filterx,
1907 const int8_t *filtery, int avg)
1910 uint8_t tmp[64 * 71], *tmp_ptr = tmp;
1912 src -= src_stride * 3;
1916 for (x = 0; x < w; x++)
1917 tmp_ptr[x] = FILTER_8TAP(src, x, filterx, 1);
1923 tmp_ptr = tmp + 64 * 3;
1927 for (x = 0; x < w; x++)
1929 dst[x] = (dst[x] + FILTER_8TAP(tmp_ptr, x, filtery, 64) + 1) >> 1;
1931 dst[x] = FILTER_8TAP(tmp_ptr, x, filtery, 64);
1938 #define filter_8tap_2d_fn(opn, opa) \
1939 static av_noinline void opn ## _8tap_2d_hv_c(uint8_t *dst, \
1940 ptrdiff_t dst_stride, \
1941 const uint8_t *src, \
1942 ptrdiff_t src_stride, \
1944 const int8_t *filterx, \
1945 const int8_t *filtery) \
1947 do_8tap_2d_c(dst, dst_stride, src, src_stride, \
1948 w, h, filterx, filtery, opa); \
1951 filter_8tap_2d_fn(put, 0)
1952 filter_8tap_2d_fn(avg, 1)
1954 #undef filter_8tap_2d_fn
1958 #define filter_fn_1d(sz, dir, dir_m, type, type_idx, avg) \
1960 avg ## _8tap_ ## type ## _ ## sz ## dir ## _c(uint8_t *dst, \
1961 ptrdiff_t dst_stride, \
1962 const uint8_t *src, \
1963 ptrdiff_t src_stride, \
1964 int h, int mx, int my) \
1966 avg ## _8tap_1d_ ## dir ## _c(dst, dst_stride, src, src_stride, sz, h, \
1967 ff_vp9_subpel_filters[type_idx][dir_m - 1]); \
1970 #define filter_fn_2d(sz, type, type_idx, avg) \
1971 static void avg ## _8tap_ ## type ## _ ## sz ## hv_c(uint8_t *dst, \
1972 ptrdiff_t dst_stride, \
1973 const uint8_t *src, \
1974 ptrdiff_t src_stride, \
1975 int h, int mx, int my) \
1977 avg ## _8tap_2d_hv_c(dst, dst_stride, src, src_stride, sz, h, \
1978 ff_vp9_subpel_filters[type_idx][mx - 1], \
1979 ff_vp9_subpel_filters[type_idx][my - 1]); \
1982 #define FILTER_BILIN(src, x, mxy, stride) \
1983 (src[x] + ((mxy * (src[x + stride] - src[x]) + 8) >> 4))
1985 static av_always_inline void do_bilin_1d_c(uint8_t *dst,
1986 ptrdiff_t dst_stride,
1988 ptrdiff_t src_stride,
1989 int w, int h, ptrdiff_t ds,
1995 for (x = 0; x < w; x++)
1997 dst[x] = (dst[x] + FILTER_BILIN(src, x, mxy, ds) + 1) >> 1;
1999 dst[x] = FILTER_BILIN(src, x, mxy, ds);
2006 #define bilin_1d_fn(opn, opa, dir, ds) \
2007 static av_noinline void opn ## _bilin_1d_ ## dir ## _c(uint8_t *dst, \
2008 ptrdiff_t dst_stride, \
2009 const uint8_t *src, \
2010 ptrdiff_t src_stride, \
2011 int w, int h, int mxy) \
2013 do_bilin_1d_c(dst, dst_stride, src, src_stride, w, h, ds, mxy, opa); \
2016 bilin_1d_fn(put, 0, v, src_stride)
2017 bilin_1d_fn(put, 0, h, 1)
2018 bilin_1d_fn(avg, 1, v, src_stride)
2019 bilin_1d_fn(avg, 1, h, 1)
2023 static av_always_inline void do_bilin_2d_c(uint8_t *dst,
2024 ptrdiff_t dst_stride,
2026 ptrdiff_t src_stride,
2027 int w, int h, int mx, int my,
2030 uint8_t tmp[64 * 65], *tmp_ptr = tmp;
2036 for (x = 0; x < w; x++)
2037 tmp_ptr[x] = FILTER_BILIN(src, x, mx, 1);
2047 for (x = 0; x < w; x++)
2049 dst[x] = (dst[x] + FILTER_BILIN(tmp_ptr, x, my, 64) + 1) >> 1;
2051 dst[x] = FILTER_BILIN(tmp_ptr, x, my, 64);
2058 #define bilin_2d_fn(opn, opa) \
2059 static av_noinline void opn ## _bilin_2d_hv_c(uint8_t *dst, \
2060 ptrdiff_t dst_stride, \
2061 const uint8_t *src, \
2062 ptrdiff_t src_stride, \
2066 do_bilin_2d_c(dst, dst_stride, src, src_stride, w, h, mx, my, opa); \
2076 #define bilinf_fn_1d(sz, dir, dir_m, avg) \
2077 static void avg ## _bilin_ ## sz ## dir ## _c(uint8_t *dst, \
2078 ptrdiff_t dst_stride, \
2079 const uint8_t *src, \
2080 ptrdiff_t src_stride, \
2081 int h, int mx, int my) \
2083 avg ## _bilin_1d_ ## dir ## _c(dst, dst_stride, src, src_stride, \
2087 #define bilinf_fn_2d(sz, avg) \
2088 static void avg ## _bilin_ ## sz ## hv_c(uint8_t *dst, \
2089 ptrdiff_t dst_stride, \
2090 const uint8_t *src, \
2091 ptrdiff_t src_stride, \
2092 int h, int mx, int my) \
2094 avg ## _bilin_2d_hv_c(dst, dst_stride, src, src_stride, \
2098 #define filter_fn(sz, avg) \
2099 filter_fn_1d(sz, h, mx, regular, FILTER_8TAP_REGULAR, avg) \
2100 filter_fn_1d(sz, v, my, regular, FILTER_8TAP_REGULAR, avg) \
2101 filter_fn_2d(sz, regular, FILTER_8TAP_REGULAR, avg) \
2102 filter_fn_1d(sz, h, mx, smooth, FILTER_8TAP_SMOOTH, avg) \
2103 filter_fn_1d(sz, v, my, smooth, FILTER_8TAP_SMOOTH, avg) \
2104 filter_fn_2d(sz, smooth, FILTER_8TAP_SMOOTH, avg) \
2105 filter_fn_1d(sz, h, mx, sharp, FILTER_8TAP_SHARP, avg) \
2106 filter_fn_1d(sz, v, my, sharp, FILTER_8TAP_SHARP, avg) \
2107 filter_fn_2d(sz, sharp, FILTER_8TAP_SHARP, avg) \
2108 bilinf_fn_1d(sz, h, mx, avg) \
2109 bilinf_fn_1d(sz, v, my, avg) \
2110 bilinf_fn_2d(sz, avg)
2112 #define filter_fn_set(avg) \
2113 filter_fn(64, avg) \
2114 filter_fn(32, avg) \
2115 filter_fn(16, avg) \
2123 #undef filter_fn_set
2129 static av_cold void vp9dsp_mc_init(VP9DSPContext *dsp)
2131 #define init_fpel(idx1, idx2, sz, type) \
2132 dsp->mc[idx1][FILTER_8TAP_SMOOTH][idx2][0][0] = type ## sz ## _c; \
2133 dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = type ## sz ## _c; \
2134 dsp->mc[idx1][FILTER_8TAP_SHARP][idx2][0][0] = type ## sz ## _c; \
2135 dsp->mc[idx1][FILTER_BILINEAR][idx2][0][0] = type ## sz ## _c
2137 #define init_copy_avg(idx, sz) \
2138 init_fpel(idx, 0, sz, copy); \
2139 init_fpel(idx, 1, sz, avg)
2141 init_copy_avg(0, 64);
2142 init_copy_avg(1, 32);
2143 init_copy_avg(2, 16);
2144 init_copy_avg(3, 8);
2145 init_copy_avg(4, 4);
2147 #undef init_copy_avg
2150 #define init_subpel1(idx1, idx2, idxh, idxv, sz, dir, type) \
2151 dsp->mc[idx1][FILTER_8TAP_SMOOTH][idx2][idxh][idxv] = type ## _8tap_smooth_ ## sz ## dir ## _c; \
2152 dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][idxh][idxv] = type ## _8tap_regular_ ## sz ## dir ## _c; \
2153 dsp->mc[idx1][FILTER_8TAP_SHARP][idx2][idxh][idxv] = type ## _8tap_sharp_ ## sz ## dir ## _c; \
2154 dsp->mc[idx1][FILTER_BILINEAR][idx2][idxh][idxv] = type ## _bilin_ ## sz ## dir ## _c
2156 #define init_subpel2(idx, idxh, idxv, dir, type) \
2157 init_subpel1(0, idx, idxh, idxv, 64, dir, type); \
2158 init_subpel1(1, idx, idxh, idxv, 32, dir, type); \
2159 init_subpel1(2, idx, idxh, idxv, 16, dir, type); \
2160 init_subpel1(3, idx, idxh, idxv, 8, dir, type); \
2161 init_subpel1(4, idx, idxh, idxv, 4, dir, type)
2163 #define init_subpel3(idx, type) \
2164 init_subpel2(idx, 1, 1, hv, type); \
2165 init_subpel2(idx, 0, 1, v, type); \
2166 init_subpel2(idx, 1, 0, h, type)
2168 init_subpel3(0, put);
2169 init_subpel3(1, avg);
2176 av_cold void ff_vp9dsp_init(VP9DSPContext *dsp)
2178 vp9dsp_intrapred_init(dsp);
2179 vp9dsp_itxfm_init(dsp);
2180 vp9dsp_loopfilter_init(dsp);
2181 vp9dsp_mc_init(dsp);
2184 ff_vp9dsp_init_aarch64(dsp);
2186 ff_vp9dsp_init_arm(dsp);
2188 ff_vp9dsp_init_x86(dsp);