18f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// Copyright 2010 Google Inc. All Rights Reserved. 28f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// 38f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// Use of this source code is governed by a BSD-style license 48f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// that can be found in the COPYING file in the root of the source 58f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// tree. An additional intellectual property rights grant can be found 68f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// in the file PATENTS. All contributing project authors may 78f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// be found in the AUTHORS file in the root of the source tree. 88f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// ----------------------------------------------------------------------------- 98f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// 108f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// Speed-critical decoding functions. 118f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// 128f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// Author: Skal (pascal.massimino@gmail.com) 138f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 148f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#include "./dsp.h" 158f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#include "../dec/vp8i.h" 168f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 178f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle//------------------------------------------------------------------------------ 188f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 198f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic WEBP_INLINE uint8_t clip_8b(int v) { 208f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle return (!(v & ~0xff)) ? v : (v < 0) ? 0 : 255; 218f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 228f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 238f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle//------------------------------------------------------------------------------ 248f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// Transforms (Paragraph 14.4) 258f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 268f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#define STORE(x, y, v) \ 278f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle dst[x + y * BPS] = clip_8b(dst[x + y * BPS] + ((v) >> 3)) 288f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 298f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#define STORE2(y, dc, d, c) do { \ 308f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int DC = (dc); \ 318f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE(0, y, DC + (d)); \ 328f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE(1, y, DC + (c)); \ 338f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE(2, y, DC - (c)); \ 348f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE(3, y, DC - (d)); \ 358f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} while (0) 368f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 378f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic const int kC1 = 20091 + (1 << 16); 388f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic const int kC2 = 35468; 398f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#define MUL(a, b) (((a) * (b)) >> 16) 408f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 418f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void TransformOne(const int16_t* in, uint8_t* dst) { 428f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int C[4 * 4], *tmp; 438f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int i; 448f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle tmp = C; 458f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 4; ++i) { // vertical pass 468f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a = in[0] + in[8]; // [-4096, 4094] 478f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int b = in[0] - in[8]; // [-4095, 4095] 488f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int c = MUL(in[4], kC2) - MUL(in[12], kC1); // [-3783, 3783] 498f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int d = MUL(in[4], kC1) + MUL(in[12], kC2); // [-3785, 3781] 508f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle tmp[0] = a + d; // [-7881, 7875] 518f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle tmp[1] = b + c; // [-7878, 7878] 528f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle tmp[2] = b - c; // [-7878, 7878] 538f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle tmp[3] = a - d; // [-7877, 7879] 548f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle tmp += 4; 558f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle in++; 568f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 578f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle // Each pass is expanding the dynamic range by ~3.85 (upper bound). 588f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle // The exact value is (2. + (kC1 + kC2) / 65536). 598f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle // After the second pass, maximum interval is [-3794, 3794], assuming 608f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle // an input in [-2048, 2047] interval. We then need to add a dst value 618f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle // in the [0, 255] range. 628f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle // In the worst case scenario, the input to clip_8b() can be as large as 638f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle // [-60713, 60968]. 648f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle tmp = C; 658f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 4; ++i) { // horizontal pass 668f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int dc = tmp[0] + 4; 678f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a = dc + tmp[8]; 688f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int b = dc - tmp[8]; 698f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int c = MUL(tmp[4], kC2) - MUL(tmp[12], kC1); 708f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int d = MUL(tmp[4], kC1) + MUL(tmp[12], kC2); 718f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE(0, 0, a + d); 728f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE(1, 0, b + c); 738f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE(2, 0, b - c); 748f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE(3, 0, a - d); 758f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle tmp++; 768f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle dst += BPS; 778f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 788f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 798f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 808f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// Simplified transform when only in[0], in[1] and in[4] are non-zero 818f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void TransformAC3(const int16_t* in, uint8_t* dst) { 828f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a = in[0] + 4; 838f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int c4 = MUL(in[4], kC2); 848f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int d4 = MUL(in[4], kC1); 858f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int c1 = MUL(in[1], kC2); 868f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int d1 = MUL(in[1], kC1); 878f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE2(0, a + d4, d1, c1); 888f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE2(1, a + c4, d1, c1); 898f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE2(2, a - c4, d1, c1); 908f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE2(3, a - d4, d1, c1); 918f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 928f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#undef MUL 938f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#undef STORE2 948f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 958f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void TransformTwo(const int16_t* in, uint8_t* dst, int do_two) { 968f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle TransformOne(in, dst); 978f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (do_two) { 988f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle TransformOne(in + 16, dst + 4); 998f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 1008f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 1018f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1028f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void TransformUV(const int16_t* in, uint8_t* dst) { 1038f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8Transform(in + 0 * 16, dst, 1); 1048f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8Transform(in + 2 * 16, dst + 4 * BPS, 1); 1058f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 1068f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1078f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void TransformDC(const int16_t *in, uint8_t* dst) { 1088f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int DC = in[0] + 4; 1098f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int i, j; 1108f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (j = 0; j < 4; ++j) { 1118f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 4; ++i) { 1128f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle STORE(i, j, DC); 1138f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 1148f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 1158f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 1168f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1178f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void TransformDCUV(const int16_t* in, uint8_t* dst) { 1188f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (in[0 * 16]) VP8TransformDC(in + 0 * 16, dst); 1198f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (in[1 * 16]) VP8TransformDC(in + 1 * 16, dst + 4); 1208f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (in[2 * 16]) VP8TransformDC(in + 2 * 16, dst + 4 * BPS); 1218f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (in[3 * 16]) VP8TransformDC(in + 3 * 16, dst + 4 * BPS + 4); 1228f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 1238f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1248f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#undef STORE 1258f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1268f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle//------------------------------------------------------------------------------ 1278f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// Paragraph 14.3 1288f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1298f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void TransformWHT(const int16_t* in, int16_t* out) { 1308f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int tmp[16]; 1318f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int i; 1328f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 4; ++i) { 1338f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a0 = in[0 + i] + in[12 + i]; 1348f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a1 = in[4 + i] + in[ 8 + i]; 1358f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a2 = in[4 + i] - in[ 8 + i]; 1368f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a3 = in[0 + i] - in[12 + i]; 1378f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle tmp[0 + i] = a0 + a1; 1388f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle tmp[8 + i] = a0 - a1; 1398f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle tmp[4 + i] = a3 + a2; 1408f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle tmp[12 + i] = a3 - a2; 1418f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 1428f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 4; ++i) { 1438f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int dc = tmp[0 + i * 4] + 3; // w/ rounder 1448f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a0 = dc + tmp[3 + i * 4]; 1458f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a1 = tmp[1 + i * 4] + tmp[2 + i * 4]; 1468f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a2 = tmp[1 + i * 4] - tmp[2 + i * 4]; 1478f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a3 = dc - tmp[3 + i * 4]; 1488f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle out[ 0] = (a0 + a1) >> 3; 1498f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle out[16] = (a3 + a2) >> 3; 1508f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle out[32] = (a0 - a1) >> 3; 1518f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle out[48] = (a3 - a2) >> 3; 1528f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle out += 64; 1538f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 1548f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 1558f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1568f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlevoid (*VP8TransformWHT)(const int16_t* in, int16_t* out); 1578f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1588f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle//------------------------------------------------------------------------------ 1598f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// Intra predictions 1608f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1618f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#define DST(x, y) dst[(x) + (y) * BPS] 1628f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1638f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic WEBP_INLINE void TrueMotion(uint8_t *dst, int size) { 1648f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const uint8_t* top = dst - BPS; 1658f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const uint8_t* const clip0 = VP8kclip1 - top[-1]; 1668f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int y; 1678f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (y = 0; y < size; ++y) { 1688f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const uint8_t* const clip = clip0 + dst[-1]; 1698f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int x; 1708f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (x = 0; x < size; ++x) { 1718f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle dst[x] = clip[top[x]]; 1728f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 1738f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle dst += BPS; 1748f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 1758f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 1768f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void TM4(uint8_t *dst) { TrueMotion(dst, 4); } 1778f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void TM8uv(uint8_t *dst) { TrueMotion(dst, 8); } 1788f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void TM16(uint8_t *dst) { TrueMotion(dst, 16); } 1798f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1808f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle//------------------------------------------------------------------------------ 1818f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// 16x16 1828f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1838f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void VE16(uint8_t *dst) { // vertical 1848f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int j; 1858f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (j = 0; j < 16; ++j) { 1868f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle memcpy(dst + j * BPS, dst - BPS, 16); 1878f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 1888f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 1898f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1908f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void HE16(uint8_t *dst) { // horizontal 1918f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int j; 1928f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (j = 16; j > 0; --j) { 1938f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle memset(dst, dst[-1], 16); 1948f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle dst += BPS; 1958f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 1968f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 1978f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 1988f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic WEBP_INLINE void Put16(int v, uint8_t* dst) { 1998f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int j; 2008f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (j = 0; j < 16; ++j) { 2018f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle memset(dst + j * BPS, v, 16); 2028f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 2038f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 2048f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 2058f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void DC16(uint8_t *dst) { // DC 2068f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int DC = 16; 2078f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int j; 2088f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (j = 0; j < 16; ++j) { 2098f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DC += dst[-1 + j * BPS] + dst[j - BPS]; 2108f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 2118f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle Put16(DC >> 5, dst); 2128f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 2138f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 2148f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void DC16NoTop(uint8_t *dst) { // DC with top samples not available 2158f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int DC = 8; 2168f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int j; 2178f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (j = 0; j < 16; ++j) { 2188f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DC += dst[-1 + j * BPS]; 2198f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 2208f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle Put16(DC >> 4, dst); 2218f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 2228f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 2238f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void DC16NoLeft(uint8_t *dst) { // DC with left samples not available 2248f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int DC = 8; 2258f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int i; 2268f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 16; ++i) { 2278f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DC += dst[i - BPS]; 2288f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 2298f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle Put16(DC >> 4, dst); 2308f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 2318f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 2328f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void DC16NoTopLeft(uint8_t *dst) { // DC with no top and left samples 2338f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle Put16(0x80, dst); 2348f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 2358f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 2368f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle//------------------------------------------------------------------------------ 2378f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// 4x4 2388f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 2398f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#define AVG3(a, b, c) (((a) + 2 * (b) + (c) + 2) >> 2) 2408f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#define AVG2(a, b) (((a) + (b) + 1) >> 1) 2418f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 2428f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void VE4(uint8_t *dst) { // vertical 2438f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const uint8_t* top = dst - BPS; 2448f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const uint8_t vals[4] = { 2458f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle AVG3(top[-1], top[0], top[1]), 2468f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle AVG3(top[ 0], top[1], top[2]), 2478f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle AVG3(top[ 1], top[2], top[3]), 2488f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle AVG3(top[ 2], top[3], top[4]) 2498f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle }; 2508f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int i; 2518f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 4; ++i) { 2528f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle memcpy(dst + i * BPS, vals, sizeof(vals)); 2538f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 2548f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 2558f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 2568f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void HE4(uint8_t *dst) { // horizontal 2578f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int A = dst[-1 - BPS]; 2588f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int B = dst[-1]; 2598f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int C = dst[-1 + BPS]; 2608f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int D = dst[-1 + 2 * BPS]; 2618f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int E = dst[-1 + 3 * BPS]; 2628f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle *(uint32_t*)(dst + 0 * BPS) = 0x01010101U * AVG3(A, B, C); 2638f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle *(uint32_t*)(dst + 1 * BPS) = 0x01010101U * AVG3(B, C, D); 2648f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle *(uint32_t*)(dst + 2 * BPS) = 0x01010101U * AVG3(C, D, E); 2658f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle *(uint32_t*)(dst + 3 * BPS) = 0x01010101U * AVG3(D, E, E); 2668f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 2678f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 2688f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void DC4(uint8_t *dst) { // DC 2698f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle uint32_t dc = 4; 2708f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int i; 2718f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 4; ++i) dc += dst[i - BPS] + dst[-1 + i * BPS]; 2728f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle dc >>= 3; 2738f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 4; ++i) memset(dst + i * BPS, dc, 4); 2748f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 2758f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 2768f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void RD4(uint8_t *dst) { // Down-right 2778f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int I = dst[-1 + 0 * BPS]; 2788f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int J = dst[-1 + 1 * BPS]; 2798f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int K = dst[-1 + 2 * BPS]; 2808f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int L = dst[-1 + 3 * BPS]; 2818f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int X = dst[-1 - BPS]; 2828f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int A = dst[0 - BPS]; 2838f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int B = dst[1 - BPS]; 2848f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int C = dst[2 - BPS]; 2858f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int D = dst[3 - BPS]; 2868f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 3) = AVG3(J, K, L); 2878f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 2) = DST(1, 3) = AVG3(I, J, K); 2888f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 1) = DST(1, 2) = DST(2, 3) = AVG3(X, I, J); 2898f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 0) = DST(1, 1) = DST(2, 2) = DST(3, 3) = AVG3(A, X, I); 2908f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(1, 0) = DST(2, 1) = DST(3, 2) = AVG3(B, A, X); 2918f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(2, 0) = DST(3, 1) = AVG3(C, B, A); 2928f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 0) = AVG3(D, C, B); 2938f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 2948f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 2958f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void LD4(uint8_t *dst) { // Down-Left 2968f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int A = dst[0 - BPS]; 2978f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int B = dst[1 - BPS]; 2988f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int C = dst[2 - BPS]; 2998f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int D = dst[3 - BPS]; 3008f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int E = dst[4 - BPS]; 3018f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int F = dst[5 - BPS]; 3028f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int G = dst[6 - BPS]; 3038f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int H = dst[7 - BPS]; 3048f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 0) = AVG3(A, B, C); 3058f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(1, 0) = DST(0, 1) = AVG3(B, C, D); 3068f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(2, 0) = DST(1, 1) = DST(0, 2) = AVG3(C, D, E); 3078f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 0) = DST(2, 1) = DST(1, 2) = DST(0, 3) = AVG3(D, E, F); 3088f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 1) = DST(2, 2) = DST(1, 3) = AVG3(E, F, G); 3098f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 2) = DST(2, 3) = AVG3(F, G, H); 3108f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 3) = AVG3(G, H, H); 3118f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 3128f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 3138f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void VR4(uint8_t *dst) { // Vertical-Right 3148f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int I = dst[-1 + 0 * BPS]; 3158f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int J = dst[-1 + 1 * BPS]; 3168f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int K = dst[-1 + 2 * BPS]; 3178f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int X = dst[-1 - BPS]; 3188f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int A = dst[0 - BPS]; 3198f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int B = dst[1 - BPS]; 3208f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int C = dst[2 - BPS]; 3218f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int D = dst[3 - BPS]; 3228f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 0) = DST(1, 2) = AVG2(X, A); 3238f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(1, 0) = DST(2, 2) = AVG2(A, B); 3248f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(2, 0) = DST(3, 2) = AVG2(B, C); 3258f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 0) = AVG2(C, D); 3268f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 3278f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 3) = AVG3(K, J, I); 3288f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 2) = AVG3(J, I, X); 3298f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 1) = DST(1, 3) = AVG3(I, X, A); 3308f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(1, 1) = DST(2, 3) = AVG3(X, A, B); 3318f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(2, 1) = DST(3, 3) = AVG3(A, B, C); 3328f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 1) = AVG3(B, C, D); 3338f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 3348f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 3358f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void VL4(uint8_t *dst) { // Vertical-Left 3368f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int A = dst[0 - BPS]; 3378f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int B = dst[1 - BPS]; 3388f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int C = dst[2 - BPS]; 3398f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int D = dst[3 - BPS]; 3408f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int E = dst[4 - BPS]; 3418f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int F = dst[5 - BPS]; 3428f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int G = dst[6 - BPS]; 3438f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int H = dst[7 - BPS]; 3448f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 0) = AVG2(A, B); 3458f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(1, 0) = DST(0, 2) = AVG2(B, C); 3468f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(2, 0) = DST(1, 2) = AVG2(C, D); 3478f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 0) = DST(2, 2) = AVG2(D, E); 3488f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 3498f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 1) = AVG3(A, B, C); 3508f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(1, 1) = DST(0, 3) = AVG3(B, C, D); 3518f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(2, 1) = DST(1, 3) = AVG3(C, D, E); 3528f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 1) = DST(2, 3) = AVG3(D, E, F); 3538f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 2) = AVG3(E, F, G); 3548f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 3) = AVG3(F, G, H); 3558f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 3568f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 3578f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void HU4(uint8_t *dst) { // Horizontal-Up 3588f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int I = dst[-1 + 0 * BPS]; 3598f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int J = dst[-1 + 1 * BPS]; 3608f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int K = dst[-1 + 2 * BPS]; 3618f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int L = dst[-1 + 3 * BPS]; 3628f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 0) = AVG2(I, J); 3638f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(2, 0) = DST(0, 1) = AVG2(J, K); 3648f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(2, 1) = DST(0, 2) = AVG2(K, L); 3658f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(1, 0) = AVG3(I, J, K); 3668f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 0) = DST(1, 1) = AVG3(J, K, L); 3678f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 1) = DST(1, 2) = AVG3(K, L, L); 3688f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 2) = DST(2, 2) = 3698f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 3) = DST(1, 3) = DST(2, 3) = DST(3, 3) = L; 3708f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 3718f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 3728f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void HD4(uint8_t *dst) { // Horizontal-Down 3738f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int I = dst[-1 + 0 * BPS]; 3748f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int J = dst[-1 + 1 * BPS]; 3758f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int K = dst[-1 + 2 * BPS]; 3768f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int L = dst[-1 + 3 * BPS]; 3778f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int X = dst[-1 - BPS]; 3788f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int A = dst[0 - BPS]; 3798f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int B = dst[1 - BPS]; 3808f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int C = dst[2 - BPS]; 3818f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 3828f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 0) = DST(2, 1) = AVG2(I, X); 3838f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 1) = DST(2, 2) = AVG2(J, I); 3848f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 2) = DST(2, 3) = AVG2(K, J); 3858f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(0, 3) = AVG2(L, K); 3868f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 3878f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(3, 0) = AVG3(A, B, C); 3888f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(2, 0) = AVG3(X, A, B); 3898f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(1, 0) = DST(3, 1) = AVG3(I, X, A); 3908f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(1, 1) = DST(3, 2) = AVG3(J, I, X); 3918f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(1, 2) = DST(3, 3) = AVG3(K, J, I); 3928f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DST(1, 3) = AVG3(L, K, J); 3938f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 3948f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 3958f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#undef DST 3968f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#undef AVG3 3978f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#undef AVG2 3988f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 3998f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle//------------------------------------------------------------------------------ 4008f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// Chroma 4018f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4028f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void VE8uv(uint8_t *dst) { // vertical 4038f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int j; 4048f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (j = 0; j < 8; ++j) { 4058f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle memcpy(dst + j * BPS, dst - BPS, 8); 4068f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 4078f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 4088f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4098f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void HE8uv(uint8_t *dst) { // horizontal 4108f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int j; 4118f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (j = 0; j < 8; ++j) { 4128f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle memset(dst, dst[-1], 8); 4138f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle dst += BPS; 4148f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 4158f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 4168f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4178f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// helper for chroma-DC predictions 4188f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic WEBP_INLINE void Put8x8uv(uint8_t value, uint8_t* dst) { 4198f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int j; 4208f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (j = 0; j < 8; ++j) { 4218f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle memset(dst + j * BPS, value, 8); 4228f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 4238f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 4248f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4258f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void DC8uv(uint8_t *dst) { // DC 4268f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int dc0 = 8; 4278f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int i; 4288f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 8; ++i) { 4298f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle dc0 += dst[i - BPS] + dst[-1 + i * BPS]; 4308f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 4318f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle Put8x8uv(dc0 >> 4, dst); 4328f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 4338f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4348f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void DC8uvNoLeft(uint8_t *dst) { // DC with no left samples 4358f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int dc0 = 4; 4368f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int i; 4378f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 8; ++i) { 4388f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle dc0 += dst[i - BPS]; 4398f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 4408f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle Put8x8uv(dc0 >> 3, dst); 4418f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 4428f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4438f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void DC8uvNoTop(uint8_t *dst) { // DC with no top samples 4448f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int dc0 = 4; 4458f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int i; 4468f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 8; ++i) { 4478f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle dc0 += dst[-1 + i * BPS]; 4488f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 4498f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle Put8x8uv(dc0 >> 3, dst); 4508f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 4518f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4528f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void DC8uvNoTopLeft(uint8_t *dst) { // DC with nothing 4538f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle Put8x8uv(0x80, dst); 4548f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 4558f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4568f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle//------------------------------------------------------------------------------ 4578f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// default C implementations 4588f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4598f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravleconst VP8PredFunc VP8PredLuma4[NUM_BMODES] = { 4608f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DC4, TM4, VE4, HE4, RD4, VR4, LD4, VL4, HD4, HU4 4618f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle}; 4628f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4638f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravleconst VP8PredFunc VP8PredLuma16[NUM_B_DC_MODES] = { 4648f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DC16, TM16, VE16, HE16, 4658f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DC16NoTop, DC16NoLeft, DC16NoTopLeft 4668f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle}; 4678f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4688f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravleconst VP8PredFunc VP8PredChroma8[NUM_B_DC_MODES] = { 4698f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DC8uv, TM8uv, VE8uv, HE8uv, 4708f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle DC8uvNoTop, DC8uvNoLeft, DC8uvNoTopLeft 4718f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle}; 4728f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4738f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle//------------------------------------------------------------------------------ 4748f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// Edge filtering functions 4758f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4768f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// 4 pixels in, 2 pixels out 4778f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic WEBP_INLINE void do_filter2(uint8_t* p, int step) { 4788f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int p1 = p[-2*step], p0 = p[-step], q0 = p[0], q1 = p[step]; 4798f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a = 3 * (q0 - p0) + VP8ksclip1[p1 - q1]; // in [-893,892] 4808f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a1 = VP8ksclip2[(a + 4) >> 3]; // in [-16,15] 4818f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a2 = VP8ksclip2[(a + 3) >> 3]; 4828f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p[-step] = VP8kclip1[p0 + a2]; 4838f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p[ 0] = VP8kclip1[q0 - a1]; 4848f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 4858f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4868f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// 4 pixels in, 4 pixels out 4878f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic WEBP_INLINE void do_filter4(uint8_t* p, int step) { 4888f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int p1 = p[-2*step], p0 = p[-step], q0 = p[0], q1 = p[step]; 4898f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a = 3 * (q0 - p0); 4908f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a1 = VP8ksclip2[(a + 4) >> 3]; 4918f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a2 = VP8ksclip2[(a + 3) >> 3]; 4928f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a3 = (a1 + 1) >> 1; 4938f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p[-2*step] = VP8kclip1[p1 + a3]; 4948f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p[- step] = VP8kclip1[p0 + a2]; 4958f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p[ 0] = VP8kclip1[q0 - a1]; 4968f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p[ step] = VP8kclip1[q1 - a3]; 4978f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 4988f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 4998f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// 6 pixels in, 6 pixels out 5008f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic WEBP_INLINE void do_filter6(uint8_t* p, int step) { 5018f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int p2 = p[-3*step], p1 = p[-2*step], p0 = p[-step]; 5028f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int q0 = p[0], q1 = p[step], q2 = p[2*step]; 5038f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a = VP8ksclip1[3 * (q0 - p0) + VP8ksclip1[p1 - q1]]; 5048f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle // a is in [-128,127], a1 in [-27,27], a2 in [-18,18] and a3 in [-9,9] 5058f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a1 = (27 * a + 63) >> 7; // eq. to ((3 * a + 7) * 9) >> 7 5068f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a2 = (18 * a + 63) >> 7; // eq. to ((2 * a + 7) * 9) >> 7 5078f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int a3 = (9 * a + 63) >> 7; // eq. to ((1 * a + 7) * 9) >> 7 5088f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p[-3*step] = VP8kclip1[p2 + a3]; 5098f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p[-2*step] = VP8kclip1[p1 + a2]; 5108f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p[- step] = VP8kclip1[p0 + a1]; 5118f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p[ 0] = VP8kclip1[q0 - a1]; 5128f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p[ step] = VP8kclip1[q1 - a2]; 5138f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p[ 2*step] = VP8kclip1[q2 - a3]; 5148f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 5158f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 5168f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic WEBP_INLINE int hev(const uint8_t* p, int step, int thresh) { 5178f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int p1 = p[-2*step], p0 = p[-step], q0 = p[0], q1 = p[step]; 5188f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle return (VP8kabs0[p1 - p0] > thresh) || (VP8kabs0[q1 - q0] > thresh); 5198f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 5208f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 5218f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic WEBP_INLINE int needs_filter(const uint8_t* p, int step, int t) { 5228f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int p1 = p[-2 * step], p0 = p[-step], q0 = p[0], q1 = p[step]; 5238f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle return ((4 * VP8kabs0[p0 - q0] + VP8kabs0[p1 - q1]) <= t); 5248f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 5258f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 5268f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic WEBP_INLINE int needs_filter2(const uint8_t* p, 5278f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int step, int t, int it) { 5288f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int p3 = p[-4 * step], p2 = p[-3 * step], p1 = p[-2 * step]; 5298f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int p0 = p[-step], q0 = p[0]; 5308f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int q1 = p[step], q2 = p[2 * step], q3 = p[3 * step]; 5318f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if ((4 * VP8kabs0[p0 - q0] + VP8kabs0[p1 - q1]) > t) return 0; 5328f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle return VP8kabs0[p3 - p2] <= it && VP8kabs0[p2 - p1] <= it && 5338f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8kabs0[p1 - p0] <= it && VP8kabs0[q3 - q2] <= it && 5348f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8kabs0[q2 - q1] <= it && VP8kabs0[q1 - q0] <= it; 5358f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 5368f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 5378f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle//------------------------------------------------------------------------------ 5388f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// Simple In-loop filtering (Paragraph 15.2) 5398f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 5408f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void SimpleVFilter16(uint8_t* p, int stride, int thresh) { 5418f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int i; 5428f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int thresh2 = 2 * thresh + 1; 5438f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 16; ++i) { 5448f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (needs_filter(p + i, stride, thresh2)) { 5458f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle do_filter2(p + i, stride); 5468f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 5478f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 5488f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 5498f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 5508f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void SimpleHFilter16(uint8_t* p, int stride, int thresh) { 5518f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int i; 5528f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int thresh2 = 2 * thresh + 1; 5538f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (i = 0; i < 16; ++i) { 5548f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (needs_filter(p + i * stride, 1, thresh2)) { 5558f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle do_filter2(p + i * stride, 1); 5568f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 5578f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 5588f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 5598f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 5608f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void SimpleVFilter16i(uint8_t* p, int stride, int thresh) { 5618f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int k; 5628f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (k = 3; k > 0; --k) { 5638f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p += 4 * stride; 5648f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle SimpleVFilter16(p, stride, thresh); 5658f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 5668f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 5678f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 5688f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void SimpleHFilter16i(uint8_t* p, int stride, int thresh) { 5698f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int k; 5708f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (k = 3; k > 0; --k) { 5718f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p += 4; 5728f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle SimpleHFilter16(p, stride, thresh); 5738f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 5748f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 5758f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 5768f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle//------------------------------------------------------------------------------ 5778f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// Complex In-loop filtering (Paragraph 15.3) 5788f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 5798f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic WEBP_INLINE void FilterLoop26(uint8_t* p, 5808f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int hstride, int vstride, int size, 5818f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int thresh, int ithresh, int hev_thresh) { 5828f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int thresh2 = 2 * thresh + 1; 5838f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle while (size-- > 0) { 5848f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (needs_filter2(p, hstride, thresh2, ithresh)) { 5858f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (hev(p, hstride, hev_thresh)) { 5868f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle do_filter2(p, hstride); 5878f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } else { 5888f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle do_filter6(p, hstride); 5898f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 5908f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 5918f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p += vstride; 5928f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 5938f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 5948f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 5958f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic WEBP_INLINE void FilterLoop24(uint8_t* p, 5968f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int hstride, int vstride, int size, 5978f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int thresh, int ithresh, int hev_thresh) { 5988f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle const int thresh2 = 2 * thresh + 1; 5998f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle while (size-- > 0) { 6008f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (needs_filter2(p, hstride, thresh2, ithresh)) { 6018f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (hev(p, hstride, hev_thresh)) { 6028f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle do_filter2(p, hstride); 6038f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } else { 6048f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle do_filter4(p, hstride); 6058f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 6068f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 6078f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p += vstride; 6088f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 6098f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 6108f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6118f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// on macroblock edges 6128f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void VFilter16(uint8_t* p, int stride, 6138f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int thresh, int ithresh, int hev_thresh) { 6148f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle FilterLoop26(p, stride, 1, 16, thresh, ithresh, hev_thresh); 6158f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 6168f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6178f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void HFilter16(uint8_t* p, int stride, 6188f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int thresh, int ithresh, int hev_thresh) { 6198f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle FilterLoop26(p, 1, stride, 16, thresh, ithresh, hev_thresh); 6208f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 6218f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6228f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// on three inner edges 6238f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void VFilter16i(uint8_t* p, int stride, 6248f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int thresh, int ithresh, int hev_thresh) { 6258f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int k; 6268f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (k = 3; k > 0; --k) { 6278f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p += 4 * stride; 6288f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle FilterLoop24(p, stride, 1, 16, thresh, ithresh, hev_thresh); 6298f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 6308f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 6318f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6328f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void HFilter16i(uint8_t* p, int stride, 6338f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int thresh, int ithresh, int hev_thresh) { 6348f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int k; 6358f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle for (k = 3; k > 0; --k) { 6368f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle p += 4; 6378f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle FilterLoop24(p, 1, stride, 16, thresh, ithresh, hev_thresh); 6388f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 6398f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 6408f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6418f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle// 8-pixels wide variant, for chroma filtering 6428f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void VFilter8(uint8_t* u, uint8_t* v, int stride, 6438f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int thresh, int ithresh, int hev_thresh) { 6448f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle FilterLoop26(u, stride, 1, 8, thresh, ithresh, hev_thresh); 6458f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle FilterLoop26(v, stride, 1, 8, thresh, ithresh, hev_thresh); 6468f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 6478f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6488f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void HFilter8(uint8_t* u, uint8_t* v, int stride, 6498f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int thresh, int ithresh, int hev_thresh) { 6508f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle FilterLoop26(u, 1, stride, 8, thresh, ithresh, hev_thresh); 6518f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle FilterLoop26(v, 1, stride, 8, thresh, ithresh, hev_thresh); 6528f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 6538f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6548f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void VFilter8i(uint8_t* u, uint8_t* v, int stride, 6558f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int thresh, int ithresh, int hev_thresh) { 6568f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle FilterLoop24(u + 4 * stride, stride, 1, 8, thresh, ithresh, hev_thresh); 6578f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle FilterLoop24(v + 4 * stride, stride, 1, 8, thresh, ithresh, hev_thresh); 6588f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 6598f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6608f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlestatic void HFilter8i(uint8_t* u, uint8_t* v, int stride, 6618f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle int thresh, int ithresh, int hev_thresh) { 6628f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle FilterLoop24(u + 4, 1, stride, 8, thresh, ithresh, hev_thresh); 6638f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle FilterLoop24(v + 4, 1, stride, 8, thresh, ithresh, hev_thresh); 6648f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 6658f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6668f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle//------------------------------------------------------------------------------ 6678f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6688f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8DecIdct2 VP8Transform; 6698f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8DecIdct VP8TransformAC3; 6708f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8DecIdct VP8TransformUV; 6718f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8DecIdct VP8TransformDC; 6728f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8DecIdct VP8TransformDCUV; 6738f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6748f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8LumaFilterFunc VP8VFilter16; 6758f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8LumaFilterFunc VP8HFilter16; 6768f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8ChromaFilterFunc VP8VFilter8; 6778f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8ChromaFilterFunc VP8HFilter8; 6788f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8LumaFilterFunc VP8VFilter16i; 6798f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8LumaFilterFunc VP8HFilter16i; 6808f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8ChromaFilterFunc VP8VFilter8i; 6818f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8ChromaFilterFunc VP8HFilter8i; 6828f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8SimpleFilterFunc VP8SimpleVFilter16; 6838f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8SimpleFilterFunc VP8SimpleHFilter16; 6848f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8SimpleFilterFunc VP8SimpleVFilter16i; 6858f0d92bba199d906c70a5e40d7f3516c1a424117Calin JuravleVP8SimpleFilterFunc VP8SimpleHFilter16i; 6868f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6878f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravleextern void VP8DspInitSSE2(void); 6888f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravleextern void VP8DspInitNEON(void); 6898f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravleextern void VP8DspInitMIPS32(void); 6908f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6918f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravlevoid VP8DspInit(void) { 6928f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8InitClipTables(); 6938f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 6948f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8TransformWHT = TransformWHT; 6958f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8Transform = TransformTwo; 6968f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8TransformUV = TransformUV; 6978f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8TransformDC = TransformDC; 6988f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8TransformDCUV = TransformDCUV; 6998f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8TransformAC3 = TransformAC3; 7008f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 7018f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8VFilter16 = VFilter16; 7028f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8HFilter16 = HFilter16; 7038f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8VFilter8 = VFilter8; 7048f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8HFilter8 = HFilter8; 7058f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8VFilter16i = VFilter16i; 7068f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8HFilter16i = HFilter16i; 7078f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8VFilter8i = VFilter8i; 7088f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8HFilter8i = HFilter8i; 7098f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8SimpleVFilter16 = SimpleVFilter16; 7108f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8SimpleHFilter16 = SimpleHFilter16; 7118f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8SimpleVFilter16i = SimpleVFilter16i; 7128f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8SimpleHFilter16i = SimpleHFilter16i; 7138f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 7148f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle // If defined, use CPUInfo() to overwrite some pointers with faster versions. 7158f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (VP8GetCPUInfo != NULL) { 7168f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#if defined(WEBP_USE_SSE2) 7178f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (VP8GetCPUInfo(kSSE2)) { 7188f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8DspInitSSE2(); 7198f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 7208f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#elif defined(WEBP_USE_NEON) 7218f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (VP8GetCPUInfo(kNEON)) { 7228f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8DspInitNEON(); 7238f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 7248f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#elif defined(WEBP_USE_MIPS32) 7258f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle if (VP8GetCPUInfo(kMIPS32)) { 7268f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle VP8DspInitMIPS32(); 7278f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 7288f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle#endif 7298f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle } 7308f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle} 7318f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle 7328f0d92bba199d906c70a5e40d7f3516c1a424117Calin Juravle