OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. | 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 18 matching lines...) Expand all Loading... |
29 const int16_t *filter_x, int filter_x_stride, | 29 const int16_t *filter_x, int filter_x_stride, |
30 const int16_t *filter_y, int filter_y_stride, | 30 const int16_t *filter_y, int filter_y_stride, |
31 int w, int h); | 31 int w, int h); |
32 | 32 |
33 struct ConvolveFunctions { | 33 struct ConvolveFunctions { |
34 ConvolveFunctions(ConvolveFunc h8, ConvolveFunc h8_avg, | 34 ConvolveFunctions(ConvolveFunc h8, ConvolveFunc h8_avg, |
35 ConvolveFunc v8, ConvolveFunc v8_avg, | 35 ConvolveFunc v8, ConvolveFunc v8_avg, |
36 ConvolveFunc hv8, ConvolveFunc hv8_avg, | 36 ConvolveFunc hv8, ConvolveFunc hv8_avg, |
37 int bd) | 37 int bd) |
38 : h8_(h8), v8_(v8), hv8_(hv8), h8_avg_(h8_avg), v8_avg_(v8_avg), | 38 : h8_(h8), v8_(v8), hv8_(hv8), h8_avg_(h8_avg), v8_avg_(v8_avg), |
39 hv8_avg_(hv8_avg), use_high_bd_(bd) {} | 39 hv8_avg_(hv8_avg), use_highbd_(bd) {} |
40 | 40 |
41 ConvolveFunc h8_; | 41 ConvolveFunc h8_; |
42 ConvolveFunc v8_; | 42 ConvolveFunc v8_; |
43 ConvolveFunc hv8_; | 43 ConvolveFunc hv8_; |
44 ConvolveFunc h8_avg_; | 44 ConvolveFunc h8_avg_; |
45 ConvolveFunc v8_avg_; | 45 ConvolveFunc v8_avg_; |
46 ConvolveFunc hv8_avg_; | 46 ConvolveFunc hv8_avg_; |
47 int use_high_bd_; // 0 if high bitdepth not used, else the actual bit depth. | 47 int use_highbd_; // 0 if high bitdepth not used, else the actual bit depth. |
48 }; | 48 }; |
49 | 49 |
50 typedef std::tr1::tuple<int, int, const ConvolveFunctions *> ConvolveParam; | 50 typedef std::tr1::tuple<int, int, const ConvolveFunctions *> ConvolveParam; |
51 | 51 |
52 // Reference 8-tap subpixel filter, slightly modified to fit into this test. | 52 // Reference 8-tap subpixel filter, slightly modified to fit into this test. |
53 #define VP9_FILTER_WEIGHT 128 | 53 #define VP9_FILTER_WEIGHT 128 |
54 #define VP9_FILTER_SHIFT 7 | 54 #define VP9_FILTER_SHIFT 7 |
55 uint8_t clip_pixel(int x) { | 55 uint8_t clip_pixel(int x) { |
56 return x < 0 ? 0 : | 56 return x < 0 ? 0 : |
57 x > 255 ? 255 : | 57 x > 255 ? 255 : |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
163 | 163 |
164 assert(output_width <= kMaxDimension); | 164 assert(output_width <= kMaxDimension); |
165 assert(output_height <= kMaxDimension); | 165 assert(output_height <= kMaxDimension); |
166 filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, tmp, 64, | 166 filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, tmp, 64, |
167 output_width, output_height); | 167 output_width, output_height); |
168 block2d_average_c(tmp, 64, dst_ptr, dst_stride, | 168 block2d_average_c(tmp, 64, dst_ptr, dst_stride, |
169 output_width, output_height); | 169 output_width, output_height); |
170 } | 170 } |
171 | 171 |
172 #if CONFIG_VP9_HIGHBITDEPTH | 172 #if CONFIG_VP9_HIGHBITDEPTH |
173 void high_filter_block2d_8_c(const uint16_t *src_ptr, | 173 void highbd_filter_block2d_8_c(const uint16_t *src_ptr, |
174 const unsigned int src_stride, | 174 const unsigned int src_stride, |
175 const int16_t *HFilter, | 175 const int16_t *HFilter, |
176 const int16_t *VFilter, | 176 const int16_t *VFilter, |
177 uint16_t *dst_ptr, | 177 uint16_t *dst_ptr, |
178 unsigned int dst_stride, | 178 unsigned int dst_stride, |
179 unsigned int output_width, | 179 unsigned int output_width, |
180 unsigned int output_height, | 180 unsigned int output_height, |
181 int bd) { | 181 int bd) { |
182 // Between passes, we use an intermediate buffer whose height is extended to | 182 // Between passes, we use an intermediate buffer whose height is extended to |
183 // have enough horizontally filtered values as input for the vertical pass. | 183 // have enough horizontally filtered values as input for the vertical pass. |
184 // This buffer is allocated to be big enough for the largest block type we | 184 // This buffer is allocated to be big enough for the largest block type we |
185 // support. | 185 // support. |
186 const int kInterp_Extend = 4; | 186 const int kInterp_Extend = 4; |
187 const unsigned int intermediate_height = | 187 const unsigned int intermediate_height = |
188 (kInterp_Extend - 1) + output_height + kInterp_Extend; | 188 (kInterp_Extend - 1) + output_height + kInterp_Extend; |
189 | 189 |
190 /* Size of intermediate_buffer is max_intermediate_height * filter_max_width, | 190 /* Size of intermediate_buffer is max_intermediate_height * filter_max_width, |
191 * where max_intermediate_height = (kInterp_Extend - 1) + filter_max_height | 191 * where max_intermediate_height = (kInterp_Extend - 1) + filter_max_height |
(...skipping 18 matching lines...) Expand all Loading... |
210 (src_ptr[1] * HFilter[1]) + | 210 (src_ptr[1] * HFilter[1]) + |
211 (src_ptr[2] * HFilter[2]) + | 211 (src_ptr[2] * HFilter[2]) + |
212 (src_ptr[3] * HFilter[3]) + | 212 (src_ptr[3] * HFilter[3]) + |
213 (src_ptr[4] * HFilter[4]) + | 213 (src_ptr[4] * HFilter[4]) + |
214 (src_ptr[5] * HFilter[5]) + | 214 (src_ptr[5] * HFilter[5]) + |
215 (src_ptr[6] * HFilter[6]) + | 215 (src_ptr[6] * HFilter[6]) + |
216 (src_ptr[7] * HFilter[7]) + | 216 (src_ptr[7] * HFilter[7]) + |
217 (VP9_FILTER_WEIGHT >> 1); // Rounding | 217 (VP9_FILTER_WEIGHT >> 1); // Rounding |
218 | 218 |
219 // Normalize back to 0-255... | 219 // Normalize back to 0-255... |
220 *output_ptr = clip_pixel_high(temp >> VP9_FILTER_SHIFT, bd); | 220 *output_ptr = clip_pixel_highbd(temp >> VP9_FILTER_SHIFT, bd); |
221 ++src_ptr; | 221 ++src_ptr; |
222 output_ptr += intermediate_height; | 222 output_ptr += intermediate_height; |
223 } | 223 } |
224 src_ptr += src_next_row_stride; | 224 src_ptr += src_next_row_stride; |
225 output_ptr += intermediate_next_stride; | 225 output_ptr += intermediate_next_stride; |
226 } | 226 } |
227 } | 227 } |
228 | 228 |
229 // Vertical pass (transposed intermediate -> dst). | 229 // Vertical pass (transposed intermediate -> dst). |
230 { | 230 { |
231 uint16_t *src_ptr = intermediate_buffer; | 231 uint16_t *src_ptr = intermediate_buffer; |
232 const int dst_next_row_stride = dst_stride - output_width; | 232 const int dst_next_row_stride = dst_stride - output_width; |
233 unsigned int i, j; | 233 unsigned int i, j; |
234 for (i = 0; i < output_height; ++i) { | 234 for (i = 0; i < output_height; ++i) { |
235 for (j = 0; j < output_width; ++j) { | 235 for (j = 0; j < output_width; ++j) { |
236 // Apply filter... | 236 // Apply filter... |
237 const int temp = (src_ptr[0] * VFilter[0]) + | 237 const int temp = (src_ptr[0] * VFilter[0]) + |
238 (src_ptr[1] * VFilter[1]) + | 238 (src_ptr[1] * VFilter[1]) + |
239 (src_ptr[2] * VFilter[2]) + | 239 (src_ptr[2] * VFilter[2]) + |
240 (src_ptr[3] * VFilter[3]) + | 240 (src_ptr[3] * VFilter[3]) + |
241 (src_ptr[4] * VFilter[4]) + | 241 (src_ptr[4] * VFilter[4]) + |
242 (src_ptr[5] * VFilter[5]) + | 242 (src_ptr[5] * VFilter[5]) + |
243 (src_ptr[6] * VFilter[6]) + | 243 (src_ptr[6] * VFilter[6]) + |
244 (src_ptr[7] * VFilter[7]) + | 244 (src_ptr[7] * VFilter[7]) + |
245 (VP9_FILTER_WEIGHT >> 1); // Rounding | 245 (VP9_FILTER_WEIGHT >> 1); // Rounding |
246 | 246 |
247 // Normalize back to 0-255... | 247 // Normalize back to 0-255... |
248 *dst_ptr++ = clip_pixel_high(temp >> VP9_FILTER_SHIFT, bd); | 248 *dst_ptr++ = clip_pixel_highbd(temp >> VP9_FILTER_SHIFT, bd); |
249 src_ptr += intermediate_height; | 249 src_ptr += intermediate_height; |
250 } | 250 } |
251 src_ptr += intermediate_next_stride; | 251 src_ptr += intermediate_next_stride; |
252 dst_ptr += dst_next_row_stride; | 252 dst_ptr += dst_next_row_stride; |
253 } | 253 } |
254 } | 254 } |
255 } | 255 } |
256 | 256 |
257 void high_block2d_average_c(uint16_t *src, | 257 void highbd_block2d_average_c(uint16_t *src, |
258 unsigned int src_stride, | 258 unsigned int src_stride, |
259 uint16_t *output_ptr, | 259 uint16_t *output_ptr, |
260 unsigned int output_stride, | 260 unsigned int output_stride, |
261 unsigned int output_width, | 261 unsigned int output_width, |
262 unsigned int output_height, | 262 unsigned int output_height, |
263 int bd) { | 263 int bd) { |
264 unsigned int i, j; | 264 unsigned int i, j; |
265 for (i = 0; i < output_height; ++i) { | 265 for (i = 0; i < output_height; ++i) { |
266 for (j = 0; j < output_width; ++j) { | 266 for (j = 0; j < output_width; ++j) { |
267 output_ptr[j] = (output_ptr[j] + src[i * src_stride + j] + 1) >> 1; | 267 output_ptr[j] = (output_ptr[j] + src[i * src_stride + j] + 1) >> 1; |
268 } | 268 } |
269 output_ptr += output_stride; | 269 output_ptr += output_stride; |
270 } | 270 } |
271 } | 271 } |
272 | 272 |
273 void high_filter_average_block2d_8_c(const uint16_t *src_ptr, | 273 void highbd_filter_average_block2d_8_c(const uint16_t *src_ptr, |
274 const unsigned int src_stride, | 274 const unsigned int src_stride, |
275 const int16_t *HFilter, | 275 const int16_t *HFilter, |
276 const int16_t *VFilter, | 276 const int16_t *VFilter, |
277 uint16_t *dst_ptr, | 277 uint16_t *dst_ptr, |
278 unsigned int dst_stride, | 278 unsigned int dst_stride, |
279 unsigned int output_width, | 279 unsigned int output_width, |
280 unsigned int output_height, | 280 unsigned int output_height, |
281 int bd) { | 281 int bd) { |
282 uint16_t tmp[kMaxDimension * kMaxDimension]; | 282 uint16_t tmp[kMaxDimension * kMaxDimension]; |
283 | 283 |
284 assert(output_width <= kMaxDimension); | 284 assert(output_width <= kMaxDimension); |
285 assert(output_height <= kMaxDimension); | 285 assert(output_height <= kMaxDimension); |
286 high_filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, tmp, 64, | 286 highbd_filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, tmp, 64, |
287 output_width, output_height, bd); | 287 output_width, output_height, bd); |
288 high_block2d_average_c(tmp, 64, dst_ptr, dst_stride, | 288 highbd_block2d_average_c(tmp, 64, dst_ptr, dst_stride, |
289 output_width, output_height, bd); | 289 output_width, output_height, bd); |
290 } | 290 } |
291 #endif // CONFIG_VP9_HIGHBITDEPTH | 291 #endif // CONFIG_VP9_HIGHBITDEPTH |
292 | 292 |
293 class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> { | 293 class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> { |
294 public: | 294 public: |
295 static void SetUpTestCase() { | 295 static void SetUpTestCase() { |
296 // Force input_ to be unaligned, output to be 16 byte aligned. | 296 // Force input_ to be unaligned, output to be 16 byte aligned. |
297 input_ = reinterpret_cast<uint8_t*>( | 297 input_ = reinterpret_cast<uint8_t*>( |
298 vpx_memalign(kDataAlignment, kInputBufferSize + 1)) + 1; | 298 vpx_memalign(kDataAlignment, kInputBufferSize + 1)) + 1; |
299 output_ = reinterpret_cast<uint8_t*>( | 299 output_ = reinterpret_cast<uint8_t*>( |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
339 bool IsIndexInBorder(int i) { | 339 bool IsIndexInBorder(int i) { |
340 return (i < BorderTop() * kOuterBlockSize || | 340 return (i < BorderTop() * kOuterBlockSize || |
341 i >= (BorderTop() + Height()) * kOuterBlockSize || | 341 i >= (BorderTop() + Height()) * kOuterBlockSize || |
342 i % kOuterBlockSize < BorderLeft() || | 342 i % kOuterBlockSize < BorderLeft() || |
343 i % kOuterBlockSize >= (BorderLeft() + Width())); | 343 i % kOuterBlockSize >= (BorderLeft() + Width())); |
344 } | 344 } |
345 | 345 |
346 virtual void SetUp() { | 346 virtual void SetUp() { |
347 UUT_ = GET_PARAM(2); | 347 UUT_ = GET_PARAM(2); |
348 #if CONFIG_VP9_HIGHBITDEPTH | 348 #if CONFIG_VP9_HIGHBITDEPTH |
349 if (UUT_->use_high_bd_ != 0) | 349 if (UUT_->use_highbd_ != 0) |
350 mask_ = (1 << UUT_->use_high_bd_) - 1; | 350 mask_ = (1 << UUT_->use_highbd_) - 1; |
351 else | 351 else |
352 mask_ = 255; | 352 mask_ = 255; |
353 #endif | 353 #endif |
354 /* Set up guard blocks for an inner block centered in the outer block */ | 354 /* Set up guard blocks for an inner block centered in the outer block */ |
355 for (int i = 0; i < kOutputBufferSize; ++i) { | 355 for (int i = 0; i < kOutputBufferSize; ++i) { |
356 if (IsIndexInBorder(i)) | 356 if (IsIndexInBorder(i)) |
357 output_[i] = 255; | 357 output_[i] = 255; |
358 else | 358 else |
359 output_[i] = 0; | 359 output_[i] = 0; |
360 } | 360 } |
(...skipping 23 matching lines...) Expand all Loading... |
384 | 384 |
385 void CheckGuardBlocks() { | 385 void CheckGuardBlocks() { |
386 for (int i = 0; i < kOutputBufferSize; ++i) { | 386 for (int i = 0; i < kOutputBufferSize; ++i) { |
387 if (IsIndexInBorder(i)) | 387 if (IsIndexInBorder(i)) |
388 EXPECT_EQ(255, output_[i]); | 388 EXPECT_EQ(255, output_[i]); |
389 } | 389 } |
390 } | 390 } |
391 | 391 |
392 uint8_t *input() const { | 392 uint8_t *input() const { |
393 #if CONFIG_VP9_HIGHBITDEPTH | 393 #if CONFIG_VP9_HIGHBITDEPTH |
394 if (UUT_->use_high_bd_ == 0) { | 394 if (UUT_->use_highbd_ == 0) { |
395 return input_ + BorderTop() * kOuterBlockSize + BorderLeft(); | 395 return input_ + BorderTop() * kOuterBlockSize + BorderLeft(); |
396 } else { | 396 } else { |
397 return CONVERT_TO_BYTEPTR(input16_ + BorderTop() * kOuterBlockSize + | 397 return CONVERT_TO_BYTEPTR(input16_ + BorderTop() * kOuterBlockSize + |
398 BorderLeft()); | 398 BorderLeft()); |
399 } | 399 } |
400 #else | 400 #else |
401 return input_ + BorderTop() * kOuterBlockSize + BorderLeft(); | 401 return input_ + BorderTop() * kOuterBlockSize + BorderLeft(); |
402 #endif | 402 #endif |
403 } | 403 } |
404 | 404 |
405 uint8_t *output() const { | 405 uint8_t *output() const { |
406 #if CONFIG_VP9_HIGHBITDEPTH | 406 #if CONFIG_VP9_HIGHBITDEPTH |
407 if (UUT_->use_high_bd_ == 0) { | 407 if (UUT_->use_highbd_ == 0) { |
408 return output_ + BorderTop() * kOuterBlockSize + BorderLeft(); | 408 return output_ + BorderTop() * kOuterBlockSize + BorderLeft(); |
409 } else { | 409 } else { |
410 return CONVERT_TO_BYTEPTR(output16_ + BorderTop() * kOuterBlockSize + | 410 return CONVERT_TO_BYTEPTR(output16_ + BorderTop() * kOuterBlockSize + |
411 BorderLeft()); | 411 BorderLeft()); |
412 } | 412 } |
413 #else | 413 #else |
414 return output_ + BorderTop() * kOuterBlockSize + BorderLeft(); | 414 return output_ + BorderTop() * kOuterBlockSize + BorderLeft(); |
415 #endif | 415 #endif |
416 } | 416 } |
417 | 417 |
418 uint16_t lookup(uint8_t *list, int index) const { | 418 uint16_t lookup(uint8_t *list, int index) const { |
419 #if CONFIG_VP9_HIGHBITDEPTH | 419 #if CONFIG_VP9_HIGHBITDEPTH |
420 if (UUT_->use_high_bd_ == 0) { | 420 if (UUT_->use_highbd_ == 0) { |
421 return list[index]; | 421 return list[index]; |
422 } else { | 422 } else { |
423 return CONVERT_TO_SHORTPTR(list)[index]; | 423 return CONVERT_TO_SHORTPTR(list)[index]; |
424 } | 424 } |
425 #else | 425 #else |
426 return list[index]; | 426 return list[index]; |
427 #endif | 427 #endif |
428 } | 428 } |
429 | 429 |
430 void assign_val(uint8_t *list, int index, uint16_t val) const { | 430 void assign_val(uint8_t *list, int index, uint16_t val) const { |
431 #if CONFIG_VP9_HIGHBITDEPTH | 431 #if CONFIG_VP9_HIGHBITDEPTH |
432 if (UUT_->use_high_bd_ == 0) { | 432 if (UUT_->use_highbd_ == 0) { |
433 list[index] = (uint8_t) val; | 433 list[index] = (uint8_t) val; |
434 } else { | 434 } else { |
435 CONVERT_TO_SHORTPTR(list)[index] = val; | 435 CONVERT_TO_SHORTPTR(list)[index] = val; |
436 } | 436 } |
437 #else | 437 #else |
438 list[index] = (uint8_t) val; | 438 list[index] = (uint8_t) val; |
439 #endif | 439 #endif |
440 } | 440 } |
441 | 441 |
442 void wrapper_filter_average_block2d_8_c(const uint8_t *src_ptr, | 442 void wrapper_filter_average_block2d_8_c(const uint8_t *src_ptr, |
443 const unsigned int src_stride, | 443 const unsigned int src_stride, |
444 const int16_t *HFilter, | 444 const int16_t *HFilter, |
445 const int16_t *VFilter, | 445 const int16_t *VFilter, |
446 uint8_t *dst_ptr, | 446 uint8_t *dst_ptr, |
447 unsigned int dst_stride, | 447 unsigned int dst_stride, |
448 unsigned int output_width, | 448 unsigned int output_width, |
449 unsigned int output_height) { | 449 unsigned int output_height) { |
450 #if CONFIG_VP9_HIGHBITDEPTH | 450 #if CONFIG_VP9_HIGHBITDEPTH |
451 if (UUT_->use_high_bd_ == 0) { | 451 if (UUT_->use_highbd_ == 0) { |
452 filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, | 452 filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, |
453 dst_ptr, dst_stride, output_width, | 453 dst_ptr, dst_stride, output_width, |
454 output_height); | 454 output_height); |
455 } else { | 455 } else { |
456 high_filter_average_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr), src_stride, | 456 highbd_filter_average_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr), |
457 HFilter, VFilter, | 457 src_stride, HFilter, VFilter, |
458 CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, | 458 CONVERT_TO_SHORTPTR(dst_ptr), |
459 output_width, output_height, | 459 dst_stride, output_width, output_height, |
460 UUT_->use_high_bd_); | 460 UUT_->use_highbd_); |
461 } | 461 } |
462 #else | 462 #else |
463 filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, | 463 filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, |
464 dst_ptr, dst_stride, output_width, | 464 dst_ptr, dst_stride, output_width, |
465 output_height); | 465 output_height); |
466 #endif | 466 #endif |
467 } | 467 } |
468 | 468 |
469 void wrapper_filter_block2d_8_c(const uint8_t *src_ptr, | 469 void wrapper_filter_block2d_8_c(const uint8_t *src_ptr, |
470 const unsigned int src_stride, | 470 const unsigned int src_stride, |
471 const int16_t *HFilter, | 471 const int16_t *HFilter, |
472 const int16_t *VFilter, | 472 const int16_t *VFilter, |
473 uint8_t *dst_ptr, | 473 uint8_t *dst_ptr, |
474 unsigned int dst_stride, | 474 unsigned int dst_stride, |
475 unsigned int output_width, | 475 unsigned int output_width, |
476 unsigned int output_height) { | 476 unsigned int output_height) { |
477 #if CONFIG_VP9_HIGHBITDEPTH | 477 #if CONFIG_VP9_HIGHBITDEPTH |
478 if (UUT_->use_high_bd_ == 0) { | 478 if (UUT_->use_highbd_ == 0) { |
479 filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, | 479 filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, |
480 dst_ptr, dst_stride, output_width, output_height); | 480 dst_ptr, dst_stride, output_width, output_height); |
481 } else { | 481 } else { |
482 high_filter_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr), src_stride, | 482 highbd_filter_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr), src_stride, |
483 HFilter, VFilter, | 483 HFilter, VFilter, |
484 CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, | 484 CONVERT_TO_SHORTPTR(dst_ptr), dst_stride, |
485 output_width, output_height, UUT_->use_high_bd_); | 485 output_width, output_height, UUT_->use_highbd_); |
486 } | 486 } |
487 #else | 487 #else |
488 filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, | 488 filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, |
489 dst_ptr, dst_stride, output_width, output_height); | 489 dst_ptr, dst_stride, output_width, output_height); |
490 #endif | 490 #endif |
491 } | 491 } |
492 | 492 |
493 const ConvolveFunctions* UUT_; | 493 const ConvolveFunctions* UUT_; |
494 static uint8_t* input_; | 494 static uint8_t* input_; |
495 static uint8_t* output_; | 495 static uint8_t* output_; |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
591 | 591 |
592 const int16_t kInvalidFilter[8] = { 0 }; | 592 const int16_t kInvalidFilter[8] = { 0 }; |
593 | 593 |
594 TEST_P(ConvolveTest, MatchesReferenceSubpixelFilter) { | 594 TEST_P(ConvolveTest, MatchesReferenceSubpixelFilter) { |
595 uint8_t* const in = input(); | 595 uint8_t* const in = input(); |
596 uint8_t* const out = output(); | 596 uint8_t* const out = output(); |
597 #if CONFIG_VP9_HIGHBITDEPTH | 597 #if CONFIG_VP9_HIGHBITDEPTH |
598 uint8_t ref8[kOutputStride * kMaxDimension]; | 598 uint8_t ref8[kOutputStride * kMaxDimension]; |
599 uint16_t ref16[kOutputStride * kMaxDimension]; | 599 uint16_t ref16[kOutputStride * kMaxDimension]; |
600 uint8_t* ref; | 600 uint8_t* ref; |
601 if (UUT_->use_high_bd_ == 0) { | 601 if (UUT_->use_highbd_ == 0) { |
602 ref = ref8; | 602 ref = ref8; |
603 } else { | 603 } else { |
604 ref = CONVERT_TO_BYTEPTR(ref16); | 604 ref = CONVERT_TO_BYTEPTR(ref16); |
605 } | 605 } |
606 #else | 606 #else |
607 uint8_t ref[kOutputStride * kMaxDimension]; | 607 uint8_t ref[kOutputStride * kMaxDimension]; |
608 #endif | 608 #endif |
609 | 609 |
610 for (int filter_bank = 0; filter_bank < kNumFilterBanks; ++filter_bank) { | 610 for (int filter_bank = 0; filter_bank < kNumFilterBanks; ++filter_bank) { |
611 const InterpKernel *filters = | 611 const InterpKernel *filters = |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
650 } | 650 } |
651 } | 651 } |
652 | 652 |
653 TEST_P(ConvolveTest, MatchesReferenceAveragingSubpixelFilter) { | 653 TEST_P(ConvolveTest, MatchesReferenceAveragingSubpixelFilter) { |
654 uint8_t* const in = input(); | 654 uint8_t* const in = input(); |
655 uint8_t* const out = output(); | 655 uint8_t* const out = output(); |
656 #if CONFIG_VP9_HIGHBITDEPTH | 656 #if CONFIG_VP9_HIGHBITDEPTH |
657 uint8_t ref8[kOutputStride * kMaxDimension]; | 657 uint8_t ref8[kOutputStride * kMaxDimension]; |
658 uint16_t ref16[kOutputStride * kMaxDimension]; | 658 uint16_t ref16[kOutputStride * kMaxDimension]; |
659 uint8_t* ref; | 659 uint8_t* ref; |
660 if (UUT_->use_high_bd_ == 0) { | 660 if (UUT_->use_highbd_ == 0) { |
661 ref = ref8; | 661 ref = ref8; |
662 } else { | 662 } else { |
663 ref = CONVERT_TO_BYTEPTR(ref16); | 663 ref = CONVERT_TO_BYTEPTR(ref16); |
664 } | 664 } |
665 #else | 665 #else |
666 uint8_t ref[kOutputStride * kMaxDimension]; | 666 uint8_t ref[kOutputStride * kMaxDimension]; |
667 #endif | 667 #endif |
668 | 668 |
669 // Populate ref and out with some random data | 669 // Populate ref and out with some random data |
670 ::libvpx_test::ACMRandom prng; | 670 ::libvpx_test::ACMRandom prng; |
671 for (int y = 0; y < Height(); ++y) { | 671 for (int y = 0; y < Height(); ++y) { |
672 for (int x = 0; x < Width(); ++x) { | 672 for (int x = 0; x < Width(); ++x) { |
673 uint16_t r; | 673 uint16_t r; |
674 #if CONFIG_VP9_HIGHBITDEPTH | 674 #if CONFIG_VP9_HIGHBITDEPTH |
675 if (UUT_->use_high_bd_ == 0 || UUT_->use_high_bd_ == 8) { | 675 if (UUT_->use_highbd_ == 0 || UUT_->use_highbd_ == 8) { |
676 r = prng.Rand8Extremes(); | 676 r = prng.Rand8Extremes(); |
677 } else { | 677 } else { |
678 r = prng.Rand16() & mask_; | 678 r = prng.Rand16() & mask_; |
679 } | 679 } |
680 #else | 680 #else |
681 r = prng.Rand8Extremes(); | 681 r = prng.Rand8Extremes(); |
682 #endif | 682 #endif |
683 | 683 |
684 assign_val(out, y * kOutputStride + x, r); | 684 assign_val(out, y * kOutputStride + x, r); |
685 assign_val(ref, y * kOutputStride + x, r); | 685 assign_val(ref, y * kOutputStride + x, r); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
729 } | 729 } |
730 } | 730 } |
731 | 731 |
732 TEST_P(ConvolveTest, FilterExtremes) { | 732 TEST_P(ConvolveTest, FilterExtremes) { |
733 uint8_t *const in = input(); | 733 uint8_t *const in = input(); |
734 uint8_t *const out = output(); | 734 uint8_t *const out = output(); |
735 #if CONFIG_VP9_HIGHBITDEPTH | 735 #if CONFIG_VP9_HIGHBITDEPTH |
736 uint8_t ref8[kOutputStride * kMaxDimension]; | 736 uint8_t ref8[kOutputStride * kMaxDimension]; |
737 uint16_t ref16[kOutputStride * kMaxDimension]; | 737 uint16_t ref16[kOutputStride * kMaxDimension]; |
738 uint8_t *ref; | 738 uint8_t *ref; |
739 if (UUT_->use_high_bd_ == 0) { | 739 if (UUT_->use_highbd_ == 0) { |
740 ref = ref8; | 740 ref = ref8; |
741 } else { | 741 } else { |
742 ref = CONVERT_TO_BYTEPTR(ref16); | 742 ref = CONVERT_TO_BYTEPTR(ref16); |
743 } | 743 } |
744 #else | 744 #else |
745 uint8_t ref[kOutputStride * kMaxDimension]; | 745 uint8_t ref[kOutputStride * kMaxDimension]; |
746 #endif | 746 #endif |
747 | 747 |
748 // Populate ref and out with some random data | 748 // Populate ref and out with some random data |
749 ::libvpx_test::ACMRandom prng; | 749 ::libvpx_test::ACMRandom prng; |
750 for (int y = 0; y < Height(); ++y) { | 750 for (int y = 0; y < Height(); ++y) { |
751 for (int x = 0; x < Width(); ++x) { | 751 for (int x = 0; x < Width(); ++x) { |
752 uint16_t r; | 752 uint16_t r; |
753 #if CONFIG_VP9_HIGHBITDEPTH | 753 #if CONFIG_VP9_HIGHBITDEPTH |
754 if (UUT_->use_high_bd_ == 0 || UUT_->use_high_bd_ == 8) { | 754 if (UUT_->use_highbd_ == 0 || UUT_->use_highbd_ == 8) { |
755 r = prng.Rand8Extremes(); | 755 r = prng.Rand8Extremes(); |
756 } else { | 756 } else { |
757 r = prng.Rand16() & mask_; | 757 r = prng.Rand16() & mask_; |
758 } | 758 } |
759 #else | 759 #else |
760 r = prng.Rand8Extremes(); | 760 r = prng.Rand8Extremes(); |
761 #endif | 761 #endif |
762 assign_val(out, y * kOutputStride + x, r); | 762 assign_val(out, y * kOutputStride + x, r); |
763 assign_val(ref, y * kOutputStride + x, r); | 763 assign_val(ref, y * kOutputStride + x, r); |
764 } | 764 } |
(...skipping 206 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
971 | 971 |
972 #if CONFIG_VP9_HIGHBITDEPTH | 972 #if CONFIG_VP9_HIGHBITDEPTH |
973 #if HAVE_SSE2 && ARCH_X86_64 | 973 #if HAVE_SSE2 && ARCH_X86_64 |
974 void wrap_convolve8_horiz_sse2_8(const uint8_t *src, ptrdiff_t src_stride, | 974 void wrap_convolve8_horiz_sse2_8(const uint8_t *src, ptrdiff_t src_stride, |
975 uint8_t *dst, ptrdiff_t dst_stride, | 975 uint8_t *dst, ptrdiff_t dst_stride, |
976 const int16_t *filter_x, | 976 const int16_t *filter_x, |
977 int filter_x_stride, | 977 int filter_x_stride, |
978 const int16_t *filter_y, | 978 const int16_t *filter_y, |
979 int filter_y_stride, | 979 int filter_y_stride, |
980 int w, int h) { | 980 int w, int h) { |
981 vp9_high_convolve8_horiz_sse2(src, src_stride, dst, dst_stride, filter_x, | 981 vp9_highbd_convolve8_horiz_sse2(src, src_stride, dst, dst_stride, filter_x, |
982 filter_x_stride, filter_y, filter_y_stride, | 982 filter_x_stride, filter_y, filter_y_stride, |
983 w, h, 8); | 983 w, h, 8); |
984 } | 984 } |
985 | 985 |
986 void wrap_convolve8_avg_horiz_sse2_8(const uint8_t *src, ptrdiff_t src_stride, | 986 void wrap_convolve8_avg_horiz_sse2_8(const uint8_t *src, ptrdiff_t src_stride, |
987 uint8_t *dst, ptrdiff_t dst_stride, | 987 uint8_t *dst, ptrdiff_t dst_stride, |
988 const int16_t *filter_x, | 988 const int16_t *filter_x, |
989 int filter_x_stride, | 989 int filter_x_stride, |
990 const int16_t *filter_y, | 990 const int16_t *filter_y, |
991 int filter_y_stride, | 991 int filter_y_stride, |
992 int w, int h) { | 992 int w, int h) { |
993 vp9_high_convolve8_avg_horiz_sse2(src, src_stride, dst, dst_stride, filter_x, | 993 vp9_highbd_convolve8_avg_horiz_sse2(src, src_stride, dst, dst_stride, |
994 filter_x_stride, filter_y, filter_y_stride, w, h, 8); | 994 filter_x, filter_x_stride, |
| 995 filter_y, filter_y_stride, w, h, 8); |
995 } | 996 } |
996 | 997 |
997 void wrap_convolve8_vert_sse2_8(const uint8_t *src, ptrdiff_t src_stride, | 998 void wrap_convolve8_vert_sse2_8(const uint8_t *src, ptrdiff_t src_stride, |
998 uint8_t *dst, ptrdiff_t dst_stride, | 999 uint8_t *dst, ptrdiff_t dst_stride, |
999 const int16_t *filter_x, | 1000 const int16_t *filter_x, |
1000 int filter_x_stride, | 1001 int filter_x_stride, |
1001 const int16_t *filter_y, | 1002 const int16_t *filter_y, |
1002 int filter_y_stride, | 1003 int filter_y_stride, |
1003 int w, int h) { | 1004 int w, int h) { |
1004 vp9_high_convolve8_vert_sse2(src, src_stride, dst, dst_stride, filter_x, | 1005 vp9_highbd_convolve8_vert_sse2(src, src_stride, dst, dst_stride, |
1005 filter_x_stride, filter_y, filter_y_stride, w, h, 8); | 1006 filter_x, filter_x_stride, |
| 1007 filter_y, filter_y_stride, w, h, 8); |
1006 } | 1008 } |
1007 | 1009 |
1008 void wrap_convolve8_avg_vert_sse2_8(const uint8_t *src, ptrdiff_t src_stride, | 1010 void wrap_convolve8_avg_vert_sse2_8(const uint8_t *src, ptrdiff_t src_stride, |
1009 uint8_t *dst, ptrdiff_t dst_stride, | 1011 uint8_t *dst, ptrdiff_t dst_stride, |
1010 const int16_t *filter_x, | 1012 const int16_t *filter_x, |
1011 int filter_x_stride, | 1013 int filter_x_stride, |
1012 const int16_t *filter_y, | 1014 const int16_t *filter_y, |
1013 int filter_y_stride, | 1015 int filter_y_stride, |
1014 int w, int h) { | 1016 int w, int h) { |
1015 vp9_high_convolve8_avg_vert_sse2(src, src_stride, dst, dst_stride, filter_x, | 1017 vp9_highbd_convolve8_avg_vert_sse2(src, src_stride, dst, dst_stride, |
1016 filter_x_stride, filter_y, filter_y_stride, | 1018 filter_x, filter_x_stride, |
1017 w, h, 8); | 1019 filter_y, filter_y_stride, w, h, 8); |
1018 } | 1020 } |
1019 | 1021 |
1020 void wrap_convolve8_sse2_8(const uint8_t *src, ptrdiff_t src_stride, | 1022 void wrap_convolve8_sse2_8(const uint8_t *src, ptrdiff_t src_stride, |
1021 uint8_t *dst, ptrdiff_t dst_stride, | 1023 uint8_t *dst, ptrdiff_t dst_stride, |
1022 const int16_t *filter_x, | 1024 const int16_t *filter_x, |
1023 int filter_x_stride, | 1025 int filter_x_stride, |
1024 const int16_t *filter_y, | 1026 const int16_t *filter_y, |
1025 int filter_y_stride, | 1027 int filter_y_stride, |
1026 int w, int h) { | 1028 int w, int h) { |
1027 vp9_high_convolve8_sse2(src, src_stride, dst, dst_stride, filter_x, | 1029 vp9_highbd_convolve8_sse2(src, src_stride, dst, dst_stride, |
1028 filter_x_stride, filter_y, filter_y_stride, w, h, 8); | 1030 filter_x, filter_x_stride, |
| 1031 filter_y, filter_y_stride, w, h, 8); |
1029 } | 1032 } |
1030 | 1033 |
1031 void wrap_convolve8_avg_sse2_8(const uint8_t *src, ptrdiff_t src_stride, | 1034 void wrap_convolve8_avg_sse2_8(const uint8_t *src, ptrdiff_t src_stride, |
1032 uint8_t *dst, ptrdiff_t dst_stride, | 1035 uint8_t *dst, ptrdiff_t dst_stride, |
1033 const int16_t *filter_x, | 1036 const int16_t *filter_x, |
1034 int filter_x_stride, | 1037 int filter_x_stride, |
1035 const int16_t *filter_y, | 1038 const int16_t *filter_y, |
1036 int filter_y_stride, | 1039 int filter_y_stride, |
1037 int w, int h) { | 1040 int w, int h) { |
1038 vp9_high_convolve8_avg_sse2(src, src_stride, dst, dst_stride, filter_x, | 1041 vp9_highbd_convolve8_avg_sse2(src, src_stride, dst, dst_stride, |
1039 filter_x_stride, filter_y, filter_y_stride, w, h, 8); | 1042 filter_x, filter_x_stride, |
| 1043 filter_y, filter_y_stride, w, h, 8); |
1040 } | 1044 } |
1041 | 1045 |
1042 void wrap_convolve8_horiz_sse2_10(const uint8_t *src, ptrdiff_t src_stride, | 1046 void wrap_convolve8_horiz_sse2_10(const uint8_t *src, ptrdiff_t src_stride, |
1043 uint8_t *dst, ptrdiff_t dst_stride, | 1047 uint8_t *dst, ptrdiff_t dst_stride, |
1044 const int16_t *filter_x, | 1048 const int16_t *filter_x, |
1045 int filter_x_stride, | 1049 int filter_x_stride, |
1046 const int16_t *filter_y, | 1050 const int16_t *filter_y, |
1047 int filter_y_stride, | 1051 int filter_y_stride, |
1048 int w, int h) { | 1052 int w, int h) { |
1049 vp9_high_convolve8_horiz_sse2(src, src_stride, dst, dst_stride, filter_x, | 1053 vp9_highbd_convolve8_horiz_sse2(src, src_stride, dst, dst_stride, |
1050 filter_x_stride, filter_y, filter_y_stride, w, h, 10); | 1054 filter_x, filter_x_stride, |
| 1055 filter_y, filter_y_stride, w, h, 10); |
1051 } | 1056 } |
1052 | 1057 |
1053 void wrap_convolve8_avg_horiz_sse2_10(const uint8_t *src, ptrdiff_t src_stride, | 1058 void wrap_convolve8_avg_horiz_sse2_10(const uint8_t *src, ptrdiff_t src_stride, |
1054 uint8_t *dst, ptrdiff_t dst_stride, | 1059 uint8_t *dst, ptrdiff_t dst_stride, |
1055 const int16_t *filter_x, | 1060 const int16_t *filter_x, |
1056 int filter_x_stride, | 1061 int filter_x_stride, |
1057 const int16_t *filter_y, | 1062 const int16_t *filter_y, |
1058 int filter_y_stride, | 1063 int filter_y_stride, |
1059 int w, int h) { | 1064 int w, int h) { |
1060 vp9_high_convolve8_avg_horiz_sse2(src, src_stride, dst, dst_stride, filter_x, | 1065 vp9_highbd_convolve8_avg_horiz_sse2(src, src_stride, dst, dst_stride, |
1061 filter_x_stride, filter_y, filter_y_stride, w, h, 10); | 1066 filter_x, filter_x_stride, |
| 1067 filter_y, filter_y_stride, w, h, 10); |
1062 } | 1068 } |
1063 | 1069 |
1064 void wrap_convolve8_vert_sse2_10(const uint8_t *src, ptrdiff_t src_stride, | 1070 void wrap_convolve8_vert_sse2_10(const uint8_t *src, ptrdiff_t src_stride, |
1065 uint8_t *dst, ptrdiff_t dst_stride, | 1071 uint8_t *dst, ptrdiff_t dst_stride, |
1066 const int16_t *filter_x, | 1072 const int16_t *filter_x, |
1067 int filter_x_stride, | 1073 int filter_x_stride, |
1068 const int16_t *filter_y, | 1074 const int16_t *filter_y, |
1069 int filter_y_stride, | 1075 int filter_y_stride, |
1070 int w, int h) { | 1076 int w, int h) { |
1071 vp9_high_convolve8_vert_sse2(src, src_stride, dst, dst_stride, filter_x, | 1077 vp9_highbd_convolve8_vert_sse2(src, src_stride, dst, dst_stride, |
1072 filter_x_stride, filter_y, filter_y_stride, w, h, 10); | 1078 filter_x, filter_x_stride, |
| 1079 filter_y, filter_y_stride, w, h, 10); |
1073 } | 1080 } |
1074 | 1081 |
1075 void wrap_convolve8_avg_vert_sse2_10(const uint8_t *src, ptrdiff_t src_stride, | 1082 void wrap_convolve8_avg_vert_sse2_10(const uint8_t *src, ptrdiff_t src_stride, |
1076 uint8_t *dst, ptrdiff_t dst_stride, | 1083 uint8_t *dst, ptrdiff_t dst_stride, |
1077 const int16_t *filter_x, | 1084 const int16_t *filter_x, |
1078 int filter_x_stride, | 1085 int filter_x_stride, |
1079 const int16_t *filter_y, | 1086 const int16_t *filter_y, |
1080 int filter_y_stride, | 1087 int filter_y_stride, |
1081 int w, int h) { | 1088 int w, int h) { |
1082 vp9_high_convolve8_avg_vert_sse2(src, src_stride, dst, dst_stride, filter_x, | 1089 vp9_highbd_convolve8_avg_vert_sse2(src, src_stride, dst, dst_stride, |
1083 filter_x_stride, filter_y, filter_y_stride, w, h, 10); | 1090 filter_x, filter_x_stride, |
| 1091 filter_y, filter_y_stride, w, h, 10); |
1084 } | 1092 } |
1085 | 1093 |
1086 void wrap_convolve8_sse2_10(const uint8_t *src, ptrdiff_t src_stride, | 1094 void wrap_convolve8_sse2_10(const uint8_t *src, ptrdiff_t src_stride, |
1087 uint8_t *dst, ptrdiff_t dst_stride, | 1095 uint8_t *dst, ptrdiff_t dst_stride, |
1088 const int16_t *filter_x, | 1096 const int16_t *filter_x, |
1089 int filter_x_stride, | 1097 int filter_x_stride, |
1090 const int16_t *filter_y, | 1098 const int16_t *filter_y, |
1091 int filter_y_stride, | 1099 int filter_y_stride, |
1092 int w, int h) { | 1100 int w, int h) { |
1093 vp9_high_convolve8_sse2(src, src_stride, dst, dst_stride, filter_x, | 1101 vp9_highbd_convolve8_sse2(src, src_stride, dst, dst_stride, |
1094 filter_x_stride, filter_y, filter_y_stride, w, h, 10); | 1102 filter_x, filter_x_stride, |
| 1103 filter_y, filter_y_stride, w, h, 10); |
1095 } | 1104 } |
1096 | 1105 |
1097 void wrap_convolve8_avg_sse2_10(const uint8_t *src, ptrdiff_t src_stride, | 1106 void wrap_convolve8_avg_sse2_10(const uint8_t *src, ptrdiff_t src_stride, |
1098 uint8_t *dst, ptrdiff_t dst_stride, | 1107 uint8_t *dst, ptrdiff_t dst_stride, |
1099 const int16_t *filter_x, | 1108 const int16_t *filter_x, |
1100 int filter_x_stride, | 1109 int filter_x_stride, |
1101 const int16_t *filter_y, | 1110 const int16_t *filter_y, |
1102 int filter_y_stride, | 1111 int filter_y_stride, |
1103 int w, int h) { | 1112 int w, int h) { |
1104 vp9_high_convolve8_avg_sse2(src, src_stride, dst, dst_stride, filter_x, | 1113 vp9_highbd_convolve8_avg_sse2(src, src_stride, dst, dst_stride, |
1105 filter_x_stride, filter_y, filter_y_stride, | 1114 filter_x, filter_x_stride, |
1106 w, h, 10); | 1115 filter_y, filter_y_stride, w, h, 10); |
1107 } | 1116 } |
1108 | 1117 |
1109 void wrap_convolve8_horiz_sse2_12(const uint8_t *src, ptrdiff_t src_stride, | 1118 void wrap_convolve8_horiz_sse2_12(const uint8_t *src, ptrdiff_t src_stride, |
1110 uint8_t *dst, ptrdiff_t dst_stride, | 1119 uint8_t *dst, ptrdiff_t dst_stride, |
1111 const int16_t *filter_x, | 1120 const int16_t *filter_x, |
1112 int filter_x_stride, | 1121 int filter_x_stride, |
1113 const int16_t *filter_y, | 1122 const int16_t *filter_y, |
1114 int filter_y_stride, | 1123 int filter_y_stride, |
1115 int w, int h) { | 1124 int w, int h) { |
1116 vp9_high_convolve8_horiz_sse2(src, src_stride, dst, dst_stride, filter_x, | 1125 vp9_highbd_convolve8_horiz_sse2(src, src_stride, dst, dst_stride, |
1117 filter_x_stride, filter_y, filter_y_stride, | 1126 filter_x, filter_x_stride, |
1118 w, h, 12); | 1127 filter_y, filter_y_stride, w, h, 12); |
1119 } | 1128 } |
1120 | 1129 |
1121 void wrap_convolve8_avg_horiz_sse2_12(const uint8_t *src, ptrdiff_t src_stride, | 1130 void wrap_convolve8_avg_horiz_sse2_12(const uint8_t *src, ptrdiff_t src_stride, |
1122 uint8_t *dst, ptrdiff_t dst_stride, | 1131 uint8_t *dst, ptrdiff_t dst_stride, |
1123 const int16_t *filter_x, | 1132 const int16_t *filter_x, |
1124 int filter_x_stride, | 1133 int filter_x_stride, |
1125 const int16_t *filter_y, | 1134 const int16_t *filter_y, |
1126 int filter_y_stride, | 1135 int filter_y_stride, |
1127 int w, int h) { | 1136 int w, int h) { |
1128 vp9_high_convolve8_avg_horiz_sse2(src, src_stride, dst, dst_stride, filter_x, | 1137 vp9_highbd_convolve8_avg_horiz_sse2(src, src_stride, dst, dst_stride, |
1129 filter_x_stride, filter_y, filter_y_stride, | 1138 filter_x, filter_x_stride, |
1130 w, h, 12); | 1139 filter_y, filter_y_stride, w, h, 12); |
1131 } | 1140 } |
1132 | 1141 |
1133 void wrap_convolve8_vert_sse2_12(const uint8_t *src, ptrdiff_t src_stride, | 1142 void wrap_convolve8_vert_sse2_12(const uint8_t *src, ptrdiff_t src_stride, |
1134 uint8_t *dst, ptrdiff_t dst_stride, | 1143 uint8_t *dst, ptrdiff_t dst_stride, |
1135 const int16_t *filter_x, | 1144 const int16_t *filter_x, |
1136 int filter_x_stride, | 1145 int filter_x_stride, |
1137 const int16_t *filter_y, | 1146 const int16_t *filter_y, |
1138 int filter_y_stride, | 1147 int filter_y_stride, |
1139 int w, int h) { | 1148 int w, int h) { |
1140 vp9_high_convolve8_vert_sse2(src, src_stride, dst, dst_stride, filter_x, | 1149 vp9_highbd_convolve8_vert_sse2(src, src_stride, dst, dst_stride, |
1141 filter_x_stride, filter_y, filter_y_stride, | 1150 filter_x, filter_x_stride, |
1142 w, h, 12); | 1151 filter_y, filter_y_stride, w, h, 12); |
1143 } | 1152 } |
1144 | 1153 |
1145 void wrap_convolve8_avg_vert_sse2_12(const uint8_t *src, ptrdiff_t src_stride, | 1154 void wrap_convolve8_avg_vert_sse2_12(const uint8_t *src, ptrdiff_t src_stride, |
1146 uint8_t *dst, ptrdiff_t dst_stride, | 1155 uint8_t *dst, ptrdiff_t dst_stride, |
1147 const int16_t *filter_x, | 1156 const int16_t *filter_x, |
1148 int filter_x_stride, | 1157 int filter_x_stride, |
1149 const int16_t *filter_y, | 1158 const int16_t *filter_y, |
1150 int filter_y_stride, | 1159 int filter_y_stride, |
1151 int w, int h) { | 1160 int w, int h) { |
1152 vp9_high_convolve8_avg_vert_sse2(src, src_stride, dst, dst_stride, filter_x, | 1161 vp9_highbd_convolve8_avg_vert_sse2(src, src_stride, dst, dst_stride, |
1153 filter_x_stride, filter_y, filter_y_stride, w
, h, 12); | 1162 filter_x, filter_x_stride, |
| 1163 filter_y, filter_y_stride, w, h, 12); |
1154 } | 1164 } |
1155 | 1165 |
1156 void wrap_convolve8_sse2_12(const uint8_t *src, ptrdiff_t src_stride, | 1166 void wrap_convolve8_sse2_12(const uint8_t *src, ptrdiff_t src_stride, |
1157 uint8_t *dst, ptrdiff_t dst_stride, | 1167 uint8_t *dst, ptrdiff_t dst_stride, |
1158 const int16_t *filter_x, | 1168 const int16_t *filter_x, |
1159 int filter_x_stride, | 1169 int filter_x_stride, |
1160 const int16_t *filter_y, | 1170 const int16_t *filter_y, |
1161 int filter_y_stride, | 1171 int filter_y_stride, |
1162 int w, int h) { | 1172 int w, int h) { |
1163 vp9_high_convolve8_sse2(src, src_stride, dst, dst_stride, filter_x, | 1173 vp9_highbd_convolve8_sse2(src, src_stride, dst, dst_stride, |
1164 filter_x_stride, filter_y, filter_y_stride, w, h, 12); | 1174 filter_x, filter_x_stride, |
| 1175 filter_y, filter_y_stride, w, h, 12); |
1165 } | 1176 } |
1166 | 1177 |
1167 void wrap_convolve8_avg_sse2_12(const uint8_t *src, ptrdiff_t src_stride, | 1178 void wrap_convolve8_avg_sse2_12(const uint8_t *src, ptrdiff_t src_stride, |
1168 uint8_t *dst, ptrdiff_t dst_stride, | 1179 uint8_t *dst, ptrdiff_t dst_stride, |
1169 const int16_t *filter_x, | 1180 const int16_t *filter_x, |
1170 int filter_x_stride, | 1181 int filter_x_stride, |
1171 const int16_t *filter_y, | 1182 const int16_t *filter_y, |
1172 int filter_y_stride, | 1183 int filter_y_stride, |
1173 int w, int h) { | 1184 int w, int h) { |
1174 vp9_high_convolve8_avg_sse2(src, src_stride, dst, dst_stride, filter_x, | 1185 vp9_highbd_convolve8_avg_sse2(src, src_stride, dst, dst_stride, |
1175 filter_x_stride, filter_y, filter_y_stride, w, h,
12); | 1186 filter_x, filter_x_stride, |
| 1187 filter_y, filter_y_stride, w, h, 12); |
1176 } | 1188 } |
1177 #endif // HAVE_SSE2 && ARCH_X86_64 | 1189 #endif // HAVE_SSE2 && ARCH_X86_64 |
1178 | 1190 |
1179 void wrap_convolve8_horiz_c_8(const uint8_t *src, ptrdiff_t src_stride, | 1191 void wrap_convolve8_horiz_c_8(const uint8_t *src, ptrdiff_t src_stride, |
1180 uint8_t *dst, ptrdiff_t dst_stride, | 1192 uint8_t *dst, ptrdiff_t dst_stride, |
1181 const int16_t *filter_x, | 1193 const int16_t *filter_x, |
1182 int filter_x_stride, | 1194 int filter_x_stride, |
1183 const int16_t *filter_y, | 1195 const int16_t *filter_y, |
1184 int filter_y_stride, | 1196 int filter_y_stride, |
1185 int w, int h) { | 1197 int w, int h) { |
1186 vp9_high_convolve8_horiz_c(src, src_stride, dst, dst_stride, filter_x, | 1198 vp9_highbd_convolve8_horiz_c(src, src_stride, dst, dst_stride, |
1187 filter_x_stride, filter_y, filter_y_stride, w, h, 8
); | 1199 filter_x, filter_x_stride, |
| 1200 filter_y, filter_y_stride, w, h, 8); |
1188 } | 1201 } |
1189 | 1202 |
1190 void wrap_convolve8_avg_horiz_c_8(const uint8_t *src, ptrdiff_t src_stride, | 1203 void wrap_convolve8_avg_horiz_c_8(const uint8_t *src, ptrdiff_t src_stride, |
1191 uint8_t *dst, ptrdiff_t dst_stride, | 1204 uint8_t *dst, ptrdiff_t dst_stride, |
1192 const int16_t *filter_x, | 1205 const int16_t *filter_x, |
1193 int filter_x_stride, | 1206 int filter_x_stride, |
1194 const int16_t *filter_y, | 1207 const int16_t *filter_y, |
1195 int filter_y_stride, | 1208 int filter_y_stride, |
1196 int w, int h) { | 1209 int w, int h) { |
1197 vp9_high_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride, filter_x, | 1210 vp9_highbd_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride, |
1198 filter_x_stride, filter_y, filter_y_stride, w,
h, 8); | 1211 filter_x, filter_x_stride, |
| 1212 filter_y, filter_y_stride, w, h, 8); |
1199 } | 1213 } |
1200 | 1214 |
1201 void wrap_convolve8_vert_c_8(const uint8_t *src, ptrdiff_t src_stride, | 1215 void wrap_convolve8_vert_c_8(const uint8_t *src, ptrdiff_t src_stride, |
1202 uint8_t *dst, ptrdiff_t dst_stride, | 1216 uint8_t *dst, ptrdiff_t dst_stride, |
1203 const int16_t *filter_x, | 1217 const int16_t *filter_x, |
1204 int filter_x_stride, | 1218 int filter_x_stride, |
1205 const int16_t *filter_y, | 1219 const int16_t *filter_y, |
1206 int filter_y_stride, | 1220 int filter_y_stride, |
1207 int w, int h) { | 1221 int w, int h) { |
1208 vp9_high_convolve8_vert_c(src, src_stride, dst, dst_stride, filter_x, | 1222 vp9_highbd_convolve8_vert_c(src, src_stride, dst, dst_stride, |
1209 filter_x_stride, filter_y, filter_y_stride, w, h, 8)
; | 1223 filter_x, filter_x_stride, |
| 1224 filter_y, filter_y_stride, w, h, 8); |
1210 } | 1225 } |
1211 | 1226 |
1212 void wrap_convolve8_avg_vert_c_8(const uint8_t *src, ptrdiff_t src_stride, | 1227 void wrap_convolve8_avg_vert_c_8(const uint8_t *src, ptrdiff_t src_stride, |
1213 uint8_t *dst, ptrdiff_t dst_stride, | 1228 uint8_t *dst, ptrdiff_t dst_stride, |
1214 const int16_t *filter_x, | 1229 const int16_t *filter_x, |
1215 int filter_x_stride, | 1230 int filter_x_stride, |
1216 const int16_t *filter_y, | 1231 const int16_t *filter_y, |
1217 int filter_y_stride, | 1232 int filter_y_stride, |
1218 int w, int h) { | 1233 int w, int h) { |
1219 vp9_high_convolve8_avg_vert_c(src, src_stride, dst, dst_stride, filter_x, | 1234 vp9_highbd_convolve8_avg_vert_c(src, src_stride, dst, dst_stride, |
1220 filter_x_stride, filter_y, filter_y_stride, w, h
, 8); | 1235 filter_x, filter_x_stride, |
| 1236 filter_y, filter_y_stride, w, h, 8); |
1221 } | 1237 } |
1222 | 1238 |
1223 void wrap_convolve8_c_8(const uint8_t *src, ptrdiff_t src_stride, | 1239 void wrap_convolve8_c_8(const uint8_t *src, ptrdiff_t src_stride, |
1224 uint8_t *dst, ptrdiff_t dst_stride, | 1240 uint8_t *dst, ptrdiff_t dst_stride, |
1225 const int16_t *filter_x, | 1241 const int16_t *filter_x, |
1226 int filter_x_stride, | 1242 int filter_x_stride, |
1227 const int16_t *filter_y, | 1243 const int16_t *filter_y, |
1228 int filter_y_stride, | 1244 int filter_y_stride, |
1229 int w, int h) { | 1245 int w, int h) { |
1230 vp9_high_convolve8_c(src, src_stride, dst, dst_stride, filter_x, | 1246 vp9_highbd_convolve8_c(src, src_stride, dst, dst_stride, |
1231 filter_x_stride, filter_y, filter_y_stride, w, h, 8); | 1247 filter_x, filter_x_stride, |
| 1248 filter_y, filter_y_stride, w, h, 8); |
1232 } | 1249 } |
1233 | 1250 |
1234 void wrap_convolve8_avg_c_8(const uint8_t *src, ptrdiff_t src_stride, | 1251 void wrap_convolve8_avg_c_8(const uint8_t *src, ptrdiff_t src_stride, |
1235 uint8_t *dst, ptrdiff_t dst_stride, | 1252 uint8_t *dst, ptrdiff_t dst_stride, |
1236 const int16_t *filter_x, | 1253 const int16_t *filter_x, |
1237 int filter_x_stride, | 1254 int filter_x_stride, |
1238 const int16_t *filter_y, | 1255 const int16_t *filter_y, |
1239 int filter_y_stride, | 1256 int filter_y_stride, |
1240 int w, int h) { | 1257 int w, int h) { |
1241 vp9_high_convolve8_avg_c(src, src_stride, dst, dst_stride, filter_x, | 1258 vp9_highbd_convolve8_avg_c(src, src_stride, dst, dst_stride, |
1242 filter_x_stride, filter_y, filter_y_stride, | 1259 filter_x, filter_x_stride, |
1243 w, h, 8); | 1260 filter_y, filter_y_stride, w, h, 8); |
1244 } | 1261 } |
1245 | 1262 |
1246 void wrap_convolve8_horiz_c_10(const uint8_t *src, ptrdiff_t src_stride, | 1263 void wrap_convolve8_horiz_c_10(const uint8_t *src, ptrdiff_t src_stride, |
1247 uint8_t *dst, ptrdiff_t dst_stride, | 1264 uint8_t *dst, ptrdiff_t dst_stride, |
1248 const int16_t *filter_x, | 1265 const int16_t *filter_x, |
1249 int filter_x_stride, | 1266 int filter_x_stride, |
1250 const int16_t *filter_y, | 1267 const int16_t *filter_y, |
1251 int filter_y_stride, | 1268 int filter_y_stride, |
1252 int w, int h) { | 1269 int w, int h) { |
1253 vp9_high_convolve8_horiz_c(src, src_stride, dst, dst_stride, filter_x, | 1270 vp9_highbd_convolve8_horiz_c(src, src_stride, dst, dst_stride, |
1254 filter_x_stride, filter_y, filter_y_stride, w, h, 1
0); | 1271 filter_x, filter_x_stride, |
| 1272 filter_y, filter_y_stride, w, h, 10); |
1255 } | 1273 } |
1256 | 1274 |
1257 void wrap_convolve8_avg_horiz_c_10(const uint8_t *src, ptrdiff_t src_stride, | 1275 void wrap_convolve8_avg_horiz_c_10(const uint8_t *src, ptrdiff_t src_stride, |
1258 uint8_t *dst, ptrdiff_t dst_stride, | 1276 uint8_t *dst, ptrdiff_t dst_stride, |
1259 const int16_t *filter_x, | 1277 const int16_t *filter_x, |
1260 int filter_x_stride, | 1278 int filter_x_stride, |
1261 const int16_t *filter_y, | 1279 const int16_t *filter_y, |
1262 int filter_y_stride, | 1280 int filter_y_stride, |
1263 int w, int h) { | 1281 int w, int h) { |
1264 vp9_high_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride, filter_x, | 1282 vp9_highbd_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride, |
1265 filter_x_stride, filter_y, filter_y_stride, | 1283 filter_x, filter_x_stride, |
1266 w, h, 10); | 1284 filter_y, filter_y_stride, w, h, 10); |
1267 } | 1285 } |
1268 | 1286 |
1269 void wrap_convolve8_vert_c_10(const uint8_t *src, ptrdiff_t src_stride, | 1287 void wrap_convolve8_vert_c_10(const uint8_t *src, ptrdiff_t src_stride, |
1270 uint8_t *dst, ptrdiff_t dst_stride, | 1288 uint8_t *dst, ptrdiff_t dst_stride, |
1271 const int16_t *filter_x, | 1289 const int16_t *filter_x, |
1272 int filter_x_stride, | 1290 int filter_x_stride, |
1273 const int16_t *filter_y, | 1291 const int16_t *filter_y, |
1274 int filter_y_stride, | 1292 int filter_y_stride, |
1275 int w, int h) { | 1293 int w, int h) { |
1276 vp9_high_convolve8_vert_c(src, src_stride, dst, dst_stride, filter_x, | 1294 vp9_highbd_convolve8_vert_c(src, src_stride, dst, dst_stride, |
1277 filter_x_stride, filter_y, filter_y_stride, w, h, 10
); | 1295 filter_x, filter_x_stride, |
| 1296 filter_y, filter_y_stride, w, h, 10); |
1278 } | 1297 } |
1279 | 1298 |
1280 void wrap_convolve8_avg_vert_c_10(const uint8_t *src, ptrdiff_t src_stride, | 1299 void wrap_convolve8_avg_vert_c_10(const uint8_t *src, ptrdiff_t src_stride, |
1281 uint8_t *dst, ptrdiff_t dst_stride, | 1300 uint8_t *dst, ptrdiff_t dst_stride, |
1282 const int16_t *filter_x, | 1301 const int16_t *filter_x, |
1283 int filter_x_stride, | 1302 int filter_x_stride, |
1284 const int16_t *filter_y, | 1303 const int16_t *filter_y, |
1285 int filter_y_stride, | 1304 int filter_y_stride, |
1286 int w, int h) { | 1305 int w, int h) { |
1287 vp9_high_convolve8_avg_vert_c(src, src_stride, dst, dst_stride, filter_x, | 1306 vp9_highbd_convolve8_avg_vert_c(src, src_stride, dst, dst_stride, |
1288 filter_x_stride, filter_y, filter_y_stride, w, h
, 10); | 1307 filter_x, filter_x_stride, |
| 1308 filter_y, filter_y_stride, w, h, 10); |
1289 } | 1309 } |
1290 | 1310 |
1291 void wrap_convolve8_c_10(const uint8_t *src, ptrdiff_t src_stride, | 1311 void wrap_convolve8_c_10(const uint8_t *src, ptrdiff_t src_stride, |
1292 uint8_t *dst, ptrdiff_t dst_stride, | 1312 uint8_t *dst, ptrdiff_t dst_stride, |
1293 const int16_t *filter_x, | 1313 const int16_t *filter_x, |
1294 int filter_x_stride, | 1314 int filter_x_stride, |
1295 const int16_t *filter_y, | 1315 const int16_t *filter_y, |
1296 int filter_y_stride, | 1316 int filter_y_stride, |
1297 int w, int h) { | 1317 int w, int h) { |
1298 vp9_high_convolve8_c(src, src_stride, dst, dst_stride, filter_x, | 1318 vp9_highbd_convolve8_c(src, src_stride, dst, dst_stride, |
1299 filter_x_stride, filter_y, filter_y_stride, w, h, 10); | 1319 filter_x, filter_x_stride, |
| 1320 filter_y, filter_y_stride, w, h, 10); |
1300 } | 1321 } |
1301 | 1322 |
1302 void wrap_convolve8_avg_c_10(const uint8_t *src, ptrdiff_t src_stride, | 1323 void wrap_convolve8_avg_c_10(const uint8_t *src, ptrdiff_t src_stride, |
1303 uint8_t *dst, ptrdiff_t dst_stride, | 1324 uint8_t *dst, ptrdiff_t dst_stride, |
1304 const int16_t *filter_x, | 1325 const int16_t *filter_x, |
1305 int filter_x_stride, | 1326 int filter_x_stride, |
1306 const int16_t *filter_y, | 1327 const int16_t *filter_y, |
1307 int filter_y_stride, | 1328 int filter_y_stride, |
1308 int w, int h) { | 1329 int w, int h) { |
1309 vp9_high_convolve8_avg_c(src, src_stride, dst, dst_stride, filter_x, | 1330 vp9_highbd_convolve8_avg_c(src, src_stride, dst, dst_stride, |
1310 filter_x_stride, filter_y, filter_y_stride, w, h, 10)
; | 1331 filter_x, filter_x_stride, |
| 1332 filter_y, filter_y_stride, w, h, 10); |
1311 } | 1333 } |
1312 | 1334 |
1313 void wrap_convolve8_horiz_c_12(const uint8_t *src, ptrdiff_t src_stride, | 1335 void wrap_convolve8_horiz_c_12(const uint8_t *src, ptrdiff_t src_stride, |
1314 uint8_t *dst, ptrdiff_t dst_stride, | 1336 uint8_t *dst, ptrdiff_t dst_stride, |
1315 const int16_t *filter_x, | 1337 const int16_t *filter_x, |
1316 int filter_x_stride, | 1338 int filter_x_stride, |
1317 const int16_t *filter_y, | 1339 const int16_t *filter_y, |
1318 int filter_y_stride, | 1340 int filter_y_stride, |
1319 int w, int h) { | 1341 int w, int h) { |
1320 vp9_high_convolve8_horiz_c(src, src_stride, dst, dst_stride, filter_x, | 1342 vp9_highbd_convolve8_horiz_c(src, src_stride, dst, dst_stride, |
1321 filter_x_stride, filter_y, filter_y_stride, | 1343 filter_x, filter_x_stride, |
1322 w, h, 12); | 1344 filter_y, filter_y_stride, w, h, 12); |
1323 } | 1345 } |
1324 | 1346 |
1325 void wrap_convolve8_avg_horiz_c_12(const uint8_t *src, ptrdiff_t src_stride, | 1347 void wrap_convolve8_avg_horiz_c_12(const uint8_t *src, ptrdiff_t src_stride, |
1326 uint8_t *dst, ptrdiff_t dst_stride, | 1348 uint8_t *dst, ptrdiff_t dst_stride, |
1327 const int16_t *filter_x, | 1349 const int16_t *filter_x, |
1328 int filter_x_stride, | 1350 int filter_x_stride, |
1329 const int16_t *filter_y, | 1351 const int16_t *filter_y, |
1330 int filter_y_stride, | 1352 int filter_y_stride, |
1331 int w, int h) { | 1353 int w, int h) { |
1332 vp9_high_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride, filter_x, | 1354 vp9_highbd_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride, |
1333 filter_x_stride, filter_y, filter_y_stride, | 1355 filter_x, filter_x_stride, |
1334 w, h, 12); | 1356 filter_y, filter_y_stride, w, h, 12); |
1335 } | 1357 } |
1336 | 1358 |
1337 void wrap_convolve8_vert_c_12(const uint8_t *src, ptrdiff_t src_stride, | 1359 void wrap_convolve8_vert_c_12(const uint8_t *src, ptrdiff_t src_stride, |
1338 uint8_t *dst, ptrdiff_t dst_stride, | 1360 uint8_t *dst, ptrdiff_t dst_stride, |
1339 const int16_t *filter_x, | 1361 const int16_t *filter_x, |
1340 int filter_x_stride, | 1362 int filter_x_stride, |
1341 const int16_t *filter_y, | 1363 const int16_t *filter_y, |
1342 int filter_y_stride, | 1364 int filter_y_stride, |
1343 int w, int h) { | 1365 int w, int h) { |
1344 vp9_high_convolve8_vert_c(src, src_stride, dst, dst_stride, filter_x, | 1366 vp9_highbd_convolve8_vert_c(src, src_stride, dst, dst_stride, |
1345 filter_x_stride, filter_y, filter_y_stride, | 1367 filter_x, filter_x_stride, |
1346 w, h, 12); | 1368 filter_y, filter_y_stride, w, h, 12); |
1347 } | 1369 } |
1348 | 1370 |
1349 void wrap_convolve8_avg_vert_c_12(const uint8_t *src, ptrdiff_t src_stride, | 1371 void wrap_convolve8_avg_vert_c_12(const uint8_t *src, ptrdiff_t src_stride, |
1350 uint8_t *dst, ptrdiff_t dst_stride, | 1372 uint8_t *dst, ptrdiff_t dst_stride, |
1351 const int16_t *filter_x, | 1373 const int16_t *filter_x, |
1352 int filter_x_stride, | 1374 int filter_x_stride, |
1353 const int16_t *filter_y, | 1375 const int16_t *filter_y, |
1354 int filter_y_stride, | 1376 int filter_y_stride, |
1355 int w, int h) { | 1377 int w, int h) { |
1356 vp9_high_convolve8_avg_vert_c(src, src_stride, dst, dst_stride, filter_x, | 1378 vp9_highbd_convolve8_avg_vert_c(src, src_stride, dst, dst_stride, |
1357 filter_x_stride, filter_y, filter_y_stride, | 1379 filter_x, filter_x_stride, |
1358 w, h, 12); | 1380 filter_y, filter_y_stride, w, h, 12); |
1359 } | 1381 } |
1360 | 1382 |
1361 void wrap_convolve8_c_12(const uint8_t *src, ptrdiff_t src_stride, | 1383 void wrap_convolve8_c_12(const uint8_t *src, ptrdiff_t src_stride, |
1362 uint8_t *dst, ptrdiff_t dst_stride, | 1384 uint8_t *dst, ptrdiff_t dst_stride, |
1363 const int16_t *filter_x, | 1385 const int16_t *filter_x, |
1364 int filter_x_stride, | 1386 int filter_x_stride, |
1365 const int16_t *filter_y, | 1387 const int16_t *filter_y, |
1366 int filter_y_stride, | 1388 int filter_y_stride, |
1367 int w, int h) { | 1389 int w, int h) { |
1368 vp9_high_convolve8_c(src, src_stride, dst, dst_stride, filter_x, | 1390 vp9_highbd_convolve8_c(src, src_stride, dst, dst_stride, |
1369 filter_x_stride, filter_y, filter_y_stride, | 1391 filter_x, filter_x_stride, |
1370 w, h, 12); | 1392 filter_y, filter_y_stride, w, h, 12); |
1371 } | 1393 } |
1372 | 1394 |
1373 void wrap_convolve8_avg_c_12(const uint8_t *src, ptrdiff_t src_stride, | 1395 void wrap_convolve8_avg_c_12(const uint8_t *src, ptrdiff_t src_stride, |
1374 uint8_t *dst, ptrdiff_t dst_stride, | 1396 uint8_t *dst, ptrdiff_t dst_stride, |
1375 const int16_t *filter_x, | 1397 const int16_t *filter_x, |
1376 int filter_x_stride, | 1398 int filter_x_stride, |
1377 const int16_t *filter_y, | 1399 const int16_t *filter_y, |
1378 int filter_y_stride, | 1400 int filter_y_stride, |
1379 int w, int h) { | 1401 int w, int h) { |
1380 vp9_high_convolve8_avg_c(src, src_stride, dst, dst_stride, filter_x, | 1402 vp9_highbd_convolve8_avg_c(src, src_stride, dst, dst_stride, |
1381 filter_x_stride, filter_y, filter_y_stride, | 1403 filter_x, filter_x_stride, |
1382 w, h, 12); | 1404 filter_y, filter_y_stride, w, h, 12); |
1383 } | 1405 } |
1384 | 1406 |
1385 const ConvolveFunctions convolve8_c( | 1407 const ConvolveFunctions convolve8_c( |
1386 wrap_convolve8_horiz_c_8, wrap_convolve8_avg_horiz_c_8, | 1408 wrap_convolve8_horiz_c_8, wrap_convolve8_avg_horiz_c_8, |
1387 wrap_convolve8_vert_c_8, wrap_convolve8_avg_vert_c_8, | 1409 wrap_convolve8_vert_c_8, wrap_convolve8_avg_vert_c_8, |
1388 wrap_convolve8_c_8, wrap_convolve8_avg_c_8, 8); | 1410 wrap_convolve8_c_8, wrap_convolve8_avg_c_8, 8); |
1389 INSTANTIATE_TEST_CASE_P(C_8, ConvolveTest, ::testing::Values( | 1411 INSTANTIATE_TEST_CASE_P(C_8, ConvolveTest, ::testing::Values( |
1390 make_tuple(4, 4, &convolve8_c), | 1412 make_tuple(4, 4, &convolve8_c), |
1391 make_tuple(8, 4, &convolve8_c), | 1413 make_tuple(8, 4, &convolve8_c), |
1392 make_tuple(4, 8, &convolve8_c), | 1414 make_tuple(4, 8, &convolve8_c), |
(...skipping 227 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1620 make_tuple(8, 16, &convolve8_dspr2), | 1642 make_tuple(8, 16, &convolve8_dspr2), |
1621 make_tuple(16, 16, &convolve8_dspr2), | 1643 make_tuple(16, 16, &convolve8_dspr2), |
1622 make_tuple(32, 16, &convolve8_dspr2), | 1644 make_tuple(32, 16, &convolve8_dspr2), |
1623 make_tuple(16, 32, &convolve8_dspr2), | 1645 make_tuple(16, 32, &convolve8_dspr2), |
1624 make_tuple(32, 32, &convolve8_dspr2), | 1646 make_tuple(32, 32, &convolve8_dspr2), |
1625 make_tuple(64, 32, &convolve8_dspr2), | 1647 make_tuple(64, 32, &convolve8_dspr2), |
1626 make_tuple(32, 64, &convolve8_dspr2), | 1648 make_tuple(32, 64, &convolve8_dspr2), |
1627 make_tuple(64, 64, &convolve8_dspr2))); | 1649 make_tuple(64, 64, &convolve8_dspr2))); |
1628 #endif | 1650 #endif |
1629 } // namespace | 1651 } // namespace |
OLD | NEW |