dec.c revision 8b720228d581a84fd173b6dcb2fa295b59db489a
1// Copyright 2010 Google Inc. All Rights Reserved. 2// 3// Use of this source code is governed by a BSD-style license 4// that can be found in the COPYING file in the root of the source 5// tree. An additional intellectual property rights grant can be found 6// in the file PATENTS. All contributing project authors may 7// be found in the AUTHORS file in the root of the source tree. 8// ----------------------------------------------------------------------------- 9// 10// Speed-critical decoding functions. 11// 12// Author: Skal (pascal.massimino@gmail.com) 13 14#include "./dsp.h" 15#include "../dec/vp8i.h" 16 17//------------------------------------------------------------------------------ 18// run-time tables (~4k) 19 20static uint8_t abs0[255 + 255 + 1]; // abs(i) 21static uint8_t abs1[255 + 255 + 1]; // abs(i)>>1 22static int8_t sclip1[1020 + 1020 + 1]; // clips [-1020, 1020] to [-128, 127] 23static int8_t sclip2[112 + 112 + 1]; // clips [-112, 112] to [-16, 15] 24static uint8_t clip1[255 + 510 + 1]; // clips [-255,510] to [0,255] 25 26// We declare this variable 'volatile' to prevent instruction reordering 27// and make sure it's set to true _last_ (so as to be thread-safe) 28static volatile int tables_ok = 0; 29 30static void DspInitTables(void) { 31 if (!tables_ok) { 32 int i; 33 for (i = -255; i <= 255; ++i) { 34 abs0[255 + i] = (i < 0) ? -i : i; 35 abs1[255 + i] = abs0[255 + i] >> 1; 36 } 37 for (i = -1020; i <= 1020; ++i) { 38 sclip1[1020 + i] = (i < -128) ? -128 : (i > 127) ? 127 : i; 39 } 40 for (i = -112; i <= 112; ++i) { 41 sclip2[112 + i] = (i < -16) ? -16 : (i > 15) ? 15 : i; 42 } 43 for (i = -255; i <= 255 + 255; ++i) { 44 clip1[255 + i] = (i < 0) ? 0 : (i > 255) ? 255 : i; 45 } 46 tables_ok = 1; 47 } 48} 49 50static WEBP_INLINE uint8_t clip_8b(int v) { 51 return (!(v & ~0xff)) ? v : (v < 0) ? 0 : 255; 52} 53 54//------------------------------------------------------------------------------ 55// Transforms (Paragraph 14.4) 56 57#define STORE(x, y, v) \ 58 dst[x + y * BPS] = clip_8b(dst[x + y * BPS] + ((v) >> 3)) 59 60#define STORE2(y, dc, d, c) do { \ 61 const int DC = (dc); \ 62 STORE(0, y, DC + (d)); \ 63 STORE(1, y, DC + (c)); \ 64 STORE(2, y, DC - (c)); \ 65 STORE(3, y, DC - (d)); \ 66} while (0) 67 68static const int kC1 = 20091 + (1 << 16); 69static const int kC2 = 35468; 70#define MUL(a, b) (((a) * (b)) >> 16) 71 72static void TransformOne(const int16_t* in, uint8_t* dst) { 73 int C[4 * 4], *tmp; 74 int i; 75 tmp = C; 76 for (i = 0; i < 4; ++i) { // vertical pass 77 const int a = in[0] + in[8]; // [-4096, 4094] 78 const int b = in[0] - in[8]; // [-4095, 4095] 79 const int c = MUL(in[4], kC2) - MUL(in[12], kC1); // [-3783, 3783] 80 const int d = MUL(in[4], kC1) + MUL(in[12], kC2); // [-3785, 3781] 81 tmp[0] = a + d; // [-7881, 7875] 82 tmp[1] = b + c; // [-7878, 7878] 83 tmp[2] = b - c; // [-7878, 7878] 84 tmp[3] = a - d; // [-7877, 7879] 85 tmp += 4; 86 in++; 87 } 88 // Each pass is expanding the dynamic range by ~3.85 (upper bound). 89 // The exact value is (2. + (kC1 + kC2) / 65536). 90 // After the second pass, maximum interval is [-3794, 3794], assuming 91 // an input in [-2048, 2047] interval. We then need to add a dst value 92 // in the [0, 255] range. 93 // In the worst case scenario, the input to clip_8b() can be as large as 94 // [-60713, 60968]. 95 tmp = C; 96 for (i = 0; i < 4; ++i) { // horizontal pass 97 const int dc = tmp[0] + 4; 98 const int a = dc + tmp[8]; 99 const int b = dc - tmp[8]; 100 const int c = MUL(tmp[4], kC2) - MUL(tmp[12], kC1); 101 const int d = MUL(tmp[4], kC1) + MUL(tmp[12], kC2); 102 STORE(0, 0, a + d); 103 STORE(1, 0, b + c); 104 STORE(2, 0, b - c); 105 STORE(3, 0, a - d); 106 tmp++; 107 dst += BPS; 108 } 109} 110 111// Simplified transform when only in[0], in[1] and in[4] are non-zero 112static void TransformAC3(const int16_t* in, uint8_t* dst) { 113 const int a = in[0] + 4; 114 const int c4 = MUL(in[4], kC2); 115 const int d4 = MUL(in[4], kC1); 116 const int c1 = MUL(in[1], kC2); 117 const int d1 = MUL(in[1], kC1); 118 STORE2(0, a + d4, d1, c1); 119 STORE2(1, a + c4, d1, c1); 120 STORE2(2, a - c4, d1, c1); 121 STORE2(3, a - d4, d1, c1); 122} 123#undef MUL 124#undef STORE2 125 126static void TransformTwo(const int16_t* in, uint8_t* dst, int do_two) { 127 TransformOne(in, dst); 128 if (do_two) { 129 TransformOne(in + 16, dst + 4); 130 } 131} 132 133static void TransformUV(const int16_t* in, uint8_t* dst) { 134 VP8Transform(in + 0 * 16, dst, 1); 135 VP8Transform(in + 2 * 16, dst + 4 * BPS, 1); 136} 137 138static void TransformDC(const int16_t *in, uint8_t* dst) { 139 const int DC = in[0] + 4; 140 int i, j; 141 for (j = 0; j < 4; ++j) { 142 for (i = 0; i < 4; ++i) { 143 STORE(i, j, DC); 144 } 145 } 146} 147 148static void TransformDCUV(const int16_t* in, uint8_t* dst) { 149 if (in[0 * 16]) TransformDC(in + 0 * 16, dst); 150 if (in[1 * 16]) TransformDC(in + 1 * 16, dst + 4); 151 if (in[2 * 16]) TransformDC(in + 2 * 16, dst + 4 * BPS); 152 if (in[3 * 16]) TransformDC(in + 3 * 16, dst + 4 * BPS + 4); 153} 154 155#undef STORE 156 157//------------------------------------------------------------------------------ 158// Paragraph 14.3 159 160static void TransformWHT(const int16_t* in, int16_t* out) { 161 int tmp[16]; 162 int i; 163 for (i = 0; i < 4; ++i) { 164 const int a0 = in[0 + i] + in[12 + i]; 165 const int a1 = in[4 + i] + in[ 8 + i]; 166 const int a2 = in[4 + i] - in[ 8 + i]; 167 const int a3 = in[0 + i] - in[12 + i]; 168 tmp[0 + i] = a0 + a1; 169 tmp[8 + i] = a0 - a1; 170 tmp[4 + i] = a3 + a2; 171 tmp[12 + i] = a3 - a2; 172 } 173 for (i = 0; i < 4; ++i) { 174 const int dc = tmp[0 + i * 4] + 3; // w/ rounder 175 const int a0 = dc + tmp[3 + i * 4]; 176 const int a1 = tmp[1 + i * 4] + tmp[2 + i * 4]; 177 const int a2 = tmp[1 + i * 4] - tmp[2 + i * 4]; 178 const int a3 = dc - tmp[3 + i * 4]; 179 out[ 0] = (a0 + a1) >> 3; 180 out[16] = (a3 + a2) >> 3; 181 out[32] = (a0 - a1) >> 3; 182 out[48] = (a3 - a2) >> 3; 183 out += 64; 184 } 185} 186 187void (*VP8TransformWHT)(const int16_t* in, int16_t* out) = TransformWHT; 188 189//------------------------------------------------------------------------------ 190// Intra predictions 191 192#define DST(x, y) dst[(x) + (y) * BPS] 193 194static WEBP_INLINE void TrueMotion(uint8_t *dst, int size) { 195 const uint8_t* top = dst - BPS; 196 const uint8_t* const clip0 = clip1 + 255 - top[-1]; 197 int y; 198 for (y = 0; y < size; ++y) { 199 const uint8_t* const clip = clip0 + dst[-1]; 200 int x; 201 for (x = 0; x < size; ++x) { 202 dst[x] = clip[top[x]]; 203 } 204 dst += BPS; 205 } 206} 207static void TM4(uint8_t *dst) { TrueMotion(dst, 4); } 208static void TM8uv(uint8_t *dst) { TrueMotion(dst, 8); } 209static void TM16(uint8_t *dst) { TrueMotion(dst, 16); } 210 211//------------------------------------------------------------------------------ 212// 16x16 213 214static void VE16(uint8_t *dst) { // vertical 215 int j; 216 for (j = 0; j < 16; ++j) { 217 memcpy(dst + j * BPS, dst - BPS, 16); 218 } 219} 220 221static void HE16(uint8_t *dst) { // horizontal 222 int j; 223 for (j = 16; j > 0; --j) { 224 memset(dst, dst[-1], 16); 225 dst += BPS; 226 } 227} 228 229static WEBP_INLINE void Put16(int v, uint8_t* dst) { 230 int j; 231 for (j = 0; j < 16; ++j) { 232 memset(dst + j * BPS, v, 16); 233 } 234} 235 236static void DC16(uint8_t *dst) { // DC 237 int DC = 16; 238 int j; 239 for (j = 0; j < 16; ++j) { 240 DC += dst[-1 + j * BPS] + dst[j - BPS]; 241 } 242 Put16(DC >> 5, dst); 243} 244 245static void DC16NoTop(uint8_t *dst) { // DC with top samples not available 246 int DC = 8; 247 int j; 248 for (j = 0; j < 16; ++j) { 249 DC += dst[-1 + j * BPS]; 250 } 251 Put16(DC >> 4, dst); 252} 253 254static void DC16NoLeft(uint8_t *dst) { // DC with left samples not available 255 int DC = 8; 256 int i; 257 for (i = 0; i < 16; ++i) { 258 DC += dst[i - BPS]; 259 } 260 Put16(DC >> 4, dst); 261} 262 263static void DC16NoTopLeft(uint8_t *dst) { // DC with no top and left samples 264 Put16(0x80, dst); 265} 266 267//------------------------------------------------------------------------------ 268// 4x4 269 270#define AVG3(a, b, c) (((a) + 2 * (b) + (c) + 2) >> 2) 271#define AVG2(a, b) (((a) + (b) + 1) >> 1) 272 273static void VE4(uint8_t *dst) { // vertical 274 const uint8_t* top = dst - BPS; 275 const uint8_t vals[4] = { 276 AVG3(top[-1], top[0], top[1]), 277 AVG3(top[ 0], top[1], top[2]), 278 AVG3(top[ 1], top[2], top[3]), 279 AVG3(top[ 2], top[3], top[4]) 280 }; 281 int i; 282 for (i = 0; i < 4; ++i) { 283 memcpy(dst + i * BPS, vals, sizeof(vals)); 284 } 285} 286 287static void HE4(uint8_t *dst) { // horizontal 288 const int A = dst[-1 - BPS]; 289 const int B = dst[-1]; 290 const int C = dst[-1 + BPS]; 291 const int D = dst[-1 + 2 * BPS]; 292 const int E = dst[-1 + 3 * BPS]; 293 *(uint32_t*)(dst + 0 * BPS) = 0x01010101U * AVG3(A, B, C); 294 *(uint32_t*)(dst + 1 * BPS) = 0x01010101U * AVG3(B, C, D); 295 *(uint32_t*)(dst + 2 * BPS) = 0x01010101U * AVG3(C, D, E); 296 *(uint32_t*)(dst + 3 * BPS) = 0x01010101U * AVG3(D, E, E); 297} 298 299static void DC4(uint8_t *dst) { // DC 300 uint32_t dc = 4; 301 int i; 302 for (i = 0; i < 4; ++i) dc += dst[i - BPS] + dst[-1 + i * BPS]; 303 dc >>= 3; 304 for (i = 0; i < 4; ++i) memset(dst + i * BPS, dc, 4); 305} 306 307static void RD4(uint8_t *dst) { // Down-right 308 const int I = dst[-1 + 0 * BPS]; 309 const int J = dst[-1 + 1 * BPS]; 310 const int K = dst[-1 + 2 * BPS]; 311 const int L = dst[-1 + 3 * BPS]; 312 const int X = dst[-1 - BPS]; 313 const int A = dst[0 - BPS]; 314 const int B = dst[1 - BPS]; 315 const int C = dst[2 - BPS]; 316 const int D = dst[3 - BPS]; 317 DST(0, 3) = AVG3(J, K, L); 318 DST(0, 2) = DST(1, 3) = AVG3(I, J, K); 319 DST(0, 1) = DST(1, 2) = DST(2, 3) = AVG3(X, I, J); 320 DST(0, 0) = DST(1, 1) = DST(2, 2) = DST(3, 3) = AVG3(A, X, I); 321 DST(1, 0) = DST(2, 1) = DST(3, 2) = AVG3(B, A, X); 322 DST(2, 0) = DST(3, 1) = AVG3(C, B, A); 323 DST(3, 0) = AVG3(D, C, B); 324} 325 326static void LD4(uint8_t *dst) { // Down-Left 327 const int A = dst[0 - BPS]; 328 const int B = dst[1 - BPS]; 329 const int C = dst[2 - BPS]; 330 const int D = dst[3 - BPS]; 331 const int E = dst[4 - BPS]; 332 const int F = dst[5 - BPS]; 333 const int G = dst[6 - BPS]; 334 const int H = dst[7 - BPS]; 335 DST(0, 0) = AVG3(A, B, C); 336 DST(1, 0) = DST(0, 1) = AVG3(B, C, D); 337 DST(2, 0) = DST(1, 1) = DST(0, 2) = AVG3(C, D, E); 338 DST(3, 0) = DST(2, 1) = DST(1, 2) = DST(0, 3) = AVG3(D, E, F); 339 DST(3, 1) = DST(2, 2) = DST(1, 3) = AVG3(E, F, G); 340 DST(3, 2) = DST(2, 3) = AVG3(F, G, H); 341 DST(3, 3) = AVG3(G, H, H); 342} 343 344static void VR4(uint8_t *dst) { // Vertical-Right 345 const int I = dst[-1 + 0 * BPS]; 346 const int J = dst[-1 + 1 * BPS]; 347 const int K = dst[-1 + 2 * BPS]; 348 const int X = dst[-1 - BPS]; 349 const int A = dst[0 - BPS]; 350 const int B = dst[1 - BPS]; 351 const int C = dst[2 - BPS]; 352 const int D = dst[3 - BPS]; 353 DST(0, 0) = DST(1, 2) = AVG2(X, A); 354 DST(1, 0) = DST(2, 2) = AVG2(A, B); 355 DST(2, 0) = DST(3, 2) = AVG2(B, C); 356 DST(3, 0) = AVG2(C, D); 357 358 DST(0, 3) = AVG3(K, J, I); 359 DST(0, 2) = AVG3(J, I, X); 360 DST(0, 1) = DST(1, 3) = AVG3(I, X, A); 361 DST(1, 1) = DST(2, 3) = AVG3(X, A, B); 362 DST(2, 1) = DST(3, 3) = AVG3(A, B, C); 363 DST(3, 1) = AVG3(B, C, D); 364} 365 366static void VL4(uint8_t *dst) { // Vertical-Left 367 const int A = dst[0 - BPS]; 368 const int B = dst[1 - BPS]; 369 const int C = dst[2 - BPS]; 370 const int D = dst[3 - BPS]; 371 const int E = dst[4 - BPS]; 372 const int F = dst[5 - BPS]; 373 const int G = dst[6 - BPS]; 374 const int H = dst[7 - BPS]; 375 DST(0, 0) = AVG2(A, B); 376 DST(1, 0) = DST(0, 2) = AVG2(B, C); 377 DST(2, 0) = DST(1, 2) = AVG2(C, D); 378 DST(3, 0) = DST(2, 2) = AVG2(D, E); 379 380 DST(0, 1) = AVG3(A, B, C); 381 DST(1, 1) = DST(0, 3) = AVG3(B, C, D); 382 DST(2, 1) = DST(1, 3) = AVG3(C, D, E); 383 DST(3, 1) = DST(2, 3) = AVG3(D, E, F); 384 DST(3, 2) = AVG3(E, F, G); 385 DST(3, 3) = AVG3(F, G, H); 386} 387 388static void HU4(uint8_t *dst) { // Horizontal-Up 389 const int I = dst[-1 + 0 * BPS]; 390 const int J = dst[-1 + 1 * BPS]; 391 const int K = dst[-1 + 2 * BPS]; 392 const int L = dst[-1 + 3 * BPS]; 393 DST(0, 0) = AVG2(I, J); 394 DST(2, 0) = DST(0, 1) = AVG2(J, K); 395 DST(2, 1) = DST(0, 2) = AVG2(K, L); 396 DST(1, 0) = AVG3(I, J, K); 397 DST(3, 0) = DST(1, 1) = AVG3(J, K, L); 398 DST(3, 1) = DST(1, 2) = AVG3(K, L, L); 399 DST(3, 2) = DST(2, 2) = 400 DST(0, 3) = DST(1, 3) = DST(2, 3) = DST(3, 3) = L; 401} 402 403static void HD4(uint8_t *dst) { // Horizontal-Down 404 const int I = dst[-1 + 0 * BPS]; 405 const int J = dst[-1 + 1 * BPS]; 406 const int K = dst[-1 + 2 * BPS]; 407 const int L = dst[-1 + 3 * BPS]; 408 const int X = dst[-1 - BPS]; 409 const int A = dst[0 - BPS]; 410 const int B = dst[1 - BPS]; 411 const int C = dst[2 - BPS]; 412 413 DST(0, 0) = DST(2, 1) = AVG2(I, X); 414 DST(0, 1) = DST(2, 2) = AVG2(J, I); 415 DST(0, 2) = DST(2, 3) = AVG2(K, J); 416 DST(0, 3) = AVG2(L, K); 417 418 DST(3, 0) = AVG3(A, B, C); 419 DST(2, 0) = AVG3(X, A, B); 420 DST(1, 0) = DST(3, 1) = AVG3(I, X, A); 421 DST(1, 1) = DST(3, 2) = AVG3(J, I, X); 422 DST(1, 2) = DST(3, 3) = AVG3(K, J, I); 423 DST(1, 3) = AVG3(L, K, J); 424} 425 426#undef DST 427#undef AVG3 428#undef AVG2 429 430//------------------------------------------------------------------------------ 431// Chroma 432 433static void VE8uv(uint8_t *dst) { // vertical 434 int j; 435 for (j = 0; j < 8; ++j) { 436 memcpy(dst + j * BPS, dst - BPS, 8); 437 } 438} 439 440static void HE8uv(uint8_t *dst) { // horizontal 441 int j; 442 for (j = 0; j < 8; ++j) { 443 memset(dst, dst[-1], 8); 444 dst += BPS; 445 } 446} 447 448// helper for chroma-DC predictions 449static WEBP_INLINE void Put8x8uv(uint8_t value, uint8_t* dst) { 450 int j; 451#ifndef WEBP_REFERENCE_IMPLEMENTATION 452 const uint64_t v = (uint64_t)value * 0x0101010101010101ULL; 453 for (j = 0; j < 8; ++j) { 454 *(uint64_t*)(dst + j * BPS) = v; 455 } 456#else 457 for (j = 0; j < 8; ++j) memset(dst + j * BPS, value, 8); 458#endif 459} 460 461static void DC8uv(uint8_t *dst) { // DC 462 int dc0 = 8; 463 int i; 464 for (i = 0; i < 8; ++i) { 465 dc0 += dst[i - BPS] + dst[-1 + i * BPS]; 466 } 467 Put8x8uv(dc0 >> 4, dst); 468} 469 470static void DC8uvNoLeft(uint8_t *dst) { // DC with no left samples 471 int dc0 = 4; 472 int i; 473 for (i = 0; i < 8; ++i) { 474 dc0 += dst[i - BPS]; 475 } 476 Put8x8uv(dc0 >> 3, dst); 477} 478 479static void DC8uvNoTop(uint8_t *dst) { // DC with no top samples 480 int dc0 = 4; 481 int i; 482 for (i = 0; i < 8; ++i) { 483 dc0 += dst[-1 + i * BPS]; 484 } 485 Put8x8uv(dc0 >> 3, dst); 486} 487 488static void DC8uvNoTopLeft(uint8_t *dst) { // DC with nothing 489 Put8x8uv(0x80, dst); 490} 491 492//------------------------------------------------------------------------------ 493// default C implementations 494 495const VP8PredFunc VP8PredLuma4[NUM_BMODES] = { 496 DC4, TM4, VE4, HE4, RD4, VR4, LD4, VL4, HD4, HU4 497}; 498 499const VP8PredFunc VP8PredLuma16[NUM_B_DC_MODES] = { 500 DC16, TM16, VE16, HE16, 501 DC16NoTop, DC16NoLeft, DC16NoTopLeft 502}; 503 504const VP8PredFunc VP8PredChroma8[NUM_B_DC_MODES] = { 505 DC8uv, TM8uv, VE8uv, HE8uv, 506 DC8uvNoTop, DC8uvNoLeft, DC8uvNoTopLeft 507}; 508 509//------------------------------------------------------------------------------ 510// Edge filtering functions 511 512// 4 pixels in, 2 pixels out 513static WEBP_INLINE void do_filter2(uint8_t* p, int step) { 514 const int p1 = p[-2*step], p0 = p[-step], q0 = p[0], q1 = p[step]; 515 const int a = 3 * (q0 - p0) + sclip1[1020 + p1 - q1]; 516 const int a1 = sclip2[112 + ((a + 4) >> 3)]; 517 const int a2 = sclip2[112 + ((a + 3) >> 3)]; 518 p[-step] = clip1[255 + p0 + a2]; 519 p[ 0] = clip1[255 + q0 - a1]; 520} 521 522// 4 pixels in, 4 pixels out 523static WEBP_INLINE void do_filter4(uint8_t* p, int step) { 524 const int p1 = p[-2*step], p0 = p[-step], q0 = p[0], q1 = p[step]; 525 const int a = 3 * (q0 - p0); 526 const int a1 = sclip2[112 + ((a + 4) >> 3)]; 527 const int a2 = sclip2[112 + ((a + 3) >> 3)]; 528 const int a3 = (a1 + 1) >> 1; 529 p[-2*step] = clip1[255 + p1 + a3]; 530 p[- step] = clip1[255 + p0 + a2]; 531 p[ 0] = clip1[255 + q0 - a1]; 532 p[ step] = clip1[255 + q1 - a3]; 533} 534 535// 6 pixels in, 6 pixels out 536static WEBP_INLINE void do_filter6(uint8_t* p, int step) { 537 const int p2 = p[-3*step], p1 = p[-2*step], p0 = p[-step]; 538 const int q0 = p[0], q1 = p[step], q2 = p[2*step]; 539 const int a = sclip1[1020 + 3 * (q0 - p0) + sclip1[1020 + p1 - q1]]; 540 const int a1 = (27 * a + 63) >> 7; // eq. to ((3 * a + 7) * 9) >> 7 541 const int a2 = (18 * a + 63) >> 7; // eq. to ((2 * a + 7) * 9) >> 7 542 const int a3 = (9 * a + 63) >> 7; // eq. to ((1 * a + 7) * 9) >> 7 543 p[-3*step] = clip1[255 + p2 + a3]; 544 p[-2*step] = clip1[255 + p1 + a2]; 545 p[- step] = clip1[255 + p0 + a1]; 546 p[ 0] = clip1[255 + q0 - a1]; 547 p[ step] = clip1[255 + q1 - a2]; 548 p[ 2*step] = clip1[255 + q2 - a3]; 549} 550 551static WEBP_INLINE int hev(const uint8_t* p, int step, int thresh) { 552 const int p1 = p[-2*step], p0 = p[-step], q0 = p[0], q1 = p[step]; 553 return (abs0[255 + p1 - p0] > thresh) || (abs0[255 + q1 - q0] > thresh); 554} 555 556static WEBP_INLINE int needs_filter(const uint8_t* p, int step, int thresh) { 557 const int p1 = p[-2*step], p0 = p[-step], q0 = p[0], q1 = p[step]; 558 return (2 * abs0[255 + p0 - q0] + abs1[255 + p1 - q1]) <= thresh; 559} 560 561static WEBP_INLINE int needs_filter2(const uint8_t* p, 562 int step, int t, int it) { 563 const int p3 = p[-4*step], p2 = p[-3*step], p1 = p[-2*step], p0 = p[-step]; 564 const int q0 = p[0], q1 = p[step], q2 = p[2*step], q3 = p[3*step]; 565 if ((2 * abs0[255 + p0 - q0] + abs1[255 + p1 - q1]) > t) 566 return 0; 567 return abs0[255 + p3 - p2] <= it && abs0[255 + p2 - p1] <= it && 568 abs0[255 + p1 - p0] <= it && abs0[255 + q3 - q2] <= it && 569 abs0[255 + q2 - q1] <= it && abs0[255 + q1 - q0] <= it; 570} 571 572//------------------------------------------------------------------------------ 573// Simple In-loop filtering (Paragraph 15.2) 574 575static void SimpleVFilter16(uint8_t* p, int stride, int thresh) { 576 int i; 577 for (i = 0; i < 16; ++i) { 578 if (needs_filter(p + i, stride, thresh)) { 579 do_filter2(p + i, stride); 580 } 581 } 582} 583 584static void SimpleHFilter16(uint8_t* p, int stride, int thresh) { 585 int i; 586 for (i = 0; i < 16; ++i) { 587 if (needs_filter(p + i * stride, 1, thresh)) { 588 do_filter2(p + i * stride, 1); 589 } 590 } 591} 592 593static void SimpleVFilter16i(uint8_t* p, int stride, int thresh) { 594 int k; 595 for (k = 3; k > 0; --k) { 596 p += 4 * stride; 597 SimpleVFilter16(p, stride, thresh); 598 } 599} 600 601static void SimpleHFilter16i(uint8_t* p, int stride, int thresh) { 602 int k; 603 for (k = 3; k > 0; --k) { 604 p += 4; 605 SimpleHFilter16(p, stride, thresh); 606 } 607} 608 609//------------------------------------------------------------------------------ 610// Complex In-loop filtering (Paragraph 15.3) 611 612static WEBP_INLINE void FilterLoop26(uint8_t* p, 613 int hstride, int vstride, int size, 614 int thresh, int ithresh, int hev_thresh) { 615 while (size-- > 0) { 616 if (needs_filter2(p, hstride, thresh, ithresh)) { 617 if (hev(p, hstride, hev_thresh)) { 618 do_filter2(p, hstride); 619 } else { 620 do_filter6(p, hstride); 621 } 622 } 623 p += vstride; 624 } 625} 626 627static WEBP_INLINE void FilterLoop24(uint8_t* p, 628 int hstride, int vstride, int size, 629 int thresh, int ithresh, int hev_thresh) { 630 while (size-- > 0) { 631 if (needs_filter2(p, hstride, thresh, ithresh)) { 632 if (hev(p, hstride, hev_thresh)) { 633 do_filter2(p, hstride); 634 } else { 635 do_filter4(p, hstride); 636 } 637 } 638 p += vstride; 639 } 640} 641 642// on macroblock edges 643static void VFilter16(uint8_t* p, int stride, 644 int thresh, int ithresh, int hev_thresh) { 645 FilterLoop26(p, stride, 1, 16, thresh, ithresh, hev_thresh); 646} 647 648static void HFilter16(uint8_t* p, int stride, 649 int thresh, int ithresh, int hev_thresh) { 650 FilterLoop26(p, 1, stride, 16, thresh, ithresh, hev_thresh); 651} 652 653// on three inner edges 654static void VFilter16i(uint8_t* p, int stride, 655 int thresh, int ithresh, int hev_thresh) { 656 int k; 657 for (k = 3; k > 0; --k) { 658 p += 4 * stride; 659 FilterLoop24(p, stride, 1, 16, thresh, ithresh, hev_thresh); 660 } 661} 662 663static void HFilter16i(uint8_t* p, int stride, 664 int thresh, int ithresh, int hev_thresh) { 665 int k; 666 for (k = 3; k > 0; --k) { 667 p += 4; 668 FilterLoop24(p, 1, stride, 16, thresh, ithresh, hev_thresh); 669 } 670} 671 672// 8-pixels wide variant, for chroma filtering 673static void VFilter8(uint8_t* u, uint8_t* v, int stride, 674 int thresh, int ithresh, int hev_thresh) { 675 FilterLoop26(u, stride, 1, 8, thresh, ithresh, hev_thresh); 676 FilterLoop26(v, stride, 1, 8, thresh, ithresh, hev_thresh); 677} 678 679static void HFilter8(uint8_t* u, uint8_t* v, int stride, 680 int thresh, int ithresh, int hev_thresh) { 681 FilterLoop26(u, 1, stride, 8, thresh, ithresh, hev_thresh); 682 FilterLoop26(v, 1, stride, 8, thresh, ithresh, hev_thresh); 683} 684 685static void VFilter8i(uint8_t* u, uint8_t* v, int stride, 686 int thresh, int ithresh, int hev_thresh) { 687 FilterLoop24(u + 4 * stride, stride, 1, 8, thresh, ithresh, hev_thresh); 688 FilterLoop24(v + 4 * stride, stride, 1, 8, thresh, ithresh, hev_thresh); 689} 690 691static void HFilter8i(uint8_t* u, uint8_t* v, int stride, 692 int thresh, int ithresh, int hev_thresh) { 693 FilterLoop24(u + 4, 1, stride, 8, thresh, ithresh, hev_thresh); 694 FilterLoop24(v + 4, 1, stride, 8, thresh, ithresh, hev_thresh); 695} 696 697//------------------------------------------------------------------------------ 698 699VP8DecIdct2 VP8Transform; 700VP8DecIdct VP8TransformAC3; 701VP8DecIdct VP8TransformUV; 702VP8DecIdct VP8TransformDC; 703VP8DecIdct VP8TransformDCUV; 704 705VP8LumaFilterFunc VP8VFilter16; 706VP8LumaFilterFunc VP8HFilter16; 707VP8ChromaFilterFunc VP8VFilter8; 708VP8ChromaFilterFunc VP8HFilter8; 709VP8LumaFilterFunc VP8VFilter16i; 710VP8LumaFilterFunc VP8HFilter16i; 711VP8ChromaFilterFunc VP8VFilter8i; 712VP8ChromaFilterFunc VP8HFilter8i; 713VP8SimpleFilterFunc VP8SimpleVFilter16; 714VP8SimpleFilterFunc VP8SimpleHFilter16; 715VP8SimpleFilterFunc VP8SimpleVFilter16i; 716VP8SimpleFilterFunc VP8SimpleHFilter16i; 717 718extern void VP8DspInitSSE2(void); 719extern void VP8DspInitNEON(void); 720 721void VP8DspInit(void) { 722 DspInitTables(); 723 724 VP8Transform = TransformTwo; 725 VP8TransformUV = TransformUV; 726 VP8TransformDC = TransformDC; 727 VP8TransformDCUV = TransformDCUV; 728 VP8TransformAC3 = TransformAC3; 729 730 VP8VFilter16 = VFilter16; 731 VP8HFilter16 = HFilter16; 732 VP8VFilter8 = VFilter8; 733 VP8HFilter8 = HFilter8; 734 VP8VFilter16i = VFilter16i; 735 VP8HFilter16i = HFilter16i; 736 VP8VFilter8i = VFilter8i; 737 VP8HFilter8i = HFilter8i; 738 VP8SimpleVFilter16 = SimpleVFilter16; 739 VP8SimpleHFilter16 = SimpleHFilter16; 740 VP8SimpleVFilter16i = SimpleVFilter16i; 741 VP8SimpleHFilter16i = SimpleHFilter16i; 742 743 // If defined, use CPUInfo() to overwrite some pointers with faster versions. 744 if (VP8GetCPUInfo) { 745#if defined(WEBP_USE_SSE2) 746 if (VP8GetCPUInfo(kSSE2)) { 747 VP8DspInitSSE2(); 748 } 749#elif defined(WEBP_USE_NEON) 750 if (VP8GetCPUInfo(kNEON)) { 751 VP8DspInitNEON(); 752 } 753#endif 754 } 755} 756 757