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 23 matching lines...) Expand all Loading... |
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 | 43 #if CONFIG_VP9_HIGHBITDEPTH |
44 #define intra_pred_high_sized(type, size) \ | 44 #define intra_pred_highbd_sized(type, size) \ |
45 void vp9_high_##type##_predictor_##size##x##size##_c( \ | 45 void vp9_highbd_##type##_predictor_##size##x##size##_c( \ |
46 uint16_t *dst, ptrdiff_t stride, const uint16_t *above, \ | 46 uint16_t *dst, ptrdiff_t stride, const uint16_t *above, \ |
47 const uint16_t *left, int bd) { \ | 47 const uint16_t *left, int bd) { \ |
48 high_##type##_predictor(dst, stride, size, above, left, bd); \ | 48 highbd_##type##_predictor(dst, stride, size, above, left, bd); \ |
49 } | 49 } |
50 | 50 |
51 #define intra_pred_allsizes(type) \ | 51 #define intra_pred_allsizes(type) \ |
52 intra_pred_sized(type, 4) \ | 52 intra_pred_sized(type, 4) \ |
53 intra_pred_sized(type, 8) \ | 53 intra_pred_sized(type, 8) \ |
54 intra_pred_sized(type, 16) \ | 54 intra_pred_sized(type, 16) \ |
55 intra_pred_sized(type, 32) \ | 55 intra_pred_sized(type, 32) \ |
56 intra_pred_high_sized(type, 4) \ | 56 intra_pred_highbd_sized(type, 4) \ |
57 intra_pred_high_sized(type, 8) \ | 57 intra_pred_highbd_sized(type, 8) \ |
58 intra_pred_high_sized(type, 16) \ | 58 intra_pred_highbd_sized(type, 16) \ |
59 intra_pred_high_sized(type, 32) | 59 intra_pred_highbd_sized(type, 32) |
60 | 60 |
61 #else | 61 #else |
62 | 62 |
63 #define intra_pred_allsizes(type) \ | 63 #define intra_pred_allsizes(type) \ |
64 intra_pred_sized(type, 4) \ | 64 intra_pred_sized(type, 4) \ |
65 intra_pred_sized(type, 8) \ | 65 intra_pred_sized(type, 8) \ |
66 intra_pred_sized(type, 16) \ | 66 intra_pred_sized(type, 16) \ |
67 intra_pred_sized(type, 32) | 67 intra_pred_sized(type, 32) |
68 #endif // CONFIG_VP9_HIGHBITDEPTH | 68 #endif // CONFIG_VP9_HIGHBITDEPTH |
69 | 69 |
70 #if CONFIG_VP9_HIGHBITDEPTH | 70 #if CONFIG_VP9_HIGHBITDEPTH |
71 static INLINE void high_d207_predictor(uint16_t *dst, ptrdiff_t stride, int bs, | 71 static INLINE void highbd_d207_predictor(uint16_t *dst, ptrdiff_t stride, |
72 const uint16_t *above, | 72 int bs, const uint16_t *above, |
73 const uint16_t *left, int bd) { | 73 const uint16_t *left, int bd) { |
74 int r, c; | 74 int r, c; |
75 (void) above; | 75 (void) above; |
76 (void) bd; | 76 (void) bd; |
77 | 77 |
78 // First column. | 78 // First column. |
79 for (r = 0; r < bs - 1; ++r) { | 79 for (r = 0; r < bs - 1; ++r) { |
80 dst[r * stride] = ROUND_POWER_OF_TWO(left[r] + left[r + 1], 1); | 80 dst[r * stride] = ROUND_POWER_OF_TWO(left[r] + left[r + 1], 1); |
81 } | 81 } |
82 dst[(bs - 1) * stride] = left[bs - 1]; | 82 dst[(bs - 1) * stride] = left[bs - 1]; |
83 dst++; | 83 dst++; |
(...skipping 11 matching lines...) Expand all Loading... |
95 // Rest of last row. | 95 // Rest of last row. |
96 for (c = 0; c < bs - 2; ++c) | 96 for (c = 0; c < bs - 2; ++c) |
97 dst[(bs - 1) * stride + c] = left[bs - 1]; | 97 dst[(bs - 1) * stride + c] = left[bs - 1]; |
98 | 98 |
99 for (r = bs - 2; r >= 0; --r) { | 99 for (r = bs - 2; r >= 0; --r) { |
100 for (c = 0; c < bs - 2; ++c) | 100 for (c = 0; c < bs - 2; ++c) |
101 dst[r * stride + c] = dst[(r + 1) * stride + c - 2]; | 101 dst[r * stride + c] = dst[(r + 1) * stride + c - 2]; |
102 } | 102 } |
103 } | 103 } |
104 | 104 |
105 static INLINE void high_d63_predictor(uint16_t *dst, ptrdiff_t stride, int bs, | 105 static INLINE void highbd_d63_predictor(uint16_t *dst, ptrdiff_t stride, |
106 const uint16_t *above, | 106 int bs, const uint16_t *above, |
107 const uint16_t *left, int bd) { | 107 const uint16_t *left, int bd) { |
108 int r, c; | 108 int r, c; |
109 (void) left; | 109 (void) left; |
110 (void) bd; | 110 (void) bd; |
111 for (r = 0; r < bs; ++r) { | 111 for (r = 0; r < bs; ++r) { |
112 for (c = 0; c < bs; ++c) { | 112 for (c = 0; c < bs; ++c) { |
113 dst[c] = r & 1 ? ROUND_POWER_OF_TWO(above[r/2 + c] + | 113 dst[c] = r & 1 ? ROUND_POWER_OF_TWO(above[r/2 + c] + |
114 above[r/2 + c + 1] * 2 + | 114 above[r/2 + c + 1] * 2 + |
115 above[r/2 + c + 2], 2) | 115 above[r/2 + c + 2], 2) |
116 : ROUND_POWER_OF_TWO(above[r/2 + c] + | 116 : ROUND_POWER_OF_TWO(above[r/2 + c] + |
117 above[r/2 + c + 1], 1); | 117 above[r/2 + c + 1], 1); |
118 } | 118 } |
119 dst += stride; | 119 dst += stride; |
120 } | 120 } |
121 } | 121 } |
122 | 122 |
123 static INLINE void high_d45_predictor(uint16_t *dst, ptrdiff_t stride, int bs, | 123 static INLINE void highbd_d45_predictor(uint16_t *dst, ptrdiff_t stride, int bs, |
124 const uint16_t *above, | 124 const uint16_t *above, |
125 const uint16_t *left, int bd) { | 125 const uint16_t *left, int bd) { |
126 int r, c; | 126 int r, c; |
127 (void) left; | 127 (void) left; |
128 (void) bd; | 128 (void) bd; |
129 for (r = 0; r < bs; ++r) { | 129 for (r = 0; r < bs; ++r) { |
130 for (c = 0; c < bs; ++c) { | 130 for (c = 0; c < bs; ++c) { |
131 dst[c] = r + c + 2 < bs * 2 ? ROUND_POWER_OF_TWO(above[r + c] + | 131 dst[c] = r + c + 2 < bs * 2 ? ROUND_POWER_OF_TWO(above[r + c] + |
132 above[r + c + 1] * 2 + | 132 above[r + c + 1] * 2 + |
133 above[r + c + 2], 2) | 133 above[r + c + 2], 2) |
134 : above[bs * 2 - 1]; | 134 : above[bs * 2 - 1]; |
135 } | 135 } |
136 dst += stride; | 136 dst += stride; |
137 } | 137 } |
138 } | 138 } |
139 | 139 |
140 static INLINE void high_d117_predictor(uint16_t *dst, ptrdiff_t stride, | 140 static INLINE void highbd_d117_predictor(uint16_t *dst, ptrdiff_t stride, |
141 int bs, const uint16_t *above, | 141 int bs, const uint16_t *above, |
142 const uint16_t *left, int bd) { | 142 const uint16_t *left, int bd) { |
143 int r, c; | 143 int r, c; |
144 (void) bd; | 144 (void) bd; |
145 | 145 |
146 // first row | 146 // first row |
147 for (c = 0; c < bs; c++) | 147 for (c = 0; c < bs; c++) |
148 dst[c] = ROUND_POWER_OF_TWO(above[c - 1] + above[c], 1); | 148 dst[c] = ROUND_POWER_OF_TWO(above[c - 1] + above[c], 1); |
149 dst += stride; | 149 dst += stride; |
150 | 150 |
151 // second row | 151 // second row |
152 dst[0] = ROUND_POWER_OF_TWO(left[0] + above[-1] * 2 + above[0], 2); | 152 dst[0] = ROUND_POWER_OF_TWO(left[0] + above[-1] * 2 + above[0], 2); |
153 for (c = 1; c < bs; c++) | 153 for (c = 1; c < bs; c++) |
154 dst[c] = ROUND_POWER_OF_TWO(above[c - 2] + above[c - 1] * 2 + above[c], 2); | 154 dst[c] = ROUND_POWER_OF_TWO(above[c - 2] + above[c - 1] * 2 + above[c], 2); |
155 dst += stride; | 155 dst += stride; |
156 | 156 |
157 // the rest of first col | 157 // the rest of first col |
158 dst[0] = ROUND_POWER_OF_TWO(above[-1] + left[0] * 2 + left[1], 2); | 158 dst[0] = ROUND_POWER_OF_TWO(above[-1] + left[0] * 2 + left[1], 2); |
159 for (r = 3; r < bs; ++r) | 159 for (r = 3; r < bs; ++r) |
160 dst[(r - 2) * stride] = ROUND_POWER_OF_TWO(left[r - 3] + left[r - 2] * 2 + | 160 dst[(r - 2) * stride] = ROUND_POWER_OF_TWO(left[r - 3] + left[r - 2] * 2 + |
161 left[r - 1], 2); | 161 left[r - 1], 2); |
162 | 162 |
163 // the rest of the block | 163 // the rest of the block |
164 for (r = 2; r < bs; ++r) { | 164 for (r = 2; r < bs; ++r) { |
165 for (c = 1; c < bs; c++) | 165 for (c = 1; c < bs; c++) |
166 dst[c] = dst[-2 * stride + c - 1]; | 166 dst[c] = dst[-2 * stride + c - 1]; |
167 dst += stride; | 167 dst += stride; |
168 } | 168 } |
169 } | 169 } |
170 | 170 |
171 static INLINE void high_d135_predictor(uint16_t *dst, ptrdiff_t stride, int bs, | 171 static INLINE void highbd_d135_predictor(uint16_t *dst, ptrdiff_t stride, |
172 const uint16_t *above, | 172 int bs, const uint16_t *above, |
173 const uint16_t *left, int bd) { | 173 const uint16_t *left, int bd) { |
174 int r, c; | 174 int r, c; |
175 (void) bd; | 175 (void) bd; |
176 dst[0] = ROUND_POWER_OF_TWO(left[0] + above[-1] * 2 + above[0], 2); | 176 dst[0] = ROUND_POWER_OF_TWO(left[0] + above[-1] * 2 + above[0], 2); |
177 for (c = 1; c < bs; c++) | 177 for (c = 1; c < bs; c++) |
178 dst[c] = ROUND_POWER_OF_TWO(above[c - 2] + above[c - 1] * 2 + above[c], 2); | 178 dst[c] = ROUND_POWER_OF_TWO(above[c - 2] + above[c - 1] * 2 + above[c], 2); |
179 | 179 |
180 dst[stride] = ROUND_POWER_OF_TWO(above[-1] + left[0] * 2 + left[1], 2); | 180 dst[stride] = ROUND_POWER_OF_TWO(above[-1] + left[0] * 2 + left[1], 2); |
181 for (r = 2; r < bs; ++r) | 181 for (r = 2; r < bs; ++r) |
182 dst[r * stride] = ROUND_POWER_OF_TWO(left[r - 2] + left[r - 1] * 2 + | 182 dst[r * stride] = ROUND_POWER_OF_TWO(left[r - 2] + left[r - 1] * 2 + |
183 left[r], 2); | 183 left[r], 2); |
184 | 184 |
185 dst += stride; | 185 dst += stride; |
186 for (r = 1; r < bs; ++r) { | 186 for (r = 1; r < bs; ++r) { |
187 for (c = 1; c < bs; c++) | 187 for (c = 1; c < bs; c++) |
188 dst[c] = dst[-stride + c - 1]; | 188 dst[c] = dst[-stride + c - 1]; |
189 dst += stride; | 189 dst += stride; |
190 } | 190 } |
191 } | 191 } |
192 | 192 |
193 static INLINE void high_d153_predictor(uint16_t *dst, ptrdiff_t stride, int bs, | 193 static INLINE void highbd_d153_predictor(uint16_t *dst, ptrdiff_t stride, |
194 const uint16_t *above, | 194 int bs, const uint16_t *above, |
195 const uint16_t *left, int bd) { | 195 const uint16_t *left, int bd) { |
196 int r, c; | 196 int r, c; |
197 (void) bd; | 197 (void) bd; |
198 dst[0] = ROUND_POWER_OF_TWO(above[-1] + left[0], 1); | 198 dst[0] = ROUND_POWER_OF_TWO(above[-1] + left[0], 1); |
199 for (r = 1; r < bs; r++) | 199 for (r = 1; r < bs; r++) |
200 dst[r * stride] = ROUND_POWER_OF_TWO(left[r - 1] + left[r], 1); | 200 dst[r * stride] = ROUND_POWER_OF_TWO(left[r - 1] + left[r], 1); |
201 dst++; | 201 dst++; |
202 | 202 |
203 dst[0] = ROUND_POWER_OF_TWO(left[0] + above[-1] * 2 + above[0], 2); | 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); | 204 dst[stride] = ROUND_POWER_OF_TWO(above[-1] + left[0] * 2 + left[1], 2); |
205 for (r = 2; r < bs; r++) | 205 for (r = 2; r < bs; r++) |
206 dst[r * stride] = ROUND_POWER_OF_TWO(left[r - 2] + left[r - 1] * 2 + | 206 dst[r * stride] = ROUND_POWER_OF_TWO(left[r - 2] + left[r - 1] * 2 + |
207 left[r], 2); | 207 left[r], 2); |
208 dst++; | 208 dst++; |
209 | 209 |
210 for (c = 0; c < bs - 2; c++) | 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); | 211 dst[c] = ROUND_POWER_OF_TWO(above[c - 1] + above[c] * 2 + above[c + 1], 2); |
212 dst += stride; | 212 dst += stride; |
213 | 213 |
214 for (r = 1; r < bs; ++r) { | 214 for (r = 1; r < bs; ++r) { |
215 for (c = 0; c < bs - 2; c++) | 215 for (c = 0; c < bs - 2; c++) |
216 dst[c] = dst[-stride + c - 2]; | 216 dst[c] = dst[-stride + c - 2]; |
217 dst += stride; | 217 dst += stride; |
218 } | 218 } |
219 } | 219 } |
220 | 220 |
221 static INLINE void high_v_predictor(uint16_t *dst, ptrdiff_t stride, int bs, | 221 static INLINE void highbd_v_predictor(uint16_t *dst, ptrdiff_t stride, |
222 const uint16_t *above, | 222 int bs, const uint16_t *above, |
223 const uint16_t *left, int bd) { | 223 const uint16_t *left, int bd) { |
224 int r; | 224 int r; |
225 (void) left; | 225 (void) left; |
226 (void) bd; | 226 (void) bd; |
227 for (r = 0; r < bs; r++) { | 227 for (r = 0; r < bs; r++) { |
228 vpx_memcpy(dst, above, bs * sizeof(uint16_t)); | 228 vpx_memcpy(dst, above, bs * sizeof(uint16_t)); |
229 dst += stride; | 229 dst += stride; |
230 } | 230 } |
231 } | 231 } |
232 | 232 |
233 static INLINE void high_h_predictor(uint16_t *dst, ptrdiff_t stride, int bs, | 233 static INLINE void highbd_h_predictor(uint16_t *dst, ptrdiff_t stride, |
234 const uint16_t *above, const uint16_t *left, | 234 int bs, const uint16_t *above, |
235 int bd) { | 235 const uint16_t *left, int bd) { |
236 int r; | 236 int r; |
237 (void) above; | 237 (void) above; |
238 (void) bd; | 238 (void) bd; |
239 for (r = 0; r < bs; r++) { | 239 for (r = 0; r < bs; r++) { |
240 vpx_memset16(dst, left[r], bs); | 240 vpx_memset16(dst, left[r], bs); |
241 dst += stride; | 241 dst += stride; |
242 } | 242 } |
243 } | 243 } |
244 | 244 |
245 static INLINE void high_tm_predictor(uint16_t *dst, ptrdiff_t stride, int bs, | 245 static INLINE void highbd_tm_predictor(uint16_t *dst, ptrdiff_t stride, |
246 const uint16_t *above, | 246 int bs, const uint16_t *above, |
247 const uint16_t *left, int bd) { | 247 const uint16_t *left, int bd) { |
248 int r, c; | 248 int r, c; |
249 int ytop_left = above[-1]; | 249 int ytop_left = above[-1]; |
250 (void) bd; | 250 (void) bd; |
251 | 251 |
252 for (r = 0; r < bs; r++) { | 252 for (r = 0; r < bs; r++) { |
253 for (c = 0; c < bs; c++) | 253 for (c = 0; c < bs; c++) |
254 dst[c] = clip_pixel_high(left[r] + above[c] - ytop_left, bd); | 254 dst[c] = clip_pixel_highbd(left[r] + above[c] - ytop_left, bd); |
255 dst += stride; | 255 dst += stride; |
256 } | 256 } |
257 } | 257 } |
258 | 258 |
259 static INLINE void high_dc_128_predictor(uint16_t *dst, ptrdiff_t stride, | 259 static INLINE void highbd_dc_128_predictor(uint16_t *dst, ptrdiff_t stride, |
260 int bs, const uint16_t *above, | 260 int bs, const uint16_t *above, |
261 const uint16_t *left, int bd) { | 261 const uint16_t *left, int bd) { |
262 int r; | 262 int r; |
263 (void) above; | 263 (void) above; |
264 (void) left; | 264 (void) left; |
265 | 265 |
266 for (r = 0; r < bs; r++) { | 266 for (r = 0; r < bs; r++) { |
267 vpx_memset16(dst, 128 << (bd - 8), bs); | 267 vpx_memset16(dst, 128 << (bd - 8), bs); |
268 dst += stride; | 268 dst += stride; |
269 } | 269 } |
270 } | 270 } |
271 | 271 |
272 static INLINE void high_dc_left_predictor(uint16_t *dst, ptrdiff_t stride, | 272 static INLINE void highbd_dc_left_predictor(uint16_t *dst, ptrdiff_t stride, |
273 int bs, const uint16_t *above, | 273 int bs, const uint16_t *above, |
274 const uint16_t *left, int bd) { | 274 const uint16_t *left, int bd) { |
275 int i, r, expected_dc, sum = 0; | 275 int i, r, expected_dc, sum = 0; |
276 (void) above; | 276 (void) above; |
277 (void) bd; | 277 (void) bd; |
278 | 278 |
279 for (i = 0; i < bs; i++) | 279 for (i = 0; i < bs; i++) |
280 sum += left[i]; | 280 sum += left[i]; |
281 expected_dc = (sum + (bs >> 1)) / bs; | 281 expected_dc = (sum + (bs >> 1)) / bs; |
282 | 282 |
283 for (r = 0; r < bs; r++) { | 283 for (r = 0; r < bs; r++) { |
284 vpx_memset16(dst, expected_dc, bs); | 284 vpx_memset16(dst, expected_dc, bs); |
285 dst += stride; | 285 dst += stride; |
286 } | 286 } |
287 } | 287 } |
288 | 288 |
289 static INLINE void high_dc_top_predictor(uint16_t *dst, ptrdiff_t stride, | 289 static INLINE void highbd_dc_top_predictor(uint16_t *dst, ptrdiff_t stride, |
290 int bs, const uint16_t *above, | 290 int bs, const uint16_t *above, |
291 const uint16_t *left, int bd) { | 291 const uint16_t *left, int bd) { |
292 int i, r, expected_dc, sum = 0; | 292 int i, r, expected_dc, sum = 0; |
293 (void) left; | 293 (void) left; |
294 (void) bd; | 294 (void) bd; |
295 | 295 |
296 for (i = 0; i < bs; i++) | 296 for (i = 0; i < bs; i++) |
297 sum += above[i]; | 297 sum += above[i]; |
298 expected_dc = (sum + (bs >> 1)) / bs; | 298 expected_dc = (sum + (bs >> 1)) / bs; |
299 | 299 |
300 for (r = 0; r < bs; r++) { | 300 for (r = 0; r < bs; r++) { |
301 vpx_memset16(dst, expected_dc, bs); | 301 vpx_memset16(dst, expected_dc, bs); |
302 dst += stride; | 302 dst += stride; |
303 } | 303 } |
304 } | 304 } |
305 | 305 |
306 static INLINE void high_dc_predictor(uint16_t *dst, ptrdiff_t stride, | 306 static INLINE void highbd_dc_predictor(uint16_t *dst, ptrdiff_t stride, |
307 int bs, const uint16_t *above, | 307 int bs, const uint16_t *above, |
308 const uint16_t *left, int bd) { | 308 const uint16_t *left, int bd) { |
309 int i, r, expected_dc, sum = 0; | 309 int i, r, expected_dc, sum = 0; |
310 const int count = 2 * bs; | 310 const int count = 2 * bs; |
311 (void) bd; | 311 (void) bd; |
312 | 312 |
313 for (i = 0; i < bs; i++) { | 313 for (i = 0; i < bs; i++) { |
314 sum += above[i]; | 314 sum += above[i]; |
315 sum += left[i]; | 315 sum += left[i]; |
316 } | 316 } |
317 | 317 |
318 expected_dc = (sum + (count >> 1)) / count; | 318 expected_dc = (sum + (count >> 1)) / count; |
(...skipping 276 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
595 INIT_ALL_SIZES(pred[D135_PRED], d135); | 595 INIT_ALL_SIZES(pred[D135_PRED], d135); |
596 INIT_ALL_SIZES(pred[D153_PRED], d153); | 596 INIT_ALL_SIZES(pred[D153_PRED], d153); |
597 INIT_ALL_SIZES(pred[TM_PRED], tm); | 597 INIT_ALL_SIZES(pred[TM_PRED], tm); |
598 | 598 |
599 INIT_ALL_SIZES(dc_pred[0][0], dc_128); | 599 INIT_ALL_SIZES(dc_pred[0][0], dc_128); |
600 INIT_ALL_SIZES(dc_pred[0][1], dc_top); | 600 INIT_ALL_SIZES(dc_pred[0][1], dc_top); |
601 INIT_ALL_SIZES(dc_pred[1][0], dc_left); | 601 INIT_ALL_SIZES(dc_pred[1][0], dc_left); |
602 INIT_ALL_SIZES(dc_pred[1][1], dc); | 602 INIT_ALL_SIZES(dc_pred[1][1], dc); |
603 | 603 |
604 #if CONFIG_VP9_HIGHBITDEPTH | 604 #if CONFIG_VP9_HIGHBITDEPTH |
605 INIT_ALL_SIZES(pred_high[V_PRED], high_v); | 605 INIT_ALL_SIZES(pred_high[V_PRED], highbd_v); |
606 INIT_ALL_SIZES(pred_high[H_PRED], high_h); | 606 INIT_ALL_SIZES(pred_high[H_PRED], highbd_h); |
607 INIT_ALL_SIZES(pred_high[D207_PRED], high_d207); | 607 INIT_ALL_SIZES(pred_high[D207_PRED], highbd_d207); |
608 INIT_ALL_SIZES(pred_high[D45_PRED], high_d45); | 608 INIT_ALL_SIZES(pred_high[D45_PRED], highbd_d45); |
609 INIT_ALL_SIZES(pred_high[D63_PRED], high_d63); | 609 INIT_ALL_SIZES(pred_high[D63_PRED], highbd_d63); |
610 INIT_ALL_SIZES(pred_high[D117_PRED], high_d117); | 610 INIT_ALL_SIZES(pred_high[D117_PRED], highbd_d117); |
611 INIT_ALL_SIZES(pred_high[D135_PRED], high_d135); | 611 INIT_ALL_SIZES(pred_high[D135_PRED], highbd_d135); |
612 INIT_ALL_SIZES(pred_high[D153_PRED], high_d153); | 612 INIT_ALL_SIZES(pred_high[D153_PRED], highbd_d153); |
613 INIT_ALL_SIZES(pred_high[TM_PRED], high_tm); | 613 INIT_ALL_SIZES(pred_high[TM_PRED], highbd_tm); |
614 | 614 |
615 INIT_ALL_SIZES(dc_pred_high[0][0], high_dc_128); | 615 INIT_ALL_SIZES(dc_pred_high[0][0], highbd_dc_128); |
616 INIT_ALL_SIZES(dc_pred_high[0][1], high_dc_top); | 616 INIT_ALL_SIZES(dc_pred_high[0][1], highbd_dc_top); |
617 INIT_ALL_SIZES(dc_pred_high[1][0], high_dc_left); | 617 INIT_ALL_SIZES(dc_pred_high[1][0], highbd_dc_left); |
618 INIT_ALL_SIZES(dc_pred_high[1][1], high_dc); | 618 INIT_ALL_SIZES(dc_pred_high[1][1], highbd_dc); |
619 #endif // CONFIG_VP9_HIGHBITDEPTH | 619 #endif // CONFIG_VP9_HIGHBITDEPTH |
620 | 620 |
621 #undef intra_pred_allsizes | 621 #undef intra_pred_allsizes |
622 } | 622 } |
623 | 623 |
624 #if CONFIG_VP9_HIGHBITDEPTH | 624 #if CONFIG_VP9_HIGHBITDEPTH |
625 static void build_intra_predictors_high(const MACROBLOCKD *xd, | 625 static void build_intra_predictors_high(const MACROBLOCKD *xd, |
626 const uint8_t *ref8, | 626 const uint8_t *ref8, |
627 int ref_stride, | 627 int ref_stride, |
628 uint8_t *dst8, | 628 uint8_t *dst8, |
(...skipping 270 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
899 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { | 899 if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { |
900 build_intra_predictors_high(xd, ref, ref_stride, dst, dst_stride, mode, | 900 build_intra_predictors_high(xd, ref, ref_stride, dst, dst_stride, mode, |
901 tx_size, have_top, have_left, have_right, | 901 tx_size, have_top, have_left, have_right, |
902 x, y, plane, xd->bd); | 902 x, y, plane, xd->bd); |
903 return; | 903 return; |
904 } | 904 } |
905 #endif | 905 #endif |
906 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, |
907 have_top, have_left, have_right, x, y, plane); | 907 have_top, have_left, have_right, x, y, plane); |
908 } | 908 } |
OLD | NEW |