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 13 matching lines...) Expand all Loading... |
24 DCT_ADST, // H | 24 DCT_ADST, // H |
25 DCT_DCT, // D45 | 25 DCT_DCT, // D45 |
26 ADST_ADST, // D135 | 26 ADST_ADST, // D135 |
27 ADST_DCT, // D117 | 27 ADST_DCT, // D117 |
28 DCT_ADST, // D153 | 28 DCT_ADST, // D153 |
29 DCT_ADST, // D207 | 29 DCT_ADST, // D207 |
30 ADST_DCT, // D63 | 30 ADST_DCT, // D63 |
31 ADST_ADST, // TM | 31 ADST_ADST, // TM |
32 }; | 32 }; |
33 | 33 |
| 34 // This serves as a wrapper function, so that all the prediction functions |
| 35 // can be unified and accessed as a pointer array. Note that the boundary |
| 36 // above and left are not necessarily used all the time. |
34 #define intra_pred_sized(type, size) \ | 37 #define intra_pred_sized(type, size) \ |
35 void vp9_##type##_predictor_##size##x##size##_c(uint8_t *dst, \ | 38 void vp9_##type##_predictor_##size##x##size##_c(uint8_t *dst, \ |
36 ptrdiff_t stride, \ | 39 ptrdiff_t stride, \ |
37 const uint8_t *above, \ | 40 const uint8_t *above, \ |
38 const uint8_t *left) { \ | 41 const uint8_t *left) { \ |
39 type##_predictor(dst, stride, size, above, left); \ | 42 type##_predictor(dst, stride, size, above, left); \ |
40 } | 43 } |
41 | 44 |
42 #define intra_pred_allsizes(type) \ | 45 #define intra_pred_allsizes(type) \ |
43 intra_pred_sized(type, 4) \ | 46 intra_pred_sized(type, 4) \ |
44 intra_pred_sized(type, 8) \ | 47 intra_pred_sized(type, 8) \ |
45 intra_pred_sized(type, 16) \ | 48 intra_pred_sized(type, 16) \ |
46 intra_pred_sized(type, 32) | 49 intra_pred_sized(type, 32) |
47 | 50 |
48 static INLINE void d207_predictor(uint8_t *dst, ptrdiff_t stride, int bs, | 51 static INLINE void d207_predictor(uint8_t *dst, ptrdiff_t stride, int bs, |
49 const uint8_t *above, const uint8_t *left) { | 52 const uint8_t *above, const uint8_t *left) { |
50 int r, c; | 53 int r, c; |
51 | 54 (void) above; |
52 // first column | 55 // first column |
53 for (r = 0; r < bs - 1; ++r) | 56 for (r = 0; r < bs - 1; ++r) |
54 dst[r * stride] = ROUND_POWER_OF_TWO(left[r] + left[r + 1], 1); | 57 dst[r * stride] = ROUND_POWER_OF_TWO(left[r] + left[r + 1], 1); |
55 dst[(bs - 1) * stride] = left[bs - 1]; | 58 dst[(bs - 1) * stride] = left[bs - 1]; |
56 dst++; | 59 dst++; |
57 | 60 |
58 // second column | 61 // second column |
59 for (r = 0; r < bs - 2; ++r) | 62 for (r = 0; r < bs - 2; ++r) |
60 dst[r * stride] = ROUND_POWER_OF_TWO(left[r] + left[r + 1] * 2 + | 63 dst[r * stride] = ROUND_POWER_OF_TWO(left[r] + left[r + 1] * 2 + |
61 left[r + 2], 2); | 64 left[r + 2], 2); |
62 dst[(bs - 2) * stride] = ROUND_POWER_OF_TWO(left[bs - 2] + | 65 dst[(bs - 2) * stride] = ROUND_POWER_OF_TWO(left[bs - 2] + |
63 left[bs - 1] * 3, 2); | 66 left[bs - 1] * 3, 2); |
64 dst[(bs - 1) * stride] = left[bs - 1]; | 67 dst[(bs - 1) * stride] = left[bs - 1]; |
65 dst++; | 68 dst++; |
66 | 69 |
67 // rest of last row | 70 // rest of last row |
68 for (c = 0; c < bs - 2; ++c) | 71 for (c = 0; c < bs - 2; ++c) |
69 dst[(bs - 1) * stride + c] = left[bs - 1]; | 72 dst[(bs - 1) * stride + c] = left[bs - 1]; |
70 | 73 |
71 for (r = bs - 2; r >= 0; --r) | 74 for (r = bs - 2; r >= 0; --r) |
72 for (c = 0; c < bs - 2; ++c) | 75 for (c = 0; c < bs - 2; ++c) |
73 dst[r * stride + c] = dst[(r + 1) * stride + c - 2]; | 76 dst[r * stride + c] = dst[(r + 1) * stride + c - 2]; |
74 } | 77 } |
75 intra_pred_allsizes(d207) | 78 intra_pred_allsizes(d207) |
76 | 79 |
77 static INLINE void d63_predictor(uint8_t *dst, ptrdiff_t stride, int bs, | 80 static INLINE void d63_predictor(uint8_t *dst, ptrdiff_t stride, int bs, |
78 const uint8_t *above, const uint8_t *left) { | 81 const uint8_t *above, const uint8_t *left) { |
79 int r, c; | 82 int r, c; |
| 83 (void) left; |
80 for (r = 0; r < bs; ++r) { | 84 for (r = 0; r < bs; ++r) { |
81 for (c = 0; c < bs; ++c) | 85 for (c = 0; c < bs; ++c) |
82 dst[c] = r & 1 ? ROUND_POWER_OF_TWO(above[r/2 + c] + | 86 dst[c] = r & 1 ? ROUND_POWER_OF_TWO(above[r/2 + c] + |
83 above[r/2 + c + 1] * 2 + | 87 above[r/2 + c + 1] * 2 + |
84 above[r/2 + c + 2], 2) | 88 above[r/2 + c + 2], 2) |
85 : ROUND_POWER_OF_TWO(above[r/2 + c] + | 89 : ROUND_POWER_OF_TWO(above[r/2 + c] + |
86 above[r/2 + c + 1], 1); | 90 above[r/2 + c + 1], 1); |
87 dst += stride; | 91 dst += stride; |
88 } | 92 } |
89 } | 93 } |
90 intra_pred_allsizes(d63) | 94 intra_pred_allsizes(d63) |
91 | 95 |
92 static INLINE void d45_predictor(uint8_t *dst, ptrdiff_t stride, int bs, | 96 static INLINE void d45_predictor(uint8_t *dst, ptrdiff_t stride, int bs, |
93 const uint8_t *above, const uint8_t *left) { | 97 const uint8_t *above, const uint8_t *left) { |
94 int r, c; | 98 int r, c; |
| 99 (void) left; |
95 for (r = 0; r < bs; ++r) { | 100 for (r = 0; r < bs; ++r) { |
96 for (c = 0; c < bs; ++c) | 101 for (c = 0; c < bs; ++c) |
97 dst[c] = r + c + 2 < bs * 2 ? ROUND_POWER_OF_TWO(above[r + c] + | 102 dst[c] = r + c + 2 < bs * 2 ? ROUND_POWER_OF_TWO(above[r + c] + |
98 above[r + c + 1] * 2 + | 103 above[r + c + 1] * 2 + |
99 above[r + c + 2], 2) | 104 above[r + c + 2], 2) |
100 : above[bs * 2 - 1]; | 105 : above[bs * 2 - 1]; |
101 dst += stride; | 106 dst += stride; |
102 } | 107 } |
103 } | 108 } |
104 intra_pred_allsizes(d45) | 109 intra_pred_allsizes(d45) |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
177 for (c = 0; c < bs - 2; c++) | 182 for (c = 0; c < bs - 2; c++) |
178 dst[c] = dst[-stride + c - 2]; | 183 dst[c] = dst[-stride + c - 2]; |
179 dst += stride; | 184 dst += stride; |
180 } | 185 } |
181 } | 186 } |
182 intra_pred_allsizes(d153) | 187 intra_pred_allsizes(d153) |
183 | 188 |
184 static INLINE void v_predictor(uint8_t *dst, ptrdiff_t stride, int bs, | 189 static INLINE void v_predictor(uint8_t *dst, ptrdiff_t stride, int bs, |
185 const uint8_t *above, const uint8_t *left) { | 190 const uint8_t *above, const uint8_t *left) { |
186 int r; | 191 int r; |
| 192 (void) left; |
187 | 193 |
188 for (r = 0; r < bs; r++) { | 194 for (r = 0; r < bs; r++) { |
189 vpx_memcpy(dst, above, bs); | 195 vpx_memcpy(dst, above, bs); |
190 dst += stride; | 196 dst += stride; |
191 } | 197 } |
192 } | 198 } |
193 intra_pred_allsizes(v) | 199 intra_pred_allsizes(v) |
194 | 200 |
195 static INLINE void h_predictor(uint8_t *dst, ptrdiff_t stride, int bs, | 201 static INLINE void h_predictor(uint8_t *dst, ptrdiff_t stride, int bs, |
196 const uint8_t *above, const uint8_t *left) { | 202 const uint8_t *above, const uint8_t *left) { |
197 int r; | 203 int r; |
| 204 (void) above; |
198 | 205 |
199 for (r = 0; r < bs; r++) { | 206 for (r = 0; r < bs; r++) { |
200 vpx_memset(dst, left[r], bs); | 207 vpx_memset(dst, left[r], bs); |
201 dst += stride; | 208 dst += stride; |
202 } | 209 } |
203 } | 210 } |
204 intra_pred_allsizes(h) | 211 intra_pred_allsizes(h) |
205 | 212 |
206 static INLINE void tm_predictor(uint8_t *dst, ptrdiff_t stride, int bs, | 213 static INLINE void tm_predictor(uint8_t *dst, ptrdiff_t stride, int bs, |
207 const uint8_t *above, const uint8_t *left) { | 214 const uint8_t *above, const uint8_t *left) { |
208 int r, c; | 215 int r, c; |
209 int ytop_left = above[-1]; | 216 int ytop_left = above[-1]; |
210 | 217 |
211 for (r = 0; r < bs; r++) { | 218 for (r = 0; r < bs; r++) { |
212 for (c = 0; c < bs; c++) | 219 for (c = 0; c < bs; c++) |
213 dst[c] = clip_pixel(left[r] + above[c] - ytop_left); | 220 dst[c] = clip_pixel(left[r] + above[c] - ytop_left); |
214 dst += stride; | 221 dst += stride; |
215 } | 222 } |
216 } | 223 } |
217 intra_pred_allsizes(tm) | 224 intra_pred_allsizes(tm) |
218 | 225 |
219 static INLINE void dc_128_predictor(uint8_t *dst, ptrdiff_t stride, int bs, | 226 static INLINE void dc_128_predictor(uint8_t *dst, ptrdiff_t stride, int bs, |
220 const uint8_t *above, const uint8_t *left) { | 227 const uint8_t *above, const uint8_t *left) { |
221 int r; | 228 int r; |
| 229 (void) above; |
| 230 (void) left; |
222 | 231 |
223 for (r = 0; r < bs; r++) { | 232 for (r = 0; r < bs; r++) { |
224 vpx_memset(dst, 128, bs); | 233 vpx_memset(dst, 128, bs); |
225 dst += stride; | 234 dst += stride; |
226 } | 235 } |
227 } | 236 } |
228 intra_pred_allsizes(dc_128) | 237 intra_pred_allsizes(dc_128) |
229 | 238 |
230 static INLINE void dc_left_predictor(uint8_t *dst, ptrdiff_t stride, int bs, | 239 static INLINE void dc_left_predictor(uint8_t *dst, ptrdiff_t stride, int bs, |
231 const uint8_t *above, | 240 const uint8_t *above, |
232 const uint8_t *left) { | 241 const uint8_t *left) { |
233 int i, r, expected_dc, sum = 0; | 242 int i, r, expected_dc, sum = 0; |
| 243 (void) above; |
234 | 244 |
235 for (i = 0; i < bs; i++) | 245 for (i = 0; i < bs; i++) |
236 sum += left[i]; | 246 sum += left[i]; |
237 expected_dc = (sum + (bs >> 1)) / bs; | 247 expected_dc = (sum + (bs >> 1)) / bs; |
238 | 248 |
239 for (r = 0; r < bs; r++) { | 249 for (r = 0; r < bs; r++) { |
240 vpx_memset(dst, expected_dc, bs); | 250 vpx_memset(dst, expected_dc, bs); |
241 dst += stride; | 251 dst += stride; |
242 } | 252 } |
243 } | 253 } |
244 intra_pred_allsizes(dc_left) | 254 intra_pred_allsizes(dc_left) |
245 | 255 |
246 static INLINE void dc_top_predictor(uint8_t *dst, ptrdiff_t stride, int bs, | 256 static INLINE void dc_top_predictor(uint8_t *dst, ptrdiff_t stride, int bs, |
247 const uint8_t *above, const uint8_t *left) { | 257 const uint8_t *above, const uint8_t *left) { |
248 int i, r, expected_dc, sum = 0; | 258 int i, r, expected_dc, sum = 0; |
| 259 (void) left; |
249 | 260 |
250 for (i = 0; i < bs; i++) | 261 for (i = 0; i < bs; i++) |
251 sum += above[i]; | 262 sum += above[i]; |
252 expected_dc = (sum + (bs >> 1)) / bs; | 263 expected_dc = (sum + (bs >> 1)) / bs; |
253 | 264 |
254 for (r = 0; r < bs; r++) { | 265 for (r = 0; r < bs; r++) { |
255 vpx_memset(dst, expected_dc, bs); | 266 vpx_memset(dst, expected_dc, bs); |
256 dst += stride; | 267 dst += stride; |
257 } | 268 } |
258 } | 269 } |
(...skipping 184 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
443 const int have_top = (block_idx >> bwl) || xd->up_available; | 454 const int have_top = (block_idx >> bwl) || xd->up_available; |
444 const int have_left = (block_idx & wmask) || xd->left_available; | 455 const int have_left = (block_idx & wmask) || xd->left_available; |
445 const int have_right = ((block_idx & wmask) != wmask); | 456 const int have_right = ((block_idx & wmask) != wmask); |
446 const int x = aoff * 4; | 457 const int x = aoff * 4; |
447 const int y = loff * 4; | 458 const int y = loff * 4; |
448 | 459 |
449 assert(bwl >= 0); | 460 assert(bwl >= 0); |
450 build_intra_predictors(xd, ref, ref_stride, dst, dst_stride, mode, tx_size, | 461 build_intra_predictors(xd, ref, ref_stride, dst, dst_stride, mode, tx_size, |
451 have_top, have_left, have_right, x, y, plane); | 462 have_top, have_left, have_right, x, y, plane); |
452 } | 463 } |
OLD | NEW |