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

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

  27. #define PIXOP2(OPNAME, OP) \

  28. \

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

  30. {\

  31.         do {\

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

  33.                 src1+=src_stride1; \

  34.                 src2+=src_stride2; \

  35.                 dst+=dst_stride; \

  36.         } while(--h); \

  37. }\

  38. \

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

  40. {\

  41.         do {\

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

  43.                 src1+=src_stride1; \

  44.                 src2+=src_stride2; \

  45.                 dst+=dst_stride; \

  46.         } while(--h); \

  47. }\

  48. \

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

  50. {\

  51.         do {\

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

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

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

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

  56.                 src1+=src_stride1; \

  57.                 src2+=src_stride2; \

  58.                 dst+=dst_stride; \

  59.         } while(--h); \

  60. }\

  61. \

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

  63. {\

  64.         do {\

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

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

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

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

  69.                 src1+=src_stride1; \

  70.                 src2+=src_stride2; \

  71.                 dst+=dst_stride; \

  72.         } while(--h); \

  73. }\

  74. \

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

  76. {\

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

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

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

  80.                 src1+=src_stride1; \

  81.                 src2+=src_stride2; \

  82.                 dst+=dst_stride; \

  83.         } while(--h); \

  84. }\

  85. \

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

  87. {\

  88.         do {\

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

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

  91.                 src1+=src_stride1; \

  92.                 src2+=src_stride2; \

  93.                 dst+=dst_stride; \

  94.         } while(--h); \

  95. }\

  96. \

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

  98. {\

  99.         do {\

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

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

  102.                 src1+=src_stride1; \

  103.                 src2+=src_stride2; \

  104.                 dst+=dst_stride; \

  105.         } while(--h); \

  106. }\

  107. \

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

  109. {\

  110.         do {\

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

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

  113.                 src1+=src_stride1; \

  114.                 src2+=src_stride2; \

  115.                 dst+=dst_stride; \

  116.         } while(--h); \

  117. }\

  118. \

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

  120. {\

  121.         do {\

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

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

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

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

  126.                 src1+=src_stride1; \

  127.                 src2+=src_stride2; \

  128.                 dst+=dst_stride; \

  129.         } while(--h); \

  130. }\

  131. \

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

  133. {\

  134.         do {\

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

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

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

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

  139.                 src1+=src_stride1; \

  140.                 src2+=src_stride2; \

  141.                 dst+=dst_stride; \

  142.         } while(--h); \

  143. }\

  144. \

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

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

  147. \

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

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

  150. \

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

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

  153. \

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

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

  156. \

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

  158.         do { \

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

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

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

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

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

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

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

  166.                 src1+=src_stride1;\

  167.                 src2+=src_stride2;\

  168.                 src3+=src_stride3;\

  169.                 src4+=src_stride4;\

  170.                 dst+=dst_stride;\

  171.         } while(--h); \

  172. } \

  173. \

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

  175.         do { \

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

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

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

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

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

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

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

  183.                 src1+=src_stride1;\

  184.                 src2+=src_stride2;\

  185.                 src3+=src_stride3;\

  186.                 src4+=src_stride4;\

  187.                 dst+=dst_stride;\

  188.         } while(--h); \

  189. } \

  190. \

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

  192.         do { \

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

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

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

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

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

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

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

  200.                 src1+=src_stride1;\

  201.                 src2+=src_stride2;\

  202.                 src3+=src_stride3;\

  203.                 src4+=src_stride4;\

  204.                 dst+=dst_stride;\

  205.         } while(--h); \

  206. } \

  207. \

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

  209.         do { \

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

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

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

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

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

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

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

  217.                 src1+=src_stride1;\

  218.                 src2+=src_stride2;\

  219.                 src3+=src_stride3;\

  220.                 src4+=src_stride4;\

  221.                 dst+=dst_stride;\

  222.         } while(--h); \

  223. } \

  224. \

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

  226.         do { \

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

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

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

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

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

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

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

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

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

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

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

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

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

  240.                 src1+=src_stride1;\

  241.                 src2+=src_stride2;\

  242.                 src3+=src_stride3;\

  243.                 src4+=src_stride4;\

  244.                 dst+=dst_stride;\

  245.         } while(--h); \

  246. } \

  247. \

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

  249.         do { \

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

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

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

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

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

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

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

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

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

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

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

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

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

  263.                 src1+=src_stride1;\

  264.                 src2+=src_stride2;\

  265.                 src3+=src_stride3;\

  266.                 src4+=src_stride4;\

  267.                 dst+=dst_stride;\

  268.         } while(--h); \

  269. } \

  270. \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  286.                 src1+=src_stride1;\

  287.                 src2+=src_stride2;\

  288.                 src3+=src_stride3;\

  289.                 src4+=src_stride4;\

  290.                 dst+=dst_stride;\

  291.         } while(--h); \

  292. } \

  293. \

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

  295.         do { \

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

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

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

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

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

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

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

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

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

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

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

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

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

  309.                 src1+=src_stride1;\

  310.                 src2+=src_stride2;\

  311.                 src3+=src_stride3;\

  312.                 src4+=src_stride4;\

  313.                 dst+=dst_stride;\

  314.         } while(--h); \

  315. } \

  316. \

  317. 

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

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

  320. 

  321. PIXOP2(avg, op_avg)

  322. PIXOP2(put, op_put)

  323. #undef op_avg

  324. #undef op_put

  325. 

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

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

  328. 

  329. 

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

  331. {

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

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

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

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

  336. 

  337.     do {

  338.         int t0,t1,t2,t3;

  339.         uint8_t *s0 = src;

  340.         uint8_t *s1 = src+stride;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  358.         dst+= stride;

  359.         src+= stride;

  360.     }while(--h);

  361. }

  362. 

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

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

  365.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\

  366.     do {\

  367.         uint8_t *s = src; \

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

  369.         src0= *s++;\

  370.         src1= *s++;\

  371.         src2= *s++;\

  372.         src3= *s++;\

  373.         src4= *s++;\

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

  375.         src5= *s++;\

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

  377.         src6= *s++;\

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

  379.         src7= *s++;\

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

  381.         src8= *s++;\

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

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

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

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

  386.         dst+=dstStride;\

  387.         src+=srcStride;\

  388.     }while(--h);\

  389. }\

  390. \

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

  392.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\

  393.     int w=8;\

  394.     do{\

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  409.         src8 = *s; \

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

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

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

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

  414.         dst++;\

  415.         src++;\

  416.     }while(--w);\

  417. }\

  418. \

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

  420.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\

  421.     do {\

  422.         uint8_t *s = src;\

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

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

  425.         src0= *s++;\

  426.         src1= *s++;\

  427.         src2= *s++;\

  428.         src3= *s++;\

  429.         src4= *s++;\

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

  431.         src5= *s++;\

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

  433.         src6= *s++;\

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

  435.         src7= *s++;\

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

  437.         src8= *s++;\

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

  439.         src9= *s++;\

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

  441.         src10= *s++;\

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

  443.         src11= *s++;\

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

  445.         src12= *s++;\

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

  447.         src13= *s++;\

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

  449.         src14= *s++;\

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

  451.         src15= *s++;\

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

  453.         src16= *s++;\

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

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

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

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

  458.         dst+=dstStride;\

  459.         src+=srcStride;\

  460.     }while(--h);\

  461. }\

  462. \

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

  464.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\

  465.     int w=16;\

  466.     do {\

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  498.         src16 = *s; \

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

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

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

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

  503.         dst++;\

  504.         src++;\

  505.     }while(--w);\

  506. }\

  507. \

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

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

  510. }\

  511. \

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

  513.     uint8_t half[64];\

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

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

  516. }\

  517. \

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

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

  520. }\

  521. \

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

  523.     uint8_t half[64];\

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

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

  526. }\

  527. \

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

  529.     uint8_t full[16*9];\

  530.     uint8_t half[64];\

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

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

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

  534. }\

  535. \

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

  537.     uint8_t full[16*9];\

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

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

  540. }\

  541. \

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

  543.     uint8_t full[16*9];\

  544.     uint8_t half[64];\

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

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

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

  548. }\

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

  550.     uint8_t full[16*9];\

  551.     uint8_t halfH[72];\

  552.     uint8_t halfHV[64];\

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

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

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

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

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

  558. }\

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

  560.     uint8_t full[16*9];\

  561.     uint8_t halfH[72];\

  562.     uint8_t halfHV[64];\

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

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

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

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

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

  568. }\

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

  570.     uint8_t full[16*9];\

  571.     uint8_t halfH[72];\

  572.     uint8_t halfHV[64];\

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

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

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

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

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

  578. }\

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

  580.     uint8_t full[16*9];\

  581.     uint8_t halfH[72];\

  582.     uint8_t halfHV[64];\

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

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

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

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

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

  588. }\

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

  590.     uint8_t halfH[72];\

  591.     uint8_t halfHV[64];\

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

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

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

  595. }\

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

  597.     uint8_t halfH[72];\

  598.     uint8_t halfHV[64];\

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

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

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

  602. }\

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

  604.     uint8_t full[16*9];\

  605.     uint8_t halfH[72];\

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

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

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

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

  610. }\

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

  612.     uint8_t full[16*9];\

  613.     uint8_t halfH[72];\

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

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

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

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

  618. }\

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

  620.     uint8_t halfH[72];\

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

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

  623. }\

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

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

  626. }\

  627. \

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

  629.     uint8_t half[256];\

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

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

  632. }\

  633. \

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

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

  636. }\

  637. \

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

  639.     uint8_t half[256];\

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

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

  642. }\

  643. \

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

  645.     uint8_t full[24*17];\

  646.     uint8_t half[256];\

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

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

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

  650. }\

  651. \

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

  653.     uint8_t full[24*17];\

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

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

  656. }\

  657. \

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

  659.     uint8_t full[24*17];\

  660.     uint8_t half[256];\

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

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

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

  664. }\

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

  666.     uint8_t full[24*17];\

  667.     uint8_t halfH[272];\

  668.     uint8_t halfHV[256];\

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

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

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

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

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

  674. }\

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

  676.     uint8_t full[24*17];\

  677.     uint8_t halfH[272];\

  678.     uint8_t halfHV[256];\

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

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

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

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

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

  684. }\

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

  686.     uint8_t full[24*17];\

  687.     uint8_t halfH[272];\

  688.     uint8_t halfHV[256];\

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

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

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

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

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

  694. }\

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

  696.     uint8_t full[24*17];\

  697.     uint8_t halfH[272];\

  698.     uint8_t halfHV[256];\

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

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

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

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

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

  704. }\

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

  706.     uint8_t halfH[272];\

  707.     uint8_t halfHV[256];\

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

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

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

  711. }\

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

  713.     uint8_t halfH[272];\

  714.     uint8_t halfHV[256];\

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

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

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

  718. }\

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

  720.     uint8_t full[24*17];\

  721.     uint8_t halfH[272];\

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

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

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

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

  726. }\

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

  728.     uint8_t full[24*17];\

  729.     uint8_t halfH[272];\

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

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

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

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

  734. }\

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

  736.     uint8_t halfH[272];\

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

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

  739. }

  740. 

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

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

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

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

  745. 

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

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

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

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

  750. #undef op_avg

  751. #undef op_avg_no_rnd

  752. #undef op_put

  753. #undef op_put_no_rnd

  754. 

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

  756.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  757. 

  758.     do{

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

  760.         uint8_t *s = src;

  761.         src_1 = s[-1];

  762.         src0 = *s++;

  763.         src1 = *s++;

  764.         src2 = *s++;

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

  766.         src3 = *s++;

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

  768.         src4 = *s++;

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

  770.         src5 = *s++;

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

  772.         src6 = *s++;

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

  774.         src7 = *s++;

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

  776.         src8 = *s++;

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

  778.         src9 = *s++;

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

  780.         dst+=dstStride;

  781.         src+=srcStride;

  782.     }while(--h);

  783. }

  784. 

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

  786.     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;

  787. 

  788.     do{

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

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

  791.         src_1 = *(s-srcStride);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  808.         src9 = *s;

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

  810.         src++;

  811.         dst++;

  812.     }while(--w);

  813. }

  814. 

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

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

  817. }

  818. 

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

  820.     uint8_t half[64];

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

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

  823. }

  824. 

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

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

  827. }

  828. 

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

  830.     uint8_t half[64];

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

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

  833. }

  834. 

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

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

  837. }

  838. 

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

  840.     uint8_t halfH[88];

  841.     uint8_t halfV[64];

  842.     uint8_t halfHV[64];

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

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

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

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

  847. }

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

  849.     uint8_t halfH[88];

  850.     uint8_t halfV[64];

  851.     uint8_t halfHV[64];

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

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

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

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

  856. }

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

  858.     uint8_t halfH[88];

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

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

  861. }