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