?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r1009: Move the dependencies to newer package names
[cinelerra_cv/mob.git] / quicktime / ffmpeg / libavcodec / sh4 / qpel.c
blob2e6ac8ce31d12827d2c62740970f2bf4c0fcc371
1 /*
2 this is optimized for sh, which have post increment addressing (*p++)
3 some cpu may be index (p[n]) faster than post increment (*p++)
4 */
5
6 #define LD(adr) *(uint32_t*)(adr)
7
8 #define PIXOP2(OPNAME, OP) \
9 /*static inline void OPNAME ## _no_rnd_pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
10 {\
11 do {\
12 OP(LP(dst ),no_rnd_avg32(LD32(src1 ),LD32(src2 )) ); \
13 OP(LP(dst+4),no_rnd_avg32(LD32(src1+4),LD32(src2+4)) ); \
14 src1+=src_stride1; \
15 src2+=src_stride2; \
16 dst+=dst_stride; \
17 } while(--h); \
18 }\
19 \
20 static inline void OPNAME ## _pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
21 {\
22 do {\
23 OP(LP(dst ),rnd_avg32(LD32(src1 ),LD32(src2 )) ); \
24 OP(LP(dst+4),rnd_avg32(LD32(src1+4),LD32(src2+4)) ); \
25 src1+=src_stride1; \
26 src2+=src_stride2; \
27 dst+=dst_stride; \
28 } while(--h); \
29 }\
30 \
31 static inline void OPNAME ## _pixels4_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
32 {\
33 do {\
34 OP(LP(dst ),rnd_avg32(LD32(src1 ),LD32(src2 )) ); \
35 src1+=src_stride1; \
36 src2+=src_stride2; \
37 dst+=dst_stride; \
38 } while(--h); \
39 }\
40 \
41 static inline void OPNAME ## _no_rnd_pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
42 {\
43 do {\
44 OP(LP(dst ),no_rnd_avg32(LD32(src1 ),LD32(src2 )) ); \
45 OP(LP(dst+4),no_rnd_avg32(LD32(src1+4),LD32(src2+4)) ); \
46 OP(LP(dst+8),no_rnd_avg32(LD32(src1+8),LD32(src2+8)) ); \
47 OP(LP(dst+12),no_rnd_avg32(LD32(src1+12),LD32(src2+12)) ); \
48 src1+=src_stride1; \
49 src2+=src_stride2; \
50 dst+=dst_stride; \
51 } while(--h); \
52 }\
53 \
54 static inline void OPNAME ## _pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
55 {\
56 do {\
57 OP(LP(dst ),rnd_avg32(LD32(src1 ),LD32(src2 )) ); \
58 OP(LP(dst+4),rnd_avg32(LD32(src1+4),LD32(src2+4)) ); \
59 OP(LP(dst+8),rnd_avg32(LD32(src1+8),LD32(src2+8)) ); \
60 OP(LP(dst+12),rnd_avg32(LD32(src1+12),LD32(src2+12)) ); \
61 src1+=src_stride1; \
62 src2+=src_stride2; \
63 dst+=dst_stride; \
64 } while(--h); \
65 }*/\
66 \
67 static inline void OPNAME ## _pixels4_l2_aligned(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
68 {\
69 do {\
70 OP(LP(dst ),rnd_avg32(LP(src1 ),LP(src2 )) ); \
71 src1+=src_stride1; \
72 src2+=src_stride2; \
73 dst+=dst_stride; \
74 } while(--h); \
75 }\
76 \
77 static inline void OPNAME ## _pixels4_l2_aligned2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
78 {\
79 do {\
80 OP(LP(dst ),rnd_avg32(LD32(src1 ),LP(src2 )) ); \
81 src1+=src_stride1; \
82 src2+=src_stride2; \
83 dst+=dst_stride; \
84 } while(--h); \
85 }\
86 \
87 static inline void OPNAME ## _no_rnd_pixels16_l2_aligned2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
88 {\
89 do {\
90 OP(LP(dst ),no_rnd_avg32(LD32(src1 ),LP(src2 )) ); \
91 OP(LP(dst+4),no_rnd_avg32(LD32(src1+4),LP(src2+4)) ); \
92 OP(LP(dst+8),no_rnd_avg32(LD32(src1+8),LP(src2+8)) ); \
93 OP(LP(dst+12),no_rnd_avg32(LD32(src1+12),LP(src2+12)) ); \
94 src1+=src_stride1; \
95 src2+=src_stride2; \
96 dst+=dst_stride; \
97 } while(--h); \
98 }\
99 \
100 static inline void OPNAME ## _pixels16_l2_aligned2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
101 {\
102 do {\
103 OP(LP(dst ),rnd_avg32(LD32(src1 ),LP(src2 )) ); \
104 OP(LP(dst+4),rnd_avg32(LD32(src1+4),LP(src2+4)) ); \
105 OP(LP(dst+8),rnd_avg32(LD32(src1+8),LP(src2+8)) ); \
106 OP(LP(dst+12),rnd_avg32(LD32(src1+12),LP(src2+12)) ); \
107 src1+=src_stride1; \
108 src2+=src_stride2; \
109 dst+=dst_stride; \
110 } while(--h); \
111 }\
112 \
113 static inline void OPNAME ## _no_rnd_pixels8_l2_aligned2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
114 {\
115 do { /* onlye src2 aligned */\
116 OP(LP(dst ),no_rnd_avg32(LD32(src1 ),LP(src2 )) ); \
117 OP(LP(dst+4),no_rnd_avg32(LD32(src1+4),LP(src2+4)) ); \
118 src1+=src_stride1; \
119 src2+=src_stride2; \
120 dst+=dst_stride; \
121 } while(--h); \
122 }\
123 \
124 static inline void OPNAME ## _pixels8_l2_aligned2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
125 {\
126 do {\
127 OP(LP(dst ),rnd_avg32(LD32(src1 ),LP(src2 )) ); \
128 OP(LP(dst+4),rnd_avg32(LD32(src1+4),LP(src2+4)) ); \
129 src1+=src_stride1; \
130 src2+=src_stride2; \
131 dst+=dst_stride; \
132 } while(--h); \
133 }\
134 \
135 static inline void OPNAME ## _no_rnd_pixels8_l2_aligned(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
136 {\
137 do {\
138 OP(LP(dst ),no_rnd_avg32(LP(src1 ),LP(src2 )) ); \
139 OP(LP(dst+4),no_rnd_avg32(LP(src1+4),LP(src2+4)) ); \
140 src1+=src_stride1; \
141 src2+=src_stride2; \
142 dst+=dst_stride; \
143 } while(--h); \
144 }\
145 \
146 static inline void OPNAME ## _pixels8_l2_aligned(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
147 {\
148 do {\
149 OP(LP(dst ),rnd_avg32(LP(src1 ),LP(src2 )) ); \
150 OP(LP(dst+4),rnd_avg32(LP(src1+4),LP(src2+4)) ); \
151 src1+=src_stride1; \
152 src2+=src_stride2; \
153 dst+=dst_stride; \
154 } while(--h); \
155 }\
156 \
157 static inline void OPNAME ## _no_rnd_pixels16_l2_aligned(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
158 {\
159 do {\
160 OP(LP(dst ),no_rnd_avg32(LP(src1 ),LP(src2 )) ); \
161 OP(LP(dst+4),no_rnd_avg32(LP(src1+4),LP(src2+4)) ); \
162 OP(LP(dst+8),no_rnd_avg32(LP(src1+8),LP(src2+8)) ); \
163 OP(LP(dst+12),no_rnd_avg32(LP(src1+12),LP(src2+12)) ); \
164 src1+=src_stride1; \
165 src2+=src_stride2; \
166 dst+=dst_stride; \
167 } while(--h); \
168 }\
169 \
170 static inline void OPNAME ## _pixels16_l2_aligned(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
171 {\
172 do {\
173 OP(LP(dst ),rnd_avg32(LP(src1 ),LP(src2 )) ); \
174 OP(LP(dst+4),rnd_avg32(LP(src1+4),LP(src2+4)) ); \
175 OP(LP(dst+8),rnd_avg32(LP(src1+8),LP(src2+8)) ); \
176 OP(LP(dst+12),rnd_avg32(LP(src1+12),LP(src2+12)) ); \
177 src1+=src_stride1; \
178 src2+=src_stride2; \
179 dst+=dst_stride; \
180 } while(--h); \
181 }\
182 \
183 static inline void OPNAME ## _no_rnd_pixels16_l2_aligned1(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
184 { OPNAME ## _no_rnd_pixels16_l2_aligned2(dst,src2,src1,dst_stride,src_stride2,src_stride1,h); } \
185 \
186 static inline void OPNAME ## _pixels16_l2_aligned1(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
187 { OPNAME ## _pixels16_l2_aligned2(dst,src2,src1,dst_stride,src_stride2,src_stride1,h); } \
188 \
189 static inline void OPNAME ## _no_rnd_pixels8_l2_aligned1(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
190 { OPNAME ## _no_rnd_pixels8_l2_aligned2(dst,src2,src1,dst_stride,src_stride2,src_stride1,h); } \
191 \
192 static inline void OPNAME ## _pixels8_l2_aligned1(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, int src_stride1, int src_stride2, int h) \
193 { OPNAME ## _pixels8_l2_aligned2(dst,src2,src1,dst_stride,src_stride2,src_stride1,h); } \
194 \
195 static inline void OPNAME ## _pixels8_l4_aligned(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
196 do { \
197 uint32_t a0,a1,a2,a3; \
198 UNPACK(a0,a1,LP(src1),LP(src2)); \
199 UNPACK(a2,a3,LP(src3),LP(src4)); \
200 OP(LP(dst),rnd_PACK(a0,a1,a2,a3)); \
201 UNPACK(a0,a1,LP(src1+4),LP(src2+4)); \
202 UNPACK(a2,a3,LP(src3+4),LP(src4+4)); \
203 OP(LP(dst+4),rnd_PACK(a0,a1,a2,a3)); \
204 src1+=src_stride1;\
205 src2+=src_stride2;\
206 src3+=src_stride3;\
207 src4+=src_stride4;\
208 dst+=dst_stride;\
209 } while(--h); \
210 } \
211 \
212 static inline void OPNAME ## _no_rnd_pixels8_l4_aligned(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
213 do { \
214 uint32_t a0,a1,a2,a3; \
215 UNPACK(a0,a1,LP(src1),LP(src2)); \
216 UNPACK(a2,a3,LP(src3),LP(src4)); \
217 OP(LP(dst),no_rnd_PACK(a0,a1,a2,a3)); \
218 UNPACK(a0,a1,LP(src1+4),LP(src2+4)); \
219 UNPACK(a2,a3,LP(src3+4),LP(src4+4)); \
220 OP(LP(dst+4),no_rnd_PACK(a0,a1,a2,a3)); \
221 src1+=src_stride1;\
222 src2+=src_stride2;\
223 src3+=src_stride3;\
224 src4+=src_stride4;\
225 dst+=dst_stride;\
226 } while(--h); \
227 } \
228 \
229 static inline void OPNAME ## _pixels8_l4_aligned0(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
230 do { \
231 uint32_t a0,a1,a2,a3; /* src1 only not aligned */\
232 UNPACK(a0,a1,LD32(src1),LP(src2)); \
233 UNPACK(a2,a3,LP(src3),LP(src4)); \
234 OP(LP(dst),rnd_PACK(a0,a1,a2,a3)); \
235 UNPACK(a0,a1,LD32(src1+4),LP(src2+4)); \
236 UNPACK(a2,a3,LP(src3+4),LP(src4+4)); \
237 OP(LP(dst+4),rnd_PACK(a0,a1,a2,a3)); \
238 src1+=src_stride1;\
239 src2+=src_stride2;\
240 src3+=src_stride3;\
241 src4+=src_stride4;\
242 dst+=dst_stride;\
243 } while(--h); \
244 } \
245 \
246 static inline void OPNAME ## _no_rnd_pixels8_l4_aligned0(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
247 do { \
248 uint32_t a0,a1,a2,a3; \
249 UNPACK(a0,a1,LD32(src1),LP(src2)); \
250 UNPACK(a2,a3,LP(src3),LP(src4)); \
251 OP(LP(dst),no_rnd_PACK(a0,a1,a2,a3)); \
252 UNPACK(a0,a1,LD32(src1+4),LP(src2+4)); \
253 UNPACK(a2,a3,LP(src3+4),LP(src4+4)); \
254 OP(LP(dst+4),no_rnd_PACK(a0,a1,a2,a3)); \
255 src1+=src_stride1;\
256 src2+=src_stride2;\
257 src3+=src_stride3;\
258 src4+=src_stride4;\
259 dst+=dst_stride;\
260 } while(--h); \
261 } \
262 \
263 static inline void OPNAME ## _pixels16_l4_aligned(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
264 do { \
265 uint32_t a0,a1,a2,a3; \
266 UNPACK(a0,a1,LP(src1),LP(src2)); \
267 UNPACK(a2,a3,LP(src3),LP(src4)); \
268 OP(LP(dst),rnd_PACK(a0,a1,a2,a3)); \
269 UNPACK(a0,a1,LP(src1+4),LP(src2+4)); \
270 UNPACK(a2,a3,LP(src3+4),LP(src4+4)); \
271 OP(LP(dst+8),rnd_PACK(a0,a1,a2,a3)); \
272 UNPACK(a0,a1,LP(src1+8),LP(src2+8)); \
273 UNPACK(a2,a3,LP(src3+8),LP(src4+8)); \
274 OP(LP(dst+8),rnd_PACK(a0,a1,a2,a3)); \
275 UNPACK(a0,a1,LP(src1+12),LP(src2+12)); \
276 UNPACK(a2,a3,LP(src3+12),LP(src4+12)); \
277 OP(LP(dst+12),rnd_PACK(a0,a1,a2,a3)); \
278 src1+=src_stride1;\
279 src2+=src_stride2;\
280 src3+=src_stride3;\
281 src4+=src_stride4;\
282 dst+=dst_stride;\
283 } while(--h); \
284 } \
285 \
286 static inline void OPNAME ## _no_rnd_pixels16_l4_aligned(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
287 do { \
288 uint32_t a0,a1,a2,a3; \
289 UNPACK(a0,a1,LP(src1),LP(src2)); \
290 UNPACK(a2,a3,LP(src3),LP(src4)); \
291 OP(LP(dst),no_rnd_PACK(a0,a1,a2,a3)); \
292 UNPACK(a0,a1,LP(src1+4),LP(src2+4)); \
293 UNPACK(a2,a3,LP(src3+4),LP(src4+4)); \
294 OP(LP(dst+4),no_rnd_PACK(a0,a1,a2,a3)); \
295 UNPACK(a0,a1,LP(src1+8),LP(src2+8)); \
296 UNPACK(a2,a3,LP(src3+8),LP(src4+8)); \
297 OP(LP(dst+8),no_rnd_PACK(a0,a1,a2,a3)); \
298 UNPACK(a0,a1,LP(src1+12),LP(src2+12)); \
299 UNPACK(a2,a3,LP(src3+12),LP(src4+12)); \
300 OP(LP(dst+12),no_rnd_PACK(a0,a1,a2,a3)); \
301 src1+=src_stride1;\
302 src2+=src_stride2;\
303 src3+=src_stride3;\
304 src4+=src_stride4;\
305 dst+=dst_stride;\
306 } while(--h); \
307 } \
308 \
309 static inline void OPNAME ## _pixels16_l4_aligned0(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
310 do { /* src1 is unaligned */\
311 uint32_t a0,a1,a2,a3; \
312 UNPACK(a0,a1,LD32(src1),LP(src2)); \
313 UNPACK(a2,a3,LP(src3),LP(src4)); \
314 OP(LP(dst),rnd_PACK(a0,a1,a2,a3)); \
315 UNPACK(a0,a1,LD32(src1+4),LP(src2+4)); \
316 UNPACK(a2,a3,LP(src3+4),LP(src4+4)); \
317 OP(LP(dst+8),rnd_PACK(a0,a1,a2,a3)); \
318 UNPACK(a0,a1,LD32(src1+8),LP(src2+8)); \
319 UNPACK(a2,a3,LP(src3+8),LP(src4+8)); \
320 OP(LP(dst+8),rnd_PACK(a0,a1,a2,a3)); \
321 UNPACK(a0,a1,LD32(src1+12),LP(src2+12)); \
322 UNPACK(a2,a3,LP(src3+12),LP(src4+12)); \
323 OP(LP(dst+12),rnd_PACK(a0,a1,a2,a3)); \
324 src1+=src_stride1;\
325 src2+=src_stride2;\
326 src3+=src_stride3;\
327 src4+=src_stride4;\
328 dst+=dst_stride;\
329 } while(--h); \
330 } \
331 \
332 static inline void OPNAME ## _no_rnd_pixels16_l4_aligned0(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
333 do { \
334 uint32_t a0,a1,a2,a3; \
335 UNPACK(a0,a1,LD32(src1),LP(src2)); \
336 UNPACK(a2,a3,LP(src3),LP(src4)); \
337 OP(LP(dst),no_rnd_PACK(a0,a1,a2,a3)); \
338 UNPACK(a0,a1,LD32(src1+4),LP(src2+4)); \
339 UNPACK(a2,a3,LP(src3+4),LP(src4+4)); \
340 OP(LP(dst+4),no_rnd_PACK(a0,a1,a2,a3)); \
341 UNPACK(a0,a1,LD32(src1+8),LP(src2+8)); \
342 UNPACK(a2,a3,LP(src3+8),LP(src4+8)); \
343 OP(LP(dst+8),no_rnd_PACK(a0,a1,a2,a3)); \
344 UNPACK(a0,a1,LD32(src1+12),LP(src2+12)); \
345 UNPACK(a2,a3,LP(src3+12),LP(src4+12)); \
346 OP(LP(dst+12),no_rnd_PACK(a0,a1,a2,a3)); \
347 src1+=src_stride1;\
348 src2+=src_stride2;\
349 src3+=src_stride3;\
350 src4+=src_stride4;\
351 dst+=dst_stride;\
352 } while(--h); \
353 } \
354 \
355
356 #define op_avg(a, b) a = rnd_avg32(a,b)
357 #define op_put(a, b) a = b
358
359 PIXOP2(avg, op_avg)
360 PIXOP2(put, op_put)
361 #undef op_avg
362 #undef op_put
363
364 #define avg2(a,b) ((a+b+1)>>1)
365 #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
366
367
368 static void gmc1_c(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder)
369 {
370 const int A=(16-x16)*(16-y16);
371 const int B=( x16)*(16-y16);
372 const int C=(16-x16)*( y16);
373 const int D=( x16)*( y16);
374
375 do {
376 int t0,t1,t2,t3;
377 uint8_t *s0 = src;
378 uint8_t *s1 = src+stride;
379 t0 = *s0++; t2 = *s1++;
380 t1 = *s0++; t3 = *s1++;
381 dst[0]= (A*t0 + B*t1 + C*t2 + D*t3 + rounder)>>8;
382 t0 = *s0++; t2 = *s1++;
383 dst[1]= (A*t1 + B*t0 + C*t3 + D*t2 + rounder)>>8;
384 t1 = *s0++; t3 = *s1++;
385 dst[2]= (A*t0 + B*t1 + C*t2 + D*t3 + rounder)>>8;
386 t0 = *s0++; t2 = *s1++;
387 dst[3]= (A*t1 + B*t0 + C*t3 + D*t2 + rounder)>>8;
388 t1 = *s0++; t3 = *s1++;
389 dst[4]= (A*t0 + B*t1 + C*t2 + D*t3 + rounder)>>8;
390 t0 = *s0++; t2 = *s1++;
391 dst[5]= (A*t1 + B*t0 + C*t3 + D*t2 + rounder)>>8;
392 t1 = *s0++; t3 = *s1++;
393 dst[6]= (A*t0 + B*t1 + C*t2 + D*t3 + rounder)>>8;
394 t0 = *s0++; t2 = *s1++;
395 dst[7]= (A*t1 + B*t0 + C*t3 + D*t2 + rounder)>>8;
396 dst+= stride;
397 src+= stride;
398 }while(--h);
399 }
400
401 static void gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
402 int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height)
403 {
404 int y, vx, vy;
405 const int s= 1<<shift;
406
407 width--;
408 height--;
409
410 for(y=0; y<h; y++){
411 int x;
412
413 vx= ox;
414 vy= oy;
415 for(x=0; x<8; x++){ //XXX FIXME optimize
416 int src_x, src_y, frac_x, frac_y, index;
417
418 src_x= vx>>16;
419 src_y= vy>>16;
420 frac_x= src_x&(s-1);
421 frac_y= src_y&(s-1);
422 src_x>>=shift;
423 src_y>>=shift;
424
425 if((unsigned)src_x < width){
426 if((unsigned)src_y < height){
427 index= src_x + src_y*stride;
428 dst[y*stride + x]= ( ( src[index ]*(s-frac_x)
429 + src[index +1]* frac_x )*(s-frac_y)
430 + ( src[index+stride ]*(s-frac_x)
431 + src[index+stride+1]* frac_x )* frac_y
432 + r)>>(shift*2);
433 }else{
434 index= src_x + clip(src_y, 0, height)*stride;
435 dst[y*stride + x]= ( ( src[index ]*(s-frac_x)
436 + src[index +1]* frac_x )*s
437 + r)>>(shift*2);
438 }
439 }else{
440 if((unsigned)src_y < height){
441 index= clip(src_x, 0, width) + src_y*stride;
442 dst[y*stride + x]= ( ( src[index ]*(s-frac_y)
443 + src[index+stride ]* frac_y )*s
444 + r)>>(shift*2);
445 }else{
446 index= clip(src_x, 0, width) + clip(src_y, 0, height)*stride;
447 dst[y*stride + x]= src[index ];
448 }
449 }
450
451 vx+= dxx;
452 vy+= dyx;
453 }
454 ox += dxy;
455 oy += dyy;
456 }
457 }
458 #define H264_CHROMA_MC(OPNAME, OP)\
459 static void OPNAME ## h264_chroma_mc2_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
460 const int A=(8-x)*(8-y);\
461 const int B=( x)*(8-y);\
462 const int C=(8-x)*( y);\
463 const int D=( x)*( y);\
464 \
465 assert(x<8 && y<8 && x>=0 && y>=0);\
466 \
467 do {\
468 int t0,t1,t2,t3; \
469 uint8_t *s0 = src; \
470 uint8_t *s1 = src+stride; \
471 t0 = *s0++; t2 = *s1++; \
472 t1 = *s0++; t3 = *s1++; \
473 OP(dst[0], (A*t0 + B*t1 + C*t2 + D*t3));\
474 t0 = *s0++; t2 = *s1++; \
475 OP(dst[1], (A*t1 + B*t0 + C*t3 + D*t2));\
476 dst+= stride;\
477 src+= stride;\
478 }while(--h);\
479 }\
480 \
481 static void OPNAME ## h264_chroma_mc4_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
482 const int A=(8-x)*(8-y);\
483 const int B=( x)*(8-y);\
484 const int C=(8-x)*( y);\
485 const int D=( x)*( y);\
486 \
487 assert(x<8 && y<8 && x>=0 && y>=0);\
488 \
489 do {\
490 int t0,t1,t2,t3; \
491 uint8_t *s0 = src; \
492 uint8_t *s1 = src+stride; \
493 t0 = *s0++; t2 = *s1++; \
494 t1 = *s0++; t3 = *s1++; \
495 OP(dst[0], (A*t0 + B*t1 + C*t2 + D*t3));\
496 t0 = *s0++; t2 = *s1++; \
497 OP(dst[1], (A*t1 + B*t0 + C*t3 + D*t2));\
498 t1 = *s0++; t3 = *s1++; \
499 OP(dst[2], (A*t0 + B*t1 + C*t2 + D*t3));\
500 t0 = *s0++; t2 = *s1++; \
501 OP(dst[3], (A*t1 + B*t0 + C*t3 + D*t2));\
502 dst+= stride;\
503 src+= stride;\
504 }while(--h);\
505 }\
506 \
507 static void OPNAME ## h264_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
508 const int A=(8-x)*(8-y);\
509 const int B=( x)*(8-y);\
510 const int C=(8-x)*( y);\
511 const int D=( x)*( y);\
512 \
513 assert(x<8 && y<8 && x>=0 && y>=0);\
514 \
515 do {\
516 int t0,t1,t2,t3; \
517 uint8_t *s0 = src; \
518 uint8_t *s1 = src+stride; \
519 t0 = *s0++; t2 = *s1++; \
520 t1 = *s0++; t3 = *s1++; \
521 OP(dst[0], (A*t0 + B*t1 + C*t2 + D*t3));\
522 t0 = *s0++; t2 = *s1++; \
523 OP(dst[1], (A*t1 + B*t0 + C*t3 + D*t2));\
524 t1 = *s0++; t3 = *s1++; \
525 OP(dst[2], (A*t0 + B*t1 + C*t2 + D*t3));\
526 t0 = *s0++; t2 = *s1++; \
527 OP(dst[3], (A*t1 + B*t0 + C*t3 + D*t2));\
528 t1 = *s0++; t3 = *s1++; \
529 OP(dst[4], (A*t0 + B*t1 + C*t2 + D*t3));\
530 t0 = *s0++; t2 = *s1++; \
531 OP(dst[5], (A*t1 + B*t0 + C*t3 + D*t2));\
532 t1 = *s0++; t3 = *s1++; \
533 OP(dst[6], (A*t0 + B*t1 + C*t2 + D*t3));\
534 t0 = *s0++; t2 = *s1++; \
535 OP(dst[7], (A*t1 + B*t0 + C*t3 + D*t2));\
536 dst+= stride;\
537 src+= stride;\
538 }while(--h);\
539 }
540
541 #define op_avg(a, b) a = (((a)+(((b) + 32)>>6)+1)>>1)
542 #define op_put(a, b) a = (((b) + 32)>>6)
543
544 H264_CHROMA_MC(put_ , op_put)
545 H264_CHROMA_MC(avg_ , op_avg)
546 #undef op_avg
547 #undef op_put
548
549 /* not yet optimized */
550 static inline void copy_block4(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
551 {
552 int i;
553 for(i=0; i<h; i++)
554 {
555 ST32(dst , LD32(src ));
556 dst+=dstStride;
557 src+=srcStride;
558 }
559 }
560
561 static inline void copy_block8(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
562 {
563 int i;
564 for(i=0; i<h; i++)
565 {
566 ST32(dst , LD32(src ));
567 ST32(dst+4 , LD32(src+4 ));
568 dst+=dstStride;
569 src+=srcStride;
570 }
571 }
572
573 static inline void copy_block16(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
574 {
575 int i;
576 for(i=0; i<h; i++)
577 {
578 ST32(dst , LD32(src ));
579 ST32(dst+4 , LD32(src+4 ));
580 ST32(dst+8 , LD32(src+8 ));
581 ST32(dst+12, LD32(src+12));
582 dst+=dstStride;
583 src+=srcStride;
584 }
585 }
586
587 static inline void copy_block17(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
588 {
589 int i;
590 for(i=0; i<h; i++)
591 {
592 ST32(dst , LD32(src ));
593 ST32(dst+4 , LD32(src+4 ));
594 ST32(dst+8 , LD32(src+8 ));
595 ST32(dst+12, LD32(src+12));
596 dst[16]= src[16];
597 dst+=dstStride;
598 src+=srcStride;
599 }
600 }
601
602 static inline void copy_block9(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
603 {
604 int i;
605 for(i=0; i<h; i++)
606 {
607 ST32(dst , LD32(src ));
608 ST32(dst+4 , LD32(src+4 ));
609 dst[8]= src[8];
610 dst+=dstStride;
611 src+=srcStride;
612 }
613 }
614 /* end not optimized */
615
616 #define QPEL_MC(r, OPNAME, RND, OP) \
617 static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
618 uint8_t *cm = cropTbl + MAX_NEG_CROP;\
619 do {\
620 uint8_t *s = src; \
621 int src0,src1,src2,src3,src4,src5,src6,src7,src8;\
622 src0= *s++;\
623 src1= *s++;\
624 src2= *s++;\
625 src3= *s++;\
626 src4= *s++;\
627 OP(dst[0], (src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4));\
628 src5= *s++;\
629 OP(dst[1], (src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5));\
630 src6= *s++;\
631 OP(dst[2], (src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6));\
632 src7= *s++;\
633 OP(dst[3], (src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7));\
634 src8= *s++;\
635 OP(dst[4], (src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8));\
636 OP(dst[5], (src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8));\
637 OP(dst[6], (src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7));\
638 OP(dst[7], (src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6));\
639 dst+=dstStride;\
640 src+=srcStride;\
641 }while(--h);\
642 }\
643 \
644 static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
645 uint8_t *cm = cropTbl + MAX_NEG_CROP;\
646 int w=8;\
647 do{\
648 uint8_t *s = src, *d=dst;\
649 int src0,src1,src2,src3,src4,src5,src6,src7,src8;\
650 src0 = *s; s+=srcStride; \
651 src1 = *s; s+=srcStride; \
652 src2 = *s; s+=srcStride; \
653 src3 = *s; s+=srcStride; \
654 src4 = *s; s+=srcStride; \
655 OP(*d, (src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4));d+=dstStride;\
656 src5 = *s; s+=srcStride; \
657 OP(*d, (src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5));d+=dstStride;\
658 src6 = *s; s+=srcStride; \
659 OP(*d, (src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6));d+=dstStride;\
660 src7 = *s; s+=srcStride; \
661 OP(*d, (src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7));d+=dstStride;\
662 src8 = *s; \
663 OP(*d, (src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8));d+=dstStride;\
664 OP(*d, (src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8));d+=dstStride;\
665 OP(*d, (src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7));d+=dstStride;\
666 OP(*d, (src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6));\
667 dst++;\
668 src++;\
669 }while(--w);\
670 }\
671 \
672 static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
673 uint8_t *cm = cropTbl + MAX_NEG_CROP;\
674 do {\
675 uint8_t *s = src;\
676 int src0,src1,src2,src3,src4,src5,src6,src7,src8;\
677 int src9,src10,src11,src12,src13,src14,src15,src16;\
678 src0= *s++;\
679 src1= *s++;\
680 src2= *s++;\
681 src3= *s++;\
682 src4= *s++;\
683 OP(dst[ 0], (src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 ));\
684 src5= *s++;\
685 OP(dst[ 1], (src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 ));\
686 src6= *s++;\
687 OP(dst[ 2], (src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 ));\
688 src7= *s++;\
689 OP(dst[ 3], (src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 ));\
690 src8= *s++;\
691 OP(dst[ 4], (src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 ));\
692 src9= *s++;\
693 OP(dst[ 5], (src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 ));\
694 src10= *s++;\
695 OP(dst[ 6], (src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10));\
696 src11= *s++;\
697 OP(dst[ 7], (src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11));\
698 src12= *s++;\
699 OP(dst[ 8], (src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12));\
700 src13= *s++;\
701 OP(dst[ 9], (src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13));\
702 src14= *s++;\
703 OP(dst[10], (src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14));\
704 src15= *s++;\
705 OP(dst[11], (src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15));\
706 src16= *s++;\
707 OP(dst[12], (src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16));\
708 OP(dst[13], (src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16));\
709 OP(dst[14], (src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15));\
710 OP(dst[15], (src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14));\
711 dst+=dstStride;\
712 src+=srcStride;\
713 }while(--h);\
714 }\
715 \
716 static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
717 uint8_t *cm = cropTbl + MAX_NEG_CROP;\
718 int w=16;\
719 do {\
720 uint8_t *s = src, *d=dst;\
721 int src0,src1,src2,src3,src4,src5,src6,src7,src8;\
722 int src9,src10,src11,src12,src13,src14,src15,src16;\
723 src0 = *s; s+=srcStride; \
724 src1 = *s; s+=srcStride; \
725 src2 = *s; s+=srcStride; \
726 src3 = *s; s+=srcStride; \
727 src4 = *s; s+=srcStride; \
728 OP(*d, (src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 ));d+=dstStride;\
729 src5 = *s; s+=srcStride; \
730 OP(*d, (src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 ));d+=dstStride;\
731 src6 = *s; s+=srcStride; \
732 OP(*d, (src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 ));d+=dstStride;\
733 src7 = *s; s+=srcStride; \
734 OP(*d, (src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 ));d+=dstStride;\
735 src8 = *s; s+=srcStride; \
736 OP(*d, (src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 ));d+=dstStride;\
737 src9 = *s; s+=srcStride; \
738 OP(*d, (src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 ));d+=dstStride;\
739 src10 = *s; s+=srcStride; \
740 OP(*d, (src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10));d+=dstStride;\
741 src11 = *s; s+=srcStride; \
742 OP(*d, (src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11));d+=dstStride;\
743 src12 = *s; s+=srcStride; \
744 OP(*d, (src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12));d+=dstStride;\
745 src13 = *s; s+=srcStride; \
746 OP(*d, (src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13));d+=dstStride;\
747 src14 = *s; s+=srcStride; \
748 OP(*d, (src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14));d+=dstStride;\
749 src15 = *s; s+=srcStride; \
750 OP(*d, (src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15));d+=dstStride;\
751 src16 = *s; \
752 OP(*d, (src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16));d+=dstStride;\
753 OP(*d, (src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16));d+=dstStride;\
754 OP(*d, (src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15));d+=dstStride;\
755 OP(*d, (src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14));\
756 dst++;\
757 src++;\
758 }while(--w);\
759 }\
760 \
761 static void OPNAME ## qpel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){\
762 OPNAME ## pixels8_c(dst, src, stride, 8);\
763 }\
764 \
765 static void OPNAME ## qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
766 uint8_t half[64];\
767 put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
768 OPNAME ## pixels8_l2_aligned2(dst, src, half, stride, stride, 8, 8);\
769 }\
770 \
771 static void OPNAME ## qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
772 OPNAME ## mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);\
773 }\
774 \
775 static void OPNAME ## qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
776 uint8_t half[64];\
777 put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
778 OPNAME ## pixels8_l2_aligned2(dst, src+1, half, stride, stride, 8, 8);\
779 }\
780 \
781 static void OPNAME ## qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
782 uint8_t full[16*9];\
783 uint8_t half[64];\
784 copy_block9(full, src, 16, stride, 9);\
785 put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
786 OPNAME ## pixels8_l2_aligned(dst, full, half, stride, 16, 8, 8);\
787 }\
788 \
789 static void OPNAME ## qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
790 uint8_t full[16*9];\
791 copy_block9(full, src, 16, stride, 9);\
792 OPNAME ## mpeg4_qpel8_v_lowpass(dst, full, stride, 16);\
793 }\
794 \
795 static void OPNAME ## qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
796 uint8_t full[16*9];\
797 uint8_t half[64];\
798 copy_block9(full, src, 16, stride, 9);\
799 put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
800 OPNAME ## pixels8_l2_aligned(dst, full+16, half, stride, 16, 8, 8);\
801 }\
802 static void ff_ ## OPNAME ## qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
803 uint8_t full[16*9];\
804 uint8_t halfH[72];\
805 uint8_t halfV[64];\
806 uint8_t halfHV[64];\
807 copy_block9(full, src, 16, stride, 9);\
808 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
809 put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
810 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
811 OPNAME ## pixels8_l4_aligned(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
812 }\
813 static void OPNAME ## qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
814 uint8_t full[16*9];\
815 uint8_t halfH[72];\
816 uint8_t halfHV[64];\
817 copy_block9(full, src, 16, stride, 9);\
818 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
819 put ## RND ## pixels8_l2_aligned(halfH, halfH, full, 8, 8, 16, 9);\
820 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
821 OPNAME ## pixels8_l2_aligned(dst, halfH, halfHV, stride, 8, 8, 8);\
822 }\
823 static void ff_ ## OPNAME ## qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
824 uint8_t full[16*9];\
825 uint8_t halfH[72];\
826 uint8_t halfV[64];\
827 uint8_t halfHV[64];\
828 copy_block9(full, src, 16, stride, 9);\
829 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
830 put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
831 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
832 OPNAME ## pixels8_l4_aligned0(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
833 }\
834 static void OPNAME ## qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
835 uint8_t full[16*9];\
836 uint8_t halfH[72];\
837 uint8_t halfHV[64];\
838 copy_block9(full, src, 16, stride, 9);\
839 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
840 put ## RND ## pixels8_l2_aligned1(halfH, halfH, full+1, 8, 8, 16, 9);\
841 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
842 OPNAME ## pixels8_l2_aligned(dst, halfH, halfHV, stride, 8, 8, 8);\
843 }\
844 static void ff_ ## OPNAME ## qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
845 uint8_t full[16*9];\
846 uint8_t halfH[72];\
847 uint8_t halfV[64];\
848 uint8_t halfHV[64];\
849 copy_block9(full, src, 16, stride, 9);\
850 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
851 put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
852 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
853 OPNAME ## pixels8_l4_aligned(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
854 }\
855 static void OPNAME ## qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
856 uint8_t full[16*9];\
857 uint8_t halfH[72];\
858 uint8_t halfHV[64];\
859 copy_block9(full, src, 16, stride, 9);\
860 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
861 put ## RND ## pixels8_l2_aligned(halfH, halfH, full, 8, 8, 16, 9);\
862 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
863 OPNAME ## pixels8_l2_aligned(dst, halfH+8, halfHV, stride, 8, 8, 8);\
864 }\
865 static void ff_ ## OPNAME ## qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
866 uint8_t full[16*9];\
867 uint8_t halfH[72];\
868 uint8_t halfV[64];\
869 uint8_t halfHV[64];\
870 copy_block9(full, src, 16, stride, 9);\
871 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full , 8, 16, 9);\
872 put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
873 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
874 OPNAME ## pixels8_l4_aligned0(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
875 }\
876 static void OPNAME ## qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
877 uint8_t full[16*9];\
878 uint8_t halfH[72];\
879 uint8_t halfHV[64];\
880 copy_block9(full, src, 16, stride, 9);\
881 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
882 put ## RND ## pixels8_l2_aligned1(halfH, halfH, full+1, 8, 8, 16, 9);\
883 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
884 OPNAME ## pixels8_l2_aligned(dst, halfH+8, halfHV, stride, 8, 8, 8);\
885 }\
886 static void OPNAME ## qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
887 uint8_t halfH[72];\
888 uint8_t halfHV[64];\
889 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
890 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
891 OPNAME ## pixels8_l2_aligned(dst, halfH, halfHV, stride, 8, 8, 8);\
892 }\
893 static void OPNAME ## qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
894 uint8_t halfH[72];\
895 uint8_t halfHV[64];\
896 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
897 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
898 OPNAME ## pixels8_l2_aligned(dst, halfH+8, halfHV, stride, 8, 8, 8);\
899 }\
900 static void ff_ ## OPNAME ## qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
901 uint8_t full[16*9];\
902 uint8_t halfH[72];\
903 uint8_t halfV[64];\
904 uint8_t halfHV[64];\
905 copy_block9(full, src, 16, stride, 9);\
906 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
907 put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
908 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
909 OPNAME ## pixels8_l2_aligned(dst, halfV, halfHV, stride, 8, 8, 8);\
910 }\
911 static void OPNAME ## qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
912 uint8_t full[16*9];\
913 uint8_t halfH[72];\
914 copy_block9(full, src, 16, stride, 9);\
915 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
916 put ## RND ## pixels8_l2_aligned(halfH, halfH, full, 8, 8, 16, 9);\
917 OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
918 }\
919 static void ff_ ## OPNAME ## qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
920 uint8_t full[16*9];\
921 uint8_t halfH[72];\
922 uint8_t halfV[64];\
923 uint8_t halfHV[64];\
924 copy_block9(full, src, 16, stride, 9);\
925 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
926 put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
927 put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
928 OPNAME ## pixels8_l2_aligned(dst, halfV, halfHV, stride, 8, 8, 8);\
929 }\
930 static void OPNAME ## qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
931 uint8_t full[16*9];\
932 uint8_t halfH[72];\
933 copy_block9(full, src, 16, stride, 9);\
934 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
935 put ## RND ## pixels8_l2_aligned1(halfH, halfH, full+1, 8, 8, 16, 9);\
936 OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
937 }\
938 static void OPNAME ## qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
939 uint8_t halfH[72];\
940 put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
941 OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
942 }\
943 static void OPNAME ## qpel16_mc00_c (uint8_t *dst, uint8_t *src, int stride){\
944 OPNAME ## pixels16_c(dst, src, stride, 16);\
945 }\
946 \
947 static void OPNAME ## qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
948 uint8_t half[256];\
949 put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
950 OPNAME ## pixels16_l2_aligned2(dst, src, half, stride, stride, 16, 16);\
951 }\
952 \
953 static void OPNAME ## qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
954 OPNAME ## mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);\
955 }\
956 \
957 static void OPNAME ## qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
958 uint8_t half[256];\
959 put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
960 OPNAME ## pixels16_l2_aligned2(dst, src+1, half, stride, stride, 16, 16);\
961 }\
962 \
963 static void OPNAME ## qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
964 uint8_t full[24*17];\
965 uint8_t half[256];\
966 copy_block17(full, src, 24, stride, 17);\
967 put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
968 OPNAME ## pixels16_l2_aligned(dst, full, half, stride, 24, 16, 16);\
969 }\
970 \
971 static void OPNAME ## qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
972 uint8_t full[24*17];\
973 copy_block17(full, src, 24, stride, 17);\
974 OPNAME ## mpeg4_qpel16_v_lowpass(dst, full, stride, 24);\
975 }\
976 \
977 static void OPNAME ## qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
978 uint8_t full[24*17];\
979 uint8_t half[256];\
980 copy_block17(full, src, 24, stride, 17);\
981 put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
982 OPNAME ## pixels16_l2_aligned(dst, full+24, half, stride, 24, 16, 16);\
983 }\
984 static void ff_ ## OPNAME ## qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
985 uint8_t full[24*17];\
986 uint8_t halfH[272];\
987 uint8_t halfV[256];\
988 uint8_t halfHV[256];\
989 copy_block17(full, src, 24, stride, 17);\
990 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
991 put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
992 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
993 OPNAME ## pixels16_l4_aligned(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
994 }\
995 static void OPNAME ## qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
996 uint8_t full[24*17];\
997 uint8_t halfH[272];\
998 uint8_t halfHV[256];\
999 copy_block17(full, src, 24, stride, 17);\
1000 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1001 put ## RND ## pixels16_l2_aligned(halfH, halfH, full, 16, 16, 24, 17);\
1002 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1003 OPNAME ## pixels16_l2_aligned(dst, halfH, halfHV, stride, 16, 16, 16);\
1004 }\
1005 static void ff_ ## OPNAME ## qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
1006 uint8_t full[24*17];\
1007 uint8_t halfH[272];\
1008 uint8_t halfV[256];\
1009 uint8_t halfHV[256];\
1010 copy_block17(full, src, 24, stride, 17);\
1011 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1012 put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1013 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1014 OPNAME ## pixels16_l4_aligned0(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1015 }\
1016 static void OPNAME ## qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
1017 uint8_t full[24*17];\
1018 uint8_t halfH[272];\
1019 uint8_t halfHV[256];\
1020 copy_block17(full, src, 24, stride, 17);\
1021 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1022 put ## RND ## pixels16_l2_aligned1(halfH, halfH, full+1, 16, 16, 24, 17);\
1023 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1024 OPNAME ## pixels16_l2_aligned(dst, halfH, halfHV, stride, 16, 16, 16);\
1025 }\
1026 static void ff_ ## OPNAME ## qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
1027 uint8_t full[24*17];\
1028 uint8_t halfH[272];\
1029 uint8_t halfV[256];\
1030 uint8_t halfHV[256];\
1031 copy_block17(full, src, 24, stride, 17);\
1032 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1033 put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1034 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1035 OPNAME ## pixels16_l4_aligned(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1036 }\
1037 static void OPNAME ## qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
1038 uint8_t full[24*17];\
1039 uint8_t halfH[272];\
1040 uint8_t halfHV[256];\
1041 copy_block17(full, src, 24, stride, 17);\
1042 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1043 put ## RND ## pixels16_l2_aligned(halfH, halfH, full, 16, 16, 24, 17);\
1044 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1045 OPNAME ## pixels16_l2_aligned(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1046 }\
1047 static void ff_ ## OPNAME ## qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
1048 uint8_t full[24*17];\
1049 uint8_t halfH[272];\
1050 uint8_t halfV[256];\
1051 uint8_t halfHV[256];\
1052 copy_block17(full, src, 24, stride, 17);\
1053 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full , 16, 24, 17);\
1054 put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1055 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1056 OPNAME ## pixels16_l4_aligned0(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1057 }\
1058 static void OPNAME ## qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
1059 uint8_t full[24*17];\
1060 uint8_t halfH[272];\
1061 uint8_t halfHV[256];\
1062 copy_block17(full, src, 24, stride, 17);\
1063 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1064 put ## RND ## pixels16_l2_aligned1(halfH, halfH, full+1, 16, 16, 24, 17);\
1065 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1066 OPNAME ## pixels16_l2_aligned(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1067 }\
1068 static void OPNAME ## qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
1069 uint8_t halfH[272];\
1070 uint8_t halfHV[256];\
1071 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1072 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1073 OPNAME ## pixels16_l2_aligned(dst, halfH, halfHV, stride, 16, 16, 16);\
1074 }\
1075 static void OPNAME ## qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
1076 uint8_t halfH[272];\
1077 uint8_t halfHV[256];\
1078 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1079 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1080 OPNAME ## pixels16_l2_aligned(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1081 }\
1082 static void ff_ ## OPNAME ## qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
1083 uint8_t full[24*17];\
1084 uint8_t halfH[272];\
1085 uint8_t halfV[256];\
1086 uint8_t halfHV[256];\
1087 copy_block17(full, src, 24, stride, 17);\
1088 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1089 put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1090 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1091 OPNAME ## pixels16_l2_aligned(dst, halfV, halfHV, stride, 16, 16, 16);\
1092 }\
1093 static void OPNAME ## qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
1094 uint8_t full[24*17];\
1095 uint8_t halfH[272];\
1096 copy_block17(full, src, 24, stride, 17);\
1097 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1098 put ## RND ## pixels16_l2_aligned(halfH, halfH, full, 16, 16, 24, 17);\
1099 OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1100 }\
1101 static void ff_ ## OPNAME ## qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
1102 uint8_t full[24*17];\
1103 uint8_t halfH[272];\
1104 uint8_t halfV[256];\
1105 uint8_t halfHV[256];\
1106 copy_block17(full, src, 24, stride, 17);\
1107 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1108 put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1109 put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1110 OPNAME ## pixels16_l2_aligned(dst, halfV, halfHV, stride, 16, 16, 16);\
1111 }\
1112 static void OPNAME ## qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
1113 uint8_t full[24*17];\
1114 uint8_t halfH[272];\
1115 copy_block17(full, src, 24, stride, 17);\
1116 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1117 put ## RND ## pixels16_l2_aligned1(halfH, halfH, full+1, 16, 16, 24, 17);\
1118 OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1119 }\
1120 static void OPNAME ## qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
1121 uint8_t halfH[272];\
1122 put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1123 OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1124 }
1125
1126 #define op_avg(a, b) a = (((a)+cm[((b) + 16)>>5]+1)>>1)
1127 #define op_avg_no_rnd(a, b) a = (((a)+cm[((b) + 15)>>5])>>1)
1128 #define op_put(a, b) a = cm[((b) + 16)>>5]
1129 #define op_put_no_rnd(a, b) a = cm[((b) + 15)>>5]
1130
1131 QPEL_MC(0, put_ , _ , op_put)
1132 QPEL_MC(1, put_no_rnd_, _no_rnd_, op_put_no_rnd)
1133 QPEL_MC(0, avg_ , _ , op_avg)
1134 //QPEL_MC(1, avg_no_rnd , _ , op_avg)
1135 #undef op_avg
1136 #undef op_avg_no_rnd
1137 #undef op_put
1138 #undef op_put_no_rnd
1139
1140 #if 1
1141 #define H264_LOWPASS(OPNAME, OP, OP2) \
1142 static inline void OPNAME ## h264_qpel_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride,int w,int h){\
1143 uint8_t *cm = cropTbl + MAX_NEG_CROP;\
1144 do {\
1145 int srcB,srcA,src0,src1,src2,src3,src4,src5,src6;\
1146 uint8_t *s = src-2;\
1147 srcB = *s++;\
1148 srcA = *s++;\
1149 src0 = *s++;\
1150 src1 = *s++;\
1151 src2 = *s++;\
1152 src3 = *s++;\
1153 OP(dst[0], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
1154 src4 = *s++;\
1155 OP(dst[1], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
1156 src5 = *s++;\
1157 OP(dst[2], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));\
1158 src6 = *s++;\
1159 OP(dst[3], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));\
1160 if (w>4) { /* it optimized */ \
1161 int src7,src8,src9,src10; \
1162 src7 = *s++;\
1163 OP(dst[4], (src4+src5)*20 - (src3+src6)*5 + (src2+src7));\
1164 src8 = *s++;\
1165 OP(dst[5], (src5+src6)*20 - (src4+src7)*5 + (src3+src8));\
1166 src9 = *s++;\
1167 OP(dst[6], (src6+src7)*20 - (src5+src8)*5 + (src4+src9));\
1168 src10 = *s++;\
1169 OP(dst[7], (src7+src8)*20 - (src6+src9)*5 + (src5+src10));\
1170 if (w>8) { \
1171 int src11,src12,src13,src14,src15,src16,src17,src18; \
1172 src11 = *s++;\
1173 OP(dst[8] , (src8 +src9 )*20 - (src7 +src10)*5 + (src6 +src11));\
1174 src12 = *s++;\
1175 OP(dst[9] , (src9 +src10)*20 - (src8 +src11)*5 + (src7 +src12));\
1176 src13 = *s++;\
1177 OP(dst[10], (src10+src11)*20 - (src9 +src12)*5 + (src8 +src13));\
1178 src14 = *s++;\
1179 OP(dst[11], (src11+src12)*20 - (src10+src13)*5 + (src9 +src14));\
1180 src15 = *s++;\
1181 OP(dst[12], (src12+src13)*20 - (src11+src14)*5 + (src10+src15));\
1182 src16 = *s++;\
1183 OP(dst[13], (src13+src14)*20 - (src12+src15)*5 + (src11+src16));\
1184 src17 = *s++;\
1185 OP(dst[14], (src14+src15)*20 - (src13+src16)*5 + (src12+src17));\
1186 src18 = *s++;\
1187 OP(dst[15], (src15+src16)*20 - (src14+src17)*5 + (src13+src18));\
1188 } \
1189 } \
1190 dst+=dstStride;\
1191 src+=srcStride;\
1192 }while(--h);\
1193 }\
1194 \
1195 static inline void OPNAME ## h264_qpel_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride,int w,int h){\
1196 uint8_t *cm = cropTbl + MAX_NEG_CROP;\
1197 do{\
1198 int srcB,srcA,src0,src1,src2,src3,src4,src5,src6;\
1199 uint8_t *s = src-2*srcStride,*d=dst;\
1200 srcB = *s; s+=srcStride;\
1201 srcA = *s; s+=srcStride;\
1202 src0 = *s; s+=srcStride;\
1203 src1 = *s; s+=srcStride;\
1204 src2 = *s; s+=srcStride;\
1205 src3 = *s; s+=srcStride;\
1206 OP(*d, (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));d+=dstStride;\
1207 src4 = *s; s+=srcStride;\
1208 OP(*d, (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));d+=dstStride;\
1209 src5 = *s; s+=srcStride;\
1210 OP(*d, (src2+src3)*20 - (src1+src4)*5 + (src0+src5));d+=dstStride;\
1211 src6 = *s; s+=srcStride;\
1212 OP(*d, (src3+src4)*20 - (src2+src5)*5 + (src1+src6));d+=dstStride;\
1213 if (h>4) { \
1214 int src7,src8,src9,src10; \
1215 src7 = *s; s+=srcStride;\
1216 OP(*d, (src4+src5)*20 - (src3+src6)*5 + (src2+src7));d+=dstStride;\
1217 src8 = *s; s+=srcStride;\
1218 OP(*d, (src5+src6)*20 - (src4+src7)*5 + (src3+src8));d+=dstStride;\
1219 src9 = *s; s+=srcStride;\
1220 OP(*d, (src6+src7)*20 - (src5+src8)*5 + (src4+src9));d+=dstStride;\
1221 src10 = *s; s+=srcStride;\
1222 OP(*d, (src7+src8)*20 - (src6+src9)*5 + (src5+src10));d+=dstStride;\
1223 if (h>8) { \
1224 int src11,src12,src13,src14,src15,src16,src17,src18; \
1225 src11 = *s; s+=srcStride;\
1226 OP(*d , (src8 +src9 )*20 - (src7 +src10)*5 + (src6 +src11));d+=dstStride;\
1227 src12 = *s; s+=srcStride;\
1228 OP(*d , (src9 +src10)*20 - (src8 +src11)*5 + (src7 +src12));d+=dstStride;\
1229 src13 = *s; s+=srcStride;\
1230 OP(*d, (src10+src11)*20 - (src9 +src12)*5 + (src8 +src13));d+=dstStride;\
1231 src14 = *s; s+=srcStride;\
1232 OP(*d, (src11+src12)*20 - (src10+src13)*5 + (src9 +src14));d+=dstStride;\
1233 src15 = *s; s+=srcStride;\
1234 OP(*d, (src12+src13)*20 - (src11+src14)*5 + (src10+src15));d+=dstStride;\
1235 src16 = *s; s+=srcStride;\
1236 OP(*d, (src13+src14)*20 - (src12+src15)*5 + (src11+src16));d+=dstStride;\
1237 src17 = *s; s+=srcStride;\
1238 OP(*d, (src14+src15)*20 - (src13+src16)*5 + (src12+src17));d+=dstStride;\
1239 src18 = *s; s+=srcStride;\
1240 OP(*d, (src15+src16)*20 - (src14+src17)*5 + (src13+src18));d+=dstStride;\
1241 } \
1242 } \
1243 dst++;\
1244 src++;\
1245 }while(--w);\
1246 }\
1247 \
1248 static inline void OPNAME ## h264_qpel_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride,int w,int h){\
1249 uint8_t *cm = cropTbl + MAX_NEG_CROP;\
1250 int i;\
1251 src -= 2*srcStride;\
1252 i= h+5; \
1253 do {\
1254 int srcB,srcA,src0,src1,src2,src3,src4,src5,src6;\
1255 uint8_t *s = src-2;\
1256 srcB = *s++;\
1257 srcA = *s++;\
1258 src0 = *s++;\
1259 src1 = *s++;\
1260 src2 = *s++;\
1261 src3 = *s++;\
1262 tmp[0] = ((src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
1263 src4 = *s++;\
1264 tmp[1] = ((src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
1265 src5 = *s++;\
1266 tmp[2] = ((src2+src3)*20 - (src1+src4)*5 + (src0+src5));\
1267 src6 = *s++;\
1268 tmp[3] = ((src3+src4)*20 - (src2+src5)*5 + (src1+src6));\
1269 if (w>4) { /* it optimized */ \
1270 int src7,src8,src9,src10; \
1271 src7 = *s++;\
1272 tmp[4] = ((src4+src5)*20 - (src3+src6)*5 + (src2+src7));\
1273 src8 = *s++;\
1274 tmp[5] = ((src5+src6)*20 - (src4+src7)*5 + (src3+src8));\
1275 src9 = *s++;\
1276 tmp[6] = ((src6+src7)*20 - (src5+src8)*5 + (src4+src9));\
1277 src10 = *s++;\
1278 tmp[7] = ((src7+src8)*20 - (src6+src9)*5 + (src5+src10));\
1279 if (w>8) { \
1280 int src11,src12,src13,src14,src15,src16,src17,src18; \
1281 src11 = *s++;\
1282 tmp[8] = ((src8 +src9 )*20 - (src7 +src10)*5 + (src6 +src11));\
1283 src12 = *s++;\
1284 tmp[9] = ((src9 +src10)*20 - (src8 +src11)*5 + (src7 +src12));\
1285 src13 = *s++;\
1286 tmp[10] = ((src10+src11)*20 - (src9 +src12)*5 + (src8 +src13));\
1287 src14 = *s++;\
1288 tmp[11] = ((src11+src12)*20 - (src10+src13)*5 + (src9 +src14));\
1289 src15 = *s++;\
1290 tmp[12] = ((src12+src13)*20 - (src11+src14)*5 + (src10+src15));\
1291 src16 = *s++;\
1292 tmp[13] = ((src13+src14)*20 - (src12+src15)*5 + (src11+src16));\
1293 src17 = *s++;\
1294 tmp[14] = ((src14+src15)*20 - (src13+src16)*5 + (src12+src17));\
1295 src18 = *s++;\
1296 tmp[15] = ((src15+src16)*20 - (src14+src17)*5 + (src13+src18));\
1297 } \
1298 } \
1299 tmp+=tmpStride;\
1300 src+=srcStride;\
1301 }while(--i);\
1302 tmp -= tmpStride*(h+5-2);\
1303 i = w; \
1304 do {\
1305 int tmpB,tmpA,tmp0,tmp1,tmp2,tmp3,tmp4,tmp5,tmp6;\
1306 int16_t *s = tmp-2*tmpStride; \
1307 uint8_t *d=dst;\
1308 tmpB = *s; s+=tmpStride;\
1309 tmpA = *s; s+=tmpStride;\
1310 tmp0 = *s; s+=tmpStride;\
1311 tmp1 = *s; s+=tmpStride;\
1312 tmp2 = *s; s+=tmpStride;\
1313 tmp3 = *s; s+=tmpStride;\
1314 OP2(*d, (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));d+=dstStride;\
1315 tmp4 = *s; s+=tmpStride;\
1316 OP2(*d, (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));d+=dstStride;\
1317 tmp5 = *s; s+=tmpStride;\
1318 OP2(*d, (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));d+=dstStride;\
1319 tmp6 = *s; s+=tmpStride;\
1320 OP2(*d, (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));d+=dstStride;\
1321 if (h>4) { \
1322 int tmp7,tmp8,tmp9,tmp10; \
1323 tmp7 = *s; s+=tmpStride;\
1324 OP2(*d, (tmp4+tmp5)*20 - (tmp3+tmp6)*5 + (tmp2+tmp7));d+=dstStride;\
1325 tmp8 = *s; s+=tmpStride;\
1326 OP2(*d, (tmp5+tmp6)*20 - (tmp4+tmp7)*5 + (tmp3+tmp8));d+=dstStride;\
1327 tmp9 = *s; s+=tmpStride;\
1328 OP2(*d, (tmp6+tmp7)*20 - (tmp5+tmp8)*5 + (tmp4+tmp9));d+=dstStride;\
1329 tmp10 = *s; s+=tmpStride;\
1330 OP2(*d, (tmp7+tmp8)*20 - (tmp6+tmp9)*5 + (tmp5+tmp10));d+=dstStride;\
1331 if (h>8) { \
1332 int tmp11,tmp12,tmp13,tmp14,tmp15,tmp16,tmp17,tmp18; \
1333 tmp11 = *s; s+=tmpStride;\
1334 OP2(*d , (tmp8 +tmp9 )*20 - (tmp7 +tmp10)*5 + (tmp6 +tmp11));d+=dstStride;\
1335 tmp12 = *s; s+=tmpStride;\
1336 OP2(*d , (tmp9 +tmp10)*20 - (tmp8 +tmp11)*5 + (tmp7 +tmp12));d+=dstStride;\
1337 tmp13 = *s; s+=tmpStride;\
1338 OP2(*d, (tmp10+tmp11)*20 - (tmp9 +tmp12)*5 + (tmp8 +tmp13));d+=dstStride;\
1339 tmp14 = *s; s+=tmpStride;\
1340 OP2(*d, (tmp11+tmp12)*20 - (tmp10+tmp13)*5 + (tmp9 +tmp14));d+=dstStride;\
1341 tmp15 = *s; s+=tmpStride;\
1342 OP2(*d, (tmp12+tmp13)*20 - (tmp11+tmp14)*5 + (tmp10+tmp15));d+=dstStride;\
1343 tmp16 = *s; s+=tmpStride;\
1344 OP2(*d, (tmp13+tmp14)*20 - (tmp12+tmp15)*5 + (tmp11+tmp16));d+=dstStride;\
1345 tmp17 = *s; s+=tmpStride;\
1346 OP2(*d, (tmp14+tmp15)*20 - (tmp13+tmp16)*5 + (tmp12+tmp17));d+=dstStride;\
1347 tmp18 = *s; s+=tmpStride;\
1348 OP2(*d, (tmp15+tmp16)*20 - (tmp14+tmp17)*5 + (tmp13+tmp18));d+=dstStride;\
1349 } \
1350 } \
1351 dst++;\
1352 tmp++;\
1353 }while(--i);\
1354 }\
1355 \
1356 static void OPNAME ## h264_qpel4_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1357 OPNAME ## h264_qpel_h_lowpass(dst,src,dstStride,srcStride,4,4); \
1358 }\
1359 static void OPNAME ## h264_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1360 OPNAME ## h264_qpel_h_lowpass(dst,src,dstStride,srcStride,8,8); \
1361 }\
1362 static void OPNAME ## h264_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1363 OPNAME ## h264_qpel_h_lowpass(dst,src,dstStride,srcStride,16,16); \
1364 }\
1365 \
1366 static void OPNAME ## h264_qpel4_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1367 OPNAME ## h264_qpel_v_lowpass(dst,src,dstStride,srcStride,4,4); \
1368 }\
1369 static void OPNAME ## h264_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1370 OPNAME ## h264_qpel_v_lowpass(dst,src,dstStride,srcStride,8,8); \
1371 }\
1372 static void OPNAME ## h264_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1373 OPNAME ## h264_qpel_v_lowpass(dst,src,dstStride,srcStride,16,16); \
1374 }\
1375 static void OPNAME ## h264_qpel4_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
1376 OPNAME ## h264_qpel_hv_lowpass(dst,tmp,src,dstStride,tmpStride,srcStride,4,4); \
1377 }\
1378 static void OPNAME ## h264_qpel8_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
1379 OPNAME ## h264_qpel_hv_lowpass(dst,tmp,src,dstStride,tmpStride,srcStride,8,8); \
1380 }\
1381 static void OPNAME ## h264_qpel16_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
1382 OPNAME ## h264_qpel_hv_lowpass(dst,tmp,src,dstStride,tmpStride,srcStride,16,16); \
1383 }\
1384
1385 #define H264_MC(OPNAME, SIZE) \
1386 static void OPNAME ## h264_qpel ## SIZE ## _mc00_c (uint8_t *dst, uint8_t *src, int stride){\
1387 OPNAME ## pixels ## SIZE ## _c(dst, src, stride, SIZE);\
1388 }\
1389 \
1390 static void OPNAME ## h264_qpel ## SIZE ## _mc10_c(uint8_t *dst, uint8_t *src, int stride){\
1391 uint8_t half[SIZE*SIZE];\
1392 put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);\
1393 OPNAME ## pixels ## SIZE ## _l2_aligned2(dst, src, half, stride, stride, SIZE, SIZE);\
1394 }\
1395 \
1396 static void OPNAME ## h264_qpel ## SIZE ## _mc20_c(uint8_t *dst, uint8_t *src, int stride){\
1397 OPNAME ## h264_qpel ## SIZE ## _h_lowpass(dst, src, stride, stride);\
1398 }\
1399 \
1400 static void OPNAME ## h264_qpel ## SIZE ## _mc30_c(uint8_t *dst, uint8_t *src, int stride){\
1401 uint8_t half[SIZE*SIZE];\
1402 put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);\
1403 OPNAME ## pixels ## SIZE ## _l2_aligned2(dst, src+1, half, stride, stride, SIZE, SIZE);\
1404 }\
1405 \
1406 static void OPNAME ## h264_qpel ## SIZE ## _mc01_c(uint8_t *dst, uint8_t *src, int stride){\
1407 uint8_t full[SIZE*(SIZE+5)];\
1408 uint8_t * const full_mid= full + SIZE*2;\
1409 uint8_t half[SIZE*SIZE];\
1410 copy_block ## SIZE (full, src - stride*2, SIZE, stride, SIZE + 5);\
1411 put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);\
1412 OPNAME ## pixels ## SIZE ## _l2_aligned(dst, full_mid, half, stride, SIZE, SIZE, SIZE);\
1413 }\
1414 \
1415 static void OPNAME ## h264_qpel ## SIZE ## _mc02_c(uint8_t *dst, uint8_t *src, int stride){\
1416 uint8_t full[SIZE*(SIZE+5)];\
1417 uint8_t * const full_mid= full + SIZE*2;\
1418 copy_block ## SIZE (full, src - stride*2, SIZE, stride, SIZE + 5);\
1419 OPNAME ## h264_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE);\
1420 }\
1421 \
1422 static void OPNAME ## h264_qpel ## SIZE ## _mc03_c(uint8_t *dst, uint8_t *src, int stride){\
1423 uint8_t full[SIZE*(SIZE+5)];\
1424 uint8_t * const full_mid= full + SIZE*2;\
1425 uint8_t half[SIZE*SIZE];\
1426 copy_block ## SIZE (full, src - stride*2, SIZE, stride, SIZE + 5);\
1427 put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);\
1428 OPNAME ## pixels ## SIZE ## _l2_aligned(dst, full_mid+SIZE, half, stride, SIZE, SIZE, SIZE);\
1429 }\
1430 \
1431 static void OPNAME ## h264_qpel ## SIZE ## _mc11_c(uint8_t *dst, uint8_t *src, int stride){\
1432 uint8_t full[SIZE*(SIZE+5)];\
1433 uint8_t * const full_mid= full + SIZE*2;\
1434 uint8_t halfH[SIZE*SIZE];\
1435 uint8_t halfV[SIZE*SIZE];\
1436 put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
1437 copy_block ## SIZE (full, src - stride*2, SIZE, stride, SIZE + 5);\
1438 put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
1439 OPNAME ## pixels ## SIZE ## _l2_aligned(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
1440 }\
1441 \
1442 static void OPNAME ## h264_qpel ## SIZE ## _mc31_c(uint8_t *dst, uint8_t *src, int stride){\
1443 uint8_t full[SIZE*(SIZE+5)];\
1444 uint8_t * const full_mid= full + SIZE*2;\
1445 uint8_t halfH[SIZE*SIZE];\
1446 uint8_t halfV[SIZE*SIZE];\
1447 put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
1448 copy_block ## SIZE (full, src - stride*2 + 1, SIZE, stride, SIZE + 5);\
1449 put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
1450 OPNAME ## pixels ## SIZE ## _l2_aligned(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
1451 }\
1452 \
1453 static void OPNAME ## h264_qpel ## SIZE ## _mc13_c(uint8_t *dst, uint8_t *src, int stride){\
1454 uint8_t full[SIZE*(SIZE+5)];\
1455 uint8_t * const full_mid= full + SIZE*2;\
1456 uint8_t halfH[SIZE*SIZE];\
1457 uint8_t halfV[SIZE*SIZE];\
1458 put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
1459 copy_block ## SIZE (full, src - stride*2, SIZE, stride, SIZE + 5);\
1460 put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
1461 OPNAME ## pixels ## SIZE ## _l2_aligned(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
1462 }\
1463 \
1464 static void OPNAME ## h264_qpel ## SIZE ## _mc33_c(uint8_t *dst, uint8_t *src, int stride){\
1465 uint8_t full[SIZE*(SIZE+5)];\
1466 uint8_t * const full_mid= full + SIZE*2;\
1467 uint8_t halfH[SIZE*SIZE];\
1468 uint8_t halfV[SIZE*SIZE];\
1469 put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
1470 copy_block ## SIZE (full, src - stride*2 + 1, SIZE, stride, SIZE + 5);\
1471 put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
1472 OPNAME ## pixels ## SIZE ## _l2_aligned(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
1473 }\
1474 \
1475 static void OPNAME ## h264_qpel ## SIZE ## _mc22_c(uint8_t *dst, uint8_t *src, int stride){\
1476 int16_t tmp[SIZE*(SIZE+5)];\
1477 OPNAME ## h264_qpel ## SIZE ## _hv_lowpass(dst, tmp, src, stride, SIZE, stride);\
1478 }\
1479 \
1480 static void OPNAME ## h264_qpel ## SIZE ## _mc21_c(uint8_t *dst, uint8_t *src, int stride){\
1481 int16_t tmp[SIZE*(SIZE+5)];\
1482 uint8_t halfH[SIZE*SIZE];\
1483 uint8_t halfHV[SIZE*SIZE];\
1484 put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
1485 put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
1486 OPNAME ## pixels ## SIZE ## _l2_aligned(dst, halfH, halfHV, stride, SIZE, SIZE, SIZE);\
1487 }\
1488 \
1489 static void OPNAME ## h264_qpel ## SIZE ## _mc23_c(uint8_t *dst, uint8_t *src, int stride){\
1490 int16_t tmp[SIZE*(SIZE+5)];\
1491 uint8_t halfH[SIZE*SIZE];\
1492 uint8_t halfHV[SIZE*SIZE];\
1493 put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
1494 put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
1495 OPNAME ## pixels ## SIZE ## _l2_aligned(dst, halfH, halfHV, stride, SIZE, SIZE, SIZE);\
1496 }\
1497 \
1498 static void OPNAME ## h264_qpel ## SIZE ## _mc12_c(uint8_t *dst, uint8_t *src, int stride){\
1499 uint8_t full[SIZE*(SIZE+5)];\
1500 uint8_t * const full_mid= full + SIZE*2;\
1501 int16_t tmp[SIZE*(SIZE+5)];\
1502 uint8_t halfV[SIZE*SIZE];\
1503 uint8_t halfHV[SIZE*SIZE];\
1504 copy_block ## SIZE (full, src - stride*2, SIZE, stride, SIZE + 5);\
1505 put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
1506 put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
1507 OPNAME ## pixels ## SIZE ## _l2_aligned(dst, halfV, halfHV, stride, SIZE, SIZE, SIZE);\
1508 }\
1509 \
1510 static void OPNAME ## h264_qpel ## SIZE ## _mc32_c(uint8_t *dst, uint8_t *src, int stride){\
1511 uint8_t full[SIZE*(SIZE+5)];\
1512 uint8_t * const full_mid= full + SIZE*2;\
1513 int16_t tmp[SIZE*(SIZE+5)];\
1514 uint8_t halfV[SIZE*SIZE];\
1515 uint8_t halfHV[SIZE*SIZE];\
1516 copy_block ## SIZE (full, src - stride*2 + 1, SIZE, stride, SIZE + 5);\
1517 put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
1518 put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
1519 OPNAME ## pixels ## SIZE ## _l2_aligned(dst, halfV, halfHV, stride, SIZE, SIZE, SIZE);\
1520 }\
1521
1522 #define op_avg(a, b) a = (((a)+cm[((b) + 16)>>5]+1)>>1)
1523 //#define op_avg2(a, b) a = (((a)*w1+cm[((b) + 16)>>5]*w2 + o + 64)>>7)
1524 #define op_put(a, b) a = cm[((b) + 16)>>5]
1525 #define op2_avg(a, b) a = (((a)+cm[((b) + 512)>>10]+1)>>1)
1526 #define op2_put(a, b) a = cm[((b) + 512)>>10]
1527
1528 H264_LOWPASS(put_ , op_put, op2_put)
1529 H264_LOWPASS(avg_ , op_avg, op2_avg)
1530 H264_MC(put_, 4)
1531 H264_MC(put_, 8)
1532 H264_MC(put_, 16)
1533 H264_MC(avg_, 4)
1534 H264_MC(avg_, 8)
1535 H264_MC(avg_, 16)
1536
1537 #undef op_avg
1538 #undef op_put
1539 #undef op2_avg
1540 #undef op2_put
1541 #endif
1542
1543 static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
1544 uint8_t *cm = cropTbl + MAX_NEG_CROP;
1545
1546 do{
1547 int src_1,src0,src1,src2,src3,src4,src5,src6,src7,src8,src9;
1548 uint8_t *s = src;
1549 src_1 = s[-1];
1550 src0 = *s++;
1551 src1 = *s++;
1552 src2 = *s++;
1553 dst[0]= cm[(9*(src0 + src1) - (src_1 + src2) + 8)>>4];
1554 src3 = *s++;
1555 dst[1]= cm[(9*(src1 + src2) - (src0 + src3) + 8)>>4];
1556 src4 = *s++;
1557 dst[2]= cm[(9*(src2 + src3) - (src1 + src4) + 8)>>4];
1558 src5 = *s++;
1559 dst[3]= cm[(9*(src3 + src4) - (src2 + src5) + 8)>>4];
1560 src6 = *s++;
1561 dst[4]= cm[(9*(src4 + src5) - (src3 + src6) + 8)>>4];
1562 src7 = *s++;
1563 dst[5]= cm[(9*(src5 + src6) - (src4 + src7) + 8)>>4];
1564 src8 = *s++;
1565 dst[6]= cm[(9*(src6 + src7) - (src5 + src8) + 8)>>4];
1566 src9 = *s++;
1567 dst[7]= cm[(9*(src7 + src8) - (src6 + src9) + 8)>>4];
1568 dst+=dstStride;
1569 src+=srcStride;
1570 }while(--h);
1571 }
1572
1573 static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
1574 uint8_t *cm = cropTbl + MAX_NEG_CROP;
1575
1576 do{
1577 int src_1,src0,src1,src2,src3,src4,src5,src6,src7,src8,src9;
1578 uint8_t *s = src,*d = dst;
1579 src_1 = *(s-srcStride);
1580 src0 = *s; s+=srcStride;
1581 src1 = *s; s+=srcStride;
1582 src2 = *s; s+=srcStride;
1583 *d= cm[(9*(src0 + src1) - (src_1 + src2) + 8)>>4]; d+=dstStride;
1584 src3 = *s; s+=srcStride;
1585 *d= cm[(9*(src1 + src2) - (src0 + src3) + 8)>>4]; d+=dstStride;
1586 src4 = *s; s+=srcStride;
1587 *d= cm[(9*(src2 + src3) - (src1 + src4) + 8)>>4]; d+=dstStride;
1588 src5 = *s; s+=srcStride;
1589 *d= cm[(9*(src3 + src4) - (src2 + src5) + 8)>>4]; d+=dstStride;
1590 src6 = *s; s+=srcStride;
1591 *d= cm[(9*(src4 + src5) - (src3 + src6) + 8)>>4]; d+=dstStride;
1592 src7 = *s; s+=srcStride;
1593 *d= cm[(9*(src5 + src6) - (src4 + src7) + 8)>>4]; d+=dstStride;
1594 src8 = *s; s+=srcStride;
1595 *d= cm[(9*(src6 + src7) - (src5 + src8) + 8)>>4]; d+=dstStride;
1596 src9 = *s;
1597 *d= cm[(9*(src7 + src8) - (src6 + src9) + 8)>>4]; d+=dstStride;
1598 src++;
1599 dst++;
1600 }while(--w);
1601 }
1602
1603 static void put_mspel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){
1604 put_pixels8_c(dst, src, stride, 8);
1605 }
1606
1607 static void put_mspel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){
1608 uint8_t half[64];
1609 wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
1610 put_pixels8_l2_aligned2(dst, src, half, stride, stride, 8, 8);
1611 }
1612
1613 static void put_mspel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){
1614 wmv2_mspel8_h_lowpass(dst, src, stride, stride, 8);
1615 }
1616
1617 static void put_mspel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){
1618 uint8_t half[64];
1619 wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
1620 put_pixels8_l2_aligned2(dst, src+1, half, stride, stride, 8, 8);
1621 }
1622
1623 static void put_mspel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){
1624 wmv2_mspel8_v_lowpass(dst, src, stride, stride, 8);
1625 }
1626
1627 static void put_mspel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){
1628 uint8_t halfH[88];
1629 uint8_t halfV[64];
1630 uint8_t halfHV[64];
1631 wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
1632 wmv2_mspel8_v_lowpass(halfV, src, 8, stride, 8);
1633 wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
1634 put_pixels8_l2_aligned(dst, halfV, halfHV, stride, 8, 8, 8);
1635 }
1636 static void put_mspel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){
1637 uint8_t halfH[88];
1638 uint8_t halfV[64];
1639 uint8_t halfHV[64];
1640 wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
1641 wmv2_mspel8_v_lowpass(halfV, src+1, 8, stride, 8);
1642 wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
1643 put_pixels8_l2_aligned(dst, halfV, halfHV, stride, 8, 8, 8);
1644 }
1645 static void put_mspel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){
1646 uint8_t halfH[88];
1647 wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
1648 wmv2_mspel8_v_lowpass(dst, halfH+8, stride, 8, 8);
1649 }
mob repository