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 |
11 | 11 |
12 #include "vpx_ports/config.h" | 12 #include "./vpx_config.h" |
13 #include "vpx_mem/vpx_mem.h" | 13 #include "vpx_mem/vpx_mem.h" |
14 #include "vp9/common/vp9_reconintra.h" | 14 #include "vp9/common/vp9_reconintra.h" |
15 #include "vp9_rtcd.h" | 15 #include "vp9_rtcd.h" |
16 | 16 |
17 #if CONFIG_NEWBINTRAMODES | 17 #if CONFIG_NEWBINTRAMODES |
18 static int find_grad_measure(unsigned char *x, int stride, int n, int t, | 18 static int find_grad_measure(uint8_t *x, int stride, int n, int t, |
19 int dx, int dy) { | 19 int dx, int dy) { |
20 int i, j; | 20 int i, j; |
21 int count = 0, gsum = 0, gdiv; | 21 int count = 0, gsum = 0, gdiv; |
22 /* TODO: Make this code more efficient by breaking up into two loops */ | 22 /* TODO: Make this code more efficient by breaking up into two loops */ |
23 for (i = -t; i < n; ++i) | 23 for (i = -t; i < n; ++i) |
24 for (j = -t; j < n; ++j) { | 24 for (j = -t; j < n; ++j) { |
25 int g; | 25 int g; |
26 if (i >= 0 && j >= 0) continue; | 26 if (i >= 0 && j >= 0) continue; |
27 if (i + dy >= 0 && j + dx >= 0) continue; | 27 if (i + dy >= 0 && j + dx >= 0) continue; |
28 if (i + dy < -t || i + dy >= n || j + dx < -t || j + dx >= n) continue; | 28 if (i + dy < -t || i + dy >= n || j + dx < -t || j + dx >= n) continue; |
29 g = abs(x[(i + dy) * stride + j + dx] - x[i * stride + j]); | 29 g = abs(x[(i + dy) * stride + j + dx] - x[i * stride + j]); |
30 gsum += g * g; | 30 gsum += g * g; |
31 count++; | 31 count++; |
32 } | 32 } |
33 gdiv = (dx * dx + dy * dy) * count; | 33 gdiv = (dx * dx + dy * dy) * count; |
34 return ((gsum << 8) + (gdiv >> 1)) / gdiv; | 34 return ((gsum << 8) + (gdiv >> 1)) / gdiv; |
35 } | 35 } |
36 | 36 |
37 #if CONTEXT_PRED_REPLACEMENTS == 6 | 37 #if CONTEXT_PRED_REPLACEMENTS == 6 |
38 B_PREDICTION_MODE vp9_find_dominant_direction( | 38 B_PREDICTION_MODE vp9_find_dominant_direction(uint8_t *ptr, |
39 unsigned char *ptr, int stride, int n) { | 39 int stride, int n) { |
40 int g[8], i, imin, imax; | 40 int g[8], i, imin, imax; |
41 g[1] = find_grad_measure(ptr, stride, n, 4, 2, 1); | 41 g[1] = find_grad_measure(ptr, stride, n, 4, 2, 1); |
42 g[2] = find_grad_measure(ptr, stride, n, 4, 1, 1); | 42 g[2] = find_grad_measure(ptr, stride, n, 4, 1, 1); |
43 g[3] = find_grad_measure(ptr, stride, n, 4, 1, 2); | 43 g[3] = find_grad_measure(ptr, stride, n, 4, 1, 2); |
44 g[5] = find_grad_measure(ptr, stride, n, 4, -1, 2); | 44 g[5] = find_grad_measure(ptr, stride, n, 4, -1, 2); |
45 g[6] = find_grad_measure(ptr, stride, n, 4, -1, 1); | 45 g[6] = find_grad_measure(ptr, stride, n, 4, -1, 1); |
46 g[7] = find_grad_measure(ptr, stride, n, 4, -2, 1); | 46 g[7] = find_grad_measure(ptr, stride, n, 4, -2, 1); |
47 imin = 1; | 47 imin = 1; |
48 for (i = 2; i < 8; i += 1 + (i == 3)) | 48 for (i = 2; i < 8; i += 1 + (i == 3)) |
49 imin = (g[i] < g[imin] ? i : imin); | 49 imin = (g[i] < g[imin] ? i : imin); |
(...skipping 15 matching lines...) Expand all Loading... |
65 return B_VL_PRED; | 65 return B_VL_PRED; |
66 case 6: | 66 case 6: |
67 return B_LD_PRED; | 67 return B_LD_PRED; |
68 case 7: | 68 case 7: |
69 return B_HU_PRED; | 69 return B_HU_PRED; |
70 default: | 70 default: |
71 assert(0); | 71 assert(0); |
72 } | 72 } |
73 } | 73 } |
74 #elif CONTEXT_PRED_REPLACEMENTS == 4 | 74 #elif CONTEXT_PRED_REPLACEMENTS == 4 |
75 B_PREDICTION_MODE vp9_find_dominant_direction( | 75 B_PREDICTION_MODE vp9_find_dominant_direction(uint8_t *ptr, |
76 unsigned char *ptr, int stride, int n) { | 76 int stride, int n) { |
77 int g[8], i, imin, imax; | 77 int g[8], i, imin, imax; |
78 g[1] = find_grad_measure(ptr, stride, n, 4, 2, 1); | 78 g[1] = find_grad_measure(ptr, stride, n, 4, 2, 1); |
79 g[3] = find_grad_measure(ptr, stride, n, 4, 1, 2); | 79 g[3] = find_grad_measure(ptr, stride, n, 4, 1, 2); |
80 g[5] = find_grad_measure(ptr, stride, n, 4, -1, 2); | 80 g[5] = find_grad_measure(ptr, stride, n, 4, -1, 2); |
81 g[7] = find_grad_measure(ptr, stride, n, 4, -2, 1); | 81 g[7] = find_grad_measure(ptr, stride, n, 4, -2, 1); |
82 imin = 1; | 82 imin = 1; |
83 for (i = 3; i < 8; i+=2) | 83 for (i = 3; i < 8; i+=2) |
84 imin = (g[i] < g[imin] ? i : imin); | 84 imin = (g[i] < g[imin] ? i : imin); |
85 imax = 1; | 85 imax = 1; |
86 for (i = 3; i < 8; i+=2) | 86 for (i = 3; i < 8; i+=2) |
87 imax = (g[i] > g[imax] ? i : imax); | 87 imax = (g[i] > g[imax] ? i : imax); |
88 /* | 88 /* |
89 printf("%d %d %d %d = %d %d\n", | 89 printf("%d %d %d %d = %d %d\n", |
90 g[1], g[3], g[5], g[7], imin, imax); | 90 g[1], g[3], g[5], g[7], imin, imax); |
91 */ | 91 */ |
92 switch (imin) { | 92 switch (imin) { |
93 case 1: | 93 case 1: |
94 return B_HD_PRED; | 94 return B_HD_PRED; |
95 case 3: | 95 case 3: |
96 return B_VR_PRED; | 96 return B_VR_PRED; |
97 case 5: | 97 case 5: |
98 return B_VL_PRED; | 98 return B_VL_PRED; |
99 case 7: | 99 case 7: |
100 return B_HU_PRED; | 100 return B_HU_PRED; |
101 default: | 101 default: |
102 assert(0); | 102 assert(0); |
103 } | 103 } |
104 } | 104 } |
105 #elif CONTEXT_PRED_REPLACEMENTS == 0 | 105 #elif CONTEXT_PRED_REPLACEMENTS == 0 |
106 B_PREDICTION_MODE vp9_find_dominant_direction( | 106 B_PREDICTION_MODE vp9_find_dominant_direction(uint8_t *ptr, |
107 unsigned char *ptr, int stride, int n) { | 107 int stride, int n) { |
108 int g[8], i, imin, imax; | 108 int g[8], i, imin, imax; |
109 g[0] = find_grad_measure(ptr, stride, n, 4, 1, 0); | 109 g[0] = find_grad_measure(ptr, stride, n, 4, 1, 0); |
110 g[1] = find_grad_measure(ptr, stride, n, 4, 2, 1); | 110 g[1] = find_grad_measure(ptr, stride, n, 4, 2, 1); |
111 g[2] = find_grad_measure(ptr, stride, n, 4, 1, 1); | 111 g[2] = find_grad_measure(ptr, stride, n, 4, 1, 1); |
112 g[3] = find_grad_measure(ptr, stride, n, 4, 1, 2); | 112 g[3] = find_grad_measure(ptr, stride, n, 4, 1, 2); |
113 g[4] = find_grad_measure(ptr, stride, n, 4, 0, 1); | 113 g[4] = find_grad_measure(ptr, stride, n, 4, 0, 1); |
114 g[5] = find_grad_measure(ptr, stride, n, 4, -1, 2); | 114 g[5] = find_grad_measure(ptr, stride, n, 4, -1, 2); |
115 g[6] = find_grad_measure(ptr, stride, n, 4, -1, 1); | 115 g[6] = find_grad_measure(ptr, stride, n, 4, -1, 1); |
116 g[7] = find_grad_measure(ptr, stride, n, 4, -2, 1); | 116 g[7] = find_grad_measure(ptr, stride, n, 4, -2, 1); |
117 imax = 0; | 117 imax = 0; |
(...skipping 20 matching lines...) Expand all Loading... |
138 return B_LD_PRED; | 138 return B_LD_PRED; |
139 case 7: | 139 case 7: |
140 return B_HU_PRED; | 140 return B_HU_PRED; |
141 default: | 141 default: |
142 assert(0); | 142 assert(0); |
143 } | 143 } |
144 } | 144 } |
145 #endif | 145 #endif |
146 | 146 |
147 B_PREDICTION_MODE vp9_find_bpred_context(BLOCKD *x) { | 147 B_PREDICTION_MODE vp9_find_bpred_context(BLOCKD *x) { |
148 unsigned char *ptr = *(x->base_dst) + x->dst; | 148 uint8_t *ptr = *(x->base_dst) + x->dst; |
149 int stride = x->dst_stride; | 149 int stride = x->dst_stride; |
150 return vp9_find_dominant_direction(ptr, stride, 4); | 150 return vp9_find_dominant_direction(ptr, stride, 4); |
151 } | 151 } |
152 #endif | 152 #endif |
153 | 153 |
154 void vp9_intra4x4_predict(BLOCKD *x, | 154 void vp9_intra4x4_predict(BLOCKD *x, |
155 int b_mode, | 155 int b_mode, |
156 unsigned char *predictor) { | 156 uint8_t *predictor) { |
157 int i, r, c; | 157 int i, r, c; |
158 | 158 |
159 unsigned char *Above = *(x->base_dst) + x->dst - x->dst_stride; | 159 uint8_t *above = *(x->base_dst) + x->dst - x->dst_stride; |
160 unsigned char Left[4]; | 160 uint8_t left[4]; |
161 unsigned char top_left = Above[-1]; | 161 uint8_t top_left = above[-1]; |
162 | 162 |
163 Left[0] = (*(x->base_dst))[x->dst - 1]; | 163 left[0] = (*(x->base_dst))[x->dst - 1]; |
164 Left[1] = (*(x->base_dst))[x->dst - 1 + x->dst_stride]; | 164 left[1] = (*(x->base_dst))[x->dst - 1 + x->dst_stride]; |
165 Left[2] = (*(x->base_dst))[x->dst - 1 + 2 * x->dst_stride]; | 165 left[2] = (*(x->base_dst))[x->dst - 1 + 2 * x->dst_stride]; |
166 Left[3] = (*(x->base_dst))[x->dst - 1 + 3 * x->dst_stride]; | 166 left[3] = (*(x->base_dst))[x->dst - 1 + 3 * x->dst_stride]; |
167 | 167 |
168 #if CONFIG_NEWBINTRAMODES | 168 #if CONFIG_NEWBINTRAMODES |
169 if (b_mode == B_CONTEXT_PRED) | 169 if (b_mode == B_CONTEXT_PRED) |
170 b_mode = x->bmi.as_mode.context; | 170 b_mode = x->bmi.as_mode.context; |
171 #endif | 171 #endif |
172 | 172 |
173 switch (b_mode) { | 173 switch (b_mode) { |
174 case B_DC_PRED: { | 174 case B_DC_PRED: { |
175 int expected_dc = 0; | 175 int expected_dc = 0; |
176 | 176 |
177 for (i = 0; i < 4; i++) { | 177 for (i = 0; i < 4; i++) { |
178 expected_dc += Above[i]; | 178 expected_dc += above[i]; |
179 expected_dc += Left[i]; | 179 expected_dc += left[i]; |
180 } | 180 } |
181 | 181 |
182 expected_dc = (expected_dc + 4) >> 3; | 182 expected_dc = (expected_dc + 4) >> 3; |
183 | 183 |
184 for (r = 0; r < 4; r++) { | 184 for (r = 0; r < 4; r++) { |
185 for (c = 0; c < 4; c++) { | 185 for (c = 0; c < 4; c++) { |
186 predictor[c] = expected_dc; | 186 predictor[c] = expected_dc; |
187 } | 187 } |
188 | 188 |
189 predictor += 16; | 189 predictor += 16; |
190 } | 190 } |
191 } | 191 } |
192 break; | 192 break; |
193 case B_TM_PRED: { | 193 case B_TM_PRED: { |
194 /* prediction similar to true_motion prediction */ | 194 /* prediction similar to true_motion prediction */ |
195 for (r = 0; r < 4; r++) { | 195 for (r = 0; r < 4; r++) { |
196 for (c = 0; c < 4; c++) { | 196 for (c = 0; c < 4; c++) { |
197 int pred = Above[c] - top_left + Left[r]; | 197 predictor[c] = clip_pixel(above[c] - top_left + left[r]); |
198 | |
199 if (pred < 0) | |
200 pred = 0; | |
201 | |
202 if (pred > 255) | |
203 pred = 255; | |
204 | |
205 predictor[c] = pred; | |
206 } | 198 } |
207 | 199 |
208 predictor += 16; | 200 predictor += 16; |
209 } | 201 } |
210 } | 202 } |
211 break; | 203 break; |
212 | 204 |
213 case B_VE_PRED: { | 205 case B_VE_PRED: { |
| 206 unsigned int ap[4]; |
214 | 207 |
215 unsigned int ap[4]; | 208 ap[0] = above[0]; |
216 ap[0] = Above[0]; | 209 ap[1] = above[1]; |
217 ap[1] = Above[1]; | 210 ap[2] = above[2]; |
218 ap[2] = Above[2]; | 211 ap[3] = above[3]; |
219 ap[3] = Above[3]; | |
220 | 212 |
221 for (r = 0; r < 4; r++) { | 213 for (r = 0; r < 4; r++) { |
222 for (c = 0; c < 4; c++) { | 214 for (c = 0; c < 4; c++) { |
223 | |
224 predictor[c] = ap[c]; | 215 predictor[c] = ap[c]; |
225 } | 216 } |
226 | 217 |
227 predictor += 16; | 218 predictor += 16; |
228 } | 219 } |
229 | |
230 } | 220 } |
231 break; | 221 break; |
232 | 222 |
| 223 case B_HE_PRED: { |
| 224 unsigned int lp[4]; |
233 | 225 |
234 case B_HE_PRED: { | 226 lp[0] = left[0]; |
235 | 227 lp[1] = left[1]; |
236 unsigned int lp[4]; | 228 lp[2] = left[2]; |
237 lp[0] = Left[0]; | 229 lp[3] = left[3]; |
238 lp[1] = Left[1]; | |
239 lp[2] = Left[2]; | |
240 lp[3] = Left[3]; | |
241 | 230 |
242 for (r = 0; r < 4; r++) { | 231 for (r = 0; r < 4; r++) { |
243 for (c = 0; c < 4; c++) { | 232 for (c = 0; c < 4; c++) { |
244 predictor[c] = lp[r]; | 233 predictor[c] = lp[r]; |
245 } | 234 } |
246 | 235 |
247 predictor += 16; | 236 predictor += 16; |
248 } | 237 } |
249 } | 238 } |
250 break; | 239 break; |
251 case B_LD_PRED: { | 240 case B_LD_PRED: { |
252 unsigned char *ptr = Above; | 241 uint8_t *ptr = above; |
| 242 |
253 predictor[0 * 16 + 0] = (ptr[0] + ptr[1] * 2 + ptr[2] + 2) >> 2; | 243 predictor[0 * 16 + 0] = (ptr[0] + ptr[1] * 2 + ptr[2] + 2) >> 2; |
254 predictor[0 * 16 + 1] = | 244 predictor[0 * 16 + 1] = |
255 predictor[1 * 16 + 0] = (ptr[1] + ptr[2] * 2 + ptr[3] + 2) >> 2; | 245 predictor[1 * 16 + 0] = (ptr[1] + ptr[2] * 2 + ptr[3] + 2) >> 2; |
256 predictor[0 * 16 + 2] = | 246 predictor[0 * 16 + 2] = |
257 predictor[1 * 16 + 1] = | 247 predictor[1 * 16 + 1] = |
258 predictor[2 * 16 + 0] = (ptr[2] + ptr[3] * 2 + ptr[4] + 2) >> 2; | 248 predictor[2 * 16 + 0] = (ptr[2] + ptr[3] * 2 + ptr[4] + 2) >> 2; |
259 predictor[0 * 16 + 3] = | 249 predictor[0 * 16 + 3] = |
260 predictor[1 * 16 + 2] = | 250 predictor[1 * 16 + 2] = |
261 predictor[2 * 16 + 1] = | 251 predictor[2 * 16 + 1] = |
262 predictor[3 * 16 + 0] = (ptr[3] + ptr[4] * 2 + ptr[5] + 2) >> 2; | 252 predictor[3 * 16 + 0] = (ptr[3] + ptr[4] * 2 + ptr[5] + 2) >> 2; |
263 predictor[1 * 16 + 3] = | 253 predictor[1 * 16 + 3] = |
264 predictor[2 * 16 + 2] = | 254 predictor[2 * 16 + 2] = |
265 predictor[3 * 16 + 1] = (ptr[4] + ptr[5] * 2 + ptr[6] + 2) >> 2; | 255 predictor[3 * 16 + 1] = (ptr[4] + ptr[5] * 2 + ptr[6] + 2) >> 2; |
266 predictor[2 * 16 + 3] = | 256 predictor[2 * 16 + 3] = |
267 predictor[3 * 16 + 2] = (ptr[5] + ptr[6] * 2 + ptr[7] + 2) >> 2; | 257 predictor[3 * 16 + 2] = (ptr[5] + ptr[6] * 2 + ptr[7] + 2) >> 2; |
268 predictor[3 * 16 + 3] = (ptr[6] + ptr[7] * 2 + ptr[7] + 2) >> 2; | 258 predictor[3 * 16 + 3] = (ptr[6] + ptr[7] * 2 + ptr[7] + 2) >> 2; |
269 | 259 |
270 } | 260 } |
271 break; | 261 break; |
272 case B_RD_PRED: { | 262 case B_RD_PRED: { |
| 263 uint8_t pp[9]; |
273 | 264 |
274 unsigned char pp[9]; | 265 pp[0] = left[3]; |
275 | 266 pp[1] = left[2]; |
276 pp[0] = Left[3]; | 267 pp[2] = left[1]; |
277 pp[1] = Left[2]; | 268 pp[3] = left[0]; |
278 pp[2] = Left[1]; | |
279 pp[3] = Left[0]; | |
280 pp[4] = top_left; | 269 pp[4] = top_left; |
281 pp[5] = Above[0]; | 270 pp[5] = above[0]; |
282 pp[6] = Above[1]; | 271 pp[6] = above[1]; |
283 pp[7] = Above[2]; | 272 pp[7] = above[2]; |
284 pp[8] = Above[3]; | 273 pp[8] = above[3]; |
285 | 274 |
286 predictor[3 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2; | 275 predictor[3 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2; |
287 predictor[3 * 16 + 1] = | 276 predictor[3 * 16 + 1] = |
288 predictor[2 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2; | 277 predictor[2 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2; |
289 predictor[3 * 16 + 2] = | 278 predictor[3 * 16 + 2] = |
290 predictor[2 * 16 + 1] = | 279 predictor[2 * 16 + 1] = |
291 predictor[1 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2; | 280 predictor[1 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2; |
292 predictor[3 * 16 + 3] = | 281 predictor[3 * 16 + 3] = |
293 predictor[2 * 16 + 2] = | 282 predictor[2 * 16 + 2] = |
294 predictor[1 * 16 + 1] = | 283 predictor[1 * 16 + 1] = |
295 predictor[0 * 16 + 0] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2; | 284 predictor[0 * 16 + 0] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2; |
296 predictor[2 * 16 + 3] = | 285 predictor[2 * 16 + 3] = |
297 predictor[1 * 16 + 2] = | 286 predictor[1 * 16 + 2] = |
298 predictor[0 * 16 + 1] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2; | 287 predictor[0 * 16 + 1] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2; |
299 predictor[1 * 16 + 3] = | 288 predictor[1 * 16 + 3] = |
300 predictor[0 * 16 + 2] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2; | 289 predictor[0 * 16 + 2] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2; |
301 predictor[0 * 16 + 3] = (pp[6] + pp[7] * 2 + pp[8] + 2) >> 2; | 290 predictor[0 * 16 + 3] = (pp[6] + pp[7] * 2 + pp[8] + 2) >> 2; |
302 | 291 |
303 } | 292 } |
304 break; | 293 break; |
305 case B_VR_PRED: { | 294 case B_VR_PRED: { |
| 295 uint8_t pp[9]; |
306 | 296 |
307 unsigned char pp[9]; | 297 pp[0] = left[3]; |
308 | 298 pp[1] = left[2]; |
309 pp[0] = Left[3]; | 299 pp[2] = left[1]; |
310 pp[1] = Left[2]; | 300 pp[3] = left[0]; |
311 pp[2] = Left[1]; | |
312 pp[3] = Left[0]; | |
313 pp[4] = top_left; | 301 pp[4] = top_left; |
314 pp[5] = Above[0]; | 302 pp[5] = above[0]; |
315 pp[6] = Above[1]; | 303 pp[6] = above[1]; |
316 pp[7] = Above[2]; | 304 pp[7] = above[2]; |
317 pp[8] = Above[3]; | 305 pp[8] = above[3]; |
318 | |
319 | 306 |
320 predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2; | 307 predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2; |
321 predictor[2 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2; | 308 predictor[2 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2; |
322 predictor[3 * 16 + 1] = | 309 predictor[3 * 16 + 1] = |
323 predictor[1 * 16 + 0] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2; | 310 predictor[1 * 16 + 0] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2; |
324 predictor[2 * 16 + 1] = | 311 predictor[2 * 16 + 1] = |
325 predictor[0 * 16 + 0] = (pp[4] + pp[5] + 1) >> 1; | 312 predictor[0 * 16 + 0] = (pp[4] + pp[5] + 1) >> 1; |
326 predictor[3 * 16 + 2] = | 313 predictor[3 * 16 + 2] = |
327 predictor[1 * 16 + 1] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2; | 314 predictor[1 * 16 + 1] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2; |
328 predictor[2 * 16 + 2] = | 315 predictor[2 * 16 + 2] = |
329 predictor[0 * 16 + 1] = (pp[5] + pp[6] + 1) >> 1; | 316 predictor[0 * 16 + 1] = (pp[5] + pp[6] + 1) >> 1; |
330 predictor[3 * 16 + 3] = | 317 predictor[3 * 16 + 3] = |
331 predictor[1 * 16 + 2] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2; | 318 predictor[1 * 16 + 2] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2; |
332 predictor[2 * 16 + 3] = | 319 predictor[2 * 16 + 3] = |
333 predictor[0 * 16 + 2] = (pp[6] + pp[7] + 1) >> 1; | 320 predictor[0 * 16 + 2] = (pp[6] + pp[7] + 1) >> 1; |
334 predictor[1 * 16 + 3] = (pp[6] + pp[7] * 2 + pp[8] + 2) >> 2; | 321 predictor[1 * 16 + 3] = (pp[6] + pp[7] * 2 + pp[8] + 2) >> 2; |
335 predictor[0 * 16 + 3] = (pp[7] + pp[8] + 1) >> 1; | 322 predictor[0 * 16 + 3] = (pp[7] + pp[8] + 1) >> 1; |
336 | 323 |
337 } | 324 } |
338 break; | 325 break; |
339 case B_VL_PRED: { | 326 case B_VL_PRED: { |
340 | 327 uint8_t *pp = above; |
341 unsigned char *pp = Above; | |
342 | 328 |
343 predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1; | 329 predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1; |
344 predictor[1 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2; | 330 predictor[1 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2; |
345 predictor[2 * 16 + 0] = | 331 predictor[2 * 16 + 0] = |
346 predictor[0 * 16 + 1] = (pp[1] + pp[2] + 1) >> 1; | 332 predictor[0 * 16 + 1] = (pp[1] + pp[2] + 1) >> 1; |
347 predictor[1 * 16 + 1] = | 333 predictor[1 * 16 + 1] = |
348 predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2; | 334 predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2; |
349 predictor[2 * 16 + 1] = | 335 predictor[2 * 16 + 1] = |
350 predictor[0 * 16 + 2] = (pp[2] + pp[3] + 1) >> 1; | 336 predictor[0 * 16 + 2] = (pp[2] + pp[3] + 1) >> 1; |
351 predictor[3 * 16 + 1] = | 337 predictor[3 * 16 + 1] = |
352 predictor[1 * 16 + 2] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2; | 338 predictor[1 * 16 + 2] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2; |
353 predictor[0 * 16 + 3] = | 339 predictor[0 * 16 + 3] = |
354 predictor[2 * 16 + 2] = (pp[3] + pp[4] + 1) >> 1; | 340 predictor[2 * 16 + 2] = (pp[3] + pp[4] + 1) >> 1; |
355 predictor[1 * 16 + 3] = | 341 predictor[1 * 16 + 3] = |
356 predictor[3 * 16 + 2] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2; | 342 predictor[3 * 16 + 2] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2; |
357 predictor[2 * 16 + 3] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2; | 343 predictor[2 * 16 + 3] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2; |
358 predictor[3 * 16 + 3] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2; | 344 predictor[3 * 16 + 3] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2; |
359 } | 345 } |
360 break; | 346 break; |
361 | 347 |
362 case B_HD_PRED: { | 348 case B_HD_PRED: { |
363 unsigned char pp[9]; | 349 uint8_t pp[9]; |
364 pp[0] = Left[3]; | 350 |
365 pp[1] = Left[2]; | 351 pp[0] = left[3]; |
366 pp[2] = Left[1]; | 352 pp[1] = left[2]; |
367 pp[3] = Left[0]; | 353 pp[2] = left[1]; |
| 354 pp[3] = left[0]; |
368 pp[4] = top_left; | 355 pp[4] = top_left; |
369 pp[5] = Above[0]; | 356 pp[5] = above[0]; |
370 pp[6] = Above[1]; | 357 pp[6] = above[1]; |
371 pp[7] = Above[2]; | 358 pp[7] = above[2]; |
372 pp[8] = Above[3]; | 359 pp[8] = above[3]; |
373 | 360 |
374 | 361 |
375 predictor[3 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1; | 362 predictor[3 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1; |
376 predictor[3 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2; | 363 predictor[3 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2; |
377 predictor[2 * 16 + 0] = | 364 predictor[2 * 16 + 0] = |
378 predictor[3 * 16 + 2] = (pp[1] + pp[2] + 1) >> 1; | 365 predictor[3 * 16 + 2] = (pp[1] + pp[2] + 1) >> 1; |
379 predictor[2 * 16 + 1] = | 366 predictor[2 * 16 + 1] = |
380 predictor[3 * 16 + 3] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2; | 367 predictor[3 * 16 + 3] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2; |
381 predictor[2 * 16 + 2] = | 368 predictor[2 * 16 + 2] = |
382 predictor[1 * 16 + 0] = (pp[2] + pp[3] + 1) >> 1; | 369 predictor[1 * 16 + 0] = (pp[2] + pp[3] + 1) >> 1; |
383 predictor[2 * 16 + 3] = | 370 predictor[2 * 16 + 3] = |
384 predictor[1 * 16 + 1] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2; | 371 predictor[1 * 16 + 1] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2; |
385 predictor[1 * 16 + 2] = | 372 predictor[1 * 16 + 2] = |
386 predictor[0 * 16 + 0] = (pp[3] + pp[4] + 1) >> 1; | 373 predictor[0 * 16 + 0] = (pp[3] + pp[4] + 1) >> 1; |
387 predictor[1 * 16 + 3] = | 374 predictor[1 * 16 + 3] = |
388 predictor[0 * 16 + 1] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2; | 375 predictor[0 * 16 + 1] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2; |
389 predictor[0 * 16 + 2] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2; | 376 predictor[0 * 16 + 2] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2; |
390 predictor[0 * 16 + 3] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2; | 377 predictor[0 * 16 + 3] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2; |
391 } | 378 } |
392 break; | 379 break; |
393 | 380 |
394 | 381 |
395 case B_HU_PRED: { | 382 case B_HU_PRED: { |
396 unsigned char *pp = Left; | 383 uint8_t *pp = left; |
397 predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1; | 384 predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1; |
398 predictor[0 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2; | 385 predictor[0 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2; |
399 predictor[0 * 16 + 2] = | 386 predictor[0 * 16 + 2] = |
400 predictor[1 * 16 + 0] = (pp[1] + pp[2] + 1) >> 1; | 387 predictor[1 * 16 + 0] = (pp[1] + pp[2] + 1) >> 1; |
401 predictor[0 * 16 + 3] = | 388 predictor[0 * 16 + 3] = |
402 predictor[1 * 16 + 1] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2; | 389 predictor[1 * 16 + 1] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2; |
403 predictor[1 * 16 + 2] = | 390 predictor[1 * 16 + 2] = |
404 predictor[2 * 16 + 0] = (pp[2] + pp[3] + 1) >> 1; | 391 predictor[2 * 16 + 0] = (pp[2] + pp[3] + 1) >> 1; |
405 predictor[1 * 16 + 3] = | 392 predictor[1 * 16 + 3] = |
406 predictor[2 * 16 + 1] = (pp[2] + pp[3] * 2 + pp[3] + 2) >> 2; | 393 predictor[2 * 16 + 1] = (pp[2] + pp[3] * 2 + pp[3] + 2) >> 2; |
407 predictor[2 * 16 + 2] = | 394 predictor[2 * 16 + 2] = |
408 predictor[2 * 16 + 3] = | 395 predictor[2 * 16 + 3] = |
409 predictor[3 * 16 + 0] = | 396 predictor[3 * 16 + 0] = |
410 predictor[3 * 16 + 1] = | 397 predictor[3 * 16 + 1] = |
411 predictor[3 * 16 + 2] = | 398 predictor[3 * 16 + 2] = |
412 predictor[3 * 16 + 3] = pp[3]; | 399 predictor[3 * 16 + 3] = pp[3]; |
413 } | 400 } |
414 break; | 401 break; |
415 | 402 |
416 #if CONFIG_NEWBINTRAMODES | 403 #if CONFIG_NEWBINTRAMODES |
417 case B_CONTEXT_PRED: | 404 case B_CONTEXT_PRED: |
418 break; | 405 break; |
419 /* | 406 /* |
420 case B_CORNER_PRED: | 407 case B_CORNER_PRED: |
421 corner_predictor(predictor, 16, 4, Above, Left); | 408 corner_predictor(predictor, 16, 4, above, left); |
422 break; | 409 break; |
423 */ | 410 */ |
424 #endif | 411 #endif |
425 } | 412 } |
426 } | 413 } |
427 | 414 |
428 #if CONFIG_COMP_INTRA_PRED | |
429 void vp9_comp_intra4x4_predict_c(BLOCKD *x, | |
430 int b_mode, int b_mode2, | |
431 unsigned char *out_predictor) { | |
432 unsigned char predictor[2][4 * 16]; | |
433 int i, j; | |
434 | |
435 vp9_intra4x4_predict(x, b_mode, predictor[0]); | |
436 vp9_intra4x4_predict(x, b_mode2, predictor[1]); | |
437 | |
438 for (i = 0; i < 16 * 4; i += 16) { | |
439 for (j = i; j < i + 4; j++) { | |
440 out_predictor[j] = (predictor[0][j] + predictor[1][j] + 1) >> 1; | |
441 } | |
442 } | |
443 } | |
444 #endif | |
445 | |
446 /* copy 4 bytes from the above right down so that the 4x4 prediction modes using
pixels above and | 415 /* copy 4 bytes from the above right down so that the 4x4 prediction modes using
pixels above and |
447 * to the right prediction have filled in pixels to use. | 416 * to the right prediction have filled in pixels to use. |
448 */ | 417 */ |
449 void vp9_intra_prediction_down_copy(MACROBLOCKD *xd) { | 418 void vp9_intra_prediction_down_copy(MACROBLOCKD *xd) { |
450 int extend_edge = (xd->mb_to_right_edge == 0 && xd->mb_index < 2); | 419 int extend_edge = xd->mb_to_right_edge == 0 && xd->mb_index < 2; |
451 unsigned char *above_right = *(xd->block[0].base_dst) + xd->block[0].dst - | 420 uint8_t *above_right = *(xd->block[0].base_dst) + xd->block[0].dst - |
452 xd->block[0].dst_stride + 16; | 421 xd->block[0].dst_stride + 16; |
453 unsigned int *src_ptr = (unsigned int *) | 422 uint32_t *dst_ptr0 = (uint32_t *)above_right; |
454 (above_right - (xd->mb_index == 3 ? 16 * xd->block[0].dst_stride : 0)); | 423 uint32_t *dst_ptr1 = |
| 424 (uint32_t *)(above_right + 4 * xd->block[0].dst_stride); |
| 425 uint32_t *dst_ptr2 = |
| 426 (uint32_t *)(above_right + 8 * xd->block[0].dst_stride); |
| 427 uint32_t *dst_ptr3 = |
| 428 (uint32_t *)(above_right + 12 * xd->block[0].dst_stride); |
455 | 429 |
456 unsigned int *dst_ptr0 = (unsigned int *)above_right; | 430 uint32_t *src_ptr = (uint32_t *) above_right; |
457 unsigned int *dst_ptr1 = | 431 |
458 (unsigned int *)(above_right + 4 * xd->block[0].dst_stride); | 432 if ((xd->sb_index >= 2 && xd->mb_to_right_edge == 0) || |
459 unsigned int *dst_ptr2 = | 433 (xd->sb_index == 3 && xd->mb_index & 1)) |
460 (unsigned int *)(above_right + 8 * xd->block[0].dst_stride); | 434 src_ptr = (uint32_t *) (((uint8_t *) src_ptr) - 32 * |
461 unsigned int *dst_ptr3 = | 435 xd->block[0].dst_stride); |
462 (unsigned int *)(above_right + 12 * xd->block[0].dst_stride); | 436 if (xd->mb_index == 3 || |
| 437 (xd->mb_to_right_edge == 0 && xd->mb_index == 2)) |
| 438 src_ptr = (uint32_t *) (((uint8_t *) src_ptr) - 16 * |
| 439 xd->block[0].dst_stride); |
463 | 440 |
464 if (extend_edge) { | 441 if (extend_edge) { |
465 *src_ptr = ((uint8_t *) src_ptr)[-1] * 0x01010101U; | 442 *src_ptr = ((uint8_t *) src_ptr)[-1] * 0x01010101U; |
466 } | 443 } |
467 | 444 |
468 *dst_ptr0 = *src_ptr; | 445 *dst_ptr0 = *src_ptr; |
469 *dst_ptr1 = *src_ptr; | 446 *dst_ptr1 = *src_ptr; |
470 *dst_ptr2 = *src_ptr; | 447 *dst_ptr2 = *src_ptr; |
471 *dst_ptr3 = *src_ptr; | 448 *dst_ptr3 = *src_ptr; |
472 } | 449 } |
OLD | NEW |