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.
36851 Commits
32 Branches
837MB
Tree: be40d6cc2b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'be40d6cc2b'
${ noResults }
FFmpeg/libavcodec/sh4/qpel.c

863 lines
38KB
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.  * copyright (c) 2001-2003 BERO <bero@geocities.co.jp>

  6.  *

  7.  * This file is part of Libav.

  8.  *

  9.  * Libav is free software; you can redistribute it and/or

  10.  * modify it under the terms of the GNU Lesser General Public

  11.  * License as published by the Free Software Foundation; either

  12.  * version 2.1 of the License, or (at your option) any later version.

  13.  *

  14.  * Libav is distributed in the hope that it will be useful,

  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  17.  * Lesser General Public License for more details.

  18.  *

  19.  * You should have received a copy of the GNU Lesser General Public

  20.  * License along with Libav; if not, write to the Free Software

  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  22.  */

  23. 

  24. #include "libavutil/common.h"

  25. #include "libavcodec/copy_block.h"

  26. #include "libavcodec/rnd_avg.h"

  27. 

  28. #define PIXOP2(OPNAME, OP) \

  29. \

  30. 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) \

  31. {\

  32.         do {\

  33.                 OP(LP(dst  ),rnd_avg32(LPC(src1  ),LPC(src2  )) ); \

  34.                 src1+=src_stride1; \

  35.                 src2+=src_stride2; \

  36.                 dst+=dst_stride; \

  37.         } while(--h); \

  38. }\

  39. \

  40. 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) \

  41. {\

  42.         do {\

  43.                 OP(LP(dst  ),rnd_avg32(AV_RN32(src1  ),LPC(src2  )) ); \

  44.                 src1+=src_stride1; \

  45.                 src2+=src_stride2; \

  46.                 dst+=dst_stride; \

  47.         } while(--h); \

  48. }\

  49. \

  50. 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) \

  51. {\

  52.         do {\

  53.                 OP(LP(dst  ),no_rnd_avg32(AV_RN32(src1  ),LPC(src2  )) ); \

  54.                 OP(LP(dst+4),no_rnd_avg32(AV_RN32(src1+4),LPC(src2+4)) ); \

  55.                 OP(LP(dst+8),no_rnd_avg32(AV_RN32(src1+8),LPC(src2+8)) ); \

  56.                 OP(LP(dst+12),no_rnd_avg32(AV_RN32(src1+12),LPC(src2+12)) ); \

  57.                 src1+=src_stride1; \

  58.                 src2+=src_stride2; \

  59.                 dst+=dst_stride; \

  60.         } while(--h); \

  61. }\

  62. \

  63. 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) \

  64. {\

  65.         do {\

  66.                 OP(LP(dst  ),rnd_avg32(AV_RN32(src1  ),LPC(src2  )) ); \

  67.                 OP(LP(dst+4),rnd_avg32(AV_RN32(src1+4),LPC(src2+4)) ); \

  68.                 OP(LP(dst+8),rnd_avg32(AV_RN32(src1+8),LPC(src2+8)) ); \

  69.                 OP(LP(dst+12),rnd_avg32(AV_RN32(src1+12),LPC(src2+12)) ); \

  70.                 src1+=src_stride1; \

  71.                 src2+=src_stride2; \

  72.                 dst+=dst_stride; \

  73.         } while(--h); \

  74. }\

  75. \

  76. 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) \

  77. {\

  78.         do { /* onlye src2 aligned */\

  79.                 OP(LP(dst  ),no_rnd_avg32(AV_RN32(src1  ),LPC(src2  )) ); \

  80.                 OP(LP(dst+4),no_rnd_avg32(AV_RN32(src1+4),LPC(src2+4)) ); \

  81.                 src1+=src_stride1; \

  82.                 src2+=src_stride2; \

  83.                 dst+=dst_stride; \

  84.         } while(--h); \

  85. }\

  86. \

  87. 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) \

  88. {\

  89.         do {\

  90.                 OP(LP(dst  ),rnd_avg32(AV_RN32(src1  ),LPC(src2  )) ); \

  91.                 OP(LP(dst+4),rnd_avg32(AV_RN32(src1+4),LPC(src2+4)) ); \

  92.                 src1+=src_stride1; \

  93.                 src2+=src_stride2; \

  94.                 dst+=dst_stride; \

  95.         } while(--h); \

  96. }\

  97. \

  98. 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) \

  99. {\

  100.         do {\

  101.                 OP(LP(dst  ),no_rnd_avg32(LPC(src1  ),LPC(src2  )) ); \

  102.                 OP(LP(dst+4),no_rnd_avg32(LPC(src1+4),LPC(src2+4)) ); \

  103.                 src1+=src_stride1; \

  104.                 src2+=src_stride2; \

  105.                 dst+=dst_stride; \

  106.         } while(--h); \

  107. }\

  108. \

  109. 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) \

  110. {\

  111.         do {\

  112.                 OP(LP(dst  ),rnd_avg32(LPC(src1  ),LPC(src2  )) ); \

  113.                 OP(LP(dst+4),rnd_avg32(LPC(src1+4),LPC(src2+4)) ); \

  114.                 src1+=src_stride1; \

  115.                 src2+=src_stride2; \

  116.                 dst+=dst_stride; \

  117.         } while(--h); \

  118. }\

  119. \

  120. 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) \

  121. {\

  122.         do {\

  123.                 OP(LP(dst  ),no_rnd_avg32(LPC(src1  ),LPC(src2  )) ); \

  124.                 OP(LP(dst+4),no_rnd_avg32(LPC(src1+4),LPC(src2+4)) ); \

  125.                 OP(LP(dst+8),no_rnd_avg32(LPC(src1+8),LPC(src2+8)) ); \

  126.                 OP(LP(dst+12),no_rnd_avg32(LPC(src1+12),LPC(src2+12)) ); \

  127.                 src1+=src_stride1; \

  128.                 src2+=src_stride2; \

  129.                 dst+=dst_stride; \

  130.         } while(--h); \

  131. }\

  132. \

  133. 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) \

  134. {\

  135.         do {\

  136.                 OP(LP(dst  ),rnd_avg32(LPC(src1  ),LPC(src2  )) ); \

  137.                 OP(LP(dst+4),rnd_avg32(LPC(src1+4),LPC(src2+4)) ); \

  138.                 OP(LP(dst+8),rnd_avg32(LPC(src1+8),LPC(src2+8)) ); \

  139.                 OP(LP(dst+12),rnd_avg32(LPC(src1+12),LPC(src2+12)) ); \

  140.                 src1+=src_stride1; \

  141.                 src2+=src_stride2; \

  142.                 dst+=dst_stride; \

  143.         } while(--h); \

  144. }\

  145. \

  146. 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) \

  147. { OPNAME ## _no_rnd_pixels16_l2_aligned2(dst,src2,src1,dst_stride,src_stride2,src_stride1,h); } \

  148. \

  149. 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) \

  150. { OPNAME ## _pixels16_l2_aligned2(dst,src2,src1,dst_stride,src_stride2,src_stride1,h); } \

  151. \

  152. 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) \

  153. { OPNAME ## _no_rnd_pixels8_l2_aligned2(dst,src2,src1,dst_stride,src_stride2,src_stride1,h); } \

  154. \

  155. 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) \

  156. { OPNAME ## _pixels8_l2_aligned2(dst,src2,src1,dst_stride,src_stride2,src_stride1,h); } \

  157. \

  158. 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){\

  159.         do { \

  160.                 uint32_t a0,a1,a2,a3; \

  161.                 UNPACK(a0,a1,LPC(src1),LPC(src2)); \

  162.                 UNPACK(a2,a3,LPC(src3),LPC(src4)); \

  163.                 OP(LP(dst),rnd_PACK(a0,a1,a2,a3)); \

  164.                 UNPACK(a0,a1,LPC(src1+4),LPC(src2+4)); \

  165.                 UNPACK(a2,a3,LPC(src3+4),LPC(src4+4)); \

  166.                 OP(LP(dst+4),rnd_PACK(a0,a1,a2,a3)); \

  167.                 src1+=src_stride1;\

  168.                 src2+=src_stride2;\

  169.                 src3+=src_stride3;\

  170.                 src4+=src_stride4;\

  171.                 dst+=dst_stride;\

  172.         } while(--h); \

  173. } \

  174. \

  175. 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){\

  176.         do { \

  177.                 uint32_t a0,a1,a2,a3; \

  178.                 UNPACK(a0,a1,LPC(src1),LPC(src2)); \

  179.                 UNPACK(a2,a3,LPC(src3),LPC(src4)); \

  180.                 OP(LP(dst),no_rnd_PACK(a0,a1,a2,a3)); \

  181.                 UNPACK(a0,a1,LPC(src1+4),LPC(src2+4)); \

  182.                 UNPACK(a2,a3,LPC(src3+4),LPC(src4+4)); \

  183.                 OP(LP(dst+4),no_rnd_PACK(a0,a1,a2,a3)); \

  184.                 src1+=src_stride1;\

  185.                 src2+=src_stride2;\

  186.                 src3+=src_stride3;\

  187.                 src4+=src_stride4;\

  188.                 dst+=dst_stride;\

  189.         } while(--h); \

  190. } \

  191. \

  192. 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){\

  193.         do { \

  194.                 uint32_t a0,a1,a2,a3; /* src1 only not aligned */\

  195.                 UNPACK(a0,a1,AV_RN32(src1),LPC(src2)); \

  196.                 UNPACK(a2,a3,LPC(src3),LPC(src4)); \

  197.                 OP(LP(dst),rnd_PACK(a0,a1,a2,a3)); \

  198.                 UNPACK(a0,a1,AV_RN32(src1+4),LPC(src2+4)); \

  199.                 UNPACK(a2,a3,LPC(src3+4),LPC(src4+4)); \

  200.                 OP(LP(dst+4),rnd_PACK(a0,a1,a2,a3)); \

  201.                 src1+=src_stride1;\

  202.                 src2+=src_stride2;\

  203.                 src3+=src_stride3;\

  204.                 src4+=src_stride4;\

  205.                 dst+=dst_stride;\

  206.         } while(--h); \

  207. } \

  208. \

  209. 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){\

  210.         do { \

  211.                 uint32_t a0,a1,a2,a3; \

  212.                 UNPACK(a0,a1,AV_RN32(src1),LPC(src2)); \

  213.                 UNPACK(a2,a3,LPC(src3),LPC(src4)); \

  214.                 OP(LP(dst),no_rnd_PACK(a0,a1,a2,a3)); \

  215.                 UNPACK(a0,a1,AV_RN32(src1+4),LPC(src2+4)); \

  216.                 UNPACK(a2,a3,LPC(src3+4),LPC(src4+4)); \

  217.                 OP(LP(dst+4),no_rnd_PACK(a0,a1,a2,a3)); \

  218.                 src1+=src_stride1;\

  219.                 src2+=src_stride2;\

  220.                 src3+=src_stride3;\

  221.                 src4+=src_stride4;\

  222.                 dst+=dst_stride;\

  223.         } while(--h); \

  224. } \

  225. \

  226. 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){\

  227.         do { \

  228.                 uint32_t a0,a1,a2,a3; \

  229.                 UNPACK(a0,a1,LPC(src1),LPC(src2)); \

  230.                 UNPACK(a2,a3,LPC(src3),LPC(src4)); \

  231.                 OP(LP(dst),rnd_PACK(a0,a1,a2,a3)); \

  232.                 UNPACK(a0,a1,LPC(src1+4),LPC(src2+4)); \

  233.                 UNPACK(a2,a3,LPC(src3+4),LPC(src4+4)); \

  234.                 OP(LP(dst+8),rnd_PACK(a0,a1,a2,a3)); \

  235.                 UNPACK(a0,a1,LPC(src1+8),LPC(src2+8)); \

  236.                 UNPACK(a2,a3,LPC(src3+8),LPC(src4+8)); \

  237.                 OP(LP(dst+8),rnd_PACK(a0,a1,a2,a3)); \

  238.                 UNPACK(a0,a1,LPC(src1+12),LPC(src2+12)); \

  239.                 UNPACK(a2,a3,LPC(src3+12),LPC(src4+12)); \

  240.                 OP(LP(dst+12),rnd_PACK(a0,a1,a2,a3)); \

  241.                 src1+=src_stride1;\

  242.                 src2+=src_stride2;\

  243.                 src3+=src_stride3;\

  244.                 src4+=src_stride4;\

  245.                 dst+=dst_stride;\

  246.         } while(--h); \

  247. } \

  248. \

  249. 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){\

  250.         do { \

  251.                 uint32_t a0,a1,a2,a3; \

  252.                 UNPACK(a0,a1,LPC(src1),LPC(src2)); \

  253.                 UNPACK(a2,a3,LPC(src3),LPC(src4)); \

  254.                 OP(LP(dst),no_rnd_PACK(a0,a1,a2,a3)); \

  255.                 UNPACK(a0,a1,LPC(src1+4),LPC(src2+4)); \

  256.                 UNPACK(a2,a3,LPC(src3+4),LPC(src4+4)); \

  257.                 OP(LP(dst+4),no_rnd_PACK(a0,a1,a2,a3)); \

  258.                 UNPACK(a0,a1,LPC(src1+8),LPC(src2+8)); \

  259.                 UNPACK(a2,a3,LPC(src3+8),LPC(src4+8)); \

  260.                 OP(LP(dst+8),no_rnd_PACK(a0,a1,a2,a3)); \

  261.                 UNPACK(a0,a1,LPC(src1+12),LPC(src2+12)); \

  262.                 UNPACK(a2,a3,LPC(src3+12),LPC(src4+12)); \

  263.                 OP(LP(dst+12),no_rnd_PACK(a0,a1,a2,a3)); \

  264.                 src1+=src_stride1;\

  265.                 src2+=src_stride2;\

  266.                 src3+=src_stride3;\

  267.                 src4+=src_stride4;\

  268.                 dst+=dst_stride;\

  269.         } while(--h); \

  270. } \

  271. \

  272. 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){\

  273.         do { /* src1 is unaligned */\

  274.                 uint32_t a0,a1,a2,a3; \

  275.                 UNPACK(a0,a1,AV_RN32(src1),LPC(src2)); \

  276.                 UNPACK(a2,a3,LPC(src3),LPC(src4)); \

  277.                 OP(LP(dst),rnd_PACK(a0,a1,a2,a3)); \

  278.                 UNPACK(a0,a1,AV_RN32(src1+4),LPC(src2+4)); \

  279.                 UNPACK(a2,a3,LPC(src3+4),LPC(src4+4)); \

  280.                 OP(LP(dst+8),rnd_PACK(a0,a1,a2,a3)); \

  281.                 UNPACK(a0,a1,AV_RN32(src1+8),LPC(src2+8)); \

  282.                 UNPACK(a2,a3,LPC(src3+8),LPC(src4+8)); \

  283.                 OP(LP(dst+8),rnd_PACK(a0,a1,a2,a3)); \

  284.                 UNPACK(a0,a1,AV_RN32(src1+12),LPC(src2+12)); \

  285.                 UNPACK(a2,a3,LPC(src3+12),LPC(src4+12)); \

  286.                 OP(LP(dst+12),rnd_PACK(a0,a1,a2,a3)); \

  287.                 src1+=src_stride1;\

  288.                 src2+=src_stride2;\

  289.                 src3+=src_stride3;\

  290.                 src4+=src_stride4;\

  291.                 dst+=dst_stride;\

  292.         } while(--h); \

  293. } \

  294. \

  295. 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){\

  296.         do { \

  297.                 uint32_t a0,a1,a2,a3; \

  298.                 UNPACK(a0,a1,AV_RN32(src1),LPC(src2)); \

  299.                 UNPACK(a2,a3,LPC(src3),LPC(src4)); \

  300.                 OP(LP(dst),no_rnd_PACK(a0,a1,a2,a3)); \

  301.                 UNPACK(a0,a1,AV_RN32(src1+4),LPC(src2+4)); \

  302.                 UNPACK(a2,a3,LPC(src3+4),LPC(src4+4)); \

  303.                 OP(LP(dst+4),no_rnd_PACK(a0,a1,a2,a3)); \

  304.                 UNPACK(a0,a1,AV_RN32(src1+8),LPC(src2+8)); \

  305.                 UNPACK(a2,a3,LPC(src3+8),LPC(src4+8)); \

  306.                 OP(LP(dst+8),no_rnd_PACK(a0,a1,a2,a3)); \

  307.                 UNPACK(a0,a1,AV_RN32(src1+12),LPC(src2+12)); \

  308.                 UNPACK(a2,a3,LPC(src3+12),LPC(src4+12)); \

  309.                 OP(LP(dst+12),no_rnd_PACK(a0,a1,a2,a3)); \

  310.                 src1+=src_stride1;\

  311.                 src2+=src_stride2;\

  312.                 src3+=src_stride3;\

  313.                 src4+=src_stride4;\

  314.                 dst+=dst_stride;\

  315.         } while(--h); \

  316. } \

  317. \

  318. 

  319. #define op_avg(a, b) a = rnd_avg32(a,b)

  320. #define op_put(a, b) a = b

  321. 

  322. PIXOP2(avg, op_avg)

  323. PIXOP2(put, op_put)

  324. #undef op_avg

  325. #undef op_put

  326. 

  327. #define avg2(a,b) ((a+b+1)>>1)

  328. #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)

  329. 

  330. 

  331. static void gmc1_c(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder)

  332. {

  333.     const int A=(16-x16)*(16-y16);

  334.     const int B=(   x16)*(16-y16);

  335.     const int C=(16-x16)*(   y16);

  336.     const int D=(   x16)*(   y16);

  337. 

  338.     do {

  339.         int t0,t1,t2,t3;

  340.         uint8_t *s0 = src;

  341.         uint8_t *s1 = src+stride;

  342.         t0 = *s0++; t2 = *s1++;

  343.         t1 = *s0++; t3 = *s1++;

  344.         dst[0]= (A*t0 + B*t1 + C*t2 + D*t3 + rounder)>>8;

  345.         t0 = *s0++; t2 = *s1++;

  346.         dst[1]= (A*t1 + B*t0 + C*t3 + D*t2 + rounder)>>8;

  347.         t1 = *s0++; t3 = *s1++;

  348.         dst[2]= (A*t0 + B*t1 + C*t2 + D*t3 + rounder)>>8;

  349.         t0 = *s0++; t2 = *s1++;

  350.         dst[3]= (A*t1 + B*t0 + C*t3 + D*t2 + rounder)>>8;

  351.         t1 = *s0++; t3 = *s1++;

  352.         dst[4]= (A*t0 + B*t1 + C*t2 + D*t3 + rounder)>>8;

  353.         t0 = *s0++; t2 = *s1++;

  354.         dst[5]= (A*t1 + B*t0 + C*t3 + D*t2 + rounder)>>8;

  355.         t1 = *s0++; t3 = *s1++;

  356.         dst[6]= (A*t0 + B*t1 + C*t2 + D*t3 + rounder)>>8;

  357.         t0 = *s0++; t2 = *s1++;

  358.         dst[7]= (A*t1 + B*t0 + C*t3 + D*t2 + rounder)>>8;

  359.         dst+= stride;

  360.         src+= stride;

  361.     }while(--h);

  362. }

  363. 

  364. #define QPEL_MC(r, OPNAME, RND, OP) \

  365. static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\

  366.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\

  367.     do {\

  368.         uint8_t *s = src; \

  369.         int src0,src1,src2,src3,src4,src5,src6,src7,src8;\

  370.         src0= *s++;\

  371.         src1= *s++;\

  372.         src2= *s++;\

  373.         src3= *s++;\

  374.         src4= *s++;\

  375.         OP(dst[0], (src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4));\

  376.         src5= *s++;\

  377.         OP(dst[1], (src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5));\

  378.         src6= *s++;\

  379.         OP(dst[2], (src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6));\

  380.         src7= *s++;\

  381.         OP(dst[3], (src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7));\

  382.         src8= *s++;\

  383.         OP(dst[4], (src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8));\

  384.         OP(dst[5], (src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8));\

  385.         OP(dst[6], (src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7));\

  386.         OP(dst[7], (src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6));\

  387.         dst+=dstStride;\

  388.         src+=srcStride;\

  389.     }while(--h);\

  390. }\

  391. \

  392. static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\

  393.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\

  394.     int w=8;\

  395.     do{\

  396.         uint8_t *s = src, *d=dst;\

  397.         int src0,src1,src2,src3,src4,src5,src6,src7,src8;\

  398.         src0 = *s; s+=srcStride; \

  399.         src1 = *s; s+=srcStride; \

  400.         src2 = *s; s+=srcStride; \

  401.         src3 = *s; s+=srcStride; \

  402.         src4 = *s; s+=srcStride; \

  403.         OP(*d, (src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4));d+=dstStride;\

  404.         src5 = *s; s+=srcStride; \

  405.         OP(*d, (src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5));d+=dstStride;\

  406.         src6 = *s; s+=srcStride; \

  407.         OP(*d, (src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6));d+=dstStride;\

  408.         src7 = *s; s+=srcStride; \

  409.         OP(*d, (src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7));d+=dstStride;\

  410.         src8 = *s; \

  411.         OP(*d, (src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8));d+=dstStride;\

  412.         OP(*d, (src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8));d+=dstStride;\

  413.         OP(*d, (src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7));d+=dstStride;\

  414.         OP(*d, (src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6));\

  415.         dst++;\

  416.         src++;\

  417.     }while(--w);\

  418. }\

  419. \

  420. static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\

  421.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\

  422.     do {\

  423.         uint8_t *s = src;\

  424.         int src0,src1,src2,src3,src4,src5,src6,src7,src8;\

  425.         int src9,src10,src11,src12,src13,src14,src15,src16;\

  426.         src0= *s++;\

  427.         src1= *s++;\

  428.         src2= *s++;\

  429.         src3= *s++;\

  430.         src4= *s++;\

  431.         OP(dst[ 0], (src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 ));\

  432.         src5= *s++;\

  433.         OP(dst[ 1], (src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 ));\

  434.         src6= *s++;\

  435.         OP(dst[ 2], (src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 ));\

  436.         src7= *s++;\

  437.         OP(dst[ 3], (src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 ));\

  438.         src8= *s++;\

  439.         OP(dst[ 4], (src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 ));\

  440.         src9= *s++;\

  441.         OP(dst[ 5], (src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 ));\

  442.         src10= *s++;\

  443.         OP(dst[ 6], (src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10));\

  444.         src11= *s++;\

  445.         OP(dst[ 7], (src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11));\

  446.         src12= *s++;\

  447.         OP(dst[ 8], (src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12));\

  448.         src13= *s++;\

  449.         OP(dst[ 9], (src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13));\

  450.         src14= *s++;\

  451.         OP(dst[10], (src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14));\

  452.         src15= *s++;\

  453.         OP(dst[11], (src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15));\

  454.         src16= *s++;\

  455.         OP(dst[12], (src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16));\

  456.         OP(dst[13], (src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16));\

  457.         OP(dst[14], (src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15));\

  458.         OP(dst[15], (src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14));\

  459.         dst+=dstStride;\

  460.         src+=srcStride;\

  461.     }while(--h);\

  462. }\

  463. \

  464. static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\

  465.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\

  466.     int w=16;\

  467.     do {\

  468.         uint8_t *s = src, *d=dst;\

  469.         int src0,src1,src2,src3,src4,src5,src6,src7,src8;\

  470.         int src9,src10,src11,src12,src13,src14,src15,src16;\

  471.         src0 = *s; s+=srcStride; \

  472.         src1 = *s; s+=srcStride; \

  473.         src2 = *s; s+=srcStride; \

  474.         src3 = *s; s+=srcStride; \

  475.         src4 = *s; s+=srcStride; \

  476.         OP(*d, (src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 ));d+=dstStride;\

  477.         src5 = *s; s+=srcStride; \

  478.         OP(*d, (src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 ));d+=dstStride;\

  479.         src6 = *s; s+=srcStride; \

  480.         OP(*d, (src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 ));d+=dstStride;\

  481.         src7 = *s; s+=srcStride; \

  482.         OP(*d, (src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 ));d+=dstStride;\

  483.         src8 = *s; s+=srcStride; \

  484.         OP(*d, (src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 ));d+=dstStride;\

  485.         src9 = *s; s+=srcStride; \

  486.         OP(*d, (src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 ));d+=dstStride;\

  487.         src10 = *s; s+=srcStride; \

  488.         OP(*d, (src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10));d+=dstStride;\

  489.         src11 = *s; s+=srcStride; \

  490.         OP(*d, (src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11));d+=dstStride;\

  491.         src12 = *s; s+=srcStride; \

  492.         OP(*d, (src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12));d+=dstStride;\

  493.         src13 = *s; s+=srcStride; \

  494.         OP(*d, (src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13));d+=dstStride;\

  495.         src14 = *s; s+=srcStride; \

  496.         OP(*d, (src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14));d+=dstStride;\

  497.         src15 = *s; s+=srcStride; \

  498.         OP(*d, (src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15));d+=dstStride;\

  499.         src16 = *s; \

  500.         OP(*d, (src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16));d+=dstStride;\

  501.         OP(*d, (src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16));d+=dstStride;\

  502.         OP(*d, (src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15));d+=dstStride;\

  503.         OP(*d, (src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14));\

  504.         dst++;\

  505.         src++;\

  506.     }while(--w);\

  507. }\

  508. \

  509. static void OPNAME ## qpel8_mc00_sh4 (uint8_t *dst, uint8_t *src, int stride){\

  510.     OPNAME ## pixels8_c(dst, src, stride, 8);\

  511. }\

  512. \

  513. static void OPNAME ## qpel8_mc10_sh4(uint8_t *dst, uint8_t *src, int stride){\

  514.     uint8_t half[64];\

  515.     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\

  516.     OPNAME ## pixels8_l2_aligned2(dst, src, half, stride, stride, 8, 8);\

  517. }\

  518. \

  519. static void OPNAME ## qpel8_mc20_sh4(uint8_t *dst, uint8_t *src, int stride){\

  520.     OPNAME ## mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);\

  521. }\

  522. \

  523. static void OPNAME ## qpel8_mc30_sh4(uint8_t *dst, uint8_t *src, int stride){\

  524.     uint8_t half[64];\

  525.     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\

  526.     OPNAME ## pixels8_l2_aligned2(dst, src+1, half, stride, stride, 8, 8);\

  527. }\

  528. \

  529. static void OPNAME ## qpel8_mc01_sh4(uint8_t *dst, uint8_t *src, int stride){\

  530.     uint8_t full[16*9];\

  531.     uint8_t half[64];\

  532.     copy_block9(full, src, 16, stride, 9);\

  533.     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\

  534.     OPNAME ## pixels8_l2_aligned(dst, full, half, stride, 16, 8, 8);\

  535. }\

  536. \

  537. static void OPNAME ## qpel8_mc02_sh4(uint8_t *dst, uint8_t *src, int stride){\

  538.     uint8_t full[16*9];\

  539.     copy_block9(full, src, 16, stride, 9);\

  540.     OPNAME ## mpeg4_qpel8_v_lowpass(dst, full, stride, 16);\

  541. }\

  542. \

  543. static void OPNAME ## qpel8_mc03_sh4(uint8_t *dst, uint8_t *src, int stride){\

  544.     uint8_t full[16*9];\

  545.     uint8_t half[64];\

  546.     copy_block9(full, src, 16, stride, 9);\

  547.     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\

  548.     OPNAME ## pixels8_l2_aligned(dst, full+16, half, stride, 16, 8, 8);\

  549. }\

  550. static void OPNAME ## qpel8_mc11_sh4(uint8_t *dst, uint8_t *src, int stride){\

  551.     uint8_t full[16*9];\

  552.     uint8_t halfH[72];\

  553.     uint8_t halfHV[64];\

  554.     copy_block9(full, src, 16, stride, 9);\

  555.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\

  556.     put ## RND ## pixels8_l2_aligned(halfH, halfH, full, 8, 8, 16, 9);\

  557.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\

  558.     OPNAME ## pixels8_l2_aligned(dst, halfH, halfHV, stride, 8, 8, 8);\

  559. }\

  560. static void OPNAME ## qpel8_mc31_sh4(uint8_t *dst, uint8_t *src, int stride){\

  561.     uint8_t full[16*9];\

  562.     uint8_t halfH[72];\

  563.     uint8_t halfHV[64];\

  564.     copy_block9(full, src, 16, stride, 9);\

  565.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\

  566.     put ## RND ## pixels8_l2_aligned1(halfH, halfH, full+1, 8, 8, 16, 9);\

  567.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\

  568.     OPNAME ## pixels8_l2_aligned(dst, halfH, halfHV, stride, 8, 8, 8);\

  569. }\

  570. static void OPNAME ## qpel8_mc13_sh4(uint8_t *dst, uint8_t *src, int stride){\

  571.     uint8_t full[16*9];\

  572.     uint8_t halfH[72];\

  573.     uint8_t halfHV[64];\

  574.     copy_block9(full, src, 16, stride, 9);\

  575.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\

  576.     put ## RND ## pixels8_l2_aligned(halfH, halfH, full, 8, 8, 16, 9);\

  577.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\

  578.     OPNAME ## pixels8_l2_aligned(dst, halfH+8, halfHV, stride, 8, 8, 8);\

  579. }\

  580. static void OPNAME ## qpel8_mc33_sh4(uint8_t *dst, uint8_t *src, int stride){\

  581.     uint8_t full[16*9];\

  582.     uint8_t halfH[72];\

  583.     uint8_t halfHV[64];\

  584.     copy_block9(full, src, 16, stride, 9);\

  585.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\

  586.     put ## RND ## pixels8_l2_aligned1(halfH, halfH, full+1, 8, 8, 16, 9);\

  587.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\

  588.     OPNAME ## pixels8_l2_aligned(dst, halfH+8, halfHV, stride, 8, 8, 8);\

  589. }\

  590. static void OPNAME ## qpel8_mc21_sh4(uint8_t *dst, uint8_t *src, int stride){\

  591.     uint8_t halfH[72];\

  592.     uint8_t halfHV[64];\

  593.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\

  594.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\

  595.     OPNAME ## pixels8_l2_aligned(dst, halfH, halfHV, stride, 8, 8, 8);\

  596. }\

  597. static void OPNAME ## qpel8_mc23_sh4(uint8_t *dst, uint8_t *src, int stride){\

  598.     uint8_t halfH[72];\

  599.     uint8_t halfHV[64];\

  600.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\

  601.     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\

  602.     OPNAME ## pixels8_l2_aligned(dst, halfH+8, halfHV, stride, 8, 8, 8);\

  603. }\

  604. static void OPNAME ## qpel8_mc12_sh4(uint8_t *dst, uint8_t *src, int stride){\

  605.     uint8_t full[16*9];\

  606.     uint8_t halfH[72];\

  607.     copy_block9(full, src, 16, stride, 9);\

  608.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\

  609.     put ## RND ## pixels8_l2_aligned(halfH, halfH, full, 8, 8, 16, 9);\

  610.     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\

  611. }\

  612. static void OPNAME ## qpel8_mc32_sh4(uint8_t *dst, uint8_t *src, int stride){\

  613.     uint8_t full[16*9];\

  614.     uint8_t halfH[72];\

  615.     copy_block9(full, src, 16, stride, 9);\

  616.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\

  617.     put ## RND ## pixels8_l2_aligned1(halfH, halfH, full+1, 8, 8, 16, 9);\

  618.     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\

  619. }\

  620. static void OPNAME ## qpel8_mc22_sh4(uint8_t *dst, uint8_t *src, int stride){\

  621.     uint8_t halfH[72];\

  622.     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\

  623.     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\

  624. }\

  625. static void OPNAME ## qpel16_mc00_sh4 (uint8_t *dst, uint8_t *src, int stride){\

  626.     OPNAME ## pixels16_c(dst, src, stride, 16);\

  627. }\

  628. \

  629. static void OPNAME ## qpel16_mc10_sh4(uint8_t *dst, uint8_t *src, int stride){\

  630.     uint8_t half[256];\

  631.     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\

  632.     OPNAME ## pixels16_l2_aligned2(dst, src, half, stride, stride, 16, 16);\

  633. }\

  634. \

  635. static void OPNAME ## qpel16_mc20_sh4(uint8_t *dst, uint8_t *src, int stride){\

  636.     OPNAME ## mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);\

  637. }\

  638. \

  639. static void OPNAME ## qpel16_mc30_sh4(uint8_t *dst, uint8_t *src, int stride){\

  640.     uint8_t half[256];\

  641.     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\

  642.     OPNAME ## pixels16_l2_aligned2(dst, src+1, half, stride, stride, 16, 16);\

  643. }\

  644. \

  645. static void OPNAME ## qpel16_mc01_sh4(uint8_t *dst, uint8_t *src, int stride){\

  646.     uint8_t full[24*17];\

  647.     uint8_t half[256];\

  648.     copy_block17(full, src, 24, stride, 17);\

  649.     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\

  650.     OPNAME ## pixels16_l2_aligned(dst, full, half, stride, 24, 16, 16);\

  651. }\

  652. \

  653. static void OPNAME ## qpel16_mc02_sh4(uint8_t *dst, uint8_t *src, int stride){\

  654.     uint8_t full[24*17];\

  655.     copy_block17(full, src, 24, stride, 17);\

  656.     OPNAME ## mpeg4_qpel16_v_lowpass(dst, full, stride, 24);\

  657. }\

  658. \

  659. static void OPNAME ## qpel16_mc03_sh4(uint8_t *dst, uint8_t *src, int stride){\

  660.     uint8_t full[24*17];\

  661.     uint8_t half[256];\

  662.     copy_block17(full, src, 24, stride, 17);\

  663.     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\

  664.     OPNAME ## pixels16_l2_aligned(dst, full+24, half, stride, 24, 16, 16);\

  665. }\

  666. static void OPNAME ## qpel16_mc11_sh4(uint8_t *dst, uint8_t *src, int stride){\

  667.     uint8_t full[24*17];\

  668.     uint8_t halfH[272];\

  669.     uint8_t halfHV[256];\

  670.     copy_block17(full, src, 24, stride, 17);\

  671.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\

  672.     put ## RND ## pixels16_l2_aligned(halfH, halfH, full, 16, 16, 24, 17);\

  673.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\

  674.     OPNAME ## pixels16_l2_aligned(dst, halfH, halfHV, stride, 16, 16, 16);\

  675. }\

  676. static void OPNAME ## qpel16_mc31_sh4(uint8_t *dst, uint8_t *src, int stride){\

  677.     uint8_t full[24*17];\

  678.     uint8_t halfH[272];\

  679.     uint8_t halfHV[256];\

  680.     copy_block17(full, src, 24, stride, 17);\

  681.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\

  682.     put ## RND ## pixels16_l2_aligned1(halfH, halfH, full+1, 16, 16, 24, 17);\

  683.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\

  684.     OPNAME ## pixels16_l2_aligned(dst, halfH, halfHV, stride, 16, 16, 16);\

  685. }\

  686. static void OPNAME ## qpel16_mc13_sh4(uint8_t *dst, uint8_t *src, int stride){\

  687.     uint8_t full[24*17];\

  688.     uint8_t halfH[272];\

  689.     uint8_t halfHV[256];\

  690.     copy_block17(full, src, 24, stride, 17);\

  691.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\

  692.     put ## RND ## pixels16_l2_aligned(halfH, halfH, full, 16, 16, 24, 17);\

  693.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\

  694.     OPNAME ## pixels16_l2_aligned(dst, halfH+16, halfHV, stride, 16, 16, 16);\

  695. }\

  696. static void OPNAME ## qpel16_mc33_sh4(uint8_t *dst, uint8_t *src, int stride){\

  697.     uint8_t full[24*17];\

  698.     uint8_t halfH[272];\

  699.     uint8_t halfHV[256];\

  700.     copy_block17(full, src, 24, stride, 17);\

  701.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\

  702.     put ## RND ## pixels16_l2_aligned1(halfH, halfH, full+1, 16, 16, 24, 17);\

  703.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\

  704.     OPNAME ## pixels16_l2_aligned(dst, halfH+16, halfHV, stride, 16, 16, 16);\

  705. }\

  706. static void OPNAME ## qpel16_mc21_sh4(uint8_t *dst, uint8_t *src, int stride){\

  707.     uint8_t halfH[272];\

  708.     uint8_t halfHV[256];\

  709.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\

  710.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\

  711.     OPNAME ## pixels16_l2_aligned(dst, halfH, halfHV, stride, 16, 16, 16);\

  712. }\

  713. static void OPNAME ## qpel16_mc23_sh4(uint8_t *dst, uint8_t *src, int stride){\

  714.     uint8_t halfH[272];\

  715.     uint8_t halfHV[256];\

  716.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\

  717.     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\

  718.     OPNAME ## pixels16_l2_aligned(dst, halfH+16, halfHV, stride, 16, 16, 16);\

  719. }\

  720. static void OPNAME ## qpel16_mc12_sh4(uint8_t *dst, uint8_t *src, int stride){\

  721.     uint8_t full[24*17];\

  722.     uint8_t halfH[272];\

  723.     copy_block17(full, src, 24, stride, 17);\

  724.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\

  725.     put ## RND ## pixels16_l2_aligned(halfH, halfH, full, 16, 16, 24, 17);\

  726.     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\

  727. }\

  728. static void OPNAME ## qpel16_mc32_sh4(uint8_t *dst, uint8_t *src, int stride){\

  729.     uint8_t full[24*17];\

  730.     uint8_t halfH[272];\

  731.     copy_block17(full, src, 24, stride, 17);\

  732.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\

  733.     put ## RND ## pixels16_l2_aligned1(halfH, halfH, full+1, 16, 16, 24, 17);\

  734.     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\

  735. }\

  736. static void OPNAME ## qpel16_mc22_sh4(uint8_t *dst, uint8_t *src, int stride){\

  737.     uint8_t halfH[272];\

  738.     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\

  739.     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\

  740. }

  741. 

  742. #define op_avg(a, b) a = (((a)+cm[((b) + 16)>>5]+1)>>1)

  743. #define op_avg_no_rnd(a, b) a = (((a)+cm[((b) + 15)>>5])>>1)

  744. #define op_put(a, b) a = cm[((b) + 16)>>5]

  745. #define op_put_no_rnd(a, b) a = cm[((b) + 15)>>5]

  746. 

  747. QPEL_MC(0, put_       , _       , op_put)

  748. QPEL_MC(1, put_no_rnd_, _no_rnd_, op_put_no_rnd)

  749. QPEL_MC(0, avg_       , _       , op_avg)

  750. //QPEL_MC(1, avg_no_rnd , _       , op_avg)

  751. #undef op_avg

  752. #undef op_avg_no_rnd

  753. #undef op_put

  754. #undef op_put_no_rnd

  755. 

  756. static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){

  757.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  758. 

  759.     do{

  760.         int src_1,src0,src1,src2,src3,src4,src5,src6,src7,src8,src9;

  761.         uint8_t *s = src;

  762.         src_1 = s[-1];

  763.         src0 = *s++;

  764.         src1 = *s++;

  765.         src2 = *s++;

  766.         dst[0]= cm[(9*(src0 + src1) - (src_1 + src2) + 8)>>4];

  767.         src3 = *s++;

  768.         dst[1]= cm[(9*(src1 + src2) - (src0 + src3) + 8)>>4];

  769.         src4 = *s++;

  770.         dst[2]= cm[(9*(src2 + src3) - (src1 + src4) + 8)>>4];

  771.         src5 = *s++;

  772.         dst[3]= cm[(9*(src3 + src4) - (src2 + src5) + 8)>>4];

  773.         src6 = *s++;

  774.         dst[4]= cm[(9*(src4 + src5) - (src3 + src6) + 8)>>4];

  775.         src7 = *s++;

  776.         dst[5]= cm[(9*(src5 + src6) - (src4 + src7) + 8)>>4];

  777.         src8 = *s++;

  778.         dst[6]= cm[(9*(src6 + src7) - (src5 + src8) + 8)>>4];

  779.         src9 = *s++;

  780.         dst[7]= cm[(9*(src7 + src8) - (src6 + src9) + 8)>>4];

  781.         dst+=dstStride;

  782.         src+=srcStride;

  783.     }while(--h);

  784. }

  785. 

  786. static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){

  787.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  788. 

  789.     do{

  790.         int src_1,src0,src1,src2,src3,src4,src5,src6,src7,src8,src9;

  791.         uint8_t *s = src,*d = dst;

  792.         src_1 = *(s-srcStride);

  793.         src0 = *s; s+=srcStride;

  794.         src1 = *s; s+=srcStride;

  795.         src2 = *s; s+=srcStride;

  796.         *d= cm[(9*(src0 + src1) - (src_1 + src2) + 8)>>4]; d+=dstStride;

  797.         src3 = *s; s+=srcStride;

  798.         *d= cm[(9*(src1 + src2) - (src0  + src3) + 8)>>4]; d+=dstStride;

  799.         src4 = *s; s+=srcStride;

  800.         *d= cm[(9*(src2 + src3) - (src1  + src4) + 8)>>4]; d+=dstStride;

  801.         src5 = *s; s+=srcStride;

  802.         *d= cm[(9*(src3 + src4) - (src2  + src5) + 8)>>4]; d+=dstStride;

  803.         src6 = *s; s+=srcStride;

  804.         *d= cm[(9*(src4 + src5) - (src3  + src6) + 8)>>4]; d+=dstStride;

  805.         src7 = *s; s+=srcStride;

  806.         *d= cm[(9*(src5 + src6) - (src4  + src7) + 8)>>4]; d+=dstStride;

  807.         src8 = *s; s+=srcStride;

  808.         *d= cm[(9*(src6 + src7) - (src5  + src8) + 8)>>4]; d+=dstStride;

  809.         src9 = *s;

  810.         *d= cm[(9*(src7 + src8) - (src6  + src9) + 8)>>4]; d+=dstStride;

  811.         src++;

  812.         dst++;

  813.     }while(--w);

  814. }

  815. 

  816. static void put_mspel8_mc00_sh4 (uint8_t *dst, uint8_t *src, int stride){

  817.     put_pixels8_c(dst, src, stride, 8);

  818. }

  819. 

  820. static void put_mspel8_mc10_sh4(uint8_t *dst, uint8_t *src, int stride){

  821.     uint8_t half[64];

  822.     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);

  823.     put_pixels8_l2_aligned2(dst, src, half, stride, stride, 8, 8);

  824. }

  825. 

  826. static void put_mspel8_mc20_sh4(uint8_t *dst, uint8_t *src, int stride){

  827.     wmv2_mspel8_h_lowpass(dst, src, stride, stride, 8);

  828. }

  829. 

  830. static void put_mspel8_mc30_sh4(uint8_t *dst, uint8_t *src, int stride){

  831.     uint8_t half[64];

  832.     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);

  833.     put_pixels8_l2_aligned2(dst, src+1, half, stride, stride, 8, 8);

  834. }

  835. 

  836. static void put_mspel8_mc02_sh4(uint8_t *dst, uint8_t *src, int stride){

  837.     wmv2_mspel8_v_lowpass(dst, src, stride, stride, 8);

  838. }

  839. 

  840. static void put_mspel8_mc12_sh4(uint8_t *dst, uint8_t *src, int stride){

  841.     uint8_t halfH[88];

  842.     uint8_t halfV[64];

  843.     uint8_t halfHV[64];

  844.     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);

  845.     wmv2_mspel8_v_lowpass(halfV, src, 8, stride, 8);

  846.     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);

  847.     put_pixels8_l2_aligned(dst, halfV, halfHV, stride, 8, 8, 8);

  848. }

  849. static void put_mspel8_mc32_sh4(uint8_t *dst, uint8_t *src, int stride){

  850.     uint8_t halfH[88];

  851.     uint8_t halfV[64];

  852.     uint8_t halfHV[64];

  853.     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);

  854.     wmv2_mspel8_v_lowpass(halfV, src+1, 8, stride, 8);

  855.     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);

  856.     put_pixels8_l2_aligned(dst, halfV, halfHV, stride, 8, 8, 8);

  857. }

  858. static void put_mspel8_mc22_sh4(uint8_t *dst, uint8_t *src, int stride){

  859.     uint8_t halfH[88];

  860.     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);

  861.     wmv2_mspel8_v_lowpass(dst, halfH+8, stride, 8, 8);

  862. }