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 22 matching lines...) Expand all Loading... |
33 // can be unified and accessed as a pointer array. Note that the boundary | 33 // can be unified and accessed as a pointer array. Note that the boundary |
34 // above and left are not necessarily used all the time. | 34 // above and left are not necessarily used all the time. |
35 #define intra_pred_sized(type, size) \ | 35 #define intra_pred_sized(type, size) \ |
36 void vp9_##type##_predictor_##size##x##size##_c(uint8_t *dst, \ | 36 void vp9_##type##_predictor_##size##x##size##_c(uint8_t *dst, \ |
37 ptrdiff_t stride, \ | 37 ptrdiff_t stride, \ |
38 const uint8_t *above, \ | 38 const uint8_t *above, \ |
39 const uint8_t *left) { \ | 39 const uint8_t *left) { \ |
40 type##_predictor(dst, stride, size, above, left); \ | 40 type##_predictor(dst, stride, size, above, left); \ |
41 } | 41 } |
42 | 42 |
| 43 #if CONFIG_VP9_HIGHBITDEPTH |
| 44 #define intra_pred_high_sized(type, size) \ |
| 45 void vp9_high_##type##_predictor_##size##x##size##_c( \ |
| 46 uint16_t *dst, ptrdiff_t stride, const uint16_t *above, \ |
| 47 const uint16_t *left, int bd) { \ |
| 48 high_##type##_predictor(dst, stride, size, above, left, bd); \ |
| 49 } |
| 50 |
| 51 #define intra_pred_allsizes(type) \ |
| 52 intra_pred_sized(type, 4) \ |
| 53 intra_pred_sized(type, 8) \ |
| 54 intra_pred_sized(type, 16) \ |
| 55 intra_pred_sized(type, 32) \ |
| 56 intra_pred_high_sized(type, 4) \ |
| 57 intra_pred_high_sized(type, 8) \ |
| 58 intra_pred_high_sized(type, 16) \ |
| 59 intra_pred_high_sized(type, 32) |
| 60 |
| 61 #else |
| 62 |
43 #define intra_pred_allsizes(type) \ | 63 #define intra_pred_allsizes(type) \ |
44 intra_pred_sized(type, 4) \ | 64 intra_pred_sized(type, 4) \ |
45 intra_pred_sized(type, 8) \ | 65 intra_pred_sized(type, 8) \ |
46 intra_pred_sized(type, 16) \ | 66 intra_pred_sized(type, 16) \ |
47 intra_pred_sized(type, 32) | 67 intra_pred_sized(type, 32) |
| 68 #endif // CONFIG_VP9_HIGHBITDEPTH |
| 69 |
| 70 #if CONFIG_VP9_HIGHBITDEPTH |
| 71 static INLINE void high_d207_predictor(uint16_t *dst, ptrdiff_t stride, int bs, |
| 72 const uint16_t *above, |
| 73 const uint16_t *left, int bd) { |
| 74 int r, c; |
| 75 (void) above; |
| 76 (void) bd; |
| 77 |
| 78 // First column. |
| 79 for (r = 0; r < bs - 1; ++r) { |
| 80 dst[r * stride] = ROUND_POWER_OF_TWO(left[r] + left[r + 1], 1); |
| 81 } |
| 82 dst[(bs - 1) * stride] = left[bs - 1]; |
| 83 dst++; |
| 84 |
| 85 // Second column. |
| 86 for (r = 0; r < bs - 2; ++r) { |
| 87 dst[r * stride] = ROUND_POWER_OF_TWO(left[r] + left[r + 1] * 2 + |
| 88 left[r + 2], 2); |
| 89 } |
| 90 dst[(bs - 2) * stride] = ROUND_POWER_OF_TWO(left[bs - 2] + |
| 91 left[bs - 1] * 3, 2); |
| 92 dst[(bs - 1) * stride] = left[bs - 1]; |
| 93 dst++; |
| 94 |
| 95 // Rest of last row. |
| 96 for (c = 0; c < bs - 2; ++c) |
| 97 dst[(bs - 1) * stride + c] = left[bs - 1]; |
| 98 |
| 99 for (r = bs - 2; r >= 0; --r) { |
| 100 for (c = 0; c < bs - 2; ++c) |
| 101 dst[r * stride + c] = dst[(r + 1) * stride + c - 2]; |
| 102 } |
| 103 } |
| 104 |
| 105 static INLINE void high_d63_predictor(uint16_t *dst, ptrdiff_t stride, int bs, |
| 106 const uint16_t *above, |
| 107 const uint16_t *left, int bd) { |
| 108 int r, c; |
| 109 (void) left; |
| 110 (void) bd; |
| 111 for (r = 0; r < bs; ++r) { |
| 112 for (c = 0; c < bs; ++c) { |
| 113 dst[c] = r & 1 ? ROUND_POWER_OF_TWO(above[r/2 + c] + |
| 114 above[r/2 + c + 1] * 2 + |
| 115 above[r/2 + c + 2], 2) |
| 116 : ROUND_POWER_OF_TWO(above[r/2 + c] + |
| 117 above[r/2 + c + 1], 1); |
| 118 } |
| 119 dst += stride; |
| 120 } |
| 121 } |
| 122 |
| 123 static INLINE void high_d45_predictor(uint16_t *dst, ptrdiff_t stride, int bs, |
| 124 const uint16_t *above, |
| 125 const uint16_t *left, int bd) { |
| 126 int r, c; |
| 127 (void) left; |
| 128 (void) bd; |
| 129 for (r = 0; r < bs; ++r) { |
| 130 for (c = 0; c < bs; ++c) { |
| 131 dst[c] = r + c + 2 < bs * 2 ? ROUND_POWER_OF_TWO(above[r + c] + |
| 132 above[r + c + 1] * 2 + |
| 133 above[r + c + 2], 2) |
| 134 : above[bs * 2 - 1]; |
| 135 } |
| 136 dst += stride; |
| 137 } |
| 138 } |
| 139 |
| 140 static INLINE void high_d117_predictor(uint16_t *dst, ptrdiff_t stride, |
| 141 int bs, const uint16_t *above, |
| 142 const uint16_t *left, int bd) { |
| 143 int r, c; |
| 144 (void) bd; |
| 145 |
| 146 // first row |
| 147 for (c = 0; c < bs; c++) |
| 148 dst[c] = ROUND_POWER_OF_TWO(above[c - 1] + above[c], 1); |
| 149 dst += stride; |
| 150 |
| 151 // second row |
| 152 dst[0] = ROUND_POWER_OF_TWO(left[0] + above[-1] * 2 + above[0], 2); |
| 153 for (c = 1; c < bs; c++) |
| 154 dst[c] = ROUND_POWER_OF_TWO(above[c - 2] + above[c - 1] * 2 + above[c], 2); |
| 155 dst += stride; |
| 156 |
| 157 // the rest of first col |
| 158 dst[0] = ROUND_POWER_OF_TWO(above[-1] + left[0] * 2 + left[1], 2); |
| 159 for (r = 3; r < bs; ++r) |
| 160 dst[(r - 2) * stride] = ROUND_POWER_OF_TWO(left[r - 3] + left[r - 2] * 2 + |
| 161 left[r - 1], 2); |
| 162 |
| 163 // the rest of the block |
| 164 for (r = 2; r < bs; ++r) { |
| 165 for (c = 1; c < bs; c++) |
| 166 dst[c] = dst[-2 * stride + c - 1]; |
| 167 dst += stride; |
| 168 } |
| 169 } |
| 170 |
| 171 static INLINE void high_d135_predictor(uint16_t *dst, ptrdiff_t stride, int bs, |
| 172 const uint16_t *above, |
| 173 const uint16_t *left, int bd) { |
| 174 int r, c; |
| 175 (void) bd; |
| 176 dst[0] = ROUND_POWER_OF_TWO(left[0] + above[-1] * 2 + above[0], 2); |
| 177 for (c = 1; c < bs; c++) |
| 178 dst[c] = ROUND_POWER_OF_TWO(above[c - 2] + above[c - 1] * 2 + above[c], 2); |
| 179 |
| 180 dst[stride] = ROUND_POWER_OF_TWO(above[-1] + left[0] * 2 + left[1], 2); |
| 181 for (r = 2; r < bs; ++r) |
| 182 dst[r * stride] = ROUND_POWER_OF_TWO(left[r - 2] + left[r - 1] * 2 + |
| 183 left[r], 2); |
| 184 |
| 185 dst += stride; |
| 186 for (r = 1; r < bs; ++r) { |
| 187 for (c = 1; c < bs; c++) |
| 188 dst[c] = dst[-stride + c - 1]; |
| 189 dst += stride; |
| 190 } |
| 191 } |
| 192 |
| 193 static INLINE void high_d153_predictor(uint16_t *dst, ptrdiff_t stride, int bs, |
| 194 const uint16_t *above, |
| 195 const uint16_t *left, int bd) { |
| 196 int r, c; |
| 197 (void) bd; |
| 198 dst[0] = ROUND_POWER_OF_TWO(above[-1] + left[0], 1); |
| 199 for (r = 1; r < bs; r++) |
| 200 dst[r * stride] = ROUND_POWER_OF_TWO(left[r - 1] + left[r], 1); |
| 201 dst++; |
| 202 |
| 203 dst[0] = ROUND_POWER_OF_TWO(left[0] + above[-1] * 2 + above[0], 2); |
| 204 dst[stride] = ROUND_POWER_OF_TWO(above[-1] + left[0] * 2 + left[1], 2); |
| 205 for (r = 2; r < bs; r++) |
| 206 dst[r * stride] = ROUND_POWER_OF_TWO(left[r - 2] + left[r - 1] * 2 + |
| 207 left[r], 2); |
| 208 dst++; |
| 209 |
| 210 for (c = 0; c < bs - 2; c++) |
| 211 dst[c] = ROUND_POWER_OF_TWO(above[c - 1] + above[c] * 2 + above[c + 1], 2); |
| 212 dst += stride; |
| 213 |
| 214 for (r = 1; r < bs; ++r) { |
| 215 for (c = 0; c < bs - 2; c++) |
| 216 dst[c] = dst[-stride + c - 2]; |
| 217 dst += stride; |
| 218 } |
| 219 } |
| 220 |
| 221 static INLINE void high_v_predictor(uint16_t *dst, ptrdiff_t stride, int bs, |
| 222 const uint16_t *above, |
| 223 const uint16_t *left, int bd) { |
| 224 int r; |
| 225 (void) left; |
| 226 (void) bd; |
| 227 for (r = 0; r < bs; r++) { |
| 228 vpx_memcpy(dst, above, bs * sizeof(uint16_t)); |
| 229 dst += stride; |
| 230 } |
| 231 } |
| 232 |
| 233 static INLINE void high_h_predictor(uint16_t *dst, ptrdiff_t stride, int bs, |
| 234 const uint16_t *above, const uint16_t *left, |
| 235 int bd) { |
| 236 int r; |
| 237 (void) above; |
| 238 (void) bd; |
| 239 for (r = 0; r < bs; r++) { |
| 240 vpx_memset16(dst, left[r], bs); |
| 241 dst += stride; |
| 242 } |
| 243 } |
| 244 |
| 245 static INLINE void high_tm_predictor(uint16_t *dst, ptrdiff_t stride, int bs, |
| 246 const uint16_t *above, |
| 247 const uint16_t *left, int bd) { |
| 248 int r, c; |
| 249 int ytop_left = above[-1]; |
| 250 (void) bd; |
| 251 |
| 252 for (r = 0; r < bs; r++) { |
| 253 for (c = 0; c < bs; c++) |
| 254 dst[c] = clip_pixel_high(left[r] + above[c] - ytop_left, bd); |
| 255 dst += stride; |
| 256 } |
| 257 } |
| 258 |
| 259 static INLINE void high_dc_128_predictor(uint16_t *dst, ptrdiff_t stride, |
| 260 int bs, const uint16_t *above, |
| 261 const uint16_t *left, int bd) { |
| 262 int r; |
| 263 (void) above; |
| 264 (void) left; |
| 265 |
| 266 for (r = 0; r < bs; r++) { |
| 267 vpx_memset16(dst, 128 << (bd - 8), bs); |
| 268 dst += stride; |
| 269 } |
| 270 } |
| 271 |
| 272 static INLINE void high_dc_left_predictor(uint16_t *dst, ptrdiff_t stride, |
| 273 int bs, const uint16_t *above, |
| 274 const uint16_t *left, int bd) { |
| 275 int i, r, expected_dc, sum = 0; |
| 276 (void) above; |
| 277 (void) bd; |
| 278 |
| 279 for (i = 0; i < bs; i++) |
| 280 sum += left[i]; |
| 281 expected_dc = (sum + (bs >> 1)) / bs; |
| 282 |
| 283 for (r = 0; r < bs; r++) { |
| 284 vpx_memset16(dst, expected_dc, bs); |
| 285 dst += stride; |
| 286 } |
| 287 } |
| 288 |
| 289 static INLINE void high_dc_top_predictor(uint16_t *dst, ptrdiff_t stride, |
| 290 int bs, const uint16_t *above, |
| 291 const uint16_t *left, int bd) { |
| 292 int i, r, expected_dc, sum = 0; |
| 293 (void) left; |
| 294 (void) bd; |
| 295 |
| 296 for (i = 0; i < bs; i++) |
| 297 sum += above[i]; |
| 298 expected_dc = (sum + (bs >> 1)) / bs; |
| 299 |
| 300 for (r = 0; r < bs; r++) { |
| 301 vpx_memset16(dst, expected_dc, bs); |
| 302 dst += stride; |
| 303 } |
| 304 } |
| 305 |
| 306 static INLINE void high_dc_predictor(uint16_t *dst, ptrdiff_t stride, |
| 307 int bs, const uint16_t *above, |
| 308 const uint16_t *left, int bd) { |
| 309 int i, r, expected_dc, sum = 0; |
| 310 const int count = 2 * bs; |
| 311 (void) bd; |
| 312 |
| 313 for (i = 0; i < bs; i++) { |
| 314 sum += above[i]; |
| 315 sum += left[i]; |
| 316 } |
| 317 |
| 318 expected_dc = (sum + (count >> 1)) / count; |
| 319 |
| 320 for (r = 0; r < bs; r++) { |
| 321 vpx_memset16(dst, expected_dc, bs); |
| 322 dst += stride; |
| 323 } |
| 324 } |
| 325 #endif // CONFIG_VP9_HIGHBITDEPTH |
48 | 326 |
49 static INLINE void d207_predictor(uint8_t *dst, ptrdiff_t stride, int bs, | 327 static INLINE void d207_predictor(uint8_t *dst, ptrdiff_t stride, int bs, |
50 const uint8_t *above, const uint8_t *left) { | 328 const uint8_t *above, const uint8_t *left) { |
51 int r, c; | 329 int r, c; |
52 (void) above; | 330 (void) above; |
53 // first column | 331 // first column |
54 for (r = 0; r < bs - 1; ++r) | 332 for (r = 0; r < bs - 1; ++r) |
55 dst[r * stride] = ROUND_POWER_OF_TWO(left[r] + left[r + 1], 1); | 333 dst[r * stride] = ROUND_POWER_OF_TWO(left[r] + left[r + 1], 1); |
56 dst[(bs - 1) * stride] = left[bs - 1]; | 334 dst[(bs - 1) * stride] = left[bs - 1]; |
57 dst++; | 335 dst++; |
(...skipping 228 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
286 } | 564 } |
287 intra_pred_allsizes(dc) | 565 intra_pred_allsizes(dc) |
288 #undef intra_pred_allsizes | 566 #undef intra_pred_allsizes |
289 | 567 |
290 typedef void (*intra_pred_fn)(uint8_t *dst, ptrdiff_t stride, | 568 typedef void (*intra_pred_fn)(uint8_t *dst, ptrdiff_t stride, |
291 const uint8_t *above, const uint8_t *left); | 569 const uint8_t *above, const uint8_t *left); |
292 | 570 |
293 static intra_pred_fn pred[INTRA_MODES][TX_SIZES]; | 571 static intra_pred_fn pred[INTRA_MODES][TX_SIZES]; |
294 static intra_pred_fn dc_pred[2][2][TX_SIZES]; | 572 static intra_pred_fn dc_pred[2][2][TX_SIZES]; |
295 | 573 |
| 574 #if CONFIG_VP9_HIGHBITDEPTH |
| 575 typedef void (*intra_high_pred_fn)(uint16_t *dst, ptrdiff_t stride, |
| 576 const uint16_t *above, const uint16_t *left, |
| 577 int bd); |
| 578 static intra_high_pred_fn pred_high[INTRA_MODES][4]; |
| 579 static intra_high_pred_fn dc_pred_high[2][2][4]; |
| 580 #endif // CONFIG_VP9_HIGHBITDEPTH |
| 581 |
296 void vp9_init_intra_predictors() { | 582 void vp9_init_intra_predictors() { |
297 #define INIT_ALL_SIZES(p, type) \ | 583 #define INIT_ALL_SIZES(p, type) \ |
298 p[TX_4X4] = vp9_##type##_predictor_4x4; \ | 584 p[TX_4X4] = vp9_##type##_predictor_4x4; \ |
299 p[TX_8X8] = vp9_##type##_predictor_8x8; \ | 585 p[TX_8X8] = vp9_##type##_predictor_8x8; \ |
300 p[TX_16X16] = vp9_##type##_predictor_16x16; \ | 586 p[TX_16X16] = vp9_##type##_predictor_16x16; \ |
301 p[TX_32X32] = vp9_##type##_predictor_32x32 | 587 p[TX_32X32] = vp9_##type##_predictor_32x32 |
302 | 588 |
303 INIT_ALL_SIZES(pred[V_PRED], v); | 589 INIT_ALL_SIZES(pred[V_PRED], v); |
304 INIT_ALL_SIZES(pred[H_PRED], h); | 590 INIT_ALL_SIZES(pred[H_PRED], h); |
305 INIT_ALL_SIZES(pred[D207_PRED], d207); | 591 INIT_ALL_SIZES(pred[D207_PRED], d207); |
306 INIT_ALL_SIZES(pred[D45_PRED], d45); | 592 INIT_ALL_SIZES(pred[D45_PRED], d45); |
307 INIT_ALL_SIZES(pred[D63_PRED], d63); | 593 INIT_ALL_SIZES(pred[D63_PRED], d63); |
308 INIT_ALL_SIZES(pred[D117_PRED], d117); | 594 INIT_ALL_SIZES(pred[D117_PRED], d117); |
309 INIT_ALL_SIZES(pred[D135_PRED], d135); | 595 INIT_ALL_SIZES(pred[D135_PRED], d135); |
310 INIT_ALL_SIZES(pred[D153_PRED], d153); | 596 INIT_ALL_SIZES(pred[D153_PRED], d153); |
311 INIT_ALL_SIZES(pred[TM_PRED], tm); | 597 INIT_ALL_SIZES(pred[TM_PRED], tm); |
312 | 598 |
313 INIT_ALL_SIZES(dc_pred[0][0], dc_128); | 599 INIT_ALL_SIZES(dc_pred[0][0], dc_128); |
314 INIT_ALL_SIZES(dc_pred[0][1], dc_top); | 600 INIT_ALL_SIZES(dc_pred[0][1], dc_top); |
315 INIT_ALL_SIZES(dc_pred[1][0], dc_left); | 601 INIT_ALL_SIZES(dc_pred[1][0], dc_left); |
316 INIT_ALL_SIZES(dc_pred[1][1], dc); | 602 INIT_ALL_SIZES(dc_pred[1][1], dc); |
317 | 603 |
318 #undef INIT_ALL_SIZES | 604 #if CONFIG_VP9_HIGHBITDEPTH |
| 605 INIT_ALL_SIZES(pred_high[V_PRED], high_v); |
| 606 INIT_ALL_SIZES(pred_high[H_PRED], high_h); |
| 607 INIT_ALL_SIZES(pred_high[D207_PRED], high_d207); |
| 608 INIT_ALL_SIZES(pred_high[D45_PRED], high_d45); |
| 609 INIT_ALL_SIZES(pred_high[D63_PRED], high_d63); |
| 610 INIT_ALL_SIZES(pred_high[D117_PRED], high_d117); |
| 611 INIT_ALL_SIZES(pred_high[D135_PRED], high_d135); |
| 612 INIT_ALL_SIZES(pred_high[D153_PRED], high_d153); |
| 613 INIT_ALL_SIZES(pred_high[TM_PRED], high_tm); |
| 614 |
| 615 INIT_ALL_SIZES(dc_pred_high[0][0], high_dc_128); |
| 616 INIT_ALL_SIZES(dc_pred_high[0][1], high_dc_top); |
| 617 INIT_ALL_SIZES(dc_pred_high[1][0], high_dc_left); |
| 618 INIT_ALL_SIZES(dc_pred_high[1][1], high_dc); |
| 619 #endif // CONFIG_VP9_HIGHBITDEPTH |
| 620 |
| 621 #undef intra_pred_allsizes |
319 } | 622 } |
320 | 623 |
| 624 #if CONFIG_VP9_HIGHBITDEPTH |
| 625 static void build_intra_predictors_high(const MACROBLOCKD *xd, |
| 626 const uint8_t *ref8, |
| 627 int ref_stride, |
| 628 uint8_t *dst8, |
| 629 int dst_stride, |
| 630 PREDICTION_MODE mode, |
| 631 TX_SIZE tx_size, |
| 632 int up_available, |
| 633 int left_available, |
| 634 int right_available, |
| 635 int x, int y, |
| 636 int plane, int bd) { |
| 637 int i; |
| 638 uint16_t *dst = CONVERT_TO_SHORTPTR(dst8); |
| 639 uint16_t *ref = CONVERT_TO_SHORTPTR(ref8); |
| 640 DECLARE_ALIGNED_ARRAY(16, uint16_t, left_col, 64); |
| 641 DECLARE_ALIGNED_ARRAY(16, uint16_t, above_data, 128 + 16); |
| 642 uint16_t *above_row = above_data + 16; |
| 643 const uint16_t *const_above_row = above_row; |
| 644 const int bs = 4 << tx_size; |
| 645 int frame_width, frame_height; |
| 646 int x0, y0; |
| 647 const struct macroblockd_plane *const pd = &xd->plane[plane]; |
| 648 // int base=128; |
| 649 int base = 128 << (bd - 8); |
| 650 // 127 127 127 .. 127 127 127 127 127 127 |
| 651 // 129 A B .. Y Z |
| 652 // 129 C D .. W X |
| 653 // 129 E F .. U V |
| 654 // 129 G H .. S T T T T T |
| 655 |
| 656 // Get current frame pointer, width and height. |
| 657 if (plane == 0) { |
| 658 frame_width = xd->cur_buf->y_width; |
| 659 frame_height = xd->cur_buf->y_height; |
| 660 } else { |
| 661 frame_width = xd->cur_buf->uv_width; |
| 662 frame_height = xd->cur_buf->uv_height; |
| 663 } |
| 664 |
| 665 // Get block position in current frame. |
| 666 x0 = (-xd->mb_to_left_edge >> (3 + pd->subsampling_x)) + x; |
| 667 y0 = (-xd->mb_to_top_edge >> (3 + pd->subsampling_y)) + y; |
| 668 |
| 669 // left |
| 670 if (left_available) { |
| 671 if (xd->mb_to_bottom_edge < 0) { |
| 672 /* slower path if the block needs border extension */ |
| 673 if (y0 + bs <= frame_height) { |
| 674 for (i = 0; i < bs; ++i) |
| 675 left_col[i] = ref[i * ref_stride - 1]; |
| 676 } else { |
| 677 const int extend_bottom = frame_height - y0; |
| 678 for (i = 0; i < extend_bottom; ++i) |
| 679 left_col[i] = ref[i * ref_stride - 1]; |
| 680 for (; i < bs; ++i) |
| 681 left_col[i] = ref[(extend_bottom - 1) * ref_stride - 1]; |
| 682 } |
| 683 } else { |
| 684 /* faster path if the block does not need extension */ |
| 685 for (i = 0; i < bs; ++i) |
| 686 left_col[i] = ref[i * ref_stride - 1]; |
| 687 } |
| 688 } else { |
| 689 // TODO(Peter): this value should probably change for high bitdepth |
| 690 vpx_memset16(left_col, base + 1, bs); |
| 691 } |
| 692 |
| 693 // TODO(hkuang) do not extend 2*bs pixels for all modes. |
| 694 // above |
| 695 if (up_available) { |
| 696 const uint16_t *above_ref = ref - ref_stride; |
| 697 if (xd->mb_to_right_edge < 0) { |
| 698 /* slower path if the block needs border extension */ |
| 699 if (x0 + 2 * bs <= frame_width) { |
| 700 if (right_available && bs == 4) { |
| 701 vpx_memcpy(above_row, above_ref, 2 * bs * sizeof(uint16_t)); |
| 702 } else { |
| 703 vpx_memcpy(above_row, above_ref, bs * sizeof(uint16_t)); |
| 704 vpx_memset16(above_row + bs, above_row[bs - 1], bs); |
| 705 } |
| 706 } else if (x0 + bs <= frame_width) { |
| 707 const int r = frame_width - x0; |
| 708 if (right_available && bs == 4) { |
| 709 vpx_memcpy(above_row, above_ref, r * sizeof(uint16_t)); |
| 710 vpx_memset16(above_row + r, above_row[r - 1], |
| 711 x0 + 2 * bs - frame_width); |
| 712 } else { |
| 713 vpx_memcpy(above_row, above_ref, bs * sizeof(uint16_t)); |
| 714 vpx_memset16(above_row + bs, above_row[bs - 1], bs); |
| 715 } |
| 716 } else if (x0 <= frame_width) { |
| 717 const int r = frame_width - x0; |
| 718 if (right_available && bs == 4) { |
| 719 vpx_memcpy(above_row, above_ref, r * sizeof(uint16_t)); |
| 720 vpx_memset16(above_row + r, above_row[r - 1], |
| 721 x0 + 2 * bs - frame_width); |
| 722 } else { |
| 723 vpx_memcpy(above_row, above_ref, r * sizeof(uint16_t)); |
| 724 vpx_memset16(above_row + r, above_row[r - 1], |
| 725 x0 + 2 * bs - frame_width); |
| 726 } |
| 727 } |
| 728 // TODO(Peter) this value should probably change for high bitdepth |
| 729 above_row[-1] = left_available ? above_ref[-1] : (base+1); |
| 730 } else { |
| 731 /* faster path if the block does not need extension */ |
| 732 if (bs == 4 && right_available && left_available) { |
| 733 const_above_row = above_ref; |
| 734 } else { |
| 735 vpx_memcpy(above_row, above_ref, bs * sizeof(uint16_t)); |
| 736 if (bs == 4 && right_available) |
| 737 vpx_memcpy(above_row + bs, above_ref + bs, bs * sizeof(uint16_t)); |
| 738 else |
| 739 vpx_memset16(above_row + bs, above_row[bs - 1], bs); |
| 740 // TODO(Peter): this value should probably change for high bitdepth |
| 741 above_row[-1] = left_available ? above_ref[-1] : (base+1); |
| 742 } |
| 743 } |
| 744 } else { |
| 745 vpx_memset16(above_row, base - 1, bs * 2); |
| 746 // TODO(Peter): this value should probably change for high bitdepth |
| 747 above_row[-1] = base - 1; |
| 748 } |
| 749 |
| 750 // predict |
| 751 if (mode == DC_PRED) { |
| 752 dc_pred_high[left_available][up_available][tx_size](dst, dst_stride, |
| 753 const_above_row, |
| 754 left_col, xd->bd); |
| 755 } else { |
| 756 pred_high[mode][tx_size](dst, dst_stride, const_above_row, left_col, |
| 757 xd->bd); |
| 758 } |
| 759 } |
| 760 #endif // CONFIG_VP9_HIGHBITDEPTH |
| 761 |
321 static void build_intra_predictors(const MACROBLOCKD *xd, const uint8_t *ref, | 762 static void build_intra_predictors(const MACROBLOCKD *xd, const uint8_t *ref, |
322 int ref_stride, uint8_t *dst, int dst_stride, | 763 int ref_stride, uint8_t *dst, int dst_stride, |
323 PREDICTION_MODE mode, TX_SIZE tx_size, | 764 PREDICTION_MODE mode, TX_SIZE tx_size, |
324 int up_available, int left_available, | 765 int up_available, int left_available, |
325 int right_available, int x, int y, | 766 int right_available, int x, int y, |
326 int plane) { | 767 int plane) { |
327 int i; | 768 int i; |
328 DECLARE_ALIGNED_ARRAY(16, uint8_t, left_col, 64); | 769 DECLARE_ALIGNED_ARRAY(16, uint8_t, left_col, 64); |
329 DECLARE_ALIGNED_ARRAY(16, uint8_t, above_data, 128 + 16); | 770 DECLARE_ALIGNED_ARRAY(16, uint8_t, above_data, 128 + 16); |
330 uint8_t *above_row = above_data + 16; | 771 uint8_t *above_row = above_data + 16; |
(...skipping 116 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
447 int aoff, int loff, int plane) { | 888 int aoff, int loff, int plane) { |
448 const int bwl = bwl_in - tx_size; | 889 const int bwl = bwl_in - tx_size; |
449 const int wmask = (1 << bwl) - 1; | 890 const int wmask = (1 << bwl) - 1; |
450 const int have_top = (block_idx >> bwl) || xd->up_available; | 891 const int have_top = (block_idx >> bwl) || xd->up_available; |
451 const int have_left = (block_idx & wmask) || xd->left_available; | 892 const int have_left = (block_idx & wmask) || xd->left_available; |
452 const int have_right = ((block_idx & wmask) != wmask); | 893 const int have_right = ((block_idx & wmask) != wmask); |
453 const int x = aoff * 4; | 894 const int x = aoff * 4; |
454 const int y = loff * 4; | 895 const int y = loff * 4; |
455 | 896 |
456 assert(bwl >= 0); | 897 assert(bwl >= 0); |
| 898 #if CONFIG_VP9_HIGHBITDEPTH |
| 899 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { |
| 900 build_intra_predictors_high(xd, ref, ref_stride, dst, dst_stride, mode, |
| 901 tx_size, have_top, have_left, have_right, |
| 902 x, y, plane, xd->bd); |
| 903 return; |
| 904 } |
| 905 #endif |
457 build_intra_predictors(xd, ref, ref_stride, dst, dst_stride, mode, tx_size, | 906 build_intra_predictors(xd, ref, ref_stride, dst, dst_stride, mode, tx_size, |
458 have_top, have_left, have_right, x, y, plane); | 907 have_top, have_left, have_right, x, y, plane); |
459 } | 908 } |
OLD | NEW |