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

222 lines
10KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2001 Michel Lespinasse

  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. /* NOTE: This code is based on GPL code from the libmpeg2 project.  The

  22.  * author, Michel Lespinasses, has given explicit permission to release

  23.  * under LGPL as part of Libav.

  24.  *

  25.  * Libav integration by Dieter Shirley

  26.  *

  27.  * This file is a direct copy of the AltiVec IDCT module from the libmpeg2

  28.  * project.  I've deleted all of the libmpeg2-specific code, renamed the

  29.  * functions and reordered the function parameters.  The only change to the

  30.  * IDCT function itself was to factor out the partial transposition, and to

  31.  * perform a full transpose at the end of the function. */

  32. 

  33. #include <stdlib.h>

  34. #include <string.h>

  35. #include "config.h"

  36. #if HAVE_ALTIVEC_H

  37. #include <altivec.h>

  38. #endif

  39. 

  40. #include "libavutil/ppc/types_altivec.h"

  41. #include "dsputil_altivec.h"

  42. 

  43. #define IDCT_HALF                                       \

  44.     /* 1st stage */                                     \

  45.     t1 = vec_mradds(a1, vx7, vx1);                      \

  46.     t8 = vec_mradds(a1, vx1, vec_subs(zero, vx7));      \

  47.     t7 = vec_mradds(a2, vx5, vx3);                      \

  48.     t3 = vec_mradds(ma2, vx3, vx5);                     \

  49.                                                         \

  50.     /* 2nd stage */                                     \

  51.     t5 = vec_adds(vx0, vx4);                            \

  52.     t0 = vec_subs(vx0, vx4);                            \

  53.     t2 = vec_mradds(a0, vx6, vx2);                      \

  54.     t4 = vec_mradds(a0, vx2, vec_subs(zero, vx6));      \

  55.     t6 = vec_adds(t8, t3);                              \

  56.     t3 = vec_subs(t8, t3);                              \

  57.     t8 = vec_subs(t1, t7);                              \

  58.     t1 = vec_adds(t1, t7);                              \

  59.                                                         \

  60.     /* 3rd stage */                                     \

  61.     t7 = vec_adds(t5, t2);                              \

  62.     t2 = vec_subs(t5, t2);                              \

  63.     t5 = vec_adds(t0, t4);                              \

  64.     t0 = vec_subs(t0, t4);                              \

  65.     t4 = vec_subs(t8, t3);                              \

  66.     t3 = vec_adds(t8, t3);                              \

  67.                                                         \

  68.     /* 4th stage */                                     \

  69.     vy0 = vec_adds(t7, t1);                             \

  70.     vy7 = vec_subs(t7, t1);                             \

  71.     vy1 = vec_mradds(c4, t3, t5);                       \

  72.     vy6 = vec_mradds(mc4, t3, t5);                      \

  73.     vy2 = vec_mradds(c4, t4, t0);                       \

  74.     vy5 = vec_mradds(mc4, t4, t0);                      \

  75.     vy3 = vec_adds(t2, t6);                             \

  76.     vy4 = vec_subs(t2, t6)

  77. 

  78. #define IDCT                                                                \

  79.     vec_s16 vy0, vy1, vy2, vy3, vy4, vy5, vy6, vy7;                         \

  80.     vec_s16 t0, t1, t2, t3, t4, t5, t6, t7, t8;                             \

  81.                                                                             \

  82.     vec_s16 c4   = vec_splat(constants[0], 0);                              \

  83.     vec_s16 a0   = vec_splat(constants[0], 1);                              \

  84.     vec_s16 a1   = vec_splat(constants[0], 2);                              \

  85.     vec_s16 a2   = vec_splat(constants[0], 3);                              \

  86.     vec_s16 mc4  = vec_splat(constants[0], 4);                              \

  87.     vec_s16 ma2  = vec_splat(constants[0], 5);                              \

  88.     vec_s16 bias = (vec_s16) vec_splat((vec_s32) constants[0], 3);          \

  89.                                                                             \

  90.     vec_s16 zero  = vec_splat_s16(0);                                       \

  91.     vec_u16 shift = vec_splat_u16(4);                                       \

  92.                                                                             \

  93.     vec_s16 vx0 = vec_mradds(vec_sl(block[0], shift), constants[1], zero);  \

  94.     vec_s16 vx1 = vec_mradds(vec_sl(block[1], shift), constants[2], zero);  \

  95.     vec_s16 vx2 = vec_mradds(vec_sl(block[2], shift), constants[3], zero);  \

  96.     vec_s16 vx3 = vec_mradds(vec_sl(block[3], shift), constants[4], zero);  \

  97.     vec_s16 vx4 = vec_mradds(vec_sl(block[4], shift), constants[1], zero);  \

  98.     vec_s16 vx5 = vec_mradds(vec_sl(block[5], shift), constants[4], zero);  \

  99.     vec_s16 vx6 = vec_mradds(vec_sl(block[6], shift), constants[3], zero);  \

  100.     vec_s16 vx7 = vec_mradds(vec_sl(block[7], shift), constants[2], zero);  \

  101.                                                                             \

  102.     IDCT_HALF;                                                              \

  103.                                                                             \

  104.     vx0 = vec_mergeh(vy0, vy4);                                             \

  105.     vx1 = vec_mergel(vy0, vy4);                                             \

  106.     vx2 = vec_mergeh(vy1, vy5);                                             \

  107.     vx3 = vec_mergel(vy1, vy5);                                             \

  108.     vx4 = vec_mergeh(vy2, vy6);                                             \

  109.     vx5 = vec_mergel(vy2, vy6);                                             \

  110.     vx6 = vec_mergeh(vy3, vy7);                                             \

  111.     vx7 = vec_mergel(vy3, vy7);                                             \

  112.                                                                             \

  113.     vy0 = vec_mergeh(vx0, vx4);                                             \

  114.     vy1 = vec_mergel(vx0, vx4);                                             \

  115.     vy2 = vec_mergeh(vx1, vx5);                                             \

  116.     vy3 = vec_mergel(vx1, vx5);                                             \

  117.     vy4 = vec_mergeh(vx2, vx6);                                             \

  118.     vy5 = vec_mergel(vx2, vx6);                                             \

  119.     vy6 = vec_mergeh(vx3, vx7);                                             \

  120.     vy7 = vec_mergel(vx3, vx7);                                             \

  121.                                                                             \

  122.     vx0 = vec_adds(vec_mergeh(vy0, vy4), bias);                             \

  123.     vx1 = vec_mergel(vy0, vy4);                                             \

  124.     vx2 = vec_mergeh(vy1, vy5);                                             \

  125.     vx3 = vec_mergel(vy1, vy5);                                             \

  126.     vx4 = vec_mergeh(vy2, vy6);                                             \

  127.     vx5 = vec_mergel(vy2, vy6);                                             \

  128.     vx6 = vec_mergeh(vy3, vy7);                                             \

  129.     vx7 = vec_mergel(vy3, vy7);                                             \

  130.                                                                             \

  131.     IDCT_HALF;                                                              \

  132.                                                                             \

  133.     shift = vec_splat_u16(6);                                               \

  134.     vx0 = vec_sra(vy0, shift);                                              \

  135.     vx1 = vec_sra(vy1, shift);                                              \

  136.     vx2 = vec_sra(vy2, shift);                                              \

  137.     vx3 = vec_sra(vy3, shift);                                              \

  138.     vx4 = vec_sra(vy4, shift);                                              \

  139.     vx5 = vec_sra(vy5, shift);                                              \

  140.     vx6 = vec_sra(vy6, shift);                                              \

  141.     vx7 = vec_sra(vy7, shift)

  142. 

  143. static const vec_s16 constants[5] = {

  144.     { 23170, 13573,  6518, 21895, -23170, -21895,    32,    31 },

  145.     { 16384, 22725, 21407, 19266,  16384,  19266, 21407, 22725 },

  146.     { 22725, 31521, 29692, 26722,  22725,  26722, 29692, 31521 },

  147.     { 21407, 29692, 27969, 25172,  21407,  25172, 27969, 29692 },

  148.     { 19266, 26722, 25172, 22654,  19266,  22654, 25172, 26722 }

  149. };

  150. 

  151. void ff_idct_put_altivec(uint8_t *dest, int stride, int16_t *blk)

  152. {

  153.     vec_s16 *block = (vec_s16 *) blk;

  154.     vec_u8 tmp;

  155. 

  156.     IDCT;

  157. 

  158. #define COPY(dest, src)                                     \

  159.     tmp = vec_packsu(src, src);                             \

  160.     vec_ste((vec_u32) tmp, 0, (unsigned int *) dest);       \

  161.     vec_ste((vec_u32) tmp, 4, (unsigned int *) dest)

  162. 

  163.     COPY(dest, vx0);

  164.     dest += stride;

  165.     COPY(dest, vx1);

  166.     dest += stride;

  167.     COPY(dest, vx2);

  168.     dest += stride;

  169.     COPY(dest, vx3);

  170.     dest += stride;

  171.     COPY(dest, vx4);

  172.     dest += stride;

  173.     COPY(dest, vx5);

  174.     dest += stride;

  175.     COPY(dest, vx6);

  176.     dest += stride;

  177.     COPY(dest, vx7);

  178. }

  179. 

  180. void ff_idct_add_altivec(uint8_t *dest, int stride, int16_t *blk)

  181. {

  182.     vec_s16 *block = (vec_s16 *) blk;

  183.     vec_u8 tmp;

  184.     vec_s16 tmp2, tmp3;

  185.     vec_u8 perm0;

  186.     vec_u8 perm1;

  187.     vec_u8 p0, p1, p;

  188. 

  189.     IDCT;

  190. 

  191.     p0    = vec_lvsl(0, dest);

  192.     p1    = vec_lvsl(stride, dest);

  193.     p     = vec_splat_u8(-1);

  194.     perm0 = vec_mergeh(p, p0);

  195.     perm1 = vec_mergeh(p, p1);

  196. 

  197. #define ADD(dest, src, perm)                                \

  198.     /* *(uint64_t *) &tmp = *(uint64_t *) dest; */          \

  199.     tmp  = vec_ld(0, dest);                                 \

  200.     tmp2 = (vec_s16) vec_perm(tmp, (vec_u8) zero, perm);    \

  201.     tmp3 = vec_adds(tmp2, src);                             \

  202.     tmp  = vec_packsu(tmp3, tmp3);                          \

  203.     vec_ste((vec_u32) tmp, 0, (unsigned int *) dest);       \

  204.     vec_ste((vec_u32) tmp, 4, (unsigned int *) dest)

  205. 

  206.     ADD(dest, vx0, perm0);

  207.     dest += stride;

  208.     ADD(dest, vx1, perm1);

  209.     dest += stride;

  210.     ADD(dest, vx2, perm0);

  211.     dest += stride;

  212.     ADD(dest, vx3, perm1);

  213.     dest += stride;

  214.     ADD(dest, vx4, perm0);

  215.     dest += stride;

  216.     ADD(dest, vx5, perm1);

  217.     dest += stride;

  218.     ADD(dest, vx6, perm0);

  219.     dest += stride;

  220.     ADD(dest, vx7, perm1);

  221. }