Line data Source code
1 : /*
2 : * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
3 : * Copyright (c) 2003-2011 Michael Niedermayer <michaelni@gmx.at>
4 : *
5 : * This file is part of FFmpeg.
6 : *
7 : * FFmpeg is free software; you can redistribute it and/or
8 : * modify it under the terms of the GNU Lesser General Public
9 : * License as published by the Free Software Foundation; either
10 : * version 2.1 of the License, or (at your option) any later version.
11 : *
12 : * FFmpeg is distributed in the hope that it will be useful,
13 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : * Lesser General Public License for more details.
16 : *
17 : * You should have received a copy of the GNU Lesser General Public
18 : * License along with FFmpeg; if not, write to the Free Software
19 : * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 : */
21 :
22 : /**
23 : * @file
24 : * H.264 / AVC / MPEG-4 part10 prediction functions.
25 : * @author Michael Niedermayer <michaelni@gmx.at>
26 : */
27 :
28 : #include "libavutil/intreadwrite.h"
29 :
30 : #include "mathops.h"
31 :
32 : #include "bit_depth_template.c"
33 :
34 4073824 : static void FUNCC(pred4x4_vertical)(uint8_t *_src, const uint8_t *topright,
35 : ptrdiff_t _stride)
36 : {
37 4073824 : pixel *src = (pixel*)_src;
38 4073824 : int stride = _stride>>(sizeof(pixel)-1);
39 4073824 : const pixel4 a= AV_RN4PA(src-stride);
40 :
41 4073824 : AV_WN4PA(src+0*stride, a);
42 4073824 : AV_WN4PA(src+1*stride, a);
43 4073824 : AV_WN4PA(src+2*stride, a);
44 4073824 : AV_WN4PA(src+3*stride, a);
45 4073824 : }
46 :
47 6663688 : static void FUNCC(pred4x4_horizontal)(uint8_t *_src, const uint8_t *topright,
48 : ptrdiff_t _stride)
49 : {
50 6663688 : pixel *src = (pixel*)_src;
51 6663688 : int stride = _stride>>(sizeof(pixel)-1);
52 6663688 : AV_WN4PA(src+0*stride, PIXEL_SPLAT_X4(src[-1+0*stride]));
53 6663688 : AV_WN4PA(src+1*stride, PIXEL_SPLAT_X4(src[-1+1*stride]));
54 6663688 : AV_WN4PA(src+2*stride, PIXEL_SPLAT_X4(src[-1+2*stride]));
55 6663688 : AV_WN4PA(src+3*stride, PIXEL_SPLAT_X4(src[-1+3*stride]));
56 6663688 : }
57 :
58 2937634 : static void FUNCC(pred4x4_dc)(uint8_t *_src, const uint8_t *topright,
59 : ptrdiff_t _stride)
60 : {
61 2937634 : pixel *src = (pixel*)_src;
62 2937634 : int stride = _stride>>(sizeof(pixel)-1);
63 5875268 : const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride]
64 2937634 : + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3;
65 2937634 : const pixel4 a = PIXEL_SPLAT_X4(dc);
66 :
67 2937634 : AV_WN4PA(src+0*stride, a);
68 2937634 : AV_WN4PA(src+1*stride, a);
69 2937634 : AV_WN4PA(src+2*stride, a);
70 2937634 : AV_WN4PA(src+3*stride, a);
71 2937634 : }
72 :
73 283839 : static void FUNCC(pred4x4_left_dc)(uint8_t *_src, const uint8_t *topright,
74 : ptrdiff_t _stride)
75 : {
76 283839 : pixel *src = (pixel*)_src;
77 283839 : int stride = _stride>>(sizeof(pixel)-1);
78 283839 : const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2;
79 283839 : const pixel4 a = PIXEL_SPLAT_X4(dc);
80 :
81 283839 : AV_WN4PA(src+0*stride, a);
82 283839 : AV_WN4PA(src+1*stride, a);
83 283839 : AV_WN4PA(src+2*stride, a);
84 283839 : AV_WN4PA(src+3*stride, a);
85 283839 : }
86 :
87 51212 : static void FUNCC(pred4x4_top_dc)(uint8_t *_src, const uint8_t *topright,
88 : ptrdiff_t _stride)
89 : {
90 51212 : pixel *src = (pixel*)_src;
91 51212 : int stride = _stride>>(sizeof(pixel)-1);
92 51212 : const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2;
93 51212 : const pixel4 a = PIXEL_SPLAT_X4(dc);
94 :
95 51212 : AV_WN4PA(src+0*stride, a);
96 51212 : AV_WN4PA(src+1*stride, a);
97 51212 : AV_WN4PA(src+2*stride, a);
98 51212 : AV_WN4PA(src+3*stride, a);
99 51212 : }
100 :
101 7236 : static void FUNCC(pred4x4_128_dc)(uint8_t *_src, const uint8_t *topright,
102 : ptrdiff_t _stride)
103 : {
104 7236 : pixel *src = (pixel*)_src;
105 7236 : int stride = _stride>>(sizeof(pixel)-1);
106 7236 : const pixel4 a = PIXEL_SPLAT_X4(1<<(BIT_DEPTH-1));
107 :
108 7236 : AV_WN4PA(src+0*stride, a);
109 7236 : AV_WN4PA(src+1*stride, a);
110 7236 : AV_WN4PA(src+2*stride, a);
111 7236 : AV_WN4PA(src+3*stride, a);
112 7236 : }
113 :
114 26 : static void FUNCC(pred4x4_127_dc)(uint8_t *_src, const uint8_t *topright,
115 : ptrdiff_t _stride)
116 : {
117 26 : pixel *src = (pixel*)_src;
118 26 : int stride = _stride>>(sizeof(pixel)-1);
119 26 : const pixel4 a = PIXEL_SPLAT_X4((1<<(BIT_DEPTH-1))-1);
120 :
121 26 : AV_WN4PA(src+0*stride, a);
122 26 : AV_WN4PA(src+1*stride, a);
123 26 : AV_WN4PA(src+2*stride, a);
124 26 : AV_WN4PA(src+3*stride, a);
125 26 : }
126 :
127 47 : static void FUNCC(pred4x4_129_dc)(uint8_t *_src, const uint8_t *topright,
128 : ptrdiff_t _stride)
129 : {
130 47 : pixel *src = (pixel*)_src;
131 47 : int stride = _stride>>(sizeof(pixel)-1);
132 47 : const pixel4 a = PIXEL_SPLAT_X4((1<<(BIT_DEPTH-1))+1);
133 :
134 47 : AV_WN4PA(src+0*stride, a);
135 47 : AV_WN4PA(src+1*stride, a);
136 47 : AV_WN4PA(src+2*stride, a);
137 47 : AV_WN4PA(src+3*stride, a);
138 47 : }
139 :
140 :
141 : #define LOAD_TOP_RIGHT_EDGE\
142 : const unsigned av_unused t4 = topright[0];\
143 : const unsigned av_unused t5 = topright[1];\
144 : const unsigned av_unused t6 = topright[2];\
145 : const unsigned av_unused t7 = topright[3];\
146 :
147 : #define LOAD_DOWN_LEFT_EDGE\
148 : const unsigned av_unused l4 = src[-1+4*stride];\
149 : const unsigned av_unused l5 = src[-1+5*stride];\
150 : const unsigned av_unused l6 = src[-1+6*stride];\
151 : const unsigned av_unused l7 = src[-1+7*stride];\
152 :
153 : #define LOAD_LEFT_EDGE\
154 : const unsigned av_unused l0 = src[-1+0*stride];\
155 : const unsigned av_unused l1 = src[-1+1*stride];\
156 : const unsigned av_unused l2 = src[-1+2*stride];\
157 : const unsigned av_unused l3 = src[-1+3*stride];\
158 :
159 : #define LOAD_TOP_EDGE\
160 : const unsigned av_unused t0 = src[ 0-1*stride];\
161 : const unsigned av_unused t1 = src[ 1-1*stride];\
162 : const unsigned av_unused t2 = src[ 2-1*stride];\
163 : const unsigned av_unused t3 = src[ 3-1*stride];\
164 :
165 1880343 : static void FUNCC(pred4x4_down_right)(uint8_t *_src, const uint8_t *topright,
166 : ptrdiff_t _stride)
167 : {
168 1880343 : pixel *src = (pixel*)_src;
169 1880343 : int stride = _stride>>(sizeof(pixel)-1);
170 1880343 : const int lt= src[-1-1*stride];
171 1880343 : LOAD_TOP_EDGE
172 1880343 : LOAD_LEFT_EDGE
173 :
174 1880343 : src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2;
175 3760686 : src[0+2*stride]=
176 3760686 : src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2;
177 3760686 : src[0+1*stride]=
178 5641029 : src[1+2*stride]=
179 3760686 : src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2;
180 1880343 : src[0+0*stride]=
181 3760686 : src[1+1*stride]=
182 5641029 : src[2+2*stride]=
183 3760686 : src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
184 3760686 : src[1+0*stride]=
185 5641029 : src[2+1*stride]=
186 3760686 : src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2;
187 3760686 : src[2+0*stride]=
188 3760686 : src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
189 1880343 : src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2;
190 1880343 : }
191 :
192 1119609 : static void FUNCC(pred4x4_down_left)(uint8_t *_src, const uint8_t *_topright,
193 : ptrdiff_t _stride)
194 : {
195 1119609 : pixel *src = (pixel*)_src;
196 1119609 : const pixel *topright = (const pixel*)_topright;
197 1119609 : int stride = _stride>>(sizeof(pixel)-1);
198 1119609 : LOAD_TOP_EDGE
199 1119609 : LOAD_TOP_RIGHT_EDGE
200 : // LOAD_LEFT_EDGE
201 :
202 1119609 : src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2;
203 2239218 : src[1+0*stride]=
204 2239218 : src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2;
205 2239218 : src[2+0*stride]=
206 3358827 : src[1+1*stride]=
207 2239218 : src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2;
208 2239218 : src[3+0*stride]=
209 3358827 : src[2+1*stride]=
210 3358827 : src[1+2*stride]=
211 2239218 : src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2;
212 2239218 : src[3+1*stride]=
213 3358827 : src[2+2*stride]=
214 2239218 : src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2;
215 2239218 : src[3+2*stride]=
216 2239218 : src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2;
217 1119609 : src[3+3*stride]=(t6 + 3*t7 + 2)>>2;
218 1119609 : }
219 :
220 1288846 : static void FUNCC(pred4x4_vertical_right)(uint8_t *_src,
221 : const uint8_t *topright,
222 : ptrdiff_t _stride)
223 : {
224 1288846 : pixel *src = (pixel*)_src;
225 1288846 : int stride = _stride>>(sizeof(pixel)-1);
226 1288846 : const int lt= src[-1-1*stride];
227 1288846 : LOAD_TOP_EDGE
228 1288846 : LOAD_LEFT_EDGE
229 :
230 1288846 : src[0+0*stride]=
231 1288846 : src[1+2*stride]=(lt + t0 + 1)>>1;
232 2577692 : src[1+0*stride]=
233 2577692 : src[2+2*stride]=(t0 + t1 + 1)>>1;
234 2577692 : src[2+0*stride]=
235 2577692 : src[3+2*stride]=(t1 + t2 + 1)>>1;
236 1288846 : src[3+0*stride]=(t2 + t3 + 1)>>1;
237 2577692 : src[0+1*stride]=
238 2577692 : src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
239 2577692 : src[1+1*stride]=
240 2577692 : src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2;
241 2577692 : src[2+1*stride]=
242 2577692 : src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2;
243 1288846 : src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2;
244 1288846 : src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
245 1288846 : src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
246 1288846 : }
247 :
248 1060234 : static void FUNCC(pred4x4_vertical_left)(uint8_t *_src,
249 : const uint8_t *_topright,
250 : ptrdiff_t _stride)
251 : {
252 1060234 : pixel *src = (pixel*)_src;
253 1060234 : const pixel *topright = (const pixel*)_topright;
254 1060234 : int stride = _stride>>(sizeof(pixel)-1);
255 1060234 : LOAD_TOP_EDGE
256 1060234 : LOAD_TOP_RIGHT_EDGE
257 :
258 1060234 : src[0+0*stride]=(t0 + t1 + 1)>>1;
259 2120468 : src[1+0*stride]=
260 2120468 : src[0+2*stride]=(t1 + t2 + 1)>>1;
261 2120468 : src[2+0*stride]=
262 2120468 : src[1+2*stride]=(t2 + t3 + 1)>>1;
263 2120468 : src[3+0*stride]=
264 2120468 : src[2+2*stride]=(t3 + t4+ 1)>>1;
265 1060234 : src[3+2*stride]=(t4 + t5+ 1)>>1;
266 1060234 : src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
267 2120468 : src[1+1*stride]=
268 2120468 : src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2;
269 2120468 : src[2+1*stride]=
270 2120468 : src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2;
271 2120468 : src[3+1*stride]=
272 2120468 : src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2;
273 1060234 : src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2;
274 1060234 : }
275 :
276 1982118 : static void FUNCC(pred4x4_horizontal_up)(uint8_t *_src, const uint8_t *topright,
277 : ptrdiff_t _stride)
278 : {
279 1982118 : pixel *src = (pixel*)_src;
280 1982118 : int stride = _stride>>(sizeof(pixel)-1);
281 1982118 : LOAD_LEFT_EDGE
282 :
283 1982118 : src[0+0*stride]=(l0 + l1 + 1)>>1;
284 1982118 : src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2;
285 3964236 : src[2+0*stride]=
286 3964236 : src[0+1*stride]=(l1 + l2 + 1)>>1;
287 3964236 : src[3+0*stride]=
288 3964236 : src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2;
289 3964236 : src[2+1*stride]=
290 3964236 : src[0+2*stride]=(l2 + l3 + 1)>>1;
291 3964236 : src[3+1*stride]=
292 3964236 : src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2;
293 3964236 : src[3+2*stride]=
294 5946354 : src[1+3*stride]=
295 5946354 : src[0+3*stride]=
296 5946354 : src[2+2*stride]=
297 5946354 : src[2+3*stride]=
298 3964236 : src[3+3*stride]=l3;
299 1982118 : }
300 :
301 2138269 : static void FUNCC(pred4x4_horizontal_down)(uint8_t *_src,
302 : const uint8_t *topright,
303 : ptrdiff_t _stride)
304 : {
305 2138269 : pixel *src = (pixel*)_src;
306 2138269 : int stride = _stride>>(sizeof(pixel)-1);
307 2138269 : const int lt= src[-1-1*stride];
308 2138269 : LOAD_TOP_EDGE
309 2138269 : LOAD_LEFT_EDGE
310 :
311 2138269 : src[0+0*stride]=
312 2138269 : src[2+1*stride]=(lt + l0 + 1)>>1;
313 4276538 : src[1+0*stride]=
314 4276538 : src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2;
315 2138269 : src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2;
316 2138269 : src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2;
317 4276538 : src[0+1*stride]=
318 4276538 : src[2+2*stride]=(l0 + l1 + 1)>>1;
319 4276538 : src[1+1*stride]=
320 4276538 : src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
321 4276538 : src[0+2*stride]=
322 4276538 : src[2+3*stride]=(l1 + l2+ 1)>>1;
323 4276538 : src[1+2*stride]=
324 4276538 : src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
325 2138269 : src[0+3*stride]=(l2 + l3 + 1)>>1;
326 2138269 : src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2;
327 2138269 : }
328 :
329 217123 : static void FUNCC(pred16x16_vertical)(uint8_t *_src, ptrdiff_t _stride)
330 : {
331 : int i;
332 217123 : pixel *src = (pixel*)_src;
333 217123 : int stride = _stride>>(sizeof(pixel)-1);
334 217123 : const pixel4 a = AV_RN4PA(((pixel4*)(src-stride))+0);
335 217123 : const pixel4 b = AV_RN4PA(((pixel4*)(src-stride))+1);
336 217123 : const pixel4 c = AV_RN4PA(((pixel4*)(src-stride))+2);
337 217123 : const pixel4 d = AV_RN4PA(((pixel4*)(src-stride))+3);
338 :
339 3691091 : for(i=0; i<16; i++){
340 3473968 : AV_WN4PA(((pixel4*)(src+i*stride))+0, a);
341 3473968 : AV_WN4PA(((pixel4*)(src+i*stride))+1, b);
342 3473968 : AV_WN4PA(((pixel4*)(src+i*stride))+2, c);
343 3473968 : AV_WN4PA(((pixel4*)(src+i*stride))+3, d);
344 : }
345 217123 : }
346 :
347 241707 : static void FUNCC(pred16x16_horizontal)(uint8_t *_src, ptrdiff_t stride)
348 : {
349 : int i;
350 241707 : pixel *src = (pixel*)_src;
351 241707 : stride >>= sizeof(pixel)-1;
352 :
353 4109019 : for(i=0; i<16; i++){
354 3867312 : const pixel4 a = PIXEL_SPLAT_X4(src[-1+i*stride]);
355 :
356 3867312 : AV_WN4PA(((pixel4*)(src+i*stride))+0, a);
357 3867312 : AV_WN4PA(((pixel4*)(src+i*stride))+1, a);
358 3867312 : AV_WN4PA(((pixel4*)(src+i*stride))+2, a);
359 3867312 : AV_WN4PA(((pixel4*)(src+i*stride))+3, a);
360 : }
361 241707 : }
362 :
363 : #define PREDICT_16x16_DC(v)\
364 : for(i=0; i<16; i++){\
365 : AV_WN4PA(src+ 0, v);\
366 : AV_WN4PA(src+ 4, v);\
367 : AV_WN4PA(src+ 8, v);\
368 : AV_WN4PA(src+12, v);\
369 : src += stride;\
370 : }
371 :
372 247589 : static void FUNCC(pred16x16_dc)(uint8_t *_src, ptrdiff_t stride)
373 : {
374 247589 : int i, dc=0;
375 247589 : pixel *src = (pixel*)_src;
376 : pixel4 dcsplat;
377 247589 : stride >>= sizeof(pixel)-1;
378 :
379 4209013 : for(i=0;i<16; i++){
380 3961424 : dc+= src[-1+i*stride];
381 : }
382 :
383 4209013 : for(i=0;i<16; i++){
384 3961424 : dc+= src[i-stride];
385 : }
386 :
387 247589 : dcsplat = PIXEL_SPLAT_X4((dc+16)>>5);
388 247589 : PREDICT_16x16_DC(dcsplat);
389 247589 : }
390 :
391 33234 : static void FUNCC(pred16x16_left_dc)(uint8_t *_src, ptrdiff_t stride)
392 : {
393 33234 : int i, dc=0;
394 33234 : pixel *src = (pixel*)_src;
395 : pixel4 dcsplat;
396 33234 : stride >>= sizeof(pixel)-1;
397 :
398 564978 : for(i=0;i<16; i++){
399 531744 : dc+= src[-1+i*stride];
400 : }
401 :
402 33234 : dcsplat = PIXEL_SPLAT_X4((dc+8)>>4);
403 33234 : PREDICT_16x16_DC(dcsplat);
404 33234 : }
405 :
406 5589 : static void FUNCC(pred16x16_top_dc)(uint8_t *_src, ptrdiff_t stride)
407 : {
408 5589 : int i, dc=0;
409 5589 : pixel *src = (pixel*)_src;
410 : pixel4 dcsplat;
411 5589 : stride >>= sizeof(pixel)-1;
412 :
413 95013 : for(i=0;i<16; i++){
414 89424 : dc+= src[i-stride];
415 : }
416 :
417 5589 : dcsplat = PIXEL_SPLAT_X4((dc+8)>>4);
418 5589 : PREDICT_16x16_DC(dcsplat);
419 5589 : }
420 :
421 : #define PRED16x16_X(n, v) \
422 : static void FUNCC(pred16x16_##n##_dc)(uint8_t *_src, ptrdiff_t stride)\
423 : {\
424 : int i;\
425 : pixel *src = (pixel*)_src;\
426 : stride >>= sizeof(pixel)-1;\
427 : PREDICT_16x16_DC(PIXEL_SPLAT_X4(v));\
428 : }
429 :
430 12 : PRED16x16_X(127, (1<<(BIT_DEPTH-1))-1)
431 2018 : PRED16x16_X(128, (1<<(BIT_DEPTH-1))+0)
432 10 : PRED16x16_X(129, (1<<(BIT_DEPTH-1))+1)
433 :
434 150094 : static inline void FUNCC(pred16x16_plane_compat)(uint8_t *_src,
435 : ptrdiff_t _stride,
436 : const int svq3,
437 : const int rv40)
438 : {
439 : int i, j, k;
440 : int a;
441 : INIT_CLIP
442 150094 : pixel *src = (pixel*)_src;
443 150094 : int stride = _stride>>(sizeof(pixel)-1);
444 150094 : const pixel * const src0 = src +7-stride;
445 150094 : const pixel * src1 = src +8*stride-1;
446 150094 : const pixel * src2 = src1-2*stride; // == src+6*stride-1;
447 150094 : int H = src0[1] - src0[-1];
448 150094 : int V = src1[0] - src2[ 0];
449 1200752 : for(k=2; k<=8; ++k) {
450 1050658 : src1 += stride; src2 -= stride;
451 1050658 : H += k*(src0[k] - src0[-k]);
452 1050658 : V += k*(src1[0] - src2[ 0]);
453 : }
454 150094 : if(svq3){
455 56 : H = ( 5*(H/4) ) / 16;
456 56 : V = ( 5*(V/4) ) / 16;
457 :
458 : /* required for 100% accuracy */
459 56 : i = H; H = V; V = i;
460 150038 : }else if(rv40){
461 1216 : H = ( H + (H>>2) ) >> 4;
462 1216 : V = ( V + (V>>2) ) >> 4;
463 : }else{
464 148822 : H = ( 5*H+32 ) >> 6;
465 148822 : V = ( 5*V+32 ) >> 6;
466 : }
467 :
468 150094 : a = 16*(src1[0] + src2[16] + 1) - 7*(V+H);
469 2551598 : for(j=16; j>0; --j) {
470 2401504 : int b = a;
471 2401504 : a += V;
472 12007520 : for(i=-16; i<0; i+=4) {
473 9606016 : src[16+i] = CLIP((b ) >> 5);
474 9606016 : src[17+i] = CLIP((b+ H) >> 5);
475 9606016 : src[18+i] = CLIP((b+2*H) >> 5);
476 9606016 : src[19+i] = CLIP((b+3*H) >> 5);
477 9606016 : b += 4*H;
478 : }
479 2401504 : src += stride;
480 : }
481 150094 : }
482 :
483 148822 : static void FUNCC(pred16x16_plane)(uint8_t *src, ptrdiff_t stride)
484 : {
485 148822 : FUNCC(pred16x16_plane_compat)(src, stride, 0, 0);
486 148822 : }
487 :
488 700196 : static void FUNCC(pred8x8_vertical)(uint8_t *_src, ptrdiff_t _stride)
489 : {
490 : int i;
491 700196 : pixel *src = (pixel*)_src;
492 700196 : int stride = _stride>>(sizeof(pixel)-1);
493 700196 : const pixel4 a= AV_RN4PA(((pixel4*)(src-stride))+0);
494 700196 : const pixel4 b= AV_RN4PA(((pixel4*)(src-stride))+1);
495 :
496 6301764 : for(i=0; i<8; i++){
497 5601568 : AV_WN4PA(((pixel4*)(src+i*stride))+0, a);
498 5601568 : AV_WN4PA(((pixel4*)(src+i*stride))+1, b);
499 : }
500 700196 : }
501 :
502 161462 : static void FUNCC(pred8x16_vertical)(uint8_t *_src, ptrdiff_t _stride)
503 : {
504 : int i;
505 161462 : pixel *src = (pixel*)_src;
506 161462 : int stride = _stride>>(sizeof(pixel)-1);
507 161462 : const pixel4 a= AV_RN4PA(((pixel4*)(src-stride))+0);
508 161462 : const pixel4 b= AV_RN4PA(((pixel4*)(src-stride))+1);
509 :
510 2744854 : for(i=0; i<16; i++){
511 2583392 : AV_WN4PA(((pixel4*)(src+i*stride))+0, a);
512 2583392 : AV_WN4PA(((pixel4*)(src+i*stride))+1, b);
513 : }
514 161462 : }
515 :
516 1458712 : static void FUNCC(pred8x8_horizontal)(uint8_t *_src, ptrdiff_t stride)
517 : {
518 : int i;
519 1458712 : pixel *src = (pixel*)_src;
520 1458712 : stride >>= sizeof(pixel)-1;
521 :
522 13128408 : for(i=0; i<8; i++){
523 11669696 : const pixel4 a = PIXEL_SPLAT_X4(src[-1+i*stride]);
524 11669696 : AV_WN4PA(((pixel4*)(src+i*stride))+0, a);
525 11669696 : AV_WN4PA(((pixel4*)(src+i*stride))+1, a);
526 : }
527 1458712 : }
528 :
529 297988 : static void FUNCC(pred8x16_horizontal)(uint8_t *_src, ptrdiff_t stride)
530 : {
531 : int i;
532 297988 : pixel *src = (pixel*)_src;
533 297988 : stride >>= sizeof(pixel)-1;
534 5065796 : for(i=0; i<16; i++){
535 4767808 : const pixel4 a = PIXEL_SPLAT_X4(src[-1+i*stride]);
536 4767808 : AV_WN4PA(((pixel4*)(src+i*stride))+0, a);
537 4767808 : AV_WN4PA(((pixel4*)(src+i*stride))+1, a);
538 : }
539 297988 : }
540 :
541 : #define PRED8x8_X(n, v)\
542 : static void FUNCC(pred8x8_##n##_dc)(uint8_t *_src, ptrdiff_t stride)\
543 : {\
544 : int i;\
545 : const pixel4 a = PIXEL_SPLAT_X4(v);\
546 : pixel *src = (pixel*)_src;\
547 : stride >>= sizeof(pixel)-1;\
548 : for(i=0; i<8; i++){\
549 : AV_WN4PA(((pixel4*)(src+i*stride))+0, a);\
550 : AV_WN4PA(((pixel4*)(src+i*stride))+1, a);\
551 : }\
552 : }
553 :
554 114 : PRED8x8_X(127, (1<<(BIT_DEPTH-1))-1)
555 128586 : PRED8x8_X(128, (1<<(BIT_DEPTH-1))+0)
556 268 : PRED8x8_X(129, (1<<(BIT_DEPTH-1))+1)
557 :
558 1538 : static void FUNCC(pred8x16_128_dc)(uint8_t *_src, ptrdiff_t stride)
559 : {
560 1538 : FUNCC(pred8x8_128_dc)(_src, stride);
561 1538 : FUNCC(pred8x8_128_dc)(_src+8*stride, stride);
562 1538 : }
563 :
564 530170 : static void FUNCC(pred8x8_left_dc)(uint8_t *_src, ptrdiff_t stride)
565 : {
566 : int i;
567 : int dc0, dc2;
568 : pixel4 dc0splat, dc2splat;
569 530170 : pixel *src = (pixel*)_src;
570 530170 : stride >>= sizeof(pixel)-1;
571 :
572 530170 : dc0=dc2=0;
573 2650850 : for(i=0;i<4; i++){
574 2120680 : dc0+= src[-1+i*stride];
575 2120680 : dc2+= src[-1+(i+4)*stride];
576 : }
577 530170 : dc0splat = PIXEL_SPLAT_X4((dc0 + 2)>>2);
578 530170 : dc2splat = PIXEL_SPLAT_X4((dc2 + 2)>>2);
579 :
580 2650850 : for(i=0; i<4; i++){
581 2120680 : AV_WN4PA(((pixel4*)(src+i*stride))+0, dc0splat);
582 2120680 : AV_WN4PA(((pixel4*)(src+i*stride))+1, dc0splat);
583 : }
584 2650850 : for(i=4; i<8; i++){
585 2120680 : AV_WN4PA(((pixel4*)(src+i*stride))+0, dc2splat);
586 2120680 : AV_WN4PA(((pixel4*)(src+i*stride))+1, dc2splat);
587 : }
588 530170 : }
589 :
590 97770 : static void FUNCC(pred8x16_left_dc)(uint8_t *_src, ptrdiff_t stride)
591 : {
592 97770 : FUNCC(pred8x8_left_dc)(_src, stride);
593 97770 : FUNCC(pred8x8_left_dc)(_src+8*stride, stride);
594 97770 : }
595 :
596 81326 : static void FUNCC(pred8x8_top_dc)(uint8_t *_src, ptrdiff_t stride)
597 : {
598 : int i;
599 : int dc0, dc1;
600 : pixel4 dc0splat, dc1splat;
601 81326 : pixel *src = (pixel*)_src;
602 81326 : stride >>= sizeof(pixel)-1;
603 :
604 81326 : dc0=dc1=0;
605 406630 : for(i=0;i<4; i++){
606 325304 : dc0+= src[i-stride];
607 325304 : dc1+= src[4+i-stride];
608 : }
609 81326 : dc0splat = PIXEL_SPLAT_X4((dc0 + 2)>>2);
610 81326 : dc1splat = PIXEL_SPLAT_X4((dc1 + 2)>>2);
611 :
612 406630 : for(i=0; i<4; i++){
613 325304 : AV_WN4PA(((pixel4*)(src+i*stride))+0, dc0splat);
614 325304 : AV_WN4PA(((pixel4*)(src+i*stride))+1, dc1splat);
615 : }
616 406630 : for(i=4; i<8; i++){
617 325304 : AV_WN4PA(((pixel4*)(src+i*stride))+0, dc0splat);
618 325304 : AV_WN4PA(((pixel4*)(src+i*stride))+1, dc1splat);
619 : }
620 81326 : }
621 :
622 13308 : static void FUNCC(pred8x16_top_dc)(uint8_t *_src, ptrdiff_t stride)
623 : {
624 : int i;
625 : int dc0, dc1;
626 : pixel4 dc0splat, dc1splat;
627 13308 : pixel *src = (pixel*)_src;
628 13308 : stride >>= sizeof(pixel)-1;
629 :
630 13308 : dc0=dc1=0;
631 66540 : for(i=0;i<4; i++){
632 53232 : dc0+= src[i-stride];
633 53232 : dc1+= src[4+i-stride];
634 : }
635 13308 : dc0splat = PIXEL_SPLAT_X4((dc0 + 2)>>2);
636 13308 : dc1splat = PIXEL_SPLAT_X4((dc1 + 2)>>2);
637 :
638 226236 : for(i=0; i<16; i++){
639 212928 : AV_WN4PA(((pixel4*)(src+i*stride))+0, dc0splat);
640 212928 : AV_WN4PA(((pixel4*)(src+i*stride))+1, dc1splat);
641 : }
642 13308 : }
643 :
644 2709326 : static void FUNCC(pred8x8_dc)(uint8_t *_src, ptrdiff_t stride)
645 : {
646 : int i;
647 : int dc0, dc1, dc2;
648 : pixel4 dc0splat, dc1splat, dc2splat, dc3splat;
649 2709326 : pixel *src = (pixel*)_src;
650 2709326 : stride >>= sizeof(pixel)-1;
651 :
652 2709326 : dc0=dc1=dc2=0;
653 13546630 : for(i=0;i<4; i++){
654 10837304 : dc0+= src[-1+i*stride] + src[i-stride];
655 10837304 : dc1+= src[4+i-stride];
656 10837304 : dc2+= src[-1+(i+4)*stride];
657 : }
658 2709326 : dc0splat = PIXEL_SPLAT_X4((dc0 + 4)>>3);
659 2709326 : dc1splat = PIXEL_SPLAT_X4((dc1 + 2)>>2);
660 2709326 : dc2splat = PIXEL_SPLAT_X4((dc2 + 2)>>2);
661 2709326 : dc3splat = PIXEL_SPLAT_X4((dc1 + dc2 + 4)>>3);
662 :
663 13546630 : for(i=0; i<4; i++){
664 10837304 : AV_WN4PA(((pixel4*)(src+i*stride))+0, dc0splat);
665 10837304 : AV_WN4PA(((pixel4*)(src+i*stride))+1, dc1splat);
666 : }
667 13546630 : for(i=4; i<8; i++){
668 10837304 : AV_WN4PA(((pixel4*)(src+i*stride))+0, dc2splat);
669 10837304 : AV_WN4PA(((pixel4*)(src+i*stride))+1, dc3splat);
670 : }
671 2709326 : }
672 :
673 797286 : static void FUNCC(pred8x16_dc)(uint8_t *_src, ptrdiff_t stride)
674 : {
675 : int i;
676 : int dc0, dc1, dc2, dc3, dc4;
677 : pixel4 dc0splat, dc1splat, dc2splat, dc3splat, dc4splat, dc5splat, dc6splat, dc7splat;
678 797286 : pixel *src = (pixel*)_src;
679 797286 : stride >>= sizeof(pixel)-1;
680 :
681 797286 : dc0=dc1=dc2=dc3=dc4=0;
682 3986430 : for(i=0;i<4; i++){
683 3189144 : dc0+= src[-1+i*stride] + src[i-stride];
684 3189144 : dc1+= src[4+i-stride];
685 3189144 : dc2+= src[-1+(i+4)*stride];
686 3189144 : dc3+= src[-1+(i+8)*stride];
687 3189144 : dc4+= src[-1+(i+12)*stride];
688 : }
689 797286 : dc0splat = PIXEL_SPLAT_X4((dc0 + 4)>>3);
690 797286 : dc1splat = PIXEL_SPLAT_X4((dc1 + 2)>>2);
691 797286 : dc2splat = PIXEL_SPLAT_X4((dc2 + 2)>>2);
692 797286 : dc3splat = PIXEL_SPLAT_X4((dc1 + dc2 + 4)>>3);
693 797286 : dc4splat = PIXEL_SPLAT_X4((dc3 + 2)>>2);
694 797286 : dc5splat = PIXEL_SPLAT_X4((dc1 + dc3 + 4)>>3);
695 797286 : dc6splat = PIXEL_SPLAT_X4((dc4 + 2)>>2);
696 797286 : dc7splat = PIXEL_SPLAT_X4((dc1 + dc4 + 4)>>3);
697 :
698 3986430 : for(i=0; i<4; i++){
699 3189144 : AV_WN4PA(((pixel4*)(src+i*stride))+0, dc0splat);
700 3189144 : AV_WN4PA(((pixel4*)(src+i*stride))+1, dc1splat);
701 : }
702 3986430 : for(i=4; i<8; i++){
703 3189144 : AV_WN4PA(((pixel4*)(src+i*stride))+0, dc2splat);
704 3189144 : AV_WN4PA(((pixel4*)(src+i*stride))+1, dc3splat);
705 : }
706 3986430 : for(i=8; i<12; i++){
707 3189144 : AV_WN4PA(((pixel4*)(src+i*stride))+0, dc4splat);
708 3189144 : AV_WN4PA(((pixel4*)(src+i*stride))+1, dc5splat);
709 : }
710 3986430 : for(i=12; i<16; i++){
711 3189144 : AV_WN4PA(((pixel4*)(src+i*stride))+0, dc6splat);
712 3189144 : AV_WN4PA(((pixel4*)(src+i*stride))+1, dc7splat);
713 : }
714 797286 : }
715 :
716 : //the following 4 function should not be optimized!
717 34 : static void FUNC(pred8x8_mad_cow_dc_l0t)(uint8_t *src, ptrdiff_t stride)
718 : {
719 34 : FUNCC(pred8x8_top_dc)(src, stride);
720 34 : FUNCC(pred4x4_dc)(src, NULL, stride);
721 34 : }
722 :
723 6 : static void FUNC(pred8x16_mad_cow_dc_l0t)(uint8_t *src, ptrdiff_t stride)
724 : {
725 6 : FUNCC(pred8x16_top_dc)(src, stride);
726 6 : FUNCC(pred4x4_dc)(src, NULL, stride);
727 6 : }
728 :
729 18 : static void FUNC(pred8x8_mad_cow_dc_0lt)(uint8_t *src, ptrdiff_t stride)
730 : {
731 18 : FUNCC(pred8x8_dc)(src, stride);
732 18 : FUNCC(pred4x4_top_dc)(src, NULL, stride);
733 18 : }
734 :
735 6 : static void FUNC(pred8x16_mad_cow_dc_0lt)(uint8_t *src, ptrdiff_t stride)
736 : {
737 6 : FUNCC(pred8x16_dc)(src, stride);
738 6 : FUNCC(pred4x4_top_dc)(src, NULL, stride);
739 6 : }
740 :
741 10 : static void FUNC(pred8x8_mad_cow_dc_l00)(uint8_t *src, ptrdiff_t stride)
742 : {
743 10 : FUNCC(pred8x8_left_dc)(src, stride);
744 10 : FUNCC(pred4x4_128_dc)(src + 4*stride , NULL, stride);
745 10 : FUNCC(pred4x4_128_dc)(src + 4*stride + 4*sizeof(pixel), NULL, stride);
746 10 : }
747 :
748 6 : static void FUNC(pred8x16_mad_cow_dc_l00)(uint8_t *src, ptrdiff_t stride)
749 : {
750 6 : FUNCC(pred8x16_left_dc)(src, stride);
751 6 : FUNCC(pred4x4_128_dc)(src + 4*stride , NULL, stride);
752 6 : FUNCC(pred4x4_128_dc)(src + 4*stride + 4*sizeof(pixel), NULL, stride);
753 6 : }
754 :
755 16 : static void FUNC(pred8x8_mad_cow_dc_0l0)(uint8_t *src, ptrdiff_t stride)
756 : {
757 16 : FUNCC(pred8x8_left_dc)(src, stride);
758 16 : FUNCC(pred4x4_128_dc)(src , NULL, stride);
759 16 : FUNCC(pred4x4_128_dc)(src + 4*sizeof(pixel), NULL, stride);
760 16 : }
761 :
762 6 : static void FUNC(pred8x16_mad_cow_dc_0l0)(uint8_t *src, ptrdiff_t stride)
763 : {
764 6 : FUNCC(pred8x16_left_dc)(src, stride);
765 6 : FUNCC(pred4x4_128_dc)(src , NULL, stride);
766 6 : FUNCC(pred4x4_128_dc)(src + 4*sizeof(pixel), NULL, stride);
767 6 : }
768 :
769 459710 : static void FUNCC(pred8x8_plane)(uint8_t *_src, ptrdiff_t _stride)
770 : {
771 : int j, k;
772 : int a;
773 : INIT_CLIP
774 459710 : pixel *src = (pixel*)_src;
775 459710 : int stride = _stride>>(sizeof(pixel)-1);
776 459710 : const pixel * const src0 = src +3-stride;
777 459710 : const pixel * src1 = src +4*stride-1;
778 459710 : const pixel * src2 = src1-2*stride; // == src+2*stride-1;
779 459710 : int H = src0[1] - src0[-1];
780 459710 : int V = src1[0] - src2[ 0];
781 1838840 : for(k=2; k<=4; ++k) {
782 1379130 : src1 += stride; src2 -= stride;
783 1379130 : H += k*(src0[k] - src0[-k]);
784 1379130 : V += k*(src1[0] - src2[ 0]);
785 : }
786 459710 : H = ( 17*H+16 ) >> 5;
787 459710 : V = ( 17*V+16 ) >> 5;
788 :
789 459710 : a = 16*(src1[0] + src2[8]+1) - 3*(V+H);
790 4137390 : for(j=8; j>0; --j) {
791 3677680 : int b = a;
792 3677680 : a += V;
793 3677680 : src[0] = CLIP((b ) >> 5);
794 3677680 : src[1] = CLIP((b+ H) >> 5);
795 3677680 : src[2] = CLIP((b+2*H) >> 5);
796 3677680 : src[3] = CLIP((b+3*H) >> 5);
797 3677680 : src[4] = CLIP((b+4*H) >> 5);
798 3677680 : src[5] = CLIP((b+5*H) >> 5);
799 3677680 : src[6] = CLIP((b+6*H) >> 5);
800 3677680 : src[7] = CLIP((b+7*H) >> 5);
801 3677680 : src += stride;
802 : }
803 459710 : }
804 :
805 164288 : static void FUNCC(pred8x16_plane)(uint8_t *_src, ptrdiff_t _stride)
806 : {
807 : int j, k;
808 : int a;
809 : INIT_CLIP
810 164288 : pixel *src = (pixel*)_src;
811 164288 : int stride = _stride>>(sizeof(pixel)-1);
812 164288 : const pixel * const src0 = src +3-stride;
813 164288 : const pixel * src1 = src +8*stride-1;
814 164288 : const pixel * src2 = src1-2*stride; // == src+6*stride-1;
815 164288 : int H = src0[1] - src0[-1];
816 164288 : int V = src1[0] - src2[ 0];
817 :
818 657152 : for (k = 2; k <= 4; ++k) {
819 492864 : src1 += stride; src2 -= stride;
820 492864 : H += k*(src0[k] - src0[-k]);
821 492864 : V += k*(src1[0] - src2[ 0]);
822 : }
823 821440 : for (; k <= 8; ++k) {
824 657152 : src1 += stride; src2 -= stride;
825 657152 : V += k*(src1[0] - src2[0]);
826 : }
827 :
828 164288 : H = (17*H+16) >> 5;
829 164288 : V = (5*V+32) >> 6;
830 :
831 164288 : a = 16*(src1[0] + src2[8] + 1) - 7*V - 3*H;
832 2792896 : for(j=16; j>0; --j) {
833 2628608 : int b = a;
834 2628608 : a += V;
835 2628608 : src[0] = CLIP((b ) >> 5);
836 2628608 : src[1] = CLIP((b+ H) >> 5);
837 2628608 : src[2] = CLIP((b+2*H) >> 5);
838 2628608 : src[3] = CLIP((b+3*H) >> 5);
839 2628608 : src[4] = CLIP((b+4*H) >> 5);
840 2628608 : src[5] = CLIP((b+5*H) >> 5);
841 2628608 : src[6] = CLIP((b+6*H) >> 5);
842 2628608 : src[7] = CLIP((b+7*H) >> 5);
843 2628608 : src += stride;
844 : }
845 164288 : }
846 :
847 : #define SRC(x,y) src[(x)+(y)*stride]
848 : #define PL(y) \
849 : const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2;
850 : #define PREDICT_8x8_LOAD_LEFT \
851 : const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \
852 : + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \
853 : PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \
854 : const int l7 av_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2
855 :
856 : #define PT(x) \
857 : const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
858 : #define PREDICT_8x8_LOAD_TOP \
859 : const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \
860 : + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \
861 : PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \
862 : const int t7 av_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \
863 : + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2
864 :
865 : #define PTR(x) \
866 : t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
867 : #define PREDICT_8x8_LOAD_TOPRIGHT \
868 : int t8, t9, t10, t11, t12, t13, t14, t15; \
869 : if(has_topright) { \
870 : PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \
871 : t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \
872 : } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1);
873 :
874 : #define PREDICT_8x8_LOAD_TOPLEFT \
875 : const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2
876 :
877 : #define PREDICT_8x8_DC(v) \
878 : int y; \
879 : for( y = 0; y < 8; y++ ) { \
880 : AV_WN4PA(((pixel4*)src)+0, v); \
881 : AV_WN4PA(((pixel4*)src)+1, v); \
882 : src += stride; \
883 : }
884 :
885 1037 : static void FUNCC(pred8x8l_128_dc)(uint8_t *_src, int has_topleft,
886 : int has_topright, ptrdiff_t _stride)
887 : {
888 1037 : pixel *src = (pixel*)_src;
889 1037 : int stride = _stride>>(sizeof(pixel)-1);
890 :
891 1037 : PREDICT_8x8_DC(PIXEL_SPLAT_X4(1<<(BIT_DEPTH-1)));
892 1037 : }
893 125145 : static void FUNCC(pred8x8l_left_dc)(uint8_t *_src, int has_topleft,
894 : int has_topright, ptrdiff_t _stride)
895 : {
896 125145 : pixel *src = (pixel*)_src;
897 125145 : int stride = _stride>>(sizeof(pixel)-1);
898 :
899 125145 : PREDICT_8x8_LOAD_LEFT;
900 125145 : const pixel4 dc = PIXEL_SPLAT_X4((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3);
901 125145 : PREDICT_8x8_DC(dc);
902 125145 : }
903 15066 : static void FUNCC(pred8x8l_top_dc)(uint8_t *_src, int has_topleft,
904 : int has_topright, ptrdiff_t _stride)
905 : {
906 15066 : pixel *src = (pixel*)_src;
907 15066 : int stride = _stride>>(sizeof(pixel)-1);
908 :
909 15066 : PREDICT_8x8_LOAD_TOP;
910 15066 : const pixel4 dc = PIXEL_SPLAT_X4((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3);
911 15066 : PREDICT_8x8_DC(dc);
912 15066 : }
913 1630328 : static void FUNCC(pred8x8l_dc)(uint8_t *_src, int has_topleft,
914 : int has_topright, ptrdiff_t _stride)
915 : {
916 1630328 : pixel *src = (pixel*)_src;
917 1630328 : int stride = _stride>>(sizeof(pixel)-1);
918 :
919 1630328 : PREDICT_8x8_LOAD_LEFT;
920 1630328 : PREDICT_8x8_LOAD_TOP;
921 1630328 : const pixel4 dc = PIXEL_SPLAT_X4((l0+l1+l2+l3+l4+l5+l6+l7
922 : +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4);
923 1630328 : PREDICT_8x8_DC(dc);
924 1630328 : }
925 1618276 : static void FUNCC(pred8x8l_horizontal)(uint8_t *_src, int has_topleft,
926 : int has_topright, ptrdiff_t _stride)
927 : {
928 1618276 : pixel *src = (pixel*)_src;
929 1618276 : int stride = _stride>>(sizeof(pixel)-1);
930 : pixel4 a;
931 :
932 1618276 : PREDICT_8x8_LOAD_LEFT;
933 : #define ROW(y) a = PIXEL_SPLAT_X4(l##y); \
934 : AV_WN4PA(src+y*stride, a); \
935 : AV_WN4PA(src+y*stride+4, a);
936 1618276 : ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7);
937 : #undef ROW
938 1618276 : }
939 429170 : static void FUNCC(pred8x8l_vertical)(uint8_t *_src, int has_topleft,
940 : int has_topright, ptrdiff_t _stride)
941 : {
942 : int y;
943 429170 : pixel *src = (pixel*)_src;
944 429170 : int stride = _stride>>(sizeof(pixel)-1);
945 : pixel4 a, b;
946 :
947 429170 : PREDICT_8x8_LOAD_TOP;
948 429170 : src[0] = t0;
949 429170 : src[1] = t1;
950 429170 : src[2] = t2;
951 429170 : src[3] = t3;
952 429170 : src[4] = t4;
953 429170 : src[5] = t5;
954 429170 : src[6] = t6;
955 429170 : src[7] = t7;
956 429170 : a = AV_RN4PA(((pixel4*)src)+0);
957 429170 : b = AV_RN4PA(((pixel4*)src)+1);
958 3433360 : for( y = 1; y < 8; y++ ) {
959 3004190 : AV_WN4PA(((pixel4*)(src+y*stride))+0, a);
960 3004190 : AV_WN4PA(((pixel4*)(src+y*stride))+1, b);
961 : }
962 429170 : }
963 192097 : static void FUNCC(pred8x8l_down_left)(uint8_t *_src, int has_topleft,
964 : int has_topright, ptrdiff_t _stride)
965 : {
966 192097 : pixel *src = (pixel*)_src;
967 192097 : int stride = _stride>>(sizeof(pixel)-1);
968 192097 : PREDICT_8x8_LOAD_TOP;
969 192097 : PREDICT_8x8_LOAD_TOPRIGHT;
970 192097 : SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2;
971 192097 : SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2;
972 192097 : SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2;
973 192097 : SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2;
974 192097 : SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2;
975 192097 : SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2;
976 192097 : SRC(0,6)=SRC(1,5)=SRC(2,4)=SRC(3,3)=SRC(4,2)=SRC(5,1)=SRC(6,0)= (t6 + 2*t7 + t8 + 2) >> 2;
977 192097 : SRC(0,7)=SRC(1,6)=SRC(2,5)=SRC(3,4)=SRC(4,3)=SRC(5,2)=SRC(6,1)=SRC(7,0)= (t7 + 2*t8 + t9 + 2) >> 2;
978 192097 : SRC(1,7)=SRC(2,6)=SRC(3,5)=SRC(4,4)=SRC(5,3)=SRC(6,2)=SRC(7,1)= (t8 + 2*t9 + t10 + 2) >> 2;
979 192097 : SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2;
980 192097 : SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2;
981 192097 : SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2;
982 192097 : SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2;
983 192097 : SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2;
984 192097 : SRC(7,7)= (t14 + 3*t15 + 2) >> 2;
985 192097 : }
986 290738 : static void FUNCC(pred8x8l_down_right)(uint8_t *_src, int has_topleft,
987 : int has_topright, ptrdiff_t _stride)
988 : {
989 290738 : pixel *src = (pixel*)_src;
990 290738 : int stride = _stride>>(sizeof(pixel)-1);
991 290738 : PREDICT_8x8_LOAD_TOP;
992 290738 : PREDICT_8x8_LOAD_LEFT;
993 290738 : PREDICT_8x8_LOAD_TOPLEFT;
994 290738 : SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2;
995 290738 : SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2;
996 290738 : SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2;
997 290738 : SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2;
998 290738 : SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2;
999 290738 : SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2;
1000 290738 : SRC(0,1)=SRC(1,2)=SRC(2,3)=SRC(3,4)=SRC(4,5)=SRC(5,6)=SRC(6,7)= (l1 + 2*l0 + lt + 2) >> 2;
1001 290738 : SRC(0,0)=SRC(1,1)=SRC(2,2)=SRC(3,3)=SRC(4,4)=SRC(5,5)=SRC(6,6)=SRC(7,7)= (l0 + 2*lt + t0 + 2) >> 2;
1002 290738 : SRC(1,0)=SRC(2,1)=SRC(3,2)=SRC(4,3)=SRC(5,4)=SRC(6,5)=SRC(7,6)= (lt + 2*t0 + t1 + 2) >> 2;
1003 290738 : SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2;
1004 290738 : SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2;
1005 290738 : SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2;
1006 290738 : SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2;
1007 290738 : SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2;
1008 290738 : SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2;
1009 290738 : }
1010 193839 : static void FUNCC(pred8x8l_vertical_right)(uint8_t *_src, int has_topleft,
1011 : int has_topright, ptrdiff_t _stride)
1012 : {
1013 193839 : pixel *src = (pixel*)_src;
1014 193839 : int stride = _stride>>(sizeof(pixel)-1);
1015 193839 : PREDICT_8x8_LOAD_TOP;
1016 193839 : PREDICT_8x8_LOAD_LEFT;
1017 193839 : PREDICT_8x8_LOAD_TOPLEFT;
1018 193839 : SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2;
1019 193839 : SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2;
1020 193839 : SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2;
1021 193839 : SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2;
1022 193839 : SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2;
1023 193839 : SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2;
1024 193839 : SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2;
1025 193839 : SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1;
1026 193839 : SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2;
1027 193839 : SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1;
1028 193839 : SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2;
1029 193839 : SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1;
1030 193839 : SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2;
1031 193839 : SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1;
1032 193839 : SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2;
1033 193839 : SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1;
1034 193839 : SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2;
1035 193839 : SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1;
1036 193839 : SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2;
1037 193839 : SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1;
1038 193839 : SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2;
1039 193839 : SRC(7,0)= (t6 + t7 + 1) >> 1;
1040 193839 : }
1041 445526 : static void FUNCC(pred8x8l_horizontal_down)(uint8_t *_src, int has_topleft,
1042 : int has_topright, ptrdiff_t _stride)
1043 : {
1044 445526 : pixel *src = (pixel*)_src;
1045 445526 : int stride = _stride>>(sizeof(pixel)-1);
1046 445526 : PREDICT_8x8_LOAD_TOP;
1047 445526 : PREDICT_8x8_LOAD_LEFT;
1048 445526 : PREDICT_8x8_LOAD_TOPLEFT;
1049 445526 : SRC(0,7)= (l6 + l7 + 1) >> 1;
1050 445526 : SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2;
1051 445526 : SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1;
1052 445526 : SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2;
1053 445526 : SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1;
1054 445526 : SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2;
1055 445526 : SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1;
1056 445526 : SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2;
1057 445526 : SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1;
1058 445526 : SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2;
1059 445526 : SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1;
1060 445526 : SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2;
1061 445526 : SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1;
1062 445526 : SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2;
1063 445526 : SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1;
1064 445526 : SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2;
1065 445526 : SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2;
1066 445526 : SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2;
1067 445526 : SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2;
1068 445526 : SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2;
1069 445526 : SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2;
1070 445526 : SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2;
1071 445526 : }
1072 195238 : static void FUNCC(pred8x8l_vertical_left)(uint8_t *_src, int has_topleft,
1073 : int has_topright, ptrdiff_t _stride)
1074 : {
1075 195238 : pixel *src = (pixel*)_src;
1076 195238 : int stride = _stride>>(sizeof(pixel)-1);
1077 195238 : PREDICT_8x8_LOAD_TOP;
1078 195238 : PREDICT_8x8_LOAD_TOPRIGHT;
1079 195238 : SRC(0,0)= (t0 + t1 + 1) >> 1;
1080 195238 : SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2;
1081 195238 : SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1;
1082 195238 : SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2;
1083 195238 : SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1;
1084 195238 : SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2;
1085 195238 : SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1;
1086 195238 : SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2;
1087 195238 : SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1;
1088 195238 : SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2;
1089 195238 : SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1;
1090 195238 : SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2;
1091 195238 : SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1;
1092 195238 : SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2;
1093 195238 : SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1;
1094 195238 : SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2;
1095 195238 : SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1;
1096 195238 : SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2;
1097 195238 : SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1;
1098 195238 : SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2;
1099 195238 : SRC(7,6)= (t10 + t11 + 1) >> 1;
1100 195238 : SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2;
1101 195238 : }
1102 545628 : static void FUNCC(pred8x8l_horizontal_up)(uint8_t *_src, int has_topleft,
1103 : int has_topright, ptrdiff_t _stride)
1104 : {
1105 545628 : pixel *src = (pixel*)_src;
1106 545628 : int stride = _stride>>(sizeof(pixel)-1);
1107 545628 : PREDICT_8x8_LOAD_LEFT;
1108 545628 : SRC(0,0)= (l0 + l1 + 1) >> 1;
1109 545628 : SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2;
1110 545628 : SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1;
1111 545628 : SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2;
1112 545628 : SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1;
1113 545628 : SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2;
1114 545628 : SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1;
1115 545628 : SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2;
1116 545628 : SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1;
1117 545628 : SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2;
1118 545628 : SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1;
1119 545628 : SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2;
1120 545628 : SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1;
1121 545628 : SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2;
1122 1091256 : SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)=
1123 1636884 : SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)=
1124 1636884 : SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)=
1125 1091256 : SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7;
1126 545628 : }
1127 :
1128 0 : static void FUNCC(pred8x8l_vertical_filter_add)(uint8_t *_src, int16_t *_block, int has_topleft,
1129 : int has_topright, ptrdiff_t _stride)
1130 : {
1131 : int i;
1132 0 : pixel *src = (pixel*)_src;
1133 0 : const dctcoef *block = (const dctcoef*)_block;
1134 : pixel pix[8];
1135 0 : int stride = _stride>>(sizeof(pixel)-1);
1136 0 : PREDICT_8x8_LOAD_TOP;
1137 :
1138 0 : pix[0] = t0;
1139 0 : pix[1] = t1;
1140 0 : pix[2] = t2;
1141 0 : pix[3] = t3;
1142 0 : pix[4] = t4;
1143 0 : pix[5] = t5;
1144 0 : pix[6] = t6;
1145 0 : pix[7] = t7;
1146 :
1147 0 : for(i=0; i<8; i++){
1148 0 : pixel v = pix[i];
1149 0 : src[0*stride]= v += block[0];
1150 0 : src[1*stride]= v += block[8];
1151 0 : src[2*stride]= v += block[16];
1152 0 : src[3*stride]= v += block[24];
1153 0 : src[4*stride]= v += block[32];
1154 0 : src[5*stride]= v += block[40];
1155 0 : src[6*stride]= v += block[48];
1156 0 : src[7*stride]= v + block[56];
1157 0 : src++;
1158 0 : block++;
1159 : }
1160 :
1161 0 : memset(_block, 0, sizeof(dctcoef) * 64);
1162 0 : }
1163 :
1164 0 : static void FUNCC(pred8x8l_horizontal_filter_add)(uint8_t *_src, int16_t *_block, int has_topleft,
1165 : int has_topright, ptrdiff_t _stride)
1166 : {
1167 : int i;
1168 0 : pixel *src = (pixel*)_src;
1169 0 : const dctcoef *block = (const dctcoef*)_block;
1170 : pixel pix[8];
1171 0 : int stride = _stride>>(sizeof(pixel)-1);
1172 0 : PREDICT_8x8_LOAD_LEFT;
1173 :
1174 0 : pix[0] = l0;
1175 0 : pix[1] = l1;
1176 0 : pix[2] = l2;
1177 0 : pix[3] = l3;
1178 0 : pix[4] = l4;
1179 0 : pix[5] = l5;
1180 0 : pix[6] = l6;
1181 0 : pix[7] = l7;
1182 :
1183 0 : for(i=0; i<8; i++){
1184 0 : pixel v = pix[i];
1185 0 : src[0]= v += block[0];
1186 0 : src[1]= v += block[1];
1187 0 : src[2]= v += block[2];
1188 0 : src[3]= v += block[3];
1189 0 : src[4]= v += block[4];
1190 0 : src[5]= v += block[5];
1191 0 : src[6]= v += block[6];
1192 0 : src[7]= v + block[7];
1193 0 : src+= stride;
1194 0 : block+= 8;
1195 : }
1196 :
1197 0 : memset(_block, 0, sizeof(dctcoef) * 64);
1198 0 : }
1199 :
1200 : #undef PREDICT_8x8_LOAD_LEFT
1201 : #undef PREDICT_8x8_LOAD_TOP
1202 : #undef PREDICT_8x8_LOAD_TOPLEFT
1203 : #undef PREDICT_8x8_LOAD_TOPRIGHT
1204 : #undef PREDICT_8x8_DC
1205 : #undef PTR
1206 : #undef PT
1207 : #undef PL
1208 : #undef SRC
1209 :
1210 80320 : static void FUNCC(pred4x4_vertical_add)(uint8_t *_pix, int16_t *_block,
1211 : ptrdiff_t stride)
1212 : {
1213 : int i;
1214 80320 : pixel *pix = (pixel*)_pix;
1215 80320 : const dctcoef *block = (const dctcoef*)_block;
1216 80320 : stride >>= sizeof(pixel)-1;
1217 80320 : pix -= stride;
1218 401600 : for(i=0; i<4; i++){
1219 321280 : pixel v = pix[0];
1220 321280 : pix[1*stride]= v += block[0];
1221 321280 : pix[2*stride]= v += block[4];
1222 321280 : pix[3*stride]= v += block[8];
1223 321280 : pix[4*stride]= v + block[12];
1224 321280 : pix++;
1225 321280 : block++;
1226 : }
1227 :
1228 80320 : memset(_block, 0, sizeof(dctcoef) * 16);
1229 80320 : }
1230 :
1231 104227 : static void FUNCC(pred4x4_horizontal_add)(uint8_t *_pix, int16_t *_block,
1232 : ptrdiff_t stride)
1233 : {
1234 : int i;
1235 104227 : pixel *pix = (pixel*)_pix;
1236 104227 : const dctcoef *block = (const dctcoef*)_block;
1237 104227 : stride >>= sizeof(pixel)-1;
1238 521135 : for(i=0; i<4; i++){
1239 416908 : pixel v = pix[-1];
1240 416908 : pix[0]= v += block[0];
1241 416908 : pix[1]= v += block[1];
1242 416908 : pix[2]= v += block[2];
1243 416908 : pix[3]= v + block[3];
1244 416908 : pix+= stride;
1245 416908 : block+= 4;
1246 : }
1247 :
1248 104227 : memset(_block, 0, sizeof(dctcoef) * 16);
1249 104227 : }
1250 :
1251 1074 : static void FUNCC(pred8x8l_vertical_add)(uint8_t *_pix, int16_t *_block,
1252 : ptrdiff_t stride)
1253 : {
1254 : int i;
1255 1074 : pixel *pix = (pixel*)_pix;
1256 1074 : const dctcoef *block = (const dctcoef*)_block;
1257 1074 : stride >>= sizeof(pixel)-1;
1258 1074 : pix -= stride;
1259 9666 : for(i=0; i<8; i++){
1260 8592 : pixel v = pix[0];
1261 8592 : pix[1*stride]= v += block[0];
1262 8592 : pix[2*stride]= v += block[8];
1263 8592 : pix[3*stride]= v += block[16];
1264 8592 : pix[4*stride]= v += block[24];
1265 8592 : pix[5*stride]= v += block[32];
1266 8592 : pix[6*stride]= v += block[40];
1267 8592 : pix[7*stride]= v += block[48];
1268 8592 : pix[8*stride]= v + block[56];
1269 8592 : pix++;
1270 8592 : block++;
1271 : }
1272 :
1273 1074 : memset(_block, 0, sizeof(dctcoef) * 64);
1274 1074 : }
1275 :
1276 1414 : static void FUNCC(pred8x8l_horizontal_add)(uint8_t *_pix, int16_t *_block,
1277 : ptrdiff_t stride)
1278 : {
1279 : int i;
1280 1414 : pixel *pix = (pixel*)_pix;
1281 1414 : const dctcoef *block = (const dctcoef*)_block;
1282 1414 : stride >>= sizeof(pixel)-1;
1283 12726 : for(i=0; i<8; i++){
1284 11312 : pixel v = pix[-1];
1285 11312 : pix[0]= v += block[0];
1286 11312 : pix[1]= v += block[1];
1287 11312 : pix[2]= v += block[2];
1288 11312 : pix[3]= v += block[3];
1289 11312 : pix[4]= v += block[4];
1290 11312 : pix[5]= v += block[5];
1291 11312 : pix[6]= v += block[6];
1292 11312 : pix[7]= v + block[7];
1293 11312 : pix+= stride;
1294 11312 : block+= 8;
1295 : }
1296 :
1297 1414 : memset(_block, 0, sizeof(dctcoef) * 64);
1298 1414 : }
1299 :
1300 353 : static void FUNCC(pred16x16_vertical_add)(uint8_t *pix, const int *block_offset,
1301 : int16_t *block,
1302 : ptrdiff_t stride)
1303 : {
1304 : int i;
1305 6001 : for(i=0; i<16; i++)
1306 5648 : FUNCC(pred4x4_vertical_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
1307 353 : }
1308 :
1309 272 : static void FUNCC(pred16x16_horizontal_add)(uint8_t *pix,
1310 : const int *block_offset,
1311 : int16_t *block,
1312 : ptrdiff_t stride)
1313 : {
1314 : int i;
1315 4624 : for(i=0; i<16; i++)
1316 4352 : FUNCC(pred4x4_horizontal_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
1317 272 : }
1318 :
1319 2258 : static void FUNCC(pred8x8_vertical_add)(uint8_t *pix, const int *block_offset,
1320 : int16_t *block, ptrdiff_t stride)
1321 : {
1322 : int i;
1323 11290 : for(i=0; i<4; i++)
1324 9032 : FUNCC(pred4x4_vertical_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
1325 2258 : }
1326 :
1327 0 : static void FUNCC(pred8x16_vertical_add)(uint8_t *pix, const int *block_offset,
1328 : int16_t *block, ptrdiff_t stride)
1329 : {
1330 : int i;
1331 0 : for(i=0; i<4; i++)
1332 0 : FUNCC(pred4x4_vertical_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
1333 0 : for(i=4; i<8; i++)
1334 0 : FUNCC(pred4x4_vertical_add)(pix + block_offset[i+4], block + i*16*sizeof(pixel), stride);
1335 0 : }
1336 :
1337 2888 : static void FUNCC(pred8x8_horizontal_add)(uint8_t *pix, const int *block_offset,
1338 : int16_t *block,
1339 : ptrdiff_t stride)
1340 : {
1341 : int i;
1342 14440 : for(i=0; i<4; i++)
1343 11552 : FUNCC(pred4x4_horizontal_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
1344 2888 : }
1345 :
1346 0 : static void FUNCC(pred8x16_horizontal_add)(uint8_t *pix,
1347 : const int *block_offset,
1348 : int16_t *block, ptrdiff_t stride)
1349 : {
1350 : int i;
1351 0 : for(i=0; i<4; i++)
1352 0 : FUNCC(pred4x4_horizontal_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
1353 0 : for(i=4; i<8; i++)
1354 0 : FUNCC(pred4x4_horizontal_add)(pix + block_offset[i+4], block + i*16*sizeof(pixel), stride);
1355 0 : }
|
