git.sesse.net Git - ffmpeg/blob - 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
   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 }