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.
44689 Commits
32 Branches
944MB
Tree: c5714b51aa
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c5714b51aa'
${ noResults }
FFmpeg/libavcodec/ppc/h264qpel_template.c

518 lines
18KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2004 Romain Dolbeau <romain@dolbeau.org>

  3.  *

  4.  * This file is part of Libav.

  5.  *

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

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

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

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

  10.  *

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

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

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

  14.  * Lesser General Public License for more details.

  15.  *

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

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

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

  19.  */

  20. 

  21. #include "libavutil/mem.h"

  22. 

  23. #ifdef DEBUG

  24. #define ASSERT_ALIGNED(ptr) assert(((unsigned long)ptr&0x0000000F));

  25. #else

  26. #define ASSERT_ALIGNED(ptr) ;

  27. #endif

  28. 

  29. /* this code assume stride % 16 == 0 */

  30. #ifdef PREFIX_h264_qpel16_h_lowpass_altivec

  31. static void PREFIX_h264_qpel16_h_lowpass_altivec(uint8_t *dst,

  32.                                                  const uint8_t *src,

  33.                                                  int dstStride, int srcStride)

  34. {

  35.     register int i;

  36. 

  37.     LOAD_ZERO;

  38.     const vec_u8 permM2 = vec_lvsl(-2, src);

  39.     const vec_u8 permM1 = vec_lvsl(-1, src);

  40.     const vec_u8 permP0 = vec_lvsl(+0, src);

  41.     const vec_u8 permP1 = vec_lvsl(+1, src);

  42.     const vec_u8 permP2 = vec_lvsl(+2, src);

  43.     const vec_u8 permP3 = vec_lvsl(+3, src);

  44.     const vec_s16 v5ss = vec_splat_s16(5);

  45.     const vec_u16 v5us = vec_splat_u16(5);

  46.     const vec_s16 v20ss = vec_sl(vec_splat_s16(5),vec_splat_u16(2));

  47.     const vec_s16 v16ss = vec_sl(vec_splat_s16(1),vec_splat_u16(4));

  48. 

  49.     vec_u8 srcM2, srcM1, srcP0, srcP1, srcP2, srcP3;

  50. 

  51.     register int align = ((((unsigned long)src) - 2) % 16);

  52. 

  53.     vec_s16 srcP0A, srcP0B, srcP1A, srcP1B,

  54.               srcP2A, srcP2B, srcP3A, srcP3B,

  55.               srcM1A, srcM1B, srcM2A, srcM2B,

  56.               sum1A, sum1B, sum2A, sum2B, sum3A, sum3B,

  57.               pp1A, pp1B, pp2A, pp2B, pp3A, pp3B,

  58.               psumA, psumB, sumA, sumB;

  59. 

  60.     vec_u8 sum, fsum;

  61. 

  62.     for (i = 0 ; i < 16 ; i ++) {

  63.         vec_u8 srcR1 = vec_ld(-2, src);

  64.         vec_u8 srcR2 = vec_ld(14, src);

  65. 

  66.         switch (align) {

  67.         default: {

  68.             srcM2 = vec_perm(srcR1, srcR2, permM2);

  69.             srcM1 = vec_perm(srcR1, srcR2, permM1);

  70.             srcP0 = vec_perm(srcR1, srcR2, permP0);

  71.             srcP1 = vec_perm(srcR1, srcR2, permP1);

  72.             srcP2 = vec_perm(srcR1, srcR2, permP2);

  73.             srcP3 = vec_perm(srcR1, srcR2, permP3);

  74.         } break;

  75.         case 11: {

  76.             srcM2 = vec_perm(srcR1, srcR2, permM2);

  77.             srcM1 = vec_perm(srcR1, srcR2, permM1);

  78.             srcP0 = vec_perm(srcR1, srcR2, permP0);

  79.             srcP1 = vec_perm(srcR1, srcR2, permP1);

  80.             srcP2 = vec_perm(srcR1, srcR2, permP2);

  81.             srcP3 = srcR2;

  82.         } break;

  83.         case 12: {

  84.             vec_u8 srcR3 = vec_ld(30, src);

  85.             srcM2 = vec_perm(srcR1, srcR2, permM2);

  86.             srcM1 = vec_perm(srcR1, srcR2, permM1);

  87.             srcP0 = vec_perm(srcR1, srcR2, permP0);

  88.             srcP1 = vec_perm(srcR1, srcR2, permP1);

  89.             srcP2 = srcR2;

  90.             srcP3 = vec_perm(srcR2, srcR3, permP3);

  91.         } break;

  92.         case 13: {

  93.             vec_u8 srcR3 = vec_ld(30, src);

  94.             srcM2 = vec_perm(srcR1, srcR2, permM2);

  95.             srcM1 = vec_perm(srcR1, srcR2, permM1);

  96.             srcP0 = vec_perm(srcR1, srcR2, permP0);

  97.             srcP1 = srcR2;

  98.             srcP2 = vec_perm(srcR2, srcR3, permP2);

  99.             srcP3 = vec_perm(srcR2, srcR3, permP3);

  100.         } break;

  101.         case 14: {

  102.             vec_u8 srcR3 = vec_ld(30, src);

  103.             srcM2 = vec_perm(srcR1, srcR2, permM2);

  104.             srcM1 = vec_perm(srcR1, srcR2, permM1);

  105.             srcP0 = srcR2;

  106.             srcP1 = vec_perm(srcR2, srcR3, permP1);

  107.             srcP2 = vec_perm(srcR2, srcR3, permP2);

  108.             srcP3 = vec_perm(srcR2, srcR3, permP3);

  109.         } break;

  110.         case 15: {

  111.             vec_u8 srcR3 = vec_ld(30, src);

  112.             srcM2 = vec_perm(srcR1, srcR2, permM2);

  113.             srcM1 = srcR2;

  114.             srcP0 = vec_perm(srcR2, srcR3, permP0);

  115.             srcP1 = vec_perm(srcR2, srcR3, permP1);

  116.             srcP2 = vec_perm(srcR2, srcR3, permP2);

  117.             srcP3 = vec_perm(srcR2, srcR3, permP3);

  118.         } break;

  119.         }

  120. 

  121.         srcP0A = (vec_s16) vec_mergeh(zero_u8v, srcP0);

  122.         srcP0B = (vec_s16) vec_mergel(zero_u8v, srcP0);

  123.         srcP1A = (vec_s16) vec_mergeh(zero_u8v, srcP1);

  124.         srcP1B = (vec_s16) vec_mergel(zero_u8v, srcP1);

  125. 

  126.         srcP2A = (vec_s16) vec_mergeh(zero_u8v, srcP2);

  127.         srcP2B = (vec_s16) vec_mergel(zero_u8v, srcP2);

  128.         srcP3A = (vec_s16) vec_mergeh(zero_u8v, srcP3);

  129.         srcP3B = (vec_s16) vec_mergel(zero_u8v, srcP3);

  130. 

  131.         srcM1A = (vec_s16) vec_mergeh(zero_u8v, srcM1);

  132.         srcM1B = (vec_s16) vec_mergel(zero_u8v, srcM1);

  133.         srcM2A = (vec_s16) vec_mergeh(zero_u8v, srcM2);

  134.         srcM2B = (vec_s16) vec_mergel(zero_u8v, srcM2);

  135. 

  136.         sum1A = vec_adds(srcP0A, srcP1A);

  137.         sum1B = vec_adds(srcP0B, srcP1B);

  138.         sum2A = vec_adds(srcM1A, srcP2A);

  139.         sum2B = vec_adds(srcM1B, srcP2B);

  140.         sum3A = vec_adds(srcM2A, srcP3A);

  141.         sum3B = vec_adds(srcM2B, srcP3B);

  142. 

  143.         pp1A = vec_mladd(sum1A, v20ss, v16ss);

  144.         pp1B = vec_mladd(sum1B, v20ss, v16ss);

  145. 

  146.         pp2A = vec_mladd(sum2A, v5ss, zero_s16v);

  147.         pp2B = vec_mladd(sum2B, v5ss, zero_s16v);

  148. 

  149.         pp3A = vec_add(sum3A, pp1A);

  150.         pp3B = vec_add(sum3B, pp1B);

  151. 

  152.         psumA = vec_sub(pp3A, pp2A);

  153.         psumB = vec_sub(pp3B, pp2B);

  154. 

  155.         sumA = vec_sra(psumA, v5us);

  156.         sumB = vec_sra(psumB, v5us);

  157. 

  158.         sum = vec_packsu(sumA, sumB);

  159. 

  160.         ASSERT_ALIGNED(dst);

  161. 

  162.         OP_U8_ALTIVEC(fsum, sum, vec_ld(0, dst));

  163. 

  164.         vec_st(fsum, 0, dst);

  165. 

  166.         src += srcStride;

  167.         dst += dstStride;

  168.     }

  169. }

  170. #endif /* PREFIX_h264_qpel16_h_lowpass_altivec */

  171. 

  172. /* this code assume stride % 16 == 0 */

  173. #ifdef PREFIX_h264_qpel16_v_lowpass_altivec

  174. static void PREFIX_h264_qpel16_v_lowpass_altivec(uint8_t *dst,

  175.                                                  const uint8_t *src,

  176.                                                  int dstStride, int srcStride)

  177. {

  178.     register int i;

  179. 

  180.     LOAD_ZERO;

  181.     const vec_u8 perm = vec_lvsl(0, src);

  182.     const vec_s16 v20ss = vec_sl(vec_splat_s16(5),vec_splat_u16(2));

  183.     const vec_u16 v5us = vec_splat_u16(5);

  184.     const vec_s16 v5ss = vec_splat_s16(5);

  185.     const vec_s16 v16ss = vec_sl(vec_splat_s16(1),vec_splat_u16(4));

  186. 

  187.     const uint8_t *srcbis = src - (srcStride * 2);

  188. 

  189.     const vec_u8 srcM2a = vec_ld(0, srcbis);

  190.     const vec_u8 srcM2b = vec_ld(16, srcbis);

  191.     const vec_u8 srcM2 = vec_perm(srcM2a, srcM2b, perm);

  192.     //srcbis += srcStride;

  193.     const vec_u8 srcM1a = vec_ld(0, srcbis += srcStride);

  194.     const vec_u8 srcM1b = vec_ld(16, srcbis);

  195.     const vec_u8 srcM1 = vec_perm(srcM1a, srcM1b, perm);

  196.     //srcbis += srcStride;

  197.     const vec_u8 srcP0a = vec_ld(0, srcbis += srcStride);

  198.     const vec_u8 srcP0b = vec_ld(16, srcbis);

  199.     const vec_u8 srcP0 = vec_perm(srcP0a, srcP0b, perm);

  200.     //srcbis += srcStride;

  201.     const vec_u8 srcP1a = vec_ld(0, srcbis += srcStride);

  202.     const vec_u8 srcP1b = vec_ld(16, srcbis);

  203.     const vec_u8 srcP1 = vec_perm(srcP1a, srcP1b, perm);

  204.     //srcbis += srcStride;

  205.     const vec_u8 srcP2a = vec_ld(0, srcbis += srcStride);

  206.     const vec_u8 srcP2b = vec_ld(16, srcbis);

  207.     const vec_u8 srcP2 = vec_perm(srcP2a, srcP2b, perm);

  208.     //srcbis += srcStride;

  209. 

  210.     vec_s16 srcM2ssA = (vec_s16) vec_mergeh(zero_u8v, srcM2);

  211.     vec_s16 srcM2ssB = (vec_s16) vec_mergel(zero_u8v, srcM2);

  212.     vec_s16 srcM1ssA = (vec_s16) vec_mergeh(zero_u8v, srcM1);

  213.     vec_s16 srcM1ssB = (vec_s16) vec_mergel(zero_u8v, srcM1);

  214.     vec_s16 srcP0ssA = (vec_s16) vec_mergeh(zero_u8v, srcP0);

  215.     vec_s16 srcP0ssB = (vec_s16) vec_mergel(zero_u8v, srcP0);

  216.     vec_s16 srcP1ssA = (vec_s16) vec_mergeh(zero_u8v, srcP1);

  217.     vec_s16 srcP1ssB = (vec_s16) vec_mergel(zero_u8v, srcP1);

  218.     vec_s16 srcP2ssA = (vec_s16) vec_mergeh(zero_u8v, srcP2);

  219.     vec_s16 srcP2ssB = (vec_s16) vec_mergel(zero_u8v, srcP2);

  220. 

  221.     vec_s16 pp1A, pp1B, pp2A, pp2B, pp3A, pp3B,

  222.               psumA, psumB, sumA, sumB,

  223.               srcP3ssA, srcP3ssB,

  224.               sum1A, sum1B, sum2A, sum2B, sum3A, sum3B;

  225. 

  226.     vec_u8 sum, fsum, srcP3a, srcP3b, srcP3;

  227. 

  228.     for (i = 0 ; i < 16 ; i++) {

  229.         srcP3a = vec_ld(0, srcbis += srcStride);

  230.         srcP3b = vec_ld(16, srcbis);

  231.         srcP3 = vec_perm(srcP3a, srcP3b, perm);

  232.         srcP3ssA = (vec_s16) vec_mergeh(zero_u8v, srcP3);

  233.         srcP3ssB = (vec_s16) vec_mergel(zero_u8v, srcP3);

  234.         //srcbis += srcStride;

  235. 

  236.         sum1A = vec_adds(srcP0ssA, srcP1ssA);

  237.         sum1B = vec_adds(srcP0ssB, srcP1ssB);

  238.         sum2A = vec_adds(srcM1ssA, srcP2ssA);

  239.         sum2B = vec_adds(srcM1ssB, srcP2ssB);

  240.         sum3A = vec_adds(srcM2ssA, srcP3ssA);

  241.         sum3B = vec_adds(srcM2ssB, srcP3ssB);

  242. 

  243.         srcM2ssA = srcM1ssA;

  244.         srcM2ssB = srcM1ssB;

  245.         srcM1ssA = srcP0ssA;

  246.         srcM1ssB = srcP0ssB;

  247.         srcP0ssA = srcP1ssA;

  248.         srcP0ssB = srcP1ssB;

  249.         srcP1ssA = srcP2ssA;

  250.         srcP1ssB = srcP2ssB;

  251.         srcP2ssA = srcP3ssA;

  252.         srcP2ssB = srcP3ssB;

  253. 

  254.         pp1A = vec_mladd(sum1A, v20ss, v16ss);

  255.         pp1B = vec_mladd(sum1B, v20ss, v16ss);

  256. 

  257.         pp2A = vec_mladd(sum2A, v5ss, zero_s16v);

  258.         pp2B = vec_mladd(sum2B, v5ss, zero_s16v);

  259. 

  260.         pp3A = vec_add(sum3A, pp1A);

  261.         pp3B = vec_add(sum3B, pp1B);

  262. 

  263.         psumA = vec_sub(pp3A, pp2A);

  264.         psumB = vec_sub(pp3B, pp2B);

  265. 

  266.         sumA = vec_sra(psumA, v5us);

  267.         sumB = vec_sra(psumB, v5us);

  268. 

  269.         sum = vec_packsu(sumA, sumB);

  270. 

  271.         ASSERT_ALIGNED(dst);

  272. 

  273.         OP_U8_ALTIVEC(fsum, sum, vec_ld(0, dst));

  274. 

  275.         vec_st(fsum, 0, dst);

  276. 

  277.         dst += dstStride;

  278.     }

  279. }

  280. #endif /* PREFIX_h264_qpel16_v_lowpass_altivec */

  281. 

  282. /* this code assume stride % 16 == 0 *and* tmp is properly aligned */

  283. #ifdef PREFIX_h264_qpel16_hv_lowpass_altivec

  284. static void PREFIX_h264_qpel16_hv_lowpass_altivec(uint8_t *dst, int16_t *tmp,

  285.                                                   const uint8_t *src,

  286.                                                   int dstStride, int tmpStride,

  287.                                                   int srcStride)

  288. {

  289.     register int i;

  290.     LOAD_ZERO;

  291.     const vec_u8 permM2 = vec_lvsl(-2, src);

  292.     const vec_u8 permM1 = vec_lvsl(-1, src);

  293.     const vec_u8 permP0 = vec_lvsl(+0, src);

  294.     const vec_u8 permP1 = vec_lvsl(+1, src);

  295.     const vec_u8 permP2 = vec_lvsl(+2, src);

  296.     const vec_u8 permP3 = vec_lvsl(+3, src);

  297.     const vec_s16 v20ss = vec_sl(vec_splat_s16(5),vec_splat_u16(2));

  298.     const vec_u32 v10ui = vec_splat_u32(10);

  299.     const vec_s16 v5ss = vec_splat_s16(5);

  300.     const vec_s16 v1ss = vec_splat_s16(1);

  301.     const vec_s32 v512si = vec_sl(vec_splat_s32(1),vec_splat_u32(9));

  302.     const vec_u32 v16ui = vec_sl(vec_splat_u32(1),vec_splat_u32(4));

  303. 

  304.     register int align = ((((unsigned long)src) - 2) % 16);

  305. 

  306.     vec_s16 srcP0A, srcP0B, srcP1A, srcP1B,

  307.               srcP2A, srcP2B, srcP3A, srcP3B,

  308.               srcM1A, srcM1B, srcM2A, srcM2B,

  309.               sum1A, sum1B, sum2A, sum2B, sum3A, sum3B,

  310.               pp1A, pp1B, pp2A, pp2B, psumA, psumB;

  311. 

  312.     const vec_u8 mperm = (const vec_u8)

  313.         {0x00, 0x08, 0x01, 0x09, 0x02, 0x0A, 0x03, 0x0B,

  314.          0x04, 0x0C, 0x05, 0x0D, 0x06, 0x0E, 0x07, 0x0F};

  315.     int16_t *tmpbis = tmp;

  316. 

  317.     vec_s16 tmpM1ssA, tmpM1ssB, tmpM2ssA, tmpM2ssB,

  318.               tmpP0ssA, tmpP0ssB, tmpP1ssA, tmpP1ssB,

  319.               tmpP2ssA, tmpP2ssB;

  320. 

  321.     vec_s32 pp1Ae, pp1Ao, pp1Be, pp1Bo, pp2Ae, pp2Ao, pp2Be, pp2Bo,

  322.               pp3Ae, pp3Ao, pp3Be, pp3Bo, pp1cAe, pp1cAo, pp1cBe, pp1cBo,

  323.               pp32Ae, pp32Ao, pp32Be, pp32Bo, sumAe, sumAo, sumBe, sumBo,

  324.               ssumAe, ssumAo, ssumBe, ssumBo;

  325.     vec_u8 fsum, sumv, sum;

  326.     vec_s16 ssume, ssumo;

  327. 

  328.     src -= (2 * srcStride);

  329.     for (i = 0 ; i < 21 ; i ++) {

  330.         vec_u8 srcM2, srcM1, srcP0, srcP1, srcP2, srcP3;

  331.         vec_u8 srcR1 = vec_ld(-2, src);

  332.         vec_u8 srcR2 = vec_ld(14, src);

  333. 

  334.         switch (align) {

  335.         default: {

  336.             srcM2 = vec_perm(srcR1, srcR2, permM2);

  337.             srcM1 = vec_perm(srcR1, srcR2, permM1);

  338.             srcP0 = vec_perm(srcR1, srcR2, permP0);

  339.             srcP1 = vec_perm(srcR1, srcR2, permP1);

  340.             srcP2 = vec_perm(srcR1, srcR2, permP2);

  341.             srcP3 = vec_perm(srcR1, srcR2, permP3);

  342.         } break;

  343.         case 11: {

  344.             srcM2 = vec_perm(srcR1, srcR2, permM2);

  345.             srcM1 = vec_perm(srcR1, srcR2, permM1);

  346.             srcP0 = vec_perm(srcR1, srcR2, permP0);

  347.             srcP1 = vec_perm(srcR1, srcR2, permP1);

  348.             srcP2 = vec_perm(srcR1, srcR2, permP2);

  349.             srcP3 = srcR2;

  350.         } break;

  351.         case 12: {

  352.             vec_u8 srcR3 = vec_ld(30, src);

  353.             srcM2 = vec_perm(srcR1, srcR2, permM2);

  354.             srcM1 = vec_perm(srcR1, srcR2, permM1);

  355.             srcP0 = vec_perm(srcR1, srcR2, permP0);

  356.             srcP1 = vec_perm(srcR1, srcR2, permP1);

  357.             srcP2 = srcR2;

  358.             srcP3 = vec_perm(srcR2, srcR3, permP3);

  359.         } break;

  360.         case 13: {

  361.             vec_u8 srcR3 = vec_ld(30, src);

  362.             srcM2 = vec_perm(srcR1, srcR2, permM2);

  363.             srcM1 = vec_perm(srcR1, srcR2, permM1);

  364.             srcP0 = vec_perm(srcR1, srcR2, permP0);

  365.             srcP1 = srcR2;

  366.             srcP2 = vec_perm(srcR2, srcR3, permP2);

  367.             srcP3 = vec_perm(srcR2, srcR3, permP3);

  368.         } break;

  369.         case 14: {

  370.             vec_u8 srcR3 = vec_ld(30, src);

  371.             srcM2 = vec_perm(srcR1, srcR2, permM2);

  372.             srcM1 = vec_perm(srcR1, srcR2, permM1);

  373.             srcP0 = srcR2;

  374.             srcP1 = vec_perm(srcR2, srcR3, permP1);

  375.             srcP2 = vec_perm(srcR2, srcR3, permP2);

  376.             srcP3 = vec_perm(srcR2, srcR3, permP3);

  377.         } break;

  378.         case 15: {

  379.             vec_u8 srcR3 = vec_ld(30, src);

  380.             srcM2 = vec_perm(srcR1, srcR2, permM2);

  381.             srcM1 = srcR2;

  382.             srcP0 = vec_perm(srcR2, srcR3, permP0);

  383.             srcP1 = vec_perm(srcR2, srcR3, permP1);

  384.             srcP2 = vec_perm(srcR2, srcR3, permP2);

  385.             srcP3 = vec_perm(srcR2, srcR3, permP3);

  386.         } break;

  387.         }

  388. 

  389.         srcP0A = (vec_s16) vec_mergeh(zero_u8v, srcP0);

  390.         srcP0B = (vec_s16) vec_mergel(zero_u8v, srcP0);

  391.         srcP1A = (vec_s16) vec_mergeh(zero_u8v, srcP1);

  392.         srcP1B = (vec_s16) vec_mergel(zero_u8v, srcP1);

  393. 

  394.         srcP2A = (vec_s16) vec_mergeh(zero_u8v, srcP2);

  395.         srcP2B = (vec_s16) vec_mergel(zero_u8v, srcP2);

  396.         srcP3A = (vec_s16) vec_mergeh(zero_u8v, srcP3);

  397.         srcP3B = (vec_s16) vec_mergel(zero_u8v, srcP3);

  398. 

  399.         srcM1A = (vec_s16) vec_mergeh(zero_u8v, srcM1);

  400.         srcM1B = (vec_s16) vec_mergel(zero_u8v, srcM1);

  401.         srcM2A = (vec_s16) vec_mergeh(zero_u8v, srcM2);

  402.         srcM2B = (vec_s16) vec_mergel(zero_u8v, srcM2);

  403. 

  404.         sum1A = vec_adds(srcP0A, srcP1A);

  405.         sum1B = vec_adds(srcP0B, srcP1B);

  406.         sum2A = vec_adds(srcM1A, srcP2A);

  407.         sum2B = vec_adds(srcM1B, srcP2B);

  408.         sum3A = vec_adds(srcM2A, srcP3A);

  409.         sum3B = vec_adds(srcM2B, srcP3B);

  410. 

  411.         pp1A = vec_mladd(sum1A, v20ss, sum3A);

  412.         pp1B = vec_mladd(sum1B, v20ss, sum3B);

  413. 

  414.         pp2A = vec_mladd(sum2A, v5ss, zero_s16v);

  415.         pp2B = vec_mladd(sum2B, v5ss, zero_s16v);

  416. 

  417.         psumA = vec_sub(pp1A, pp2A);

  418.         psumB = vec_sub(pp1B, pp2B);

  419. 

  420.         vec_st(psumA, 0, tmp);

  421.         vec_st(psumB, 16, tmp);

  422. 

  423.         src += srcStride;

  424.         tmp += tmpStride; /* int16_t*, and stride is 16, so it's OK here */

  425.     }

  426. 

  427.     tmpM2ssA = vec_ld(0, tmpbis);

  428.     tmpM2ssB = vec_ld(16, tmpbis);

  429.     tmpbis += tmpStride;

  430.     tmpM1ssA = vec_ld(0, tmpbis);

  431.     tmpM1ssB = vec_ld(16, tmpbis);

  432.     tmpbis += tmpStride;

  433.     tmpP0ssA = vec_ld(0, tmpbis);

  434.     tmpP0ssB = vec_ld(16, tmpbis);

  435.     tmpbis += tmpStride;

  436.     tmpP1ssA = vec_ld(0, tmpbis);

  437.     tmpP1ssB = vec_ld(16, tmpbis);

  438.     tmpbis += tmpStride;

  439.     tmpP2ssA = vec_ld(0, tmpbis);

  440.     tmpP2ssB = vec_ld(16, tmpbis);

  441.     tmpbis += tmpStride;

  442. 

  443.     for (i = 0 ; i < 16 ; i++) {

  444.         const vec_s16 tmpP3ssA = vec_ld(0, tmpbis);

  445.         const vec_s16 tmpP3ssB = vec_ld(16, tmpbis);

  446. 

  447.         const vec_s16 sum1A = vec_adds(tmpP0ssA, tmpP1ssA);

  448.         const vec_s16 sum1B = vec_adds(tmpP0ssB, tmpP1ssB);

  449.         const vec_s16 sum2A = vec_adds(tmpM1ssA, tmpP2ssA);

  450.         const vec_s16 sum2B = vec_adds(tmpM1ssB, tmpP2ssB);

  451.         const vec_s16 sum3A = vec_adds(tmpM2ssA, tmpP3ssA);

  452.         const vec_s16 sum3B = vec_adds(tmpM2ssB, tmpP3ssB);

  453. 

  454.         tmpbis += tmpStride;

  455. 

  456.         tmpM2ssA = tmpM1ssA;

  457.         tmpM2ssB = tmpM1ssB;

  458.         tmpM1ssA = tmpP0ssA;

  459.         tmpM1ssB = tmpP0ssB;

  460.         tmpP0ssA = tmpP1ssA;

  461.         tmpP0ssB = tmpP1ssB;

  462.         tmpP1ssA = tmpP2ssA;

  463.         tmpP1ssB = tmpP2ssB;

  464.         tmpP2ssA = tmpP3ssA;

  465.         tmpP2ssB = tmpP3ssB;

  466. 

  467.         pp1Ae = vec_mule(sum1A, v20ss);

  468.         pp1Ao = vec_mulo(sum1A, v20ss);

  469.         pp1Be = vec_mule(sum1B, v20ss);

  470.         pp1Bo = vec_mulo(sum1B, v20ss);

  471. 

  472.         pp2Ae = vec_mule(sum2A, v5ss);

  473.         pp2Ao = vec_mulo(sum2A, v5ss);

  474.         pp2Be = vec_mule(sum2B, v5ss);

  475.         pp2Bo = vec_mulo(sum2B, v5ss);

  476. 

  477.         pp3Ae = vec_sra((vec_s32)sum3A, v16ui);

  478.         pp3Ao = vec_mulo(sum3A, v1ss);

  479.         pp3Be = vec_sra((vec_s32)sum3B, v16ui);

  480.         pp3Bo = vec_mulo(sum3B, v1ss);

  481. 

  482.         pp1cAe = vec_add(pp1Ae, v512si);

  483.         pp1cAo = vec_add(pp1Ao, v512si);

  484.         pp1cBe = vec_add(pp1Be, v512si);

  485.         pp1cBo = vec_add(pp1Bo, v512si);

  486. 

  487.         pp32Ae = vec_sub(pp3Ae, pp2Ae);

  488.         pp32Ao = vec_sub(pp3Ao, pp2Ao);

  489.         pp32Be = vec_sub(pp3Be, pp2Be);

  490.         pp32Bo = vec_sub(pp3Bo, pp2Bo);

  491. 

  492.         sumAe = vec_add(pp1cAe, pp32Ae);

  493.         sumAo = vec_add(pp1cAo, pp32Ao);

  494.         sumBe = vec_add(pp1cBe, pp32Be);

  495.         sumBo = vec_add(pp1cBo, pp32Bo);

  496. 

  497.         ssumAe = vec_sra(sumAe, v10ui);

  498.         ssumAo = vec_sra(sumAo, v10ui);

  499.         ssumBe = vec_sra(sumBe, v10ui);

  500.         ssumBo = vec_sra(sumBo, v10ui);

  501. 

  502.         ssume = vec_packs(ssumAe, ssumBe);

  503.         ssumo = vec_packs(ssumAo, ssumBo);

  504. 

  505.         sumv = vec_packsu(ssume, ssumo);

  506.         sum = vec_perm(sumv, sumv, mperm);

  507. 

  508.         ASSERT_ALIGNED(dst);

  509. 

  510.         OP_U8_ALTIVEC(fsum, sum, vec_ld(0, dst));

  511. 

  512.         vec_st(fsum, 0, dst);

  513. 

  514.         dst += dstStride;

  515.     }

  516. }

  517. #endif /* PREFIX_h264_qpel16_hv_lowpass_altivec */