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.
45179 Commits
32 Branches
2.4GB
Tree: a3a501df24
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a3a501df24'
${ noResults }
FFmpeg/libavcodec/ppc/h264chroma_template.c

295 lines
10.0KB
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. /* this code assume that stride % 16 == 0 */

  24. 

  25. #define CHROMA_MC8_ALTIVEC_CORE(BIAS1, BIAS2) \

  26.         vsrc2ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc2uc);\

  27.         vsrc3ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc3uc);\

  28. \

  29.         psum = vec_mladd(vA, vsrc0ssH, BIAS1);\

  30.         psum = vec_mladd(vB, vsrc1ssH, psum);\

  31.         psum = vec_mladd(vC, vsrc2ssH, psum);\

  32.         psum = vec_mladd(vD, vsrc3ssH, psum);\

  33.         psum = BIAS2(psum);\

  34.         psum = vec_sr(psum, v6us);\

  35. \

  36.         vdst = vec_ld(0, dst);\

  37.         ppsum = (vec_u8)vec_pack(psum, psum);\

  38.         vfdst = vec_perm(vdst, ppsum, fperm);\

  39. \

  40.         OP_U8_ALTIVEC(fsum, vfdst, vdst);\

  41. \

  42.         vec_st(fsum, 0, dst);\

  43. \

  44.         vsrc0ssH = vsrc2ssH;\

  45.         vsrc1ssH = vsrc3ssH;\

  46. \

  47.         dst += stride;\

  48.         src += stride;

  49. 

  50. #define CHROMA_MC8_ALTIVEC_CORE_SIMPLE \

  51. \

  52.         vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc0uc);\

  53.         vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc1uc);\

  54. \

  55.         psum = vec_mladd(vA, vsrc0ssH, v32ss);\

  56.         psum = vec_mladd(vE, vsrc1ssH, psum);\

  57.         psum = vec_sr(psum, v6us);\

  58. \

  59.         vdst = vec_ld(0, dst);\

  60.         ppsum = (vec_u8)vec_pack(psum, psum);\

  61.         vfdst = vec_perm(vdst, ppsum, fperm);\

  62. \

  63.         OP_U8_ALTIVEC(fsum, vfdst, vdst);\

  64. \

  65.         vec_st(fsum, 0, dst);\

  66. \

  67.         dst += stride;\

  68.         src += stride;

  69. 

  70. #define noop(a) a

  71. #define add28(a) vec_add(v28ss, a)

  72. 

  73. #ifdef PREFIX_h264_chroma_mc8_altivec

  74. static void PREFIX_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src,

  75.                                            ptrdiff_t stride, int h,

  76.                                            int x, int y)

  77. {

  78.     DECLARE_ALIGNED(16, signed int, ABCD)[4] =

  79.                         {((8 - x) * (8 - y)),

  80.                          ((    x) * (8 - y)),

  81.                          ((8 - x) * (    y)),

  82.                          ((    x) * (    y))};

  83.     register int i;

  84.     vec_u8 fperm;

  85.     const vec_s32 vABCD = vec_ld(0, ABCD);

  86.     const vec_s16 vA = vec_splat((vec_s16)vABCD, 1);

  87.     const vec_s16 vB = vec_splat((vec_s16)vABCD, 3);

  88.     const vec_s16 vC = vec_splat((vec_s16)vABCD, 5);

  89.     const vec_s16 vD = vec_splat((vec_s16)vABCD, 7);

  90.     LOAD_ZERO;

  91.     const vec_s16 v32ss = vec_sl(vec_splat_s16(1),vec_splat_u16(5));

  92.     const vec_u16 v6us = vec_splat_u16(6);

  93.     register int loadSecond = (((unsigned long)src) % 16) <= 7 ? 0 : 1;

  94.     register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;

  95. 

  96.     vec_u8 vsrcAuc, av_uninit(vsrcBuc), vsrcperm0, vsrcperm1;

  97.     vec_u8 vsrc0uc, vsrc1uc;

  98.     vec_s16 vsrc0ssH, vsrc1ssH;

  99.     vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;

  100.     vec_s16 vsrc2ssH, vsrc3ssH, psum;

  101.     vec_u8 vdst, ppsum, vfdst, fsum;

  102. 

  103.     if (((unsigned long)dst) % 16 == 0) {

  104.         fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,

  105.                          0x14, 0x15, 0x16, 0x17,

  106.                          0x08, 0x09, 0x0A, 0x0B,

  107.                          0x0C, 0x0D, 0x0E, 0x0F};

  108.     } else {

  109.         fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,

  110.                          0x04, 0x05, 0x06, 0x07,

  111.                          0x18, 0x19, 0x1A, 0x1B,

  112.                          0x1C, 0x1D, 0x1E, 0x1F};

  113.     }

  114. 

  115.     vsrcAuc = vec_ld(0, src);

  116. 

  117.     if (loadSecond)

  118.         vsrcBuc = vec_ld(16, src);

  119.     vsrcperm0 = vec_lvsl(0, src);

  120.     vsrcperm1 = vec_lvsl(1, src);

  121. 

  122.     vsrc0uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm0);

  123.     if (reallyBadAlign)

  124.         vsrc1uc = vsrcBuc;

  125.     else

  126.         vsrc1uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm1);

  127. 

  128.     vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc0uc);

  129.     vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc1uc);

  130. 

  131.     if (ABCD[3]) {

  132.         if (!loadSecond) {// -> !reallyBadAlign

  133.             for (i = 0 ; i < h ; i++) {

  134.                 vsrcCuc = vec_ld(stride + 0, src);

  135.                 vsrc2uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

  136.                 vsrc3uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);

  137. 

  138.                 CHROMA_MC8_ALTIVEC_CORE(v32ss, noop)

  139.             }

  140.         } else {

  141.             vec_u8 vsrcDuc;

  142.             for (i = 0 ; i < h ; i++) {

  143.                 vsrcCuc = vec_ld(stride + 0, src);

  144.                 vsrcDuc = vec_ld(stride + 16, src);

  145.                 vsrc2uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

  146.                 if (reallyBadAlign)

  147.                     vsrc3uc = vsrcDuc;

  148.                 else

  149.                     vsrc3uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);

  150. 

  151.                 CHROMA_MC8_ALTIVEC_CORE(v32ss, noop)

  152.             }

  153.         }

  154.     } else {

  155.         const vec_s16 vE = vec_add(vB, vC);

  156.         if (ABCD[2]) { // x == 0 B == 0

  157.             if (!loadSecond) {// -> !reallyBadAlign

  158.                 for (i = 0 ; i < h ; i++) {

  159.                     vsrcCuc = vec_ld(stride + 0, src);

  160.                     vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

  161.                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE

  162. 

  163.                     vsrc0uc = vsrc1uc;

  164.                 }

  165.             } else {

  166.                 vec_u8 vsrcDuc;

  167.                 for (i = 0 ; i < h ; i++) {

  168.                     vsrcCuc = vec_ld(stride + 0, src);

  169.                     vsrcDuc = vec_ld(stride + 15, src);

  170.                     vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

  171.                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE

  172. 

  173.                     vsrc0uc = vsrc1uc;

  174.                 }

  175.             }

  176.         } else { // y == 0 C == 0

  177.             if (!loadSecond) {// -> !reallyBadAlign

  178.                 for (i = 0 ; i < h ; i++) {

  179.                     vsrcCuc = vec_ld(0, src);

  180.                     vsrc0uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

  181.                     vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);

  182. 

  183.                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE

  184.                 }

  185.             } else {

  186.                 vec_u8 vsrcDuc;

  187.                 for (i = 0 ; i < h ; i++) {

  188.                     vsrcCuc = vec_ld(0, src);

  189.                     vsrcDuc = vec_ld(15, src);

  190.                     vsrc0uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

  191.                     if (reallyBadAlign)

  192.                         vsrc1uc = vsrcDuc;

  193.                     else

  194.                         vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);

  195. 

  196.                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE

  197.                 }

  198.             }

  199.         }

  200.     }

  201. }

  202. #endif

  203. 

  204. /* this code assume that stride % 16 == 0 */

  205. #ifdef PREFIX_no_rnd_vc1_chroma_mc8_altivec

  206. static void PREFIX_no_rnd_vc1_chroma_mc8_altivec(uint8_t *dst, uint8_t *src,

  207.                                                  ptrdiff_t stride, int h,

  208.                                                  int x, int y)

  209. {

  210.    DECLARE_ALIGNED(16, signed int, ABCD)[4] =

  211.                         {((8 - x) * (8 - y)),

  212.                          ((    x) * (8 - y)),

  213.                          ((8 - x) * (    y)),

  214.                          ((    x) * (    y))};

  215.     register int i;

  216.     vec_u8 fperm;

  217.     const vec_s32 vABCD = vec_ld(0, ABCD);

  218.     const vec_s16 vA = vec_splat((vec_s16)vABCD, 1);

  219.     const vec_s16 vB = vec_splat((vec_s16)vABCD, 3);

  220.     const vec_s16 vC = vec_splat((vec_s16)vABCD, 5);

  221.     const vec_s16 vD = vec_splat((vec_s16)vABCD, 7);

  222.     LOAD_ZERO;

  223.     const vec_s16 v28ss = vec_sub(vec_sl(vec_splat_s16(1),vec_splat_u16(5)),vec_splat_s16(4));

  224.     const vec_u16 v6us  = vec_splat_u16(6);

  225.     register int loadSecond     = (((unsigned long)src) % 16) <= 7 ? 0 : 1;

  226.     register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;

  227. 

  228.     vec_u8 vsrcAuc, av_uninit(vsrcBuc), vsrcperm0, vsrcperm1;

  229.     vec_u8 vsrc0uc, vsrc1uc;

  230.     vec_s16 vsrc0ssH, vsrc1ssH;

  231.     vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;

  232.     vec_s16 vsrc2ssH, vsrc3ssH, psum;

  233.     vec_u8 vdst, ppsum, vfdst, fsum;

  234. 

  235.     if (((unsigned long)dst) % 16 == 0) {

  236.         fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,

  237.                          0x14, 0x15, 0x16, 0x17,

  238.                          0x08, 0x09, 0x0A, 0x0B,

  239.                          0x0C, 0x0D, 0x0E, 0x0F};

  240.     } else {

  241.         fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,

  242.                          0x04, 0x05, 0x06, 0x07,

  243.                          0x18, 0x19, 0x1A, 0x1B,

  244.                          0x1C, 0x1D, 0x1E, 0x1F};

  245.     }

  246. 

  247.     vsrcAuc = vec_ld(0, src);

  248. 

  249.     if (loadSecond)

  250.         vsrcBuc = vec_ld(16, src);

  251.     vsrcperm0 = vec_lvsl(0, src);

  252.     vsrcperm1 = vec_lvsl(1, src);

  253. 

  254.     vsrc0uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm0);

  255.     if (reallyBadAlign)

  256.         vsrc1uc = vsrcBuc;

  257.     else

  258.         vsrc1uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm1);

  259. 

  260.     vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc0uc);

  261.     vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc1uc);

  262. 

  263.     if (!loadSecond) {// -> !reallyBadAlign

  264.         for (i = 0 ; i < h ; i++) {

  265. 

  266. 

  267.             vsrcCuc = vec_ld(stride + 0, src);

  268. 

  269.             vsrc2uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);

  270.             vsrc3uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);

  271. 

  272.             CHROMA_MC8_ALTIVEC_CORE(vec_splat_s16(0), add28)

  273.         }

  274.     } else {

  275.         vec_u8 vsrcDuc;

  276.         for (i = 0 ; i < h ; i++) {

  277.             vsrcCuc = vec_ld(stride + 0, src);

  278.             vsrcDuc = vec_ld(stride + 16, src);

  279. 

  280.             vsrc2uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);

  281.             if (reallyBadAlign)

  282.                 vsrc3uc = vsrcDuc;

  283.             else

  284.                 vsrc3uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);

  285. 

  286.             CHROMA_MC8_ALTIVEC_CORE(vec_splat_s16(0), add28)

  287.         }

  288.     }

  289. }

  290. #endif

  291. 

  292. #undef noop

  293. #undef add28

  294. #undef CHROMA_MC8_ALTIVEC_CORE