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

796 lines
22KB
Raw Blame History 

  1. /*

  2.  * Altivec optimized snow DSP utils

  3.  * Copyright (c) 2006 Luca Barbato <lu_zero@gentoo.org>

  4.  *

  5.  * This library is free software; you can redistribute it and/or

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

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

  8.  * version 2 of the License, or (at your option) any later version.

  9.  *

  10.  * This library is distributed in the hope that it will be useful,

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

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

  13.  * Lesser General Public License for more details.

  14.  *

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

  16.  * License along with this library; if not, write to the Free Software

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

  18.  *

  19.  *

  20.  */

  21. 

  22. #include "../dsputil.h"

  23. 

  24. #include "gcc_fixes.h"

  25. #include "dsputil_altivec.h"

  26. #include "../snow.h"

  27. 

  28. #undef NDEBUG

  29. #include <assert.h>

  30. 

  31. 

  32. 

  33. //FIXME remove this replication

  34. #define slice_buffer_get_line(slice_buf, line_num) ((slice_buf)->line[line_num] ? (slice_buf)->line[line_num] : slice_buffer_load_line((slice_buf), (line_num)))

  35. 

  36. static DWTELEM * slice_buffer_load_line(slice_buffer * buf, int line)

  37. {

  38.     int offset;

  39.     DWTELEM * buffer;

  40. 

  41. //  av_log(NULL, AV_LOG_DEBUG, "Cache hit: %d\n", line);

  42. 

  43.     assert(buf->data_stack_top >= 0);

  44. //  assert(!buf->line[line]);

  45.     if (buf->line[line])

  46.         return buf->line[line];

  47. 

  48.     offset = buf->line_width * line;

  49.     buffer = buf->data_stack[buf->data_stack_top];

  50.     buf->data_stack_top--;

  51.     buf->line[line] = buffer;

  52. 

  53. //  av_log(NULL, AV_LOG_DEBUG, "slice_buffer_load_line: line: %d remaining: %d\n", line, buf->data_stack_top + 1);

  54. 

  55.     return buffer;

  56. }

  57. 

  58. 

  59. //altivec code

  60. 

  61. void ff_snow_horizontal_compose97i_altivec(DWTELEM *b, int width)

  62. {

  63.     const int w2= (width+1)>>1;

  64.     DECLARE_ALIGNED_16(DWTELEM, temp[(width>>1)]);

  65.     const int w_l= (width>>1);

  66.     const int w_r= w2 - 1;

  67.     int i;

  68.     vector signed int t1, t2, x, y, tmp1, tmp2;

  69.     vector signed int *vbuf, *vtmp;

  70.     vector unsigned char align;

  71. 

  72. 

  73. 

  74.     { // Lift 0

  75.         DWTELEM * const ref = b + w2 - 1;

  76.         DWTELEM b_0 = b[0];

  77.         vbuf = (vector signed int *)b;

  78. 

  79.         tmp1 = vec_ld (0, ref);

  80.         align = vec_lvsl (0, ref);

  81.         tmp2 = vec_ld (15, ref);

  82.         t1= vec_perm(tmp1, tmp2, align);

  83. 

  84.         i = 0;

  85. 

  86.         for (i=0; i<w_l-15; i+=16) {

  87. #if 0

  88.         b[i+0] = b[i+0] - ((3 * (ref[i+0] + ref[i+1]) + 4) >> 3);

  89.         b[i+1] = b[i+1] - ((3 * (ref[i+1] + ref[i+2]) + 4) >> 3);

  90.         b[i+2] = b[i+2] - ((3 * (ref[i+2] + ref[i+3]) + 4) >> 3);

  91.         b[i+3] = b[i+3] - ((3 * (ref[i+3] + ref[i+4]) + 4) >> 3);

  92. #else

  93. 

  94.         tmp1 = vec_ld (0, ref+4+i);

  95.         tmp2 = vec_ld (15, ref+4+i);

  96. 

  97.         t2 = vec_perm(tmp1, tmp2, align);

  98. 

  99.         y = vec_add(t1,vec_sld(t1,t2,4));

  100.         y = vec_add(vec_add(y,y),y);

  101. 

  102.         tmp1 = vec_ld (0, ref+8+i);

  103. 

  104.         y = vec_add(y, vec_splat_s32(4));

  105.         y = vec_sra(y, vec_splat_u32(3));

  106. 

  107.         tmp2 = vec_ld (15, ref+8+i);

  108. 

  109.         *vbuf = vec_sub(*vbuf, y);

  110. 

  111.         t1=t2;

  112. 

  113.         vbuf++;

  114. 

  115.         t2 = vec_perm(tmp1, tmp2, align);

  116. 

  117.         y = vec_add(t1,vec_sld(t1,t2,4));

  118.         y = vec_add(vec_add(y,y),y);

  119. 

  120.         tmp1 = vec_ld (0, ref+12+i);

  121. 

  122.         y = vec_add(y, vec_splat_s32(4));

  123.         y = vec_sra(y, vec_splat_u32(3));

  124. 

  125.         tmp2 = vec_ld (15, ref+12+i);

  126. 

  127.         *vbuf = vec_sub(*vbuf, y);

  128. 

  129.         t1=t2;

  130. 

  131.         vbuf++;

  132. 

  133.         t2 = vec_perm(tmp1, tmp2, align);

  134. 

  135.         y = vec_add(t1,vec_sld(t1,t2,4));

  136.         y = vec_add(vec_add(y,y),y);

  137. 

  138.         tmp1 = vec_ld (0, ref+16+i);

  139. 

  140.         y = vec_add(y, vec_splat_s32(4));

  141.         y = vec_sra(y, vec_splat_u32(3));

  142. 

  143.         tmp2 = vec_ld (15, ref+16+i);

  144. 

  145.         *vbuf = vec_sub(*vbuf, y);

  146. 

  147.         t1=t2;

  148. 

  149.         t2 = vec_perm(tmp1, tmp2, align);

  150. 

  151.         y = vec_add(t1,vec_sld(t1,t2,4));

  152.         y = vec_add(vec_add(y,y),y);

  153. 

  154.         vbuf++;

  155. 

  156.         y = vec_add(y, vec_splat_s32(4));

  157.         y = vec_sra(y, vec_splat_u32(3));

  158.         *vbuf = vec_sub(*vbuf, y);

  159. 

  160.         t1=t2;

  161. 

  162.         vbuf++;

  163. 

  164. #endif

  165.         }

  166. 

  167.         snow_horizontal_compose_lift_lead_out(i, b, b, ref, width, w_l, 0, W_DM, W_DO, W_DS);

  168.         b[0] = b_0 - ((W_DM * 2 * ref[1]+W_DO)>>W_DS);

  169.     }

  170. 

  171.     { // Lift 1

  172.         DWTELEM * const dst = b+w2;

  173. 

  174.         i = 0;

  175.         for(; (((long)&dst[i]) & 0xF) && i<w_r; i++){

  176.             dst[i] = dst[i] - (b[i] + b[i + 1]);

  177.         }

  178. 

  179.         align = vec_lvsl(0, b+i);

  180.         tmp1 = vec_ld(0, b+i);

  181.         vbuf = (vector signed int*) (dst + i);

  182.         tmp2 = vec_ld(15, b+i);

  183. 

  184.         t1 = vec_perm(tmp1, tmp2, align);

  185. 

  186.         for (; i<w_r-3; i+=4) {

  187. 

  188. #if 0

  189.             dst[i]   = dst[i]   - (b[i]   + b[i + 1]);

  190.             dst[i+1] = dst[i+1] - (b[i+1] + b[i + 2]);

  191.             dst[i+2] = dst[i+2] - (b[i+2] + b[i + 3]);

  192.             dst[i+3] = dst[i+3] - (b[i+3] + b[i + 4]);

  193. #else

  194. 

  195.         tmp1 = vec_ld(0, b+4+i);

  196.         tmp2 = vec_ld(15, b+4+i);

  197. 

  198.         t2 = vec_perm(tmp1, tmp2, align);

  199. 

  200.         y = vec_add(t1, vec_sld(t1,t2,4));

  201.         *vbuf = vec_sub (*vbuf, y);

  202. 

  203.         vbuf++;

  204. 

  205.         t1 = t2;

  206. 

  207. #endif

  208. 

  209.         }

  210. 

  211.         snow_horizontal_compose_lift_lead_out(i, dst, dst, b, width, w_r, 1, W_CM, W_CO, W_CS);

  212.     }

  213. 

  214.     { // Lift 2

  215.         DWTELEM * const ref = b+w2 - 1;

  216.         DWTELEM b_0 = b[0];

  217.         vbuf= (vector signed int *) b;

  218. 

  219.         tmp1 = vec_ld (0, ref);

  220.         align = vec_lvsl (0, ref);

  221.         tmp2 = vec_ld (15, ref);

  222.         t1= vec_perm(tmp1, tmp2, align);

  223. 

  224.         i = 0;

  225.         for (; i<w_l-15; i+=16) {

  226. #if 0

  227.             b[i]   = b[i]   - (((8 -(ref[i]   + ref[i+1])) - (b[i]  <<2)) >> 4);

  228.             b[i+1] = b[i+1] - (((8 -(ref[i+1] + ref[i+2])) - (b[i+1]<<2)) >> 4);

  229.             b[i+2] = b[i+2] - (((8 -(ref[i+2] + ref[i+3])) - (b[i+2]<<2)) >> 4);

  230.             b[i+3] = b[i+3] - (((8 -(ref[i+3] + ref[i+4])) - (b[i+3]<<2)) >> 4);

  231. #else

  232.             tmp1 = vec_ld (0, ref+4+i);

  233.             tmp2 = vec_ld (15, ref+4+i);

  234. 

  235.             t2 = vec_perm(tmp1, tmp2, align);

  236. 

  237.             y = vec_add(t1,vec_sld(t1,t2,4));

  238.             y = vec_sub(vec_splat_s32(8),y);

  239. 

  240.             tmp1 = vec_ld (0, ref+8+i);

  241. 

  242.             x = vec_sl(*vbuf,vec_splat_u32(2));

  243.             y = vec_sra(vec_sub(y,x),vec_splat_u32(4));

  244. 

  245.             tmp2 = vec_ld (15, ref+8+i);

  246. 

  247.             *vbuf = vec_sub( *vbuf, y);

  248. 

  249.             t1 = t2;

  250. 

  251.             vbuf++;

  252. 

  253.             t2 = vec_perm(tmp1, tmp2, align);

  254. 

  255.             y = vec_add(t1,vec_sld(t1,t2,4));

  256.             y = vec_sub(vec_splat_s32(8),y);

  257. 

  258.             tmp1 = vec_ld (0, ref+12+i);

  259. 

  260.             x = vec_sl(*vbuf,vec_splat_u32(2));

  261.             y = vec_sra(vec_sub(y,x),vec_splat_u32(4));

  262. 

  263.             tmp2 = vec_ld (15, ref+12+i);

  264. 

  265.             *vbuf = vec_sub( *vbuf, y);

  266. 

  267.             t1 = t2;

  268. 

  269.             vbuf++;

  270. 

  271.             t2 = vec_perm(tmp1, tmp2, align);

  272. 

  273.             y = vec_add(t1,vec_sld(t1,t2,4));

  274.             y = vec_sub(vec_splat_s32(8),y);

  275. 

  276.             tmp1 = vec_ld (0, ref+16+i);

  277. 

  278.             x = vec_sl(*vbuf,vec_splat_u32(2));

  279.             y = vec_sra(vec_sub(y,x),vec_splat_u32(4));

  280. 

  281.             tmp2 = vec_ld (15, ref+16+i);

  282. 

  283.             *vbuf = vec_sub( *vbuf, y);

  284. 

  285.             t1 = t2;

  286. 

  287.             vbuf++;

  288. 

  289.             t2 = vec_perm(tmp1, tmp2, align);

  290. 

  291.             y = vec_add(t1,vec_sld(t1,t2,4));

  292.             y = vec_sub(vec_splat_s32(8),y);

  293. 

  294.             t1 = t2;

  295. 

  296.             x = vec_sl(*vbuf,vec_splat_u32(2));

  297.             y = vec_sra(vec_sub(y,x),vec_splat_u32(4));

  298.             *vbuf = vec_sub( *vbuf, y);

  299. 

  300.             vbuf++;

  301. 

  302. #endif

  303.         }

  304. 

  305.         snow_horizontal_compose_liftS_lead_out(i, b, b, ref, width, w_l);

  306.         b[0] = b_0 - (((-2 * ref[1] + W_BO) - 4 * b_0) >> W_BS);

  307.     }

  308. 

  309.     { // Lift 3

  310.         DWTELEM * const src = b+w2;

  311. 

  312.         vbuf = (vector signed int *)b;

  313.         vtmp = (vector signed int *)temp;

  314. 

  315.         i = 0;

  316.         align = vec_lvsl(0, src);

  317. 

  318.         for (; i<w_r-3; i+=4) {

  319. #if 0

  320.             temp[i] = src[i] - ((-3*(b[i] + b[i+1]))>>1);

  321.             temp[i+1] = src[i+1] - ((-3*(b[i+1] + b[i+2]))>>1);

  322.             temp[i+2] = src[i+2] - ((-3*(b[i+2] + b[i+3]))>>1);

  323.             temp[i+3] = src[i+3] - ((-3*(b[i+3] + b[i+4]))>>1);

  324. #else

  325.             tmp1 = vec_ld(0,src+i);

  326.             t1 = vec_add(vbuf[0],vec_sld(vbuf[0],vbuf[1],4));

  327.             tmp2 = vec_ld(15,src+i);

  328.             t1 = vec_sub(vec_splat_s32(0),t1); //bad!

  329.             t1 = vec_add(t1,vec_add(t1,t1));

  330.             t2 = vec_perm(tmp1 ,tmp2 ,align);

  331.             t1 = vec_sra(t1,vec_splat_u32(1));

  332.             vbuf++;

  333.             *vtmp = vec_sub(t2,t1);

  334.             vtmp++;

  335. 

  336. #endif

  337. 

  338.         }

  339. 

  340.         snow_horizontal_compose_lift_lead_out(i, temp, src, b, width, w_r, 1, -3, 0, 1);

  341.     }

  342. 

  343.     {

  344.     //Interleave

  345.         int a;

  346.         vector signed int *t = (vector signed int *)temp,

  347.                           *v = (vector signed int *)b;

  348. 

  349.         snow_interleave_line_header(&i, width, b, temp);

  350. 

  351.         for (; (i & 0xE) != 0xE; i-=2){

  352.             b[i+1] = temp[i>>1];

  353.             b[i] = b[i>>1];

  354.         }

  355.         for (i-=14; i>=0; i-=16){

  356.            a=i/4;

  357. 

  358.            v[a+3]=vec_mergel(v[(a>>1)+1],t[(a>>1)+1]);

  359.            v[a+2]=vec_mergeh(v[(a>>1)+1],t[(a>>1)+1]);

  360.            v[a+1]=vec_mergel(v[a>>1],t[a>>1]);

  361.            v[a]=vec_mergeh(v[a>>1],t[a>>1]);

  362. 

  363.         }

  364. 

  365.     }

  366. }

  367. 

  368. void ff_snow_vertical_compose97i_altivec(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, DWTELEM *b3, DWTELEM *b4, DWTELEM *b5, int width)

  369. {

  370.     int i, w4 = width/4;

  371.     vector signed int *v0, *v1,*v2,*v3,*v4,*v5;

  372.     vector signed int t1, t2;

  373. 

  374.     v0=(vector signed int *)b0;

  375.     v1=(vector signed int *)b1;

  376.     v2=(vector signed int *)b2;

  377.     v3=(vector signed int *)b3;

  378.     v4=(vector signed int *)b4;

  379.     v5=(vector signed int *)b5;

  380. 

  381.     for (i=0; i< w4;i++)

  382.     {

  383. 

  384.     #if 0

  385.         b4[i] -= (3*(b3[i] + b5[i])+4)>>3;

  386.         b3[i] -= ((b2[i] + b4[i]));

  387.         b2[i] += ((b1[i] + b3[i])+4*b2[i]+8)>>4;

  388.         b1[i] += (3*(b0[i] + b2[i]))>>1;

  389.     #else

  390.         t1 = vec_add(v3[i], v5[i]);

  391.         t2 = vec_add(t1, vec_add(t1,t1));

  392.         t1 = vec_add(t2, vec_splat_s32(4));

  393.         v4[i] = vec_sub(v4[i], vec_sra(t1,vec_splat_u32(3)));

  394. 

  395.         v3[i] = vec_sub(v3[i], vec_add(v2[i], v4[i]));

  396. 

  397.         t1 = vec_add(vec_splat_s32(8), vec_add(v1[i], v3[i]));

  398.         t2 = vec_sl(v2[i], vec_splat_u32(2));

  399.         v2[i] = vec_add(v2[i], vec_sra(vec_add(t1,t2),vec_splat_u32(4)));

  400.         t1 = vec_add(v0[i], v2[i]);

  401.         t2 = vec_add(t1, vec_add(t1,t1));

  402.         v1[i] = vec_add(v1[i], vec_sra(t2,vec_splat_u32(1)));

  403. 

  404.     #endif

  405.     }

  406. 

  407.     for(i*=4; i < width; i++)

  408.     {

  409.         b4[i] -= (W_DM*(b3[i] + b5[i])+W_DO)>>W_DS;

  410.         b3[i] -= (W_CM*(b2[i] + b4[i])+W_CO)>>W_CS;

  411.         b2[i] += (W_BM*(b1[i] + b3[i])+4*b2[i]+W_BO)>>W_BS;

  412.         b1[i] += (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;

  413.     }

  414. }

  415. 

  416. 

  417. static void inner_add_yblock_bw_8_obmc_16_altivec(uint8_t *obmc,

  418.                                              const int obmc_stride,

  419.                                              uint8_t * * block, int b_w,

  420.                                              int b_h, int src_x, int src_y,

  421.                                              int src_stride, slice_buffer * sb,

  422.                                              int add, uint8_t * dst8)

  423. {

  424.     int y, x;

  425.     DWTELEM * dst;

  426.     vector bool int mask;

  427.     vector signed int vs;

  428.     vector unsigned short h1, h2, l1, l2;

  429.     vector unsigned char ih, il, tmp1, tmp2, align;

  430.     vector unsigned char b0,b1,b2,b3;

  431. 

  432.     for(y=0; y<b_h; y++){

  433.         //FIXME ugly missue of obmc_stride

  434. 

  435.         uint8_t *obmc1= obmc + y*obmc_stride;

  436.         uint8_t *obmc2= obmc1+ (obmc_stride>>1);

  437.         uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);

  438.         uint8_t *obmc4= obmc3+ (obmc_stride>>1);

  439. #if 1

  440.         vector unsigned char ob1;

  441.         vector unsigned char ob2;

  442.         vector unsigned char ob3;

  443.         vector unsigned char ob4;

  444. 

  445. #endif

  446.         DECLARE_ALIGNED_16(int, vbuf[16]);

  447.         vector signed int *v = (vector signed int *)vbuf, *d;

  448. 

  449.         dst = slice_buffer_get_line(sb, src_y + y);

  450.         d = (vector signed int *)(dst + src_x);

  451. 

  452. #if 0

  453.         for(x=0; x<b_w; x++){

  454.             vbuf[x] =  obmc1[x] * block[3][x + y*src_stride]

  455.                     +obmc2[x] * block[2][x + y*src_stride]

  456.                     +obmc3[x] * block[1][x + y*src_stride]

  457.                     +obmc4[x] * block[0][x + y*src_stride];

  458.         }

  459. #else

  460. 

  461. 

  462. // load blocks

  463.             //FIXME i could avoid some loads!

  464.             tmp1 = vec_ld(0, &block[3][y*src_stride]);

  465.             align = vec_lvsl(0, &block[3][y*src_stride]);

  466.             tmp2 = vec_ld(15, &block[3][y*src_stride]);

  467. 

  468.             b3 = vec_perm(tmp1,tmp2,align);

  469. 

  470.             tmp1 = vec_ld(0, &block[2][y*src_stride]);

  471.             align = vec_lvsl(0, &block[2][y*src_stride]);

  472.             tmp2 = vec_ld(15, &block[2][y*src_stride]);

  473. 

  474.             b2 = vec_perm(tmp1,tmp2,align);

  475. 

  476.             tmp1 = vec_ld(0, &block[1][y*src_stride]);

  477.             align = vec_lvsl(0, &block[1][y*src_stride]);

  478.             tmp2 = vec_ld(15, &block[1][y*src_stride]);

  479. 

  480.             b1 = vec_perm(tmp1,tmp2,align);

  481. 

  482.             tmp1 = vec_ld(0, &block[0][y*src_stride]);

  483.             align = vec_lvsl(0, &block[0][y*src_stride]);

  484.             tmp2 = vec_ld(15, &block[0][y*src_stride]);

  485. 

  486.             b0 = vec_perm(tmp1,tmp2,align);

  487. 

  488.     // load obmcs

  489. 

  490.             tmp1 = vec_ld(0, obmc1);

  491.             align = vec_lvsl(0, obmc1);

  492.             tmp2 = vec_ld(15, obmc1);

  493. 

  494.             ob1 = vec_perm(tmp1,tmp2,align);

  495. 

  496.             tmp1 = vec_ld(0, obmc2);

  497.             align = vec_lvsl(0, obmc2);

  498.             tmp2 = vec_ld(15, obmc2);

  499. 

  500.             ob2 = vec_perm(tmp1,tmp2,align);

  501. 

  502.             tmp1 = vec_ld(0, obmc3);

  503.             align = vec_lvsl(0, obmc3);

  504.             tmp2 = vec_ld(15, obmc3);

  505. 

  506.             ob3 = vec_perm(tmp1,tmp2,align);

  507. 

  508.             tmp1 = vec_ld(0, obmc4);

  509.             align = vec_lvsl(0, obmc4);

  510.             tmp2 = vec_ld(15, obmc4);

  511. 

  512.             ob4 = vec_perm(tmp1,tmp2,align);

  513.             h1 = vec_mergeh(ob1, ob2); /*h1 <- [ a,b,a,b, a,b,a,b,

  514.                                                  a,b,a,b, a,b,a,b ] */

  515.             h2 = vec_mergeh(ob3, ob4); /*h2 <- [ c,d,c,d, c,d,c,d,

  516.                                                  c,d,c,d, c,d,c,d ] */

  517. 

  518.             ih = vec_mergeh(h1,h2); /* ih <- [ a,b,c,d,a,b,c,d,a,b,c,d,a,b,c,d ]*/

  519. 

  520.             l1 = vec_mergeh(b3, b2);

  521. 

  522.             l2 = vec_mergeh(b1, b0);

  523. 

  524.             il = vec_mergeh(l1,l2);

  525. 

  526.             v[0] = vec_msum(ih, il, vec_splat_u32(0));

  527. //step1

  528. 

  529.             h1 = vec_mergeh(ob1, ob2);

  530. 

  531.             h2 = vec_mergeh(ob3, ob4);

  532. 

  533.             ih = vec_mergel(h1,h2);

  534. 

  535.             l1 = vec_mergeh(b3, b2);

  536. 

  537.             l2 = vec_mergeh(b1, b0);

  538. 

  539.             il = vec_mergel(l1,l2);

  540. 

  541.             v[1] = vec_msum(ih, il, vec_splat_u32(0));

  542. 

  543. 

  544. #endif

  545.         if(add)

  546.         {

  547.             for(x=0; x<b_w/4; x++)

  548.             {

  549.                 v[x] = vec_add(v[x], d[x]);

  550.                 v[x] = vec_sra(vec_add(v[x],

  551.                                         vec_sl( vec_splat_s32(1),

  552.                                                 vec_splat_u32(7))),

  553.                                 vec_splat_u32(8));

  554. 

  555.                 mask = vec_sl((vector signed int) vec_cmpeq(v[x],v[x]),

  556.                                                         vec_splat_u32(8));

  557.                 mask = vec_and(v[x],vec_nor(mask,mask));

  558. 

  559.                 mask = (vector signed int) vec_cmpeq((vector signed int)mask,

  560.                                         (vector signed int)vec_splat_u32(0));

  561. 

  562.                 vs = vec_sra(v[x],vec_splat_u32(8));

  563.                 vs = vec_sra(v[x],vec_splat_u32(8));

  564.                 vs = vec_sra(v[x],vec_splat_u32(15));

  565. 

  566.                 vs = vec_nor(vs,vs);

  567. 

  568.                 v[x]= vec_sel(v[x],vs,mask);

  569.             }

  570.         for(x=0; x<b_w; x++)

  571.                 dst8[x + y*src_stride] = vbuf[x];

  572.         }

  573.          else

  574.             for(x=0; x<b_w/4; x++)

  575.                 d[x] = vec_sub(d[x], v[x]);

  576. 

  577.        }

  578. 

  579. 

  580. }

  581. 

  582. static void inner_add_yblock_bw_16_obmc_32_altivec(uint8_t *obmc,

  583.                                              const int obmc_stride,

  584.                                              uint8_t * * block, int b_w,

  585.                                              int b_h, int src_x, int src_y,

  586.                                              int src_stride, slice_buffer * sb,

  587.                                              int add, uint8_t * dst8)

  588. {

  589.     int y, x;

  590.     DWTELEM * dst;

  591.     vector unsigned short h1, h2, l1, l2;

  592.     vector unsigned char ih, il, tmp1, tmp2, align;

  593.     vector unsigned char b0,b1,b2,b3;

  594. 

  595.     for(y=0; y<b_h; y++){

  596.         //FIXME ugly missue of obmc_stride

  597. 

  598.         uint8_t *obmc1= obmc + y*obmc_stride;

  599.         uint8_t *obmc2= obmc1+ (obmc_stride>>1);

  600.         uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);

  601.         uint8_t *obmc4= obmc3+ (obmc_stride>>1);

  602. 

  603.         vector unsigned char ob1;

  604.         vector unsigned char ob2;

  605.         vector unsigned char ob3;

  606.         vector unsigned char ob4;

  607. 

  608.         DECLARE_ALIGNED_16(int, vbuf[b_w]);

  609.         vector signed int *v = (vector signed int *)vbuf, *d;

  610. 

  611.         dst = slice_buffer_get_line(sb, src_y + y);

  612.         d = (vector signed int *)(dst + src_x);

  613. 

  614.         // load blocks

  615. 

  616.             tmp1 = vec_ld(0, &block[3][y*src_stride]);

  617.             align = vec_lvsl(0, &block[3][y*src_stride]);

  618.             tmp2 = vec_ld(15, &block[3][y*src_stride]);

  619. 

  620.             b3 = vec_perm(tmp1,tmp2,align);

  621. 

  622.             tmp1 = vec_ld(0, &block[2][y*src_stride]);

  623.             align = vec_lvsl(0, &block[2][y*src_stride]);

  624.             tmp2 = vec_ld(15, &block[2][y*src_stride]);

  625. 

  626.             b2 = vec_perm(tmp1,tmp2,align);

  627. 

  628.             tmp1 = vec_ld(0, &block[1][y*src_stride]);

  629.             align = vec_lvsl(0, &block[1][y*src_stride]);

  630.             tmp2 = vec_ld(15, &block[1][y*src_stride]);

  631. 

  632.             b1 = vec_perm(tmp1,tmp2,align);

  633. 

  634.             tmp1 = vec_ld(0, &block[0][y*src_stride]);

  635.             align = vec_lvsl(0, &block[0][y*src_stride]);

  636.             tmp2 = vec_ld(15, &block[0][y*src_stride]);

  637. 

  638.             b0 = vec_perm(tmp1,tmp2,align);

  639. 

  640.     // load obmcs

  641. 

  642.             tmp1 = vec_ld(0, obmc1);

  643.             align = vec_lvsl(0, obmc1);

  644.             tmp2 = vec_ld(15, obmc1);

  645. 

  646.             ob1 = vec_perm(tmp1,tmp2,align);

  647. 

  648.             tmp1 = vec_ld(0, obmc2);

  649.             align = vec_lvsl(0, obmc2);

  650.             tmp2 = vec_ld(15, obmc2);

  651. 

  652.             ob2 = vec_perm(tmp1,tmp2,align);

  653. 

  654.             tmp1 = vec_ld(0, obmc3);

  655.             align = vec_lvsl(0, obmc3);

  656.             tmp2 = vec_ld(15, obmc3);

  657. 

  658.             ob3 = vec_perm(tmp1,tmp2,align);

  659. 

  660.             tmp1 = vec_ld(0, obmc4);

  661.             align = vec_lvsl(0, obmc4);

  662.             tmp2 = vec_ld(15, obmc4);

  663. 

  664.             ob4 = vec_perm(tmp1,tmp2,align);

  665. 

  666. //step0

  667.             h1 = vec_mergeh(ob1, ob2); /*h1 <- [ a,b,a,b,

  668.                                                              a,b,a,b,

  669.                                                              a,b,a,b,

  670.                                                              a,b,a,b ] */

  671.             h2 = vec_mergeh(ob3, ob4); /*h2 <- [ c,d,c,d,

  672.                                                              c,d,c,d,

  673.                                                              c,d,c,d,

  674.                                                              c,d,c,d ] */

  675. 

  676.             ih = vec_mergeh(h1,h2); /* ih <- [ a,b,c,d,a,b,c,d,a,b,c,d,a,b,c,d ]*/

  677. 

  678.             l1 = vec_mergeh(b3, b2);

  679. 

  680.             l2 = vec_mergeh(b1, b0);

  681. 

  682.             il = vec_mergeh(l1,l2);

  683. 

  684.             v[0] = vec_msum(ih, il, vec_splat_u32(0));

  685. //step1

  686. 

  687.             h1 = vec_mergeh(ob1, ob2);

  688. 

  689.             h2 = vec_mergeh(ob3, ob4);

  690. 

  691.             ih = vec_mergel(h1,h2);

  692. 

  693.             l1 = vec_mergeh(b3, b2);

  694. 

  695.             l2 = vec_mergeh(b1, b0);

  696. 

  697.             il = vec_mergel(l1,l2);

  698. 

  699.             v[1] = vec_msum(ih, il, vec_splat_u32(0));

  700. 

  701. //step2

  702.             h1 = vec_mergel(ob1, ob2);

  703. 

  704.             h2 = vec_mergel(ob3, ob4);

  705. 

  706.             ih = vec_mergeh(h1,h2);

  707. 

  708.             l1 = vec_mergel(b3, b2);

  709. 

  710.             l2 = vec_mergel(b1, b0);

  711. 

  712.             il = vec_mergeh(l1,l2);

  713. 

  714.             v[2] = vec_msum(ih, il, vec_splat_u32(0));

  715. 

  716. //step3

  717.             h1 = vec_mergel(ob1, ob2);

  718. 

  719.             h2 = vec_mergel(ob3, ob4);

  720. 

  721.             ih = vec_mergel(h1,h2);

  722. 

  723.             l1 = vec_mergel(b3, b2);

  724. 

  725.             l2 = vec_mergel(b1, b0);

  726. 

  727.             il = vec_mergel(l1,l2);

  728. 

  729.             v[3] = vec_msum(ih, il, vec_splat_u32(0));

  730. #if 1

  731.         for(x=0; x<b_w; x++)

  732.             if(add){

  733.                 vbuf[x] += dst[x + src_x];

  734.                 vbuf[x] = (vbuf[x] + (1<<(FRAC_BITS-1))) >> FRAC_BITS;

  735.                 if(vbuf[x]&(~255)) vbuf[x]= ~(vbuf[x]>>31);

  736.                 dst8[x + y*src_stride] = vbuf[x];

  737.             }else{

  738.                 dst[x + src_x] -= vbuf[x];

  739.             }

  740. #else

  741.         if(add)

  742.         {

  743.             for(x=0; x<b_w/4; x++)

  744.             {

  745.                 v[x] = vec_add(v[x], d[x]);

  746.                 v[x] = vec_sra(vec_add(v[x],

  747.                                        vec_sl( vec_splat_s32(1),

  748.                                                vec_splat_u32(7))),

  749.                                vec_splat_u32(8));

  750. 

  751.                 mask = vec_sl((vector signed int) vec_cmpeq(v[x],v[x]),vec_splat_u32(8));

  752.                 mask = vec_and(v[x],vec_nor(mask,mask));

  753. 

  754.                 mask = (vector signed int) vec_cmpeq((vector signed int)mask,(vector signed int)vec_splat_u32(0));

  755. 

  756.                 vs = vec_sra(v[x],vec_splat_u32(8));

  757.                 vs = vec_sra(v[x],vec_splat_u32(8));

  758.                 vs = vec_sra(v[x],vec_splat_u32(15));

  759. 

  760.                 vs = vec_nor(vs,vs);

  761. 

  762.                 v[x]= vec_sel(v[x],vs,mask);

  763.             }

  764. 

  765.             for(x=0; x<b_w; x++)

  766.                 dst8[x + y*src_stride] = vbuf[x];

  767. 

  768.         }

  769.          else

  770.             for(x=0; x<b_w/4; x++)

  771.                 d[x] = vec_sub(d[x], v[x]);

  772. #endif

  773.        }

  774. }

  775. 

  776. 

  777. void ff_snow_inner_add_yblock_altivec(uint8_t *obmc, const int obmc_stride,

  778.                                       uint8_t * * block, int b_w, int b_h,

  779.                                       int src_x, int src_y, int src_stride,

  780.                                       slice_buffer * sb, int add,

  781.                                       uint8_t * dst8)

  782. {

  783.     if (b_w == 16)

  784.         inner_add_yblock_bw_16_obmc_32_altivec(obmc, obmc_stride, block, b_w,

  785.                                                b_h, src_x, src_y, src_stride,

  786.                                                sb, add, dst8);

  787.     else if (b_w == 8 && ! src_x&15 )

  788.         inner_add_yblock_bw_8_obmc_16_altivec(obmc, obmc_stride, block,

  789.                                                  b_w, b_h, src_x, src_y,

  790.                                                  src_stride, sb, add, dst8);

  791.     else

  792. 

  793.         ff_snow_inner_add_yblock(obmc, obmc_stride, block, b_w, b_h, src_x,

  794.                                  src_y, src_stride, sb, add, dst8);

  795. }