falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2516 Commits
32 Branches
1.1GB
Tree: dd6ee74e4c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dd6ee74e4c'
${ noResults }
FFmpeg/libavcodec/sh4/qpel.c

1650 lines
67KB
Raw Blame History 

  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. }