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.
39526 Commits
32 Branches
748MB
Tree: 1b51b7ba00
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1b51b7ba00'
${ noResults }
FFmpeg/libavcodec/ppc/h264chroma_template.c

290 lines
9.8KB
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.                                     int stride, int h, int x, int y) {

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

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

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

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

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

  81.     register int i;

  82.     vec_u8 fperm;

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

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

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

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

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

  88.     LOAD_ZERO;

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

  90.     const vec_u16 v6us = vec_splat_u16(6);

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

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

  93. 

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

  95.     vec_u8 vsrc0uc, vsrc1uc;

  96.     vec_s16 vsrc0ssH, vsrc1ssH;

  97.     vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;

  98.     vec_s16 vsrc2ssH, vsrc3ssH, psum;

  99.     vec_u8 vdst, ppsum, vfdst, fsum;

  100. 

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

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

  103.                          0x14, 0x15, 0x16, 0x17,

  104.                          0x08, 0x09, 0x0A, 0x0B,

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

  106.     } else {

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

  108.                          0x04, 0x05, 0x06, 0x07,

  109.                          0x18, 0x19, 0x1A, 0x1B,

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

  111.     }

  112. 

  113.     vsrcAuc = vec_ld(0, src);

  114. 

  115.     if (loadSecond)

  116.         vsrcBuc = vec_ld(16, src);

  117.     vsrcperm0 = vec_lvsl(0, src);

  118.     vsrcperm1 = vec_lvsl(1, src);

  119. 

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

  121.     if (reallyBadAlign)

  122.         vsrc1uc = vsrcBuc;

  123.     else

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

  125. 

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

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

  128. 

  129.     if (ABCD[3]) {

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

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

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

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

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

  135. 

  136.                 CHROMA_MC8_ALTIVEC_CORE(v32ss, noop)

  137.             }

  138.         } else {

  139.             vec_u8 vsrcDuc;

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

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

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

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

  144.                 if (reallyBadAlign)

  145.                     vsrc3uc = vsrcDuc;

  146.                 else

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

  148. 

  149.                 CHROMA_MC8_ALTIVEC_CORE(v32ss, noop)

  150.             }

  151.         }

  152.     } else {

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

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

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

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

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

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

  159.                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE

  160. 

  161.                     vsrc0uc = vsrc1uc;

  162.                 }

  163.             } else {

  164.                 vec_u8 vsrcDuc;

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

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

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

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

  169.                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE

  170. 

  171.                     vsrc0uc = vsrc1uc;

  172.                 }

  173.             }

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

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

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

  177.                     vsrcCuc = vec_ld(0, src);

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

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

  180. 

  181.                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE

  182.                 }

  183.             } else {

  184.                 vec_u8 vsrcDuc;

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

  186.                     vsrcCuc = vec_ld(0, src);

  187.                     vsrcDuc = vec_ld(15, src);

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

  189.                     if (reallyBadAlign)

  190.                         vsrc1uc = vsrcDuc;

  191.                     else

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

  193. 

  194.                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE

  195.                 }

  196.             }

  197.         }

  198.     }

  199. }

  200. #endif

  201. 

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

  203. #ifdef PREFIX_no_rnd_vc1_chroma_mc8_altivec

  204. static void PREFIX_no_rnd_vc1_chroma_mc8_altivec(uint8_t * dst, uint8_t * src, int stride, int h, int x, int y) {

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

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

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

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

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

  210.     register int i;

  211.     vec_u8 fperm;

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

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

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

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

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

  217.     LOAD_ZERO;

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

  219.     const vec_u16 v6us  = vec_splat_u16(6);

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

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

  222. 

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

  224.     vec_u8 vsrc0uc, vsrc1uc;

  225.     vec_s16 vsrc0ssH, vsrc1ssH;

  226.     vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;

  227.     vec_s16 vsrc2ssH, vsrc3ssH, psum;

  228.     vec_u8 vdst, ppsum, vfdst, fsum;

  229. 

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

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

  232.                          0x14, 0x15, 0x16, 0x17,

  233.                          0x08, 0x09, 0x0A, 0x0B,

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

  235.     } else {

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

  237.                          0x04, 0x05, 0x06, 0x07,

  238.                          0x18, 0x19, 0x1A, 0x1B,

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

  240.     }

  241. 

  242.     vsrcAuc = vec_ld(0, src);

  243. 

  244.     if (loadSecond)

  245.         vsrcBuc = vec_ld(16, src);

  246.     vsrcperm0 = vec_lvsl(0, src);

  247.     vsrcperm1 = vec_lvsl(1, src);

  248. 

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

  250.     if (reallyBadAlign)

  251.         vsrc1uc = vsrcBuc;

  252.     else

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

  254. 

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

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

  257. 

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

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

  260. 

  261. 

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

  263. 

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

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

  266. 

  267.             CHROMA_MC8_ALTIVEC_CORE(vec_splat_s16(0), add28)

  268.         }

  269.     } else {

  270.         vec_u8 vsrcDuc;

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

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

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

  274. 

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

  276.             if (reallyBadAlign)

  277.                 vsrc3uc = vsrcDuc;

  278.             else

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

  280. 

  281.             CHROMA_MC8_ALTIVEC_CORE(vec_splat_s16(0), add28)

  282.         }

  283.     }

  284. }

  285. #endif

  286. 

  287. #undef noop

  288. #undef add28

  289. #undef CHROMA_MC8_ALTIVEC_CORE