Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2004 Romain Dolbeau <romain@dolbeau.org>
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg 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.  * FFmpeg 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 FFmpeg; 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. #include "libavutil/ppc/types_altivec.h"
  23. #include "libavutil/ppc/util_altivec.h"
  24.  
  25. /* this code assume that stride % 16 == 0 */
  26.  
  27. #define CHROMA_MC8_ALTIVEC_CORE(BIAS1, BIAS2) \
  28.         vsrc2ssH = (vec_s16)VEC_MERGEH(zero_u8v,(vec_u8)vsrc2uc);\
  29.         vsrc3ssH = (vec_s16)VEC_MERGEH(zero_u8v,(vec_u8)vsrc3uc);\
  30. \
  31.         psum = vec_mladd(vA, vsrc0ssH, BIAS1);\
  32.         psum = vec_mladd(vB, vsrc1ssH, psum);\
  33.         psum = vec_mladd(vC, vsrc2ssH, psum);\
  34.         psum = vec_mladd(vD, vsrc3ssH, psum);\
  35.         psum = BIAS2(psum);\
  36.         psum = vec_sr(psum, v6us);\
  37. \
  38.         vdst = vec_ld(0, dst);\
  39.         ppsum = (vec_u8)vec_pack(psum, psum);\
  40.         vfdst = vec_perm(vdst, ppsum, fperm);\
  41. \
  42.         OP_U8_ALTIVEC(fsum, vfdst, vdst);\
  43. \
  44.         vec_st(fsum, 0, dst);\
  45. \
  46.         vsrc0ssH = vsrc2ssH;\
  47.         vsrc1ssH = vsrc3ssH;\
  48. \
  49.         dst += stride;\
  50.         src += stride;
  51.  
  52. #define CHROMA_MC8_ALTIVEC_CORE_SIMPLE \
  53. \
  54.         vsrc0ssH = (vec_s16)VEC_MERGEH(zero_u8v,(vec_u8)vsrc0uc);\
  55.         vsrc1ssH = (vec_s16)VEC_MERGEH(zero_u8v,(vec_u8)vsrc1uc);\
  56. \
  57.         psum = vec_mladd(vA, vsrc0ssH, v32ss);\
  58.         psum = vec_mladd(vE, vsrc1ssH, psum);\
  59.         psum = vec_sr(psum, v6us);\
  60. \
  61.         vdst = vec_ld(0, dst);\
  62.         ppsum = (vec_u8)vec_pack(psum, psum);\
  63.         vfdst = vec_perm(vdst, ppsum, fperm);\
  64. \
  65.         OP_U8_ALTIVEC(fsum, vfdst, vdst);\
  66. \
  67.         vec_st(fsum, 0, dst);\
  68. \
  69.         dst += stride;\
  70.         src += stride;
  71.  
  72. #define noop(a) a
  73. #define add28(a) vec_add(v28ss, a)
  74.  
  75. #if HAVE_BIGENDIAN
  76. #define GET_VSRC1(vs0, off, b, perm0, s){    \
  77.     vec_u8 vsrcCuc, vsrcDuc;                 \
  78.     vsrcCuc = vec_ld(off, s);                \
  79.     if (loadSecond){                         \
  80.         vsrcDuc = vec_ld(off + b, s);        \
  81.     } else                                   \
  82.         vsrcDuc = vsrcCuc;                   \
  83.                                              \
  84.     vs0 = vec_perm(vsrcCuc, vsrcDuc, perm0); \
  85. }
  86. #define GET_VSRC(vs0, vs1, off, b, perm0, perm1, s){ \
  87.     vec_u8 vsrcCuc, vsrcDuc;                         \
  88.     vsrcCuc = vec_ld(off, s);                        \
  89.     if (loadSecond){                                 \
  90.         vsrcDuc = vec_ld(off + b, s);                \
  91.     } else                                           \
  92.         vsrcDuc = vsrcCuc;                           \
  93.                                                      \
  94.     vs0 = vec_perm(vsrcCuc, vsrcDuc, perm0);         \
  95.     if (reallyBadAlign){                             \
  96.         vs1 = vsrcDuc;                               \
  97.     } else                                           \
  98.         vs1 = vec_perm(vsrcCuc, vsrcDuc, perm1);     \
  99.  }
  100.  
  101. #else
  102.  
  103. #define GET_VSRC1(vs0, off, b, perm0, s){            \
  104.     vs0 = vec_vsx_ld(off, s);                        \
  105.  }
  106. #define GET_VSRC(vs0, vs1, off, b, perm0, perm1, s){ \
  107.     vs0 = vec_vsx_ld(off, s);                        \
  108.     vs1 = vec_vsx_ld(off + 1, s);                    \
  109.  }
  110. #endif /* HAVE_BIGENDIAN */
  111.  
  112. #ifdef PREFIX_h264_chroma_mc8_altivec
  113. static void PREFIX_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src,
  114.                                     int stride, int h, int x, int y) {
  115.     DECLARE_ALIGNED(16, signed int, ABCD)[4] =
  116.                         {((8 - x) * (8 - y)),
  117.                          ((    x) * (8 - y)),
  118.                          ((8 - x) * (    y)),
  119.                          ((    x) * (    y))};
  120.     register int i;
  121.     vec_u8 fperm;
  122.     LOAD_ZERO;
  123.     const vec_s32 vABCD = vec_ld(0, ABCD);
  124.     const vec_s16 vA = VEC_SPLAT16(vABCD, 1);
  125.     const vec_s16 vB = VEC_SPLAT16(vABCD, 3);
  126.     const vec_s16 vC = VEC_SPLAT16(vABCD, 5);
  127.     const vec_s16 vD = VEC_SPLAT16(vABCD, 7);
  128.     const vec_s16 v32ss = vec_sl(vec_splat_s16(1),vec_splat_u16(5));
  129.     const vec_u16 v6us = vec_splat_u16(6);
  130.  
  131.     vec_u8 vsrcperm0, vsrcperm1;
  132.     vec_u8 vsrc0uc, vsrc1uc;
  133.     vec_s16 vsrc0ssH, vsrc1ssH;
  134.     vec_u8 vsrc2uc, vsrc3uc;
  135.     vec_s16 vsrc2ssH, vsrc3ssH, psum;
  136.     vec_u8 vdst, ppsum, vfdst, fsum;
  137. #if HAVE_BIGENDIAN
  138.     register int loadSecond = (((unsigned long)src) % 16) <= 7 ? 0 : 1;
  139.     register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;
  140.     vsrcperm0 = vec_lvsl(0, src);
  141.     vsrcperm1 = vec_lvsl(1, src);
  142. #endif
  143.  
  144.     if (((unsigned long)dst) % 16 == 0) {
  145.         fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,
  146.                          0x14, 0x15, 0x16, 0x17,
  147.                          0x08, 0x09, 0x0A, 0x0B,
  148.                          0x0C, 0x0D, 0x0E, 0x0F};
  149.     } else {
  150.         fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,
  151.                          0x04, 0x05, 0x06, 0x07,
  152.                          0x18, 0x19, 0x1A, 0x1B,
  153.                          0x1C, 0x1D, 0x1E, 0x1F};
  154.     }
  155.  
  156.     GET_VSRC(vsrc0uc, vsrc1uc, 0, 16, vsrcperm0, vsrcperm1, src);
  157.  
  158.     vsrc0ssH = (vec_s16)VEC_MERGEH(zero_u8v,(vec_u8)vsrc0uc);
  159.     vsrc1ssH = (vec_s16)VEC_MERGEH(zero_u8v,(vec_u8)vsrc1uc);
  160.  
  161.     if (ABCD[3]) {
  162.         for (i = 0 ; i < h ; i++) {
  163.             GET_VSRC(vsrc2uc, vsrc3uc, stride, 16, vsrcperm0, vsrcperm1, src);
  164.             CHROMA_MC8_ALTIVEC_CORE(v32ss, noop);
  165.         }
  166.     } else {
  167.         const vec_s16 vE = vec_add(vB, vC);
  168.         if (ABCD[2]) { // x == 0 B == 0
  169.             for (i = 0 ; i < h ; i++) {
  170.                 GET_VSRC1(vsrc1uc, stride, 15, vsrcperm0, src);
  171.                 CHROMA_MC8_ALTIVEC_CORE_SIMPLE;
  172.                 vsrc0uc = vsrc1uc;
  173.             }
  174.         } else { // y == 0 C == 0
  175.             for (i = 0 ; i < h ; i++) {
  176.                GET_VSRC(vsrc0uc, vsrc1uc, 0, 15, vsrcperm0, vsrcperm1, src);
  177.                CHROMA_MC8_ALTIVEC_CORE_SIMPLE;
  178.             }
  179.         }
  180.     }
  181. }
  182. #endif
  183.  
  184. /* this code assume that stride % 16 == 0 */
  185. #ifdef PREFIX_no_rnd_vc1_chroma_mc8_altivec
  186. static void PREFIX_no_rnd_vc1_chroma_mc8_altivec(uint8_t * dst, uint8_t * src, int stride, int h, int x, int y) {
  187.    DECLARE_ALIGNED(16, signed int, ABCD)[4] =
  188.                         {((8 - x) * (8 - y)),
  189.                          ((    x) * (8 - y)),
  190.                          ((8 - x) * (    y)),
  191.                          ((    x) * (    y))};
  192.     register int i;
  193.     vec_u8 fperm;
  194.     LOAD_ZERO;
  195.     const vec_s32 vABCD = vec_ld(0, ABCD);
  196.     const vec_s16 vA = VEC_SPLAT16(vABCD, 1);
  197.     const vec_s16 vB = VEC_SPLAT16(vABCD, 3);
  198.     const vec_s16 vC = VEC_SPLAT16(vABCD, 5);
  199.     const vec_s16 vD = VEC_SPLAT16(vABCD, 7);
  200.     const vec_s16 v28ss = vec_sub(vec_sl(vec_splat_s16(1),vec_splat_u16(5)),vec_splat_s16(4));
  201.     const vec_u16 v6us  = vec_splat_u16(6);
  202.  
  203.     vec_u8 vsrcperm0, vsrcperm1;
  204.     vec_u8 vsrc0uc, vsrc1uc;
  205.     vec_s16 vsrc0ssH, vsrc1ssH;
  206.     vec_u8 vsrc2uc, vsrc3uc;
  207.     vec_s16 vsrc2ssH, vsrc3ssH, psum;
  208.     vec_u8 vdst, ppsum, vfdst, fsum;
  209. #if HAVE_BIGENDIAN
  210.     register int loadSecond     = (((unsigned long)src) % 16) <= 7 ? 0 : 1;
  211.     register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;
  212.     vsrcperm0 = vec_lvsl(0, src);
  213.     vsrcperm1 = vec_lvsl(1, src);
  214. #endif
  215.  
  216.     if (((unsigned long)dst) % 16 == 0) {
  217.         fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,
  218.                          0x14, 0x15, 0x16, 0x17,
  219.                          0x08, 0x09, 0x0A, 0x0B,
  220.                          0x0C, 0x0D, 0x0E, 0x0F};
  221.     } else {
  222.         fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,
  223.                          0x04, 0x05, 0x06, 0x07,
  224.                          0x18, 0x19, 0x1A, 0x1B,
  225.                          0x1C, 0x1D, 0x1E, 0x1F};
  226.     }
  227.  
  228.     GET_VSRC(vsrc0uc, vsrc1uc, 0, 16, vsrcperm0, vsrcperm1, src);
  229.  
  230.     vsrc0ssH = (vec_s16)VEC_MERGEH(zero_u8v, (vec_u8)vsrc0uc);
  231.     vsrc1ssH = (vec_s16)VEC_MERGEH(zero_u8v, (vec_u8)vsrc1uc);
  232.  
  233.     for (i = 0 ; i < h ; i++) {
  234.         GET_VSRC(vsrc2uc, vsrc3uc, stride, 16, vsrcperm0, vsrcperm1, src);
  235.         CHROMA_MC8_ALTIVEC_CORE(vec_splat_s16(0), add28);
  236.     }
  237. }
  238. #endif
  239.  
  240. #undef noop
  241. #undef add28
  242. #undef CHROMA_MC8_ALTIVEC_CORE
  243.