admin/x264
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

x264 source for verification 2026-05-22

Browse Source
This commit is contained in:
admin
2026-05-22 16:45:04 +08:00
commit 4647f166e5
270 changed files with 166522 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

820
common/ppc/dct.c Normal file
View File

@@ -0,0 +1,820 @@
/*****************************************************************************
* dct.c: ppc transform and zigzag
*****************************************************************************
* Copyright (C) 2003-2025 x264 project
*
* Authors: Guillaume Poirier <gpoirier@mplayerhq.hu>
* Eric Petit <eric.petit@lapsus.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*
* This program is also available under a commercial proprietary license.
* For more information, contact us at licensing@x264.com.
*****************************************************************************/
#include "common/common.h"
#include "ppccommon.h"
#include "dct.h"
#if !HIGH_BIT_DEPTH
#define VEC_DCT(a0,a1,a2,a3,b0,b1,b2,b3) \
b1 = vec_add( a0, a3 ); \
b3 = vec_add( a1, a2 ); \
b0 = vec_add( b1, b3 ); \
b2 = vec_sub( b1, b3 ); \
a0 = vec_sub( a0, a3 ); \
a1 = vec_sub( a1, a2 ); \
b1 = vec_add( a0, a0 ); \
b1 = vec_add( b1, a1 ); \
b3 = vec_sub( a0, a1 ); \
b3 = vec_sub( b3, a1 )
void x264_sub4x4_dct_altivec( int16_t dct[16], uint8_t *pix1, uint8_t *pix2 )
{
PREP_DIFF_8BYTEALIGNED;
vec_s16_t dct0v, dct1v, dct2v, dct3v;
vec_s16_t tmp0v, tmp1v, tmp2v, tmp3v;
vec_u8_t permHighv;
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 4, dct0v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 4, dct1v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 4, dct2v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 4, dct3v );
VEC_DCT( dct0v, dct1v, dct2v, dct3v, tmp0v, tmp1v, tmp2v, tmp3v );
VEC_TRANSPOSE_4( tmp0v, tmp1v, tmp2v, tmp3v,
dct0v, dct1v, dct2v, dct3v );
permHighv = (vec_u8_t) CV(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17);
VEC_DCT( dct0v, dct1v, dct2v, dct3v, tmp0v, tmp1v, tmp2v, tmp3v );
vec_st(vec_perm(tmp0v, tmp1v, permHighv), 0, dct);
vec_st(vec_perm(tmp2v, tmp3v, permHighv), 16, dct);
}
void x264_sub8x8_dct_altivec( int16_t dct[4][16], uint8_t *pix1, uint8_t *pix2 )
{
PREP_DIFF_8BYTEALIGNED;
vec_s16_t dct0v, dct1v, dct2v, dct3v, dct4v, dct5v, dct6v, dct7v;
vec_s16_t tmp0v, tmp1v, tmp2v, tmp3v, tmp4v, tmp5v, tmp6v, tmp7v;
vec_u8_t permHighv, permLowv;
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct0v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct1v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct2v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct3v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct4v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct5v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct6v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct7v );
VEC_DCT( dct0v, dct1v, dct2v, dct3v, tmp0v, tmp1v, tmp2v, tmp3v );
VEC_DCT( dct4v, dct5v, dct6v, dct7v, tmp4v, tmp5v, tmp6v, tmp7v );
VEC_TRANSPOSE_8( tmp0v, tmp1v, tmp2v, tmp3v,
tmp4v, tmp5v, tmp6v, tmp7v,
dct0v, dct1v, dct2v, dct3v,
dct4v, dct5v, dct6v, dct7v );
permHighv = (vec_u8_t) CV(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17);
permLowv = (vec_u8_t) CV(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F);
VEC_DCT( dct0v, dct1v, dct2v, dct3v, tmp0v, tmp1v, tmp2v, tmp3v );
VEC_DCT( dct4v, dct5v, dct6v, dct7v, tmp4v, tmp5v, tmp6v, tmp7v );
vec_st(vec_perm(tmp0v, tmp1v, permHighv), 0, *dct);
vec_st(vec_perm(tmp2v, tmp3v, permHighv), 16, *dct);
vec_st(vec_perm(tmp4v, tmp5v, permHighv), 32, *dct);
vec_st(vec_perm(tmp6v, tmp7v, permHighv), 48, *dct);
vec_st(vec_perm(tmp0v, tmp1v, permLowv), 64, *dct);
vec_st(vec_perm(tmp2v, tmp3v, permLowv), 80, *dct);
vec_st(vec_perm(tmp4v, tmp5v, permLowv), 96, *dct);
vec_st(vec_perm(tmp6v, tmp7v, permLowv), 112, *dct);
}
void x264_sub16x16_dct_altivec( int16_t dct[16][16], uint8_t *pix1, uint8_t *pix2 )
{
x264_sub8x8_dct_altivec( &dct[ 0], &pix1[0], &pix2[0] );
x264_sub8x8_dct_altivec( &dct[ 4], &pix1[8], &pix2[8] );
x264_sub8x8_dct_altivec( &dct[ 8], &pix1[8*FENC_STRIDE+0], &pix2[8*FDEC_STRIDE+0] );
x264_sub8x8_dct_altivec( &dct[12], &pix1[8*FENC_STRIDE+8], &pix2[8*FDEC_STRIDE+8] );
}
/***************************************************************************
* 8x8 transform:
***************************************************************************/
static void pix_diff( uint8_t *p1, uint8_t *p2, vec_s16_t *diff, int i )
{
vec_s16_t pix1v, pix2v, tmp[4];
vec_u8_t pix1v8, pix2v8;
LOAD_ZERO;
for( int j = 0; j < 4; j++ )
{
pix1v8 = vec_vsx_ld( 0, p1 );
pix2v8 = vec_vsx_ld( 0, p2 );
pix1v = vec_u8_to_s16_h( pix1v8 );
pix2v = vec_u8_to_s16_h( pix2v8 );
tmp[j] = vec_sub( pix1v, pix2v );
p1 += FENC_STRIDE;
p2 += FDEC_STRIDE;
}
diff[i] = vec_add( tmp[0], tmp[1] );
diff[i] = vec_add( diff[i], tmp[2] );
diff[i] = vec_add( diff[i], tmp[3] );
}
void x264_sub8x8_dct_dc_altivec( int16_t dct[4], uint8_t *pix1, uint8_t *pix2 )
{
vec_s16_t diff[2], tmp;
vec_s32_t sum[2];
vec_s32_t zero32 = vec_splat_s32(0);
vec_u8_t mask = { 0x00, 0x01, 0x00, 0x01, 0x04, 0x05, 0x04, 0x05,
0x02, 0x03, 0x02, 0x03, 0x06, 0x07, 0x06, 0x07 };
pix_diff( &pix1[0], &pix2[0], diff, 0 );
pix_diff( &pix1[4*FENC_STRIDE], &pix2[4*FDEC_STRIDE], diff, 1 );
sum[0] = vec_sum4s( diff[0], zero32 );
sum[1] = vec_sum4s( diff[1], zero32 );
diff[0] = vec_packs( sum[0], sum[1] );
sum[0] = vec_sum4s( diff[0], zero32 );
diff[0] = vec_packs( sum[0], zero32 );
diff[0] = vec_perm( diff[0], diff[0], mask ); // 0 0 2 2 1 1 3 3
tmp = xxpermdi( diff[0], diff[0], 2 ); // 1 1 3 3 0 0 2 2
diff[1] = vec_add( diff[0], tmp ); // 0+1 0+1 2+3 2+3
diff[0] = vec_sub( diff[0], tmp ); // 0-1 0-1 2-3 2-3
tmp = vec_mergeh( diff[1], diff[0] ); // 0+1 0-1 0+1 0-1 2+3 2-3 2+3 2-3
diff[0] = xxpermdi( tmp, tmp, 2 ); // 2+3 2-3 2+3 2-3
diff[1] = vec_add( tmp, diff[0] ); // 0+1+2+3 0-1+2+3
diff[0] = vec_sub( tmp, diff[0] ); // 0+1-2-3 0-1-2+3
diff[0] = vec_mergeh( diff[1], diff[0] );
diff[1] = vec_ld( 0, dct );
diff[0] = xxpermdi( diff[0], diff[1], 0 );
vec_st( diff[0], 0, dct );
}
/* DCT8_1D unrolled by 8 in Altivec */
#define DCT8_1D_ALTIVEC( dct0v, dct1v, dct2v, dct3v, dct4v, dct5v, dct6v, dct7v ) \
{ \
/* int s07 = SRC(0) + SRC(7); */ \
vec_s16_t s07v = vec_add( dct0v, dct7v); \
/* int s16 = SRC(1) + SRC(6); */ \
vec_s16_t s16v = vec_add( dct1v, dct6v); \
/* int s25 = SRC(2) + SRC(5); */ \
vec_s16_t s25v = vec_add( dct2v, dct5v); \
/* int s34 = SRC(3) + SRC(4); */ \
vec_s16_t s34v = vec_add( dct3v, dct4v); \
\
/* int a0 = s07 + s34; */ \
vec_s16_t a0v = vec_add(s07v, s34v); \
/* int a1 = s16 + s25; */ \
vec_s16_t a1v = vec_add(s16v, s25v); \
/* int a2 = s07 - s34; */ \
vec_s16_t a2v = vec_sub(s07v, s34v); \
/* int a3 = s16 - s25; */ \
vec_s16_t a3v = vec_sub(s16v, s25v); \
\
/* int d07 = SRC(0) - SRC(7); */ \
vec_s16_t d07v = vec_sub( dct0v, dct7v); \
/* int d16 = SRC(1) - SRC(6); */ \
vec_s16_t d16v = vec_sub( dct1v, dct6v); \
/* int d25 = SRC(2) - SRC(5); */ \
vec_s16_t d25v = vec_sub( dct2v, dct5v); \
/* int d34 = SRC(3) - SRC(4); */ \
vec_s16_t d34v = vec_sub( dct3v, dct4v); \
\
/* int a4 = d16 + d25 + (d07 + (d07>>1)); */ \
vec_s16_t a4v = vec_add( vec_add(d16v, d25v), vec_add(d07v, vec_sra(d07v, onev)) );\
/* int a5 = d07 - d34 - (d25 + (d25>>1)); */ \
vec_s16_t a5v = vec_sub( vec_sub(d07v, d34v), vec_add(d25v, vec_sra(d25v, onev)) );\
/* int a6 = d07 + d34 - (d16 + (d16>>1)); */ \
vec_s16_t a6v = vec_sub( vec_add(d07v, d34v), vec_add(d16v, vec_sra(d16v, onev)) );\
/* int a7 = d16 - d25 + (d34 + (d34>>1)); */ \
vec_s16_t a7v = vec_add( vec_sub(d16v, d25v), vec_add(d34v, vec_sra(d34v, onev)) );\
\
/* DST(0) = a0 + a1; */ \
dct0v = vec_add( a0v, a1v ); \
/* DST(1) = a4 + (a7>>2); */ \
dct1v = vec_add( a4v, vec_sra(a7v, twov) ); \
/* DST(2) = a2 + (a3>>1); */ \
dct2v = vec_add( a2v, vec_sra(a3v, onev) ); \
/* DST(3) = a5 + (a6>>2); */ \
dct3v = vec_add( a5v, vec_sra(a6v, twov) ); \
/* DST(4) = a0 - a1; */ \
dct4v = vec_sub( a0v, a1v ); \
/* DST(5) = a6 - (a5>>2); */ \
dct5v = vec_sub( a6v, vec_sra(a5v, twov) ); \
/* DST(6) = (a2>>1) - a3 ; */ \
dct6v = vec_sub( vec_sra(a2v, onev), a3v ); \
/* DST(7) = (a4>>2) - a7 ; */ \
dct7v = vec_sub( vec_sra(a4v, twov), a7v ); \
}
void x264_sub8x8_dct8_altivec( int16_t dct[64], uint8_t *pix1, uint8_t *pix2 )
{
vec_u16_t onev = vec_splat_u16(1);
vec_u16_t twov = vec_add( onev, onev );
PREP_DIFF_8BYTEALIGNED;
vec_s16_t dct0v, dct1v, dct2v, dct3v,
dct4v, dct5v, dct6v, dct7v;
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct0v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct1v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct2v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct3v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct4v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct5v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct6v );
VEC_DIFF_H_8BYTE_ALIGNED( pix1, FENC_STRIDE, pix2, FDEC_STRIDE, 8, dct7v );
DCT8_1D_ALTIVEC( dct0v, dct1v, dct2v, dct3v,
dct4v, dct5v, dct6v, dct7v );
vec_s16_t dct_tr0v, dct_tr1v, dct_tr2v, dct_tr3v,
dct_tr4v, dct_tr5v, dct_tr6v, dct_tr7v;
VEC_TRANSPOSE_8(dct0v, dct1v, dct2v, dct3v,
dct4v, dct5v, dct6v, dct7v,
dct_tr0v, dct_tr1v, dct_tr2v, dct_tr3v,
dct_tr4v, dct_tr5v, dct_tr6v, dct_tr7v );
DCT8_1D_ALTIVEC( dct_tr0v, dct_tr1v, dct_tr2v, dct_tr3v,
dct_tr4v, dct_tr5v, dct_tr6v, dct_tr7v );
vec_st( dct_tr0v, 0, dct );
vec_st( dct_tr1v, 16, dct );
vec_st( dct_tr2v, 32, dct );
vec_st( dct_tr3v, 48, dct );
vec_st( dct_tr4v, 64, dct );
vec_st( dct_tr5v, 80, dct );
vec_st( dct_tr6v, 96, dct );
vec_st( dct_tr7v, 112, dct );
}
void x264_sub16x16_dct8_altivec( int16_t dct[4][64], uint8_t *pix1, uint8_t *pix2 )
{
x264_sub8x8_dct8_altivec( dct[0], &pix1[0], &pix2[0] );
x264_sub8x8_dct8_altivec( dct[1], &pix1[8], &pix2[8] );
x264_sub8x8_dct8_altivec( dct[2], &pix1[8*FENC_STRIDE+0], &pix2[8*FDEC_STRIDE+0] );
x264_sub8x8_dct8_altivec( dct[3], &pix1[8*FENC_STRIDE+8], &pix2[8*FDEC_STRIDE+8] );
}
/****************************************************************************
* IDCT transform:
****************************************************************************/
#define ALTIVEC_STORE8_DC_SUM_CLIP(dest, dcv) \
{ \
/* unaligned load */ \
vec_u8_t dstv = vec_vsx_ld( 0, dest ); \
vec_s16_t dcvsum = vec_adds( dcv, vec_u8_to_s16_h( dstv ) ); \
vec_u8_t dcvsum8 = vec_packsu( dcvsum, vec_u8_to_s16_l( dstv ) ); \
/* unaligned store */ \
vec_vsx_st( dcvsum8, 0, dest ); \
}
void x264_add8x8_idct_dc_altivec( uint8_t *p_dst, int16_t dct[4] )
{
vec_s16_t dcv0, dcv1;
vec_s16_t v32 = vec_sl( vec_splat_s16( 8 ), vec_splat_u16( 2 ) );
vec_u16_t v6 = vec_splat_u16( 6 );
vec_s16_t dctv = vec_ld( 0, dct );
vec_u8_t dstv0, dstv1, dstv2, dstv3, dstv4, dstv5, dstv6, dstv7;
vec_s16_t dcvsum0, dcvsum1, dcvsum2, dcvsum3, dcvsum4, dcvsum5, dcvsum6, dcvsum7;
vec_u8_t dcvsum8_0, dcvsum8_1, dcvsum8_2, dcvsum8_3, dcvsum8_4, dcvsum8_5, dcvsum8_6, dcvsum8_7;
LOAD_ZERO;
dctv = vec_sra( vec_add( dctv, v32 ), v6 );
dcv1 = (vec_s16_t)vec_mergeh( dctv, dctv );
dcv0 = (vec_s16_t)vec_mergeh( (vec_s32_t)dcv1, (vec_s32_t)dcv1 );
dcv1 = (vec_s16_t)vec_mergel( (vec_s32_t)dcv1, (vec_s32_t)dcv1 );
dstv0 = vec_vsx_ld( 0, p_dst );
dstv4 = vec_vsx_ld( 0, p_dst + 4*FDEC_STRIDE );
dstv1 = vec_vsx_ld( 0, p_dst + 1*FDEC_STRIDE );
dstv5 = vec_vsx_ld( 0, p_dst + 4*FDEC_STRIDE + 1*FDEC_STRIDE );
dstv2 = vec_vsx_ld( 0, p_dst + 2*FDEC_STRIDE);
dstv6 = vec_vsx_ld( 0, p_dst + 4*FDEC_STRIDE + 2*FDEC_STRIDE );
dstv3 = vec_vsx_ld( 0, p_dst + 3*FDEC_STRIDE);
dstv7 = vec_vsx_ld( 0, p_dst + 4*FDEC_STRIDE + 3*FDEC_STRIDE );
vec_s16_t s0 = vec_u8_to_s16_h( dstv0 );
vec_s16_t s1 = vec_u8_to_s16_h( dstv4 );
vec_s16_t s2 = vec_u8_to_s16_h( dstv1 );
vec_s16_t s3 = vec_u8_to_s16_h( dstv5 );
vec_s16_t s4 = vec_u8_to_s16_h( dstv2 );
vec_s16_t s5 = vec_u8_to_s16_h( dstv6 );
vec_s16_t s6 = vec_u8_to_s16_h( dstv3 );
vec_s16_t s7 = vec_u8_to_s16_h( dstv7 );
dcvsum0 = vec_adds( dcv0, s0 );
dcvsum4 = vec_adds( dcv1, s1 );
dcvsum1 = vec_adds( dcv0, s2 );
dcvsum5 = vec_adds( dcv1, s3 );
dcvsum2 = vec_adds( dcv0, s4 );
dcvsum6 = vec_adds( dcv1, s5 );
dcvsum3 = vec_adds( dcv0, s6 );
dcvsum7 = vec_adds( dcv1, s7 );
dcvsum8_0 = vec_packsu( dcvsum0, vec_u8_to_s16_l( dstv0 ) );
dcvsum8_1 = vec_packsu( dcvsum1, vec_u8_to_s16_l( dstv1 ) );
dcvsum8_2 = vec_packsu( dcvsum2, vec_u8_to_s16_l( dstv2 ) );
dcvsum8_3 = vec_packsu( dcvsum3, vec_u8_to_s16_l( dstv3 ) );
dcvsum8_4 = vec_packsu( dcvsum4, vec_u8_to_s16_l( dstv4 ) );
dcvsum8_5 = vec_packsu( dcvsum5, vec_u8_to_s16_l( dstv5 ) );
dcvsum8_6 = vec_packsu( dcvsum6, vec_u8_to_s16_l( dstv6 ) );
dcvsum8_7 = vec_packsu( dcvsum7, vec_u8_to_s16_l( dstv7 ) );
vec_vsx_st( dcvsum8_0, 0, p_dst );
vec_vsx_st( dcvsum8_4, 0, p_dst + 4*FDEC_STRIDE );
vec_vsx_st( dcvsum8_1, 0, p_dst + 1*FDEC_STRIDE );
vec_vsx_st( dcvsum8_5, 0, p_dst + 4*FDEC_STRIDE + 1*FDEC_STRIDE );
vec_vsx_st( dcvsum8_2, 0, p_dst + 2*FDEC_STRIDE );
vec_vsx_st( dcvsum8_6, 0, p_dst + 4*FDEC_STRIDE + 2*FDEC_STRIDE );
vec_vsx_st( dcvsum8_3, 0, p_dst + 3*FDEC_STRIDE );
vec_vsx_st( dcvsum8_7, 0, p_dst + 4*FDEC_STRIDE + 3*FDEC_STRIDE );
}
#define LOAD16 \
dstv0 = vec_ld( 0, p_dst ); \
dstv1 = vec_ld( 0, p_dst + 1*FDEC_STRIDE ); \
dstv2 = vec_ld( 0, p_dst + 2*FDEC_STRIDE ); \
dstv3 = vec_ld( 0, p_dst + 3*FDEC_STRIDE );
#define SUM16 \
dcvsum0 = vec_adds( dcv0, vec_u8_to_s16_h( dstv0 ) ); \
dcvsum4 = vec_adds( dcv1, vec_u8_to_s16_l( dstv0 ) ); \
dcvsum1 = vec_adds( dcv0, vec_u8_to_s16_h( dstv1 ) ); \
dcvsum5 = vec_adds( dcv1, vec_u8_to_s16_l( dstv1 ) ); \
dcvsum2 = vec_adds( dcv0, vec_u8_to_s16_h( dstv2 ) ); \
dcvsum6 = vec_adds( dcv1, vec_u8_to_s16_l( dstv2 ) ); \
dcvsum3 = vec_adds( dcv0, vec_u8_to_s16_h( dstv3 ) ); \
dcvsum7 = vec_adds( dcv1, vec_u8_to_s16_l( dstv3 ) ); \
dcvsum8_0 = vec_packsu( dcvsum0, dcvsum4 ); \
dcvsum8_1 = vec_packsu( dcvsum1, dcvsum5 ); \
dcvsum8_2 = vec_packsu( dcvsum2, dcvsum6 ); \
dcvsum8_3 = vec_packsu( dcvsum3, dcvsum7 );
#define STORE16 \
vec_st( dcvsum8_0, 0, p_dst ); \
vec_st( dcvsum8_1, 0, p_dst + 1*FDEC_STRIDE ); \
vec_st( dcvsum8_2, 0, p_dst + 2*FDEC_STRIDE ); \
vec_st( dcvsum8_3, 0, p_dst + 3*FDEC_STRIDE );
void x264_add16x16_idct_dc_altivec( uint8_t *p_dst, int16_t dct[16] )
{
vec_s16_t dcv0, dcv1;
vec_s16_t v32 = vec_sl( vec_splat_s16( 8 ), vec_splat_u16( 2 ) );
vec_u16_t v6 = vec_splat_u16( 6 );
vec_u8_t dstv0, dstv1, dstv2, dstv3;
vec_s16_t dcvsum0, dcvsum1, dcvsum2, dcvsum3, dcvsum4, dcvsum5, dcvsum6, dcvsum7;
vec_u8_t dcvsum8_0, dcvsum8_1, dcvsum8_2, dcvsum8_3;
LOAD_ZERO;
for( int i = 0; i < 2; i++ )
{
vec_s16_t dctv = vec_ld( 0, dct );
dctv = vec_sra( vec_add( dctv, v32 ), v6 );
dcv1 = (vec_s16_t)vec_mergeh( dctv, dctv );
dcv0 = (vec_s16_t)vec_mergeh( (vec_s32_t)dcv1, (vec_s32_t)dcv1 );
dcv1 = (vec_s16_t)vec_mergel( (vec_s32_t)dcv1, (vec_s32_t)dcv1 );
LOAD16;
SUM16;
STORE16;
p_dst += 4*FDEC_STRIDE;
dcv1 = (vec_s16_t)vec_mergel( dctv, dctv );
dcv0 = (vec_s16_t)vec_mergeh( (vec_s32_t)dcv1, (vec_s32_t)dcv1 );
dcv1 = (vec_s16_t)vec_mergel( (vec_s32_t)dcv1, (vec_s32_t)dcv1 );
LOAD16;
SUM16;
STORE16;
dct += 8;
p_dst += 4*FDEC_STRIDE;
}
}
#define IDCT_1D_ALTIVEC(s0, s1, s2, s3, d0, d1, d2, d3) \
{ \
/* a0 = SRC(0) + SRC(2); */ \
vec_s16_t a0v = vec_add(s0, s2); \
/* a1 = SRC(0) - SRC(2); */ \
vec_s16_t a1v = vec_sub(s0, s2); \
/* a2 = (SRC(1)>>1) - SRC(3); */ \
vec_s16_t a2v = vec_sub(vec_sra(s1, onev), s3); \
/* a3 = (SRC(3)>>1) + SRC(1); */ \
vec_s16_t a3v = vec_add(vec_sra(s3, onev), s1); \
/* DST(0, a0 + a3); */ \
d0 = vec_add(a0v, a3v); \
/* DST(1, a1 + a2); */ \
d1 = vec_add(a1v, a2v); \
/* DST(2, a1 - a2); */ \
d2 = vec_sub(a1v, a2v); \
/* DST(3, a0 - a3); */ \
d3 = vec_sub(a0v, a3v); \
}
#define VEC_LOAD_U8_ADD_S16_STORE_U8(va) \
vdst_orig = vec_ld(0, dst); \
vdst = vec_perm(vdst_orig, zero_u8v, vdst_mask); \
vdst_ss = (vec_s16_t)vec_mergeh(zero_u8v, vdst); \
va = vec_add(va, vdst_ss); \
va_u8 = vec_s16_to_u8(va); \
va_u32 = vec_splat((vec_u32_t)va_u8, 0); \
vec_ste(va_u32, element, (uint32_t*)dst);
#define ALTIVEC_STORE4_SUM_CLIP(dest, idctv) \
{ \
/* unaligned load */ \
vec_u8_t dstv = vec_vsx_ld(0, dest); \
vec_s16_t idct_sh6 = vec_sra(idctv, sixv); \
vec_u16_t dst16 = vec_u8_to_u16_h(dstv); \
vec_s16_t idstsum = vec_adds(idct_sh6, (vec_s16_t)dst16); \
vec_u8_t idstsum8 = vec_s16_to_u8(idstsum); \
/* unaligned store */ \
vec_u32_t bodyv = vec_splat((vec_u32_t)idstsum8, 0); \
int element = ((unsigned long)dest & 0xf) >> 2; \
vec_ste(bodyv, element, (uint32_t *)dest); \
}
void x264_add4x4_idct_altivec( uint8_t *dst, int16_t dct[16] )
{
vec_u16_t onev = vec_splat_u16(1);
dct[0] += 32; // rounding for the >>6 at the end
vec_s16_t s0, s1, s2, s3;
s0 = vec_ld( 0x00, dct );
s1 = vec_sld( s0, s0, 8 );
s2 = vec_ld( 0x10, dct );
s3 = vec_sld( s2, s2, 8 );
vec_s16_t d0, d1, d2, d3;
IDCT_1D_ALTIVEC( s0, s1, s2, s3, d0, d1, d2, d3 );
vec_s16_t tr0, tr1, tr2, tr3;
VEC_TRANSPOSE_4( d0, d1, d2, d3, tr0, tr1, tr2, tr3 );
vec_s16_t idct0, idct1, idct2, idct3;
IDCT_1D_ALTIVEC( tr0, tr1, tr2, tr3, idct0, idct1, idct2, idct3 );
vec_u16_t sixv = vec_splat_u16(6);
LOAD_ZERO;
ALTIVEC_STORE4_SUM_CLIP( &dst[0*FDEC_STRIDE], idct0 );
ALTIVEC_STORE4_SUM_CLIP( &dst[1*FDEC_STRIDE], idct1 );
ALTIVEC_STORE4_SUM_CLIP( &dst[2*FDEC_STRIDE], idct2 );
ALTIVEC_STORE4_SUM_CLIP( &dst[3*FDEC_STRIDE], idct3 );
}
void x264_add8x8_idct_altivec( uint8_t *p_dst, int16_t dct[4][16] )
{
x264_add4x4_idct_altivec( &p_dst[0], dct[0] );
x264_add4x4_idct_altivec( &p_dst[4], dct[1] );
x264_add4x4_idct_altivec( &p_dst[4*FDEC_STRIDE+0], dct[2] );
x264_add4x4_idct_altivec( &p_dst[4*FDEC_STRIDE+4], dct[3] );
}
void x264_add16x16_idct_altivec( uint8_t *p_dst, int16_t dct[16][16] )
{
x264_add8x8_idct_altivec( &p_dst[0], &dct[0] );
x264_add8x8_idct_altivec( &p_dst[8], &dct[4] );
x264_add8x8_idct_altivec( &p_dst[8*FDEC_STRIDE+0], &dct[8] );
x264_add8x8_idct_altivec( &p_dst[8*FDEC_STRIDE+8], &dct[12] );
}
#define IDCT8_1D_ALTIVEC(s0, s1, s2, s3, s4, s5, s6, s7, d0, d1, d2, d3, d4, d5, d6, d7)\
{\
/* a0 = SRC(0) + SRC(4); */ \
vec_s16_t a0v = vec_add(s0, s4); \
/* a2 = SRC(0) - SRC(4); */ \
vec_s16_t a2v = vec_sub(s0, s4); \
/* a4 = (SRC(2)>>1) - SRC(6); */ \
vec_s16_t a4v = vec_sub(vec_sra(s2, onev), s6); \
/* a6 = (SRC(6)>>1) + SRC(2); */ \
vec_s16_t a6v = vec_add(vec_sra(s6, onev), s2); \
/* b0 = a0 + a6; */ \
vec_s16_t b0v = vec_add(a0v, a6v); \
/* b2 = a2 + a4; */ \
vec_s16_t b2v = vec_add(a2v, a4v); \
/* b4 = a2 - a4; */ \
vec_s16_t b4v = vec_sub(a2v, a4v); \
/* b6 = a0 - a6; */ \
vec_s16_t b6v = vec_sub(a0v, a6v); \
/* a1 = SRC(5) - SRC(3) - SRC(7) - (SRC(7)>>1); */ \
/* a1 = (SRC(5)-SRC(3)) - (SRC(7) + (SRC(7)>>1)); */ \
vec_s16_t a1v = vec_sub( vec_sub(s5, s3), vec_add(s7, vec_sra(s7, onev)) );\
/* a3 = SRC(7) + SRC(1) - SRC(3) - (SRC(3)>>1); */ \
/* a3 = (SRC(7)+SRC(1)) - (SRC(3) + (SRC(3)>>1)); */ \
vec_s16_t a3v = vec_sub( vec_add(s7, s1), vec_add(s3, vec_sra(s3, onev)) );\
/* a5 = SRC(7) - SRC(1) + SRC(5) + (SRC(5)>>1); */ \
/* a5 = (SRC(7)-SRC(1)) + SRC(5) + (SRC(5)>>1); */ \
vec_s16_t a5v = vec_add( vec_sub(s7, s1), vec_add(s5, vec_sra(s5, onev)) );\
/* a7 = SRC(5)+SRC(3) + SRC(1) + (SRC(1)>>1); */ \
vec_s16_t a7v = vec_add( vec_add(s5, s3), vec_add(s1, vec_sra(s1, onev)) );\
/* b1 = (a7>>2) + a1; */ \
vec_s16_t b1v = vec_add( vec_sra(a7v, twov), a1v); \
/* b3 = a3 + (a5>>2); */ \
vec_s16_t b3v = vec_add(a3v, vec_sra(a5v, twov)); \
/* b5 = (a3>>2) - a5; */ \
vec_s16_t b5v = vec_sub( vec_sra(a3v, twov), a5v); \
/* b7 = a7 - (a1>>2); */ \
vec_s16_t b7v = vec_sub( a7v, vec_sra(a1v, twov)); \
/* DST(0, b0 + b7); */ \
d0 = vec_add(b0v, b7v); \
/* DST(1, b2 + b5); */ \
d1 = vec_add(b2v, b5v); \
/* DST(2, b4 + b3); */ \
d2 = vec_add(b4v, b3v); \
/* DST(3, b6 + b1); */ \
d3 = vec_add(b6v, b1v); \
/* DST(4, b6 - b1); */ \
d4 = vec_sub(b6v, b1v); \
/* DST(5, b4 - b3); */ \
d5 = vec_sub(b4v, b3v); \
/* DST(6, b2 - b5); */ \
d6 = vec_sub(b2v, b5v); \
/* DST(7, b0 - b7); */ \
d7 = vec_sub(b0v, b7v); \
}
#define ALTIVEC_STORE_SUM_CLIP(dest, idctv) \
{ \
vec_s16_t idct_sh6 = vec_sra( idctv, sixv ); \
/* unaligned load */ \
vec_u8_t dstv = vec_vsx_ld( 0, dest ); \
vec_s16_t idstsum = vec_adds( idct_sh6, vec_u8_to_s16_h( dstv ) ); \
vec_u8_t idstsum8 = vec_packsu( idstsum, vec_u8_to_s16_l( dstv ) ); \
/* unaligned store */ \
vec_vsx_st( idstsum8, 0, dest ); \
}
void x264_add8x8_idct8_altivec( uint8_t *dst, int16_t dct[64] )
{
vec_u16_t onev = vec_splat_u16(1);
vec_u16_t twov = vec_splat_u16(2);
dct[0] += 32; // rounding for the >>6 at the end
vec_s16_t s0, s1, s2, s3, s4, s5, s6, s7;
s0 = vec_ld(0x00, dct);
s1 = vec_ld(0x10, dct);
s2 = vec_ld(0x20, dct);
s3 = vec_ld(0x30, dct);
s4 = vec_ld(0x40, dct);
s5 = vec_ld(0x50, dct);
s6 = vec_ld(0x60, dct);
s7 = vec_ld(0x70, dct);
vec_s16_t d0, d1, d2, d3, d4, d5, d6, d7;
IDCT8_1D_ALTIVEC(s0, s1, s2, s3, s4, s5, s6, s7, d0, d1, d2, d3, d4, d5, d6, d7);
vec_s16_t tr0, tr1, tr2, tr3, tr4, tr5, tr6, tr7;
VEC_TRANSPOSE_8( d0, d1, d2, d3, d4, d5, d6, d7,
tr0, tr1, tr2, tr3, tr4, tr5, tr6, tr7);
vec_s16_t idct0, idct1, idct2, idct3, idct4, idct5, idct6, idct7;
IDCT8_1D_ALTIVEC(tr0, tr1, tr2, tr3, tr4, tr5, tr6, tr7,
idct0, idct1, idct2, idct3, idct4, idct5, idct6, idct7);
vec_u16_t sixv = vec_splat_u16(6);
LOAD_ZERO;
ALTIVEC_STORE_SUM_CLIP(&dst[0*FDEC_STRIDE], idct0);
ALTIVEC_STORE_SUM_CLIP(&dst[1*FDEC_STRIDE], idct1);
ALTIVEC_STORE_SUM_CLIP(&dst[2*FDEC_STRIDE], idct2);
ALTIVEC_STORE_SUM_CLIP(&dst[3*FDEC_STRIDE], idct3);
ALTIVEC_STORE_SUM_CLIP(&dst[4*FDEC_STRIDE], idct4);
ALTIVEC_STORE_SUM_CLIP(&dst[5*FDEC_STRIDE], idct5);
ALTIVEC_STORE_SUM_CLIP(&dst[6*FDEC_STRIDE], idct6);
ALTIVEC_STORE_SUM_CLIP(&dst[7*FDEC_STRIDE], idct7);
}
void x264_add16x16_idct8_altivec( uint8_t *dst, int16_t dct[4][64] )
{
x264_add8x8_idct8_altivec( &dst[0], dct[0] );
x264_add8x8_idct8_altivec( &dst[8], dct[1] );
x264_add8x8_idct8_altivec( &dst[8*FDEC_STRIDE+0], dct[2] );
x264_add8x8_idct8_altivec( &dst[8*FDEC_STRIDE+8], dct[3] );
}
void x264_zigzag_scan_4x4_frame_altivec( int16_t level[16], int16_t dct[16] )
{
vec_s16_t dct0v, dct1v;
vec_s16_t tmp0v, tmp1v;
dct0v = vec_ld(0x00, dct);
dct1v = vec_ld(0x10, dct);
const vec_u8_t sel0 = (vec_u8_t) CV(0,1,8,9,2,3,4,5,10,11,16,17,24,25,18,19);
const vec_u8_t sel1 = (vec_u8_t) CV(12,13,6,7,14,15,20,21,26,27,28,29,22,23,30,31);
tmp0v = vec_perm( dct0v, dct1v, sel0 );
tmp1v = vec_perm( dct0v, dct1v, sel1 );
vec_st( tmp0v, 0x00, level );
vec_st( tmp1v, 0x10, level );
}
void x264_zigzag_scan_4x4_field_altivec( int16_t level[16], int16_t dct[16] )
{
vec_s16_t dct0v, dct1v;
vec_s16_t tmp0v, tmp1v;
dct0v = vec_ld(0x00, dct);
dct1v = vec_ld(0x10, dct);
const vec_u8_t sel0 = (vec_u8_t) CV(0,1,2,3,8,9,4,5,6,7,10,11,12,13,14,15);
tmp0v = vec_perm( dct0v, dct1v, sel0 );
tmp1v = dct1v;
vec_st( tmp0v, 0x00, level );
vec_st( tmp1v, 0x10, level );
}
void x264_zigzag_scan_8x8_frame_altivec( int16_t level[64], int16_t dct[64] )
{
vec_s16_t tmpv[6];
vec_s16_t dct0v = vec_ld( 0*16, dct );
vec_s16_t dct1v = vec_ld( 1*16, dct );
vec_s16_t dct2v = vec_ld( 2*16, dct );
vec_s16_t dct3v = vec_ld( 3*16, dct );
vec_s16_t dct4v = vec_ld( 4*16, dct );
vec_s16_t dct5v = vec_ld( 5*16, dct );
vec_s16_t dct6v = vec_ld( 6*16, dct );
vec_s16_t dct7v = vec_ld( 7*16, dct );
const vec_u8_t mask1[14] = {
{ 0x00, 0x01, 0x02, 0x03, 0x12, 0x13, 0x14, 0x15, 0x0A, 0x0B, 0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D },
{ 0x0A, 0x0B, 0x0C, 0x0D, 0x00, 0x00, 0x0E, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x10, 0x11, 0x12, 0x13 },
{ 0x00, 0x01, 0x02, 0x03, 0x18, 0x19, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F },
{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x18, 0x19, 0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F },
{ 0x00, 0x00, 0x14, 0x15, 0x18, 0x19, 0x02, 0x03, 0x04, 0x05, 0x08, 0x09, 0x06, 0x07, 0x12, 0x13 },
{ 0x12, 0x13, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F },
{ 0x1A, 0x1B, 0x10, 0x11, 0x08, 0x09, 0x04, 0x05, 0x02, 0x03, 0x0C, 0x0D, 0x14, 0x15, 0x18, 0x19 },
{ 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x0A, 0x0B },
{ 0x00, 0x01, 0x02, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x06, 0x07, 0x04, 0x05, 0x08, 0x09 },
{ 0x00, 0x11, 0x16, 0x17, 0x18, 0x19, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x1A, 0x1B },
{ 0x02, 0x03, 0x18, 0x19, 0x16, 0x17, 0x1A, 0x1B, 0x1C, 0x1D, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 },
{ 0x08, 0x09, 0x0A, 0x0B, 0x06, 0x07, 0x0E, 0x0F, 0x10, 0x11, 0x00, 0x00, 0x12, 0x13, 0x14, 0x15 },
{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x16, 0x17, 0x0C, 0x0D, 0x0E, 0x0F },
{ 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x08, 0x09, 0x06, 0x07, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }
};
tmpv[0] = vec_mergeh( dct0v, dct1v );
tmpv[1] = vec_mergeh( dct2v, dct3v );
tmpv[2] = (vec_s16_t)vec_mergeh( (vec_s32_t)tmpv[0], (vec_s32_t)tmpv[1] );
tmpv[3] = vec_perm( tmpv[2], dct0v, mask1[0] );
vec_st( tmpv[3], 0*16, level );
tmpv[4] = vec_mergeh( dct4v, dct5v );
tmpv[3] = vec_perm( tmpv[0], tmpv[4], mask1[1] );
tmpv[3] = vec_perm( tmpv[3], dct0v, mask1[2] );
tmpv[3] = vec_perm( tmpv[3], tmpv[1], mask1[3] );
vec_st( tmpv[3], 1*16, level );
tmpv[3] = vec_mergel( dct0v, dct1v );
tmpv[1] = vec_mergel( tmpv[1], dct2v );
tmpv[5] = vec_perm( tmpv[3], tmpv[1], mask1[4] );
tmpv[5] = vec_perm( tmpv[5], dct4v, mask1[5] );
vec_st( tmpv[5], 2*16, level );
tmpv[2] = vec_mergeh( dct5v, dct6v );
tmpv[5] = vec_mergeh( tmpv[2], dct7v );
tmpv[4] = vec_mergel( tmpv[4], tmpv[1] );
tmpv[0] = vec_perm( tmpv[5], tmpv[4], mask1[6] );
vec_st( tmpv[0], 3*16, level );
tmpv[1] = vec_mergel( dct2v, dct3v );
tmpv[0] = vec_mergel( dct4v, dct5v );
tmpv[4] = vec_perm( tmpv[1], tmpv[0], mask1[7] );
tmpv[3] = vec_perm( tmpv[4], tmpv[3], mask1[8] );
vec_st( tmpv[3], 4*16, level );
tmpv[3] = vec_mergeh( dct6v, dct7v );
tmpv[2] = vec_mergel( dct3v, dct4v );
tmpv[2] = vec_perm( tmpv[2], dct5v, mask1[9] );
tmpv[3] = vec_perm( tmpv[2], tmpv[3], mask1[10] );
vec_st( tmpv[3], 5*16, level );
tmpv[1] = vec_mergel( tmpv[1], tmpv[2] );
tmpv[2] = vec_mergel( dct6v, dct7v );
tmpv[1] = vec_perm( tmpv[1], tmpv[2], mask1[11] );
tmpv[1] = vec_perm( tmpv[1], dct7v, mask1[12] );
vec_st( tmpv[1], 6*16, level );
tmpv[2] = vec_perm( tmpv[2], tmpv[0], mask1[13] );
vec_st( tmpv[2], 7*16, level );
}
void x264_zigzag_interleave_8x8_cavlc_altivec( int16_t *dst, int16_t *src, uint8_t *nnz )
{
vec_s16_t tmpv[8];
vec_s16_t merge[2];
vec_s16_t permv[3];
vec_s16_t orv[4];
vec_s16_t src0v = vec_ld( 0*16, src );
vec_s16_t src1v = vec_ld( 1*16, src );
vec_s16_t src2v = vec_ld( 2*16, src );
vec_s16_t src3v = vec_ld( 3*16, src );
vec_s16_t src4v = vec_ld( 4*16, src );
vec_s16_t src5v = vec_ld( 5*16, src );
vec_s16_t src6v = vec_ld( 6*16, src );
vec_s16_t src7v = vec_ld( 7*16, src );
vec_u8_t pack;
vec_u8_t nnzv = vec_vsx_ld( 0, nnz );
vec_u8_t shift = vec_splat_u8( 7 );
LOAD_ZERO;
const vec_u8_t mask[3] = {
{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 },
{ 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F },
{ 0x10, 0x11, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x12, 0x13, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }
};
tmpv[0] = vec_mergeh( src0v, src1v );
tmpv[1] = vec_mergel( src0v, src1v );
tmpv[2] = vec_mergeh( src2v, src3v );
tmpv[3] = vec_mergel( src2v, src3v );
tmpv[4] = vec_mergeh( src4v, src5v );
tmpv[5] = vec_mergel( src4v, src5v );
tmpv[6] = vec_mergeh( src6v, src7v );
tmpv[7] = vec_mergel( src6v, src7v );
merge[0] = vec_mergeh( tmpv[0], tmpv[1] );
merge[1] = vec_mergeh( tmpv[2], tmpv[3] );
permv[0] = vec_perm( merge[0], merge[1], mask[0] );
permv[1] = vec_perm( merge[0], merge[1], mask[1] );
vec_st( permv[0], 0*16, dst );
merge[0] = vec_mergeh( tmpv[4], tmpv[5] );
merge[1] = vec_mergeh( tmpv[6], tmpv[7] );
permv[0] = vec_perm( merge[0], merge[1], mask[0] );
permv[2] = vec_perm( merge[0], merge[1], mask[1] );
vec_st( permv[0], 1*16, dst );
vec_st( permv[1], 2*16, dst );
vec_st( permv[2], 3*16, dst );
merge[0] = vec_mergel( tmpv[0], tmpv[1] );
merge[1] = vec_mergel( tmpv[2], tmpv[3] );
permv[0] = vec_perm( merge[0], merge[1], mask[0] );
permv[1] = vec_perm( merge[0], merge[1], mask[1] );
vec_st( permv[0], 4*16, dst );
merge[0] = vec_mergel( tmpv[4], tmpv[5] );
merge[1] = vec_mergel( tmpv[6], tmpv[7] );
permv[0] = vec_perm( merge[0], merge[1], mask[0] );
permv[2] = vec_perm( merge[0], merge[1], mask[1] );
vec_st( permv[0], 5*16, dst );
vec_st( permv[1], 6*16, dst );
vec_st( permv[2], 7*16, dst );
orv[0] = vec_or( src0v, src1v );
orv[1] = vec_or( src2v, src3v );
orv[2] = vec_or( src4v, src5v );
orv[3] = vec_or( src6v, src7v );
permv[0] = vec_or( orv[0], orv[1] );
permv[1] = vec_or( orv[2], orv[3] );
permv[0] = vec_or( permv[0], permv[1] );
permv[1] = vec_perm( permv[0], permv[0], mask[1] );
permv[0] = vec_or( permv[0], permv[1] );
pack = (vec_u8_t)vec_packs( permv[0], permv[0] );
pack = (vec_u8_t)vec_cmpeq( pack, zerov );
pack = vec_nor( pack, zerov );
pack = vec_sr( pack, shift );
nnzv = vec_perm( nnzv, pack, mask[2] );
vec_st( nnzv, 0, nnz );
}
#endif // !HIGH_BIT_DEPTH

70
common/ppc/dct.h Normal file
View File

@@ -0,0 +1,70 @@
/*****************************************************************************
* dct.h: ppc transform and zigzag
*****************************************************************************
* Copyright (C) 2003-2025 x264 project
*
* Authors: Eric Petit <eric.petit@lapsus.org>
* Guillaume Poirier <gpoirier@mplayerhq.hu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*
* This program is also available under a commercial proprietary license.
* For more information, contact us at licensing@x264.com.
*****************************************************************************/
#ifndef X264_PPC_DCT_H
#define X264_PPC_DCT_H
#define x264_sub4x4_dct_altivec x264_template(sub4x4_dct_altivec)
void x264_sub4x4_dct_altivec( int16_t dct[16], uint8_t *pix1, uint8_t *pix2 );
#define x264_sub8x8_dct_altivec x264_template(sub8x8_dct_altivec)
void x264_sub8x8_dct_altivec( int16_t dct[4][16], uint8_t *pix1, uint8_t *pix2 );
#define x264_sub16x16_dct_altivec x264_template(sub16x16_dct_altivec)
void x264_sub16x16_dct_altivec( int16_t dct[16][16], uint8_t *pix1, uint8_t *pix2 );
#define x264_add8x8_idct_dc_altivec x264_template(add8x8_idct_dc_altivec)
void x264_add8x8_idct_dc_altivec( uint8_t *p_dst, int16_t dct[4] );
#define x264_add16x16_idct_dc_altivec x264_template(add16x16_idct_dc_altivec)
void x264_add16x16_idct_dc_altivec( uint8_t *p_dst, int16_t dct[16] );
#define x264_add4x4_idct_altivec x264_template(add4x4_idct_altivec)
void x264_add4x4_idct_altivec( uint8_t *p_dst, int16_t dct[16] );
#define x264_add8x8_idct_altivec x264_template(add8x8_idct_altivec)
void x264_add8x8_idct_altivec( uint8_t *p_dst, int16_t dct[4][16] );
#define x264_add16x16_idct_altivec x264_template(add16x16_idct_altivec)
void x264_add16x16_idct_altivec( uint8_t *p_dst, int16_t dct[16][16] );
#define x264_sub8x8_dct_dc_altivec x264_template(sub8x8_dct_dc_altivec)
void x264_sub8x8_dct_dc_altivec( int16_t dct[4], uint8_t *pix1, uint8_t *pix2 );
#define x264_sub8x8_dct8_altivec x264_template(sub8x8_dct8_altivec)
void x264_sub8x8_dct8_altivec( int16_t dct[64], uint8_t *pix1, uint8_t *pix2 );
#define x264_sub16x16_dct8_altivec x264_template(sub16x16_dct8_altivec)
void x264_sub16x16_dct8_altivec( int16_t dct[4][64], uint8_t *pix1, uint8_t *pix2 );
#define x264_add8x8_idct8_altivec x264_template(add8x8_idct8_altivec)
void x264_add8x8_idct8_altivec( uint8_t *dst, int16_t dct[64] );
#define x264_add16x16_idct8_altivec x264_template(add16x16_idct8_altivec)
void x264_add16x16_idct8_altivec( uint8_t *dst, int16_t dct[4][64] );
#define x264_zigzag_scan_4x4_frame_altivec x264_template(zigzag_scan_4x4_frame_altivec)
void x264_zigzag_scan_4x4_frame_altivec( int16_t level[16], int16_t dct[16] );
#define x264_zigzag_scan_4x4_field_altivec x264_template(zigzag_scan_4x4_field_altivec)
void x264_zigzag_scan_4x4_field_altivec( int16_t level[16], int16_t dct[16] );
#define x264_zigzag_scan_8x8_frame_altivec x264_template(zigzag_scan_8x8_frame_altivec)
void x264_zigzag_scan_8x8_frame_altivec( int16_t level[64], int16_t dct[64] );
#define x264_zigzag_interleave_8x8_cavlc_altivec x264_template(zigzag_interleave_8x8_cavlc_altivec)
void x264_zigzag_interleave_8x8_cavlc_altivec( int16_t *dst, int16_t *src, uint8_t *nnz );
#endif

295
common/ppc/deblock.c Normal file
View File

@@ -0,0 +1,295 @@
/*****************************************************************************
* deblock.c: ppc deblocking
*****************************************************************************
* Copyright (C) 2007-2025 x264 project
*
* Authors: Guillaume Poirier <gpoirier@mplayerhq.hu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*
* This program is also available under a commercial proprietary license.
* For more information, contact us at licensing@x264.com.
*****************************************************************************/
#include "common/common.h"
#include "ppccommon.h"
#include "deblock.h"
#if !HIGH_BIT_DEPTH
#define transpose4x16(r0, r1, r2, r3) \
{ \
register vec_u8_t r4; \
register vec_u8_t r5; \
register vec_u8_t r6; \
register vec_u8_t r7; \
\
r4 = vec_mergeh(r0, r2); /*0, 2 set 0*/ \
r5 = vec_mergel(r0, r2); /*0, 2 set 1*/ \
r6 = vec_mergeh(r1, r3); /*1, 3 set 0*/ \
r7 = vec_mergel(r1, r3); /*1, 3 set 1*/ \
\
r0 = vec_mergeh(r4, r6); /*all set 0*/ \
r1 = vec_mergel(r4, r6); /*all set 1*/ \
r2 = vec_mergeh(r5, r7); /*all set 2*/ \
r3 = vec_mergel(r5, r7); /*all set 3*/ \
}
static inline void write16x4( uint8_t *dst, int dst_stride,
register vec_u8_t r0, register vec_u8_t r1,
register vec_u8_t r2, register vec_u8_t r3 )
{
ALIGNED_16(unsigned char result[64]);
uint32_t *src_int = (uint32_t *)result, *dst_int = (uint32_t *)dst;
int int_dst_stride = dst_stride >> 2;
vec_st(r0, 0, result);
vec_st(r1, 16, result);
vec_st(r2, 32, result);
vec_st(r3, 48, result);
/* FIXME: there has to be a better way!!!! */
*dst_int = *src_int;
*(dst_int+ int_dst_stride) = *(src_int + 1);
*(dst_int+ 2*int_dst_stride) = *(src_int + 2);
*(dst_int+ 3*int_dst_stride) = *(src_int + 3);
*(dst_int+ 4*int_dst_stride) = *(src_int + 4);
*(dst_int+ 5*int_dst_stride) = *(src_int + 5);
*(dst_int+ 6*int_dst_stride) = *(src_int + 6);
*(dst_int+ 7*int_dst_stride) = *(src_int + 7);
*(dst_int+ 8*int_dst_stride) = *(src_int + 8);
*(dst_int+ 9*int_dst_stride) = *(src_int + 9);
*(dst_int+10*int_dst_stride) = *(src_int + 10);
*(dst_int+11*int_dst_stride) = *(src_int + 11);
*(dst_int+12*int_dst_stride) = *(src_int + 12);
*(dst_int+13*int_dst_stride) = *(src_int + 13);
*(dst_int+14*int_dst_stride) = *(src_int + 14);
*(dst_int+15*int_dst_stride) = *(src_int + 15);
}
/** \brief performs a 6x16 transpose of data in src, and stores it to dst */
#define read_and_transpose16x6(src, src_stride, r8, r9, r10, r11, r12, r13)\
{\
register vec_u8_t r0, r1, r2, r3, r4, r5, r6, r7, r14, r15;\
r0 = vec_vsx_ld(0, src); \
r1 = vec_vsx_ld(src_stride, src); \
r2 = vec_vsx_ld(2*src_stride, src); \
r3 = vec_vsx_ld(3*src_stride, src); \
r4 = vec_vsx_ld(4*src_stride, src); \
r5 = vec_vsx_ld(5*src_stride, src); \
r6 = vec_vsx_ld(6*src_stride, src); \
r7 = vec_vsx_ld(7*src_stride, src); \
r8 = vec_vsx_ld(8*src_stride, src); \
r9 = vec_vsx_ld(9*src_stride, src); \
r10 = vec_vsx_ld(10*src_stride, src); \
r11 = vec_vsx_ld(11*src_stride, src); \
r12 = vec_vsx_ld(12*src_stride, src); \
r13 = vec_vsx_ld(13*src_stride, src); \
r14 = vec_vsx_ld(14*src_stride, src); \
r15 = vec_vsx_ld(15*src_stride, src); \
\
/*Merge first pairs*/ \
r0 = vec_mergeh(r0, r8); /*0, 8*/ \
r1 = vec_mergeh(r1, r9); /*1, 9*/ \
r2 = vec_mergeh(r2, r10); /*2,10*/ \
r3 = vec_mergeh(r3, r11); /*3,11*/ \
r4 = vec_mergeh(r4, r12); /*4,12*/ \
r5 = vec_mergeh(r5, r13); /*5,13*/ \
r6 = vec_mergeh(r6, r14); /*6,14*/ \
r7 = vec_mergeh(r7, r15); /*7,15*/ \
\
/*Merge second pairs*/ \
r8 = vec_mergeh(r0, r4); /*0,4, 8,12 set 0*/ \
r9 = vec_mergel(r0, r4); /*0,4, 8,12 set 1*/ \
r10 = vec_mergeh(r1, r5); /*1,5, 9,13 set 0*/ \
r11 = vec_mergel(r1, r5); /*1,5, 9,13 set 1*/ \
r12 = vec_mergeh(r2, r6); /*2,6,10,14 set 0*/ \
r13 = vec_mergel(r2, r6); /*2,6,10,14 set 1*/ \
r14 = vec_mergeh(r3, r7); /*3,7,11,15 set 0*/ \
r15 = vec_mergel(r3, r7); /*3,7,11,15 set 1*/ \
\
/*Third merge*/ \
r0 = vec_mergeh(r8, r12); /*0,2,4,6,8,10,12,14 set 0*/ \
r1 = vec_mergel(r8, r12); /*0,2,4,6,8,10,12,14 set 1*/ \
r2 = vec_mergeh(r9, r13); /*0,2,4,6,8,10,12,14 set 2*/ \
r4 = vec_mergeh(r10, r14); /*1,3,5,7,9,11,13,15 set 0*/ \
r5 = vec_mergel(r10, r14); /*1,3,5,7,9,11,13,15 set 1*/ \
r6 = vec_mergeh(r11, r15); /*1,3,5,7,9,11,13,15 set 2*/ \
/* Don't need to compute 3 and 7*/ \
\
/*Final merge*/ \
r8 = vec_mergeh(r0, r4); /*all set 0*/ \
r9 = vec_mergel(r0, r4); /*all set 1*/ \
r10 = vec_mergeh(r1, r5); /*all set 2*/ \
r11 = vec_mergel(r1, r5); /*all set 3*/ \
r12 = vec_mergeh(r2, r6); /*all set 4*/ \
r13 = vec_mergel(r2, r6); /*all set 5*/ \
/* Don't need to compute 14 and 15*/ \
\
}
// out: o = |x-y| < a
static inline vec_u8_t diff_lt_altivec( register vec_u8_t x, register vec_u8_t y, register vec_u8_t a )
{
return (vec_u8_t)vec_cmplt(vec_absd(x, y), a);
}
static inline vec_u8_t h264_deblock_mask( register vec_u8_t p0, register vec_u8_t p1, register vec_u8_t q0,
register vec_u8_t q1, register vec_u8_t alpha, register vec_u8_t beta )
{
register vec_u8_t mask;
register vec_u8_t tempmask;
mask = diff_lt_altivec(p0, q0, alpha);
tempmask = diff_lt_altivec(p1, p0, beta);
mask = vec_and(mask, tempmask);
tempmask = diff_lt_altivec(q1, q0, beta);
mask = vec_and(mask, tempmask);
return mask;
}
// out: newp1 = clip((p2 + ((p0 + q0 + 1) >> 1)) >> 1, p1-tc0, p1+tc0)
static inline vec_u8_t h264_deblock_q1( register vec_u8_t p0, register vec_u8_t p1, register vec_u8_t p2,
register vec_u8_t q0, register vec_u8_t tc0 )
{
register vec_u8_t average = vec_avg(p0, q0);
register vec_u8_t temp;
register vec_u8_t uncliped;
register vec_u8_t ones;
register vec_u8_t max;
register vec_u8_t min;
register vec_u8_t newp1;
temp = vec_xor(average, p2);
average = vec_avg(average, p2); /*avg(p2, avg(p0, q0)) */
ones = vec_splat_u8(1);
temp = vec_and(temp, ones); /*(p2^avg(p0, q0)) & 1 */
uncliped = vec_subs(average, temp); /*(p2+((p0+q0+1)>>1))>>1 */
max = vec_adds(p1, tc0);
min = vec_subs(p1, tc0);
newp1 = vec_max(min, uncliped);
newp1 = vec_min(max, newp1);
return newp1;
}
#define h264_deblock_p0_q0(p0, p1, q0, q1, tc0masked) \
{ \
const vec_u8_t A0v = vec_sl(vec_splat_u8(10), vec_splat_u8(4)); \
\
register vec_u8_t pq0bit = vec_xor(p0,q0); \
register vec_u8_t q1minus; \
register vec_u8_t p0minus; \
register vec_u8_t stage1; \
register vec_u8_t stage2; \
register vec_u8_t vec160; \
register vec_u8_t delta; \
register vec_u8_t deltaneg; \
\
q1minus = vec_nor(q1, q1); /* 255 - q1 */ \
stage1 = vec_avg(p1, q1minus); /* (p1 - q1 + 256)>>1 */ \
stage2 = vec_sr(stage1, vec_splat_u8(1)); /* (p1 - q1 + 256)>>2 = 64 + (p1 - q1) >> 2 */ \
p0minus = vec_nor(p0, p0); /* 255 - p0 */ \
stage1 = vec_avg(q0, p0minus); /* (q0 - p0 + 256)>>1 */ \
pq0bit = vec_and(pq0bit, vec_splat_u8(1)); \
stage2 = vec_avg(stage2, pq0bit); /* 32 + ((q0 - p0)&1 + (p1 - q1) >> 2 + 1) >> 1 */\
stage2 = vec_adds(stage2, stage1); /* 160 + ((p0 - q0) + (p1 - q1) >> 2 + 1) >> 1 */ \
vec160 = vec_ld(0, &A0v); \
deltaneg = vec_subs(vec160, stage2); /* -d */ \
delta = vec_subs(stage2, vec160); /* d */ \
deltaneg = vec_min(tc0masked, deltaneg); \
delta = vec_min(tc0masked, delta); \
p0 = vec_subs(p0, deltaneg); \
q0 = vec_subs(q0, delta); \
p0 = vec_adds(p0, delta); \
q0 = vec_adds(q0, deltaneg); \
}
#define h264_loop_filter_luma_altivec(p2, p1, p0, q0, q1, q2, alpha, beta, tc0) \
{ \
ALIGNED_16(unsigned char temp[16]); \
register vec_u8_t alphavec; \
register vec_u8_t betavec; \
register vec_u8_t mask; \
register vec_u8_t p1mask; \
register vec_u8_t q1mask; \
register vec_s8_t tc0vec; \
register vec_u8_t finaltc0; \
register vec_u8_t tc0masked; \
register vec_u8_t newp1; \
register vec_u8_t newq1; \
\
temp[0] = alpha; \
temp[1] = beta; \
alphavec = vec_ld(0, temp); \
betavec = vec_splat(alphavec, 0x1); \
alphavec = vec_splat(alphavec, 0x0); \
mask = h264_deblock_mask(p0, p1, q0, q1, alphavec, betavec); /*if in block */ \
\
M32( temp ) = M32( tc0 ); \
tc0vec = vec_ld(0, (signed char*)temp); \
tc0vec = vec_mergeh(tc0vec, tc0vec); \
tc0vec = vec_mergeh(tc0vec, tc0vec); \
mask = vec_and(mask, vec_cmpgt(tc0vec, vec_splat_s8(-1))); /* if tc0[i] >= 0 */ \
finaltc0 = vec_and((vec_u8_t)tc0vec, mask); /* tc = tc0 */ \
\
p1mask = diff_lt_altivec(p2, p0, betavec); \
p1mask = vec_and(p1mask, mask); /* if( |p2 - p0| < beta ) */ \
tc0masked = vec_and(p1mask, (vec_u8_t)tc0vec); \
finaltc0 = vec_sub(finaltc0, p1mask); /* tc++ */ \
newp1 = h264_deblock_q1(p0, p1, p2, q0, tc0masked); \
/*end if*/ \
\
q1mask = diff_lt_altivec(q2, q0, betavec); \
q1mask = vec_and(q1mask, mask); /* if( |q2 - q0| < beta ) */ \
tc0masked = vec_and(q1mask, (vec_u8_t)tc0vec); \
finaltc0 = vec_sub(finaltc0, q1mask); /* tc++ */ \
newq1 = h264_deblock_q1(p0, q1, q2, q0, tc0masked); \
/*end if*/ \
\
h264_deblock_p0_q0(p0, p1, q0, q1, finaltc0); \
p1 = newp1; \
q1 = newq1; \
}
void x264_deblock_v_luma_altivec( uint8_t *pix, intptr_t stride, int alpha, int beta, int8_t *tc0 )
{
if( (tc0[0] & tc0[1] & tc0[2] & tc0[3]) >= 0 )
{
register vec_u8_t p2 = vec_ld(-3*stride, pix);
register vec_u8_t p1 = vec_ld(-2*stride, pix);
register vec_u8_t p0 = vec_ld(-1*stride, pix);
register vec_u8_t q0 = vec_ld(0, pix);
register vec_u8_t q1 = vec_ld(stride, pix);
register vec_u8_t q2 = vec_ld(2*stride, pix);
h264_loop_filter_luma_altivec(p2, p1, p0, q0, q1, q2, alpha, beta, tc0);
vec_st(p1, -2*stride, pix);
vec_st(p0, -1*stride, pix);
vec_st(q0, 0, pix);
vec_st(q1, stride, pix);
}
}
void x264_deblock_h_luma_altivec( uint8_t *pix, intptr_t stride, int alpha, int beta, int8_t *tc0 )
{
register vec_u8_t line0, line1, line2, line3, line4, line5;
if( (tc0[0] & tc0[1] & tc0[2] & tc0[3]) < 0 )
return;
read_and_transpose16x6(pix-3, stride, line0, line1, line2, line3, line4, line5);
h264_loop_filter_luma_altivec(line0, line1, line2, line3, line4, line5, alpha, beta, tc0);
transpose4x16(line1, line2, line3, line4);
write16x4(pix-2, stride, line1, line2, line3, line4);
}
#endif // !HIGH_BIT_DEPTH

34
common/ppc/deblock.h Normal file
View File

@@ -0,0 +1,34 @@
/*****************************************************************************
* deblock.h: ppc deblocking
*****************************************************************************
* Copyright (C) 2017-2025 x264 project
*
* Authors: Anton Mitrofanov <BugMaster@narod.ru>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*
* This program is also available under a commercial proprietary license.
* For more information, contact us at licensing@x264.com.
*****************************************************************************/
#ifndef X264_PPC_DEBLOCK_H
#define X264_PPC_DEBLOCK_H
#define x264_deblock_v_luma_altivec x264_template(deblock_v_luma_altivec)
void x264_deblock_v_luma_altivec( uint8_t *pix, intptr_t stride, int alpha, int beta, int8_t *tc0 );
#define x264_deblock_h_luma_altivec x264_template(deblock_h_luma_altivec)
void x264_deblock_h_luma_altivec( uint8_t *pix, intptr_t stride, int alpha, int beta, int8_t *tc0 );
#endif

1393
common/ppc/mc.c Normal file
View File

File diff suppressed because it is too large Load Diff

32
common/ppc/mc.h Normal file
View File

@@ -0,0 +1,32 @@
/*****************************************************************************
* mc.h: ppc motion compensation
*****************************************************************************
* Copyright (C) 2003-2025 x264 project
*
* Authors: Eric Petit <eric.petit@lapsus.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*
* This program is also available under a commercial proprietary license.
* For more information, contact us at licensing@x264.com.
*****************************************************************************/
#ifndef X264_PPC_MC_H
#define X264_PPC_MC_H
#define x264_mc_init_altivec x264_template(mc_init_altivec)
void x264_mc_init_altivec( x264_mc_functions_t *pf );
#endif

1635
common/ppc/pixel.c Normal file
View File

File diff suppressed because it is too large Load Diff

32
common/ppc/pixel.h Normal file
View File

@@ -0,0 +1,32 @@
/*****************************************************************************
* pixel.h: ppc pixel metrics
*****************************************************************************
* Copyright (C) 2003-2025 x264 project
*
* Authors: Eric Petit <eric.petit@lapsus.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*
* This program is also available under a commercial proprietary license.
* For more information, contact us at licensing@x264.com.
*****************************************************************************/
#ifndef X264_PPC_PIXEL_H
#define X264_PPC_PIXEL_H
#define x264_pixel_init_altivec x264_template(pixel_init_altivec)
void x264_pixel_init_altivec( x264_pixel_function_t *pixf );
#endif

336
common/ppc/ppccommon.h Normal file
View File

@@ -0,0 +1,336 @@
/*****************************************************************************
* ppccommon.h: ppc utility macros
*****************************************************************************
* Copyright (C) 2003-2025 x264 project
*
* Authors: Eric Petit <eric.petit@lapsus.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*
* This program is also available under a commercial proprietary license.
* For more information, contact us at licensing@x264.com.
*****************************************************************************/
#if HAVE_ALTIVEC_H
#include <altivec.h>
#endif
/***********************************************************************
* For constant vectors, use parentheses on OS X and braces on Linux
**********************************************************************/
#if defined(__APPLE__) && __GNUC__ < 4
#define CV(a...) (a)
#else
#define CV(a...) {a}
#endif
/***********************************************************************
* Vector types
**********************************************************************/
#define vec_u8_t vector unsigned char
#define vec_s8_t vector signed char
#define vec_u16_t vector unsigned short
#define vec_s16_t vector signed short
#define vec_u32_t vector unsigned int
#define vec_s32_t vector signed int
#if HAVE_VSX
#define vec_u64_t vector unsigned long long
#define vec_s64_t vector signed long long
typedef union {
uint64_t s[2];
vec_u64_t v;
} vec_u64_u;
typedef union {
int64_t s[2];
vec_s64_t v;
} vec_s64_u;
#endif
typedef union {
uint32_t s[4];
vec_u32_t v;
} vec_u32_u;
typedef union {
int32_t s[4];
vec_s32_t v;
} vec_s32_u;
typedef union {
uint16_t s[8];
vec_u16_t v;
} vec_u16_u;
typedef union {
int16_t s[8];
vec_s16_t v;
} vec_s16_u;
typedef union {
uint8_t s[16];
vec_u8_t v;
} vec_u8_u;
typedef union {
int8_t s[16];
vec_s8_t v;
} vec_s8_u;
/***********************************************************************
* Null vector
**********************************************************************/
#define LOAD_ZERO const vec_u8_t zerov = vec_splat_u8( 0 )
#define zero_u8v (vec_u8_t) zerov
#define zero_s8v (vec_s8_t) zerov
#define zero_u16v (vec_u16_t) zerov
#define zero_s16v (vec_s16_t) zerov
#define zero_u32v (vec_u32_t) zerov
#define zero_s32v (vec_s32_t) zerov
/***********************************************************************
* 8 <-> 16 bits conversions
**********************************************************************/
#ifdef WORDS_BIGENDIAN
#define vec_u8_to_u16_h(v) (vec_u16_t) vec_mergeh( zero_u8v, (vec_u8_t) v )
#define vec_u8_to_u16_l(v) (vec_u16_t) vec_mergel( zero_u8v, (vec_u8_t) v )
#define vec_u8_to_s16_h(v) (vec_s16_t) vec_mergeh( zero_u8v, (vec_u8_t) v )
#define vec_u8_to_s16_l(v) (vec_s16_t) vec_mergel( zero_u8v, (vec_u8_t) v )
#else
#define vec_u8_to_u16_h(v) (vec_u16_t) vec_mergeh( (vec_u8_t) v, zero_u8v )
#define vec_u8_to_u16_l(v) (vec_u16_t) vec_mergel( (vec_u8_t) v, zero_u8v )
#define vec_u8_to_s16_h(v) (vec_s16_t) vec_mergeh( (vec_u8_t) v, zero_u8v )
#define vec_u8_to_s16_l(v) (vec_s16_t) vec_mergel( (vec_u8_t) v, zero_u8v )
#endif
#define vec_u8_to_u16(v) vec_u8_to_u16_h(v)
#define vec_u8_to_s16(v) vec_u8_to_s16_h(v)
#define vec_u16_to_u8(v) vec_pack( v, zero_u16v )
#define vec_s16_to_u8(v) vec_packsu( v, zero_s16v )
/***********************************************************************
* 16 <-> 32 bits conversions
**********************************************************************/
#ifdef WORDS_BIGENDIAN
#define vec_u16_to_u32_h(v) (vec_u32_t) vec_mergeh( zero_u16v, (vec_u16_t) v )
#define vec_u16_to_u32_l(v) (vec_u32_t) vec_mergel( zero_u16v, (vec_u16_t) v )
#define vec_u16_to_s32_h(v) (vec_s32_t) vec_mergeh( zero_u16v, (vec_u16_t) v )
#define vec_u16_to_s32_l(v) (vec_s32_t) vec_mergel( zero_u16v, (vec_u16_t) v )
#else
#define vec_u16_to_u32_h(v) (vec_u32_t) vec_mergeh( (vec_u16_t) v, zero_u16v )
#define vec_u16_to_u32_l(v) (vec_u32_t) vec_mergel( (vec_u16_t) v, zero_u16v )
#define vec_u16_to_s32_h(v) (vec_s32_t) vec_mergeh( (vec_u16_t) v, zero_u16v )
#define vec_u16_to_s32_l(v) (vec_s32_t) vec_mergel( (vec_u16_t) v, zero_u16v )
#endif
#define vec_u16_to_u32(v) vec_u16_to_u32_h(v)
#define vec_u16_to_s32(v) vec_u16_to_s32_h(v)
#define vec_u32_to_u16(v) vec_pack( v, zero_u32v )
#define vec_s32_to_u16(v) vec_packsu( v, zero_s32v )
/***********************************************************************
* VEC_STORE##n: stores n bytes from vector v to address p
**********************************************************************/
#ifndef __POWER9_VECTOR__
#define VEC_STORE8( v, p ) \
vec_vsx_st( vec_xxpermdi( v, vec_vsx_ld( 0, p ), 1 ), 0, p )
#else
#define VEC_STORE8( v, p ) vec_xst_len( v, p, 8 )
#endif
/***********************************************************************
* VEC_TRANSPOSE_8
***********************************************************************
* Transposes a 8x8 matrix of s16 vectors
**********************************************************************/
#define VEC_TRANSPOSE_8(a0,a1,a2,a3,a4,a5,a6,a7,b0,b1,b2,b3,b4,b5,b6,b7) \
b0 = vec_mergeh( a0, a4 ); \
b1 = vec_mergel( a0, a4 ); \
b2 = vec_mergeh( a1, a5 ); \
b3 = vec_mergel( a1, a5 ); \
b4 = vec_mergeh( a2, a6 ); \
b5 = vec_mergel( a2, a6 ); \
b6 = vec_mergeh( a3, a7 ); \
b7 = vec_mergel( a3, a7 ); \
a0 = vec_mergeh( b0, b4 ); \
a1 = vec_mergel( b0, b4 ); \
a2 = vec_mergeh( b1, b5 ); \
a3 = vec_mergel( b1, b5 ); \
a4 = vec_mergeh( b2, b6 ); \
a5 = vec_mergel( b2, b6 ); \
a6 = vec_mergeh( b3, b7 ); \
a7 = vec_mergel( b3, b7 ); \
b0 = vec_mergeh( a0, a4 ); \
b1 = vec_mergel( a0, a4 ); \
b2 = vec_mergeh( a1, a5 ); \
b3 = vec_mergel( a1, a5 ); \
b4 = vec_mergeh( a2, a6 ); \
b5 = vec_mergel( a2, a6 ); \
b6 = vec_mergeh( a3, a7 ); \
b7 = vec_mergel( a3, a7 )
/***********************************************************************
* VEC_TRANSPOSE_4
***********************************************************************
* Transposes a 4x4 matrix of s16 vectors.
* Actually source and destination are 8x4. The low elements of the
* source are discarded and the low elements of the destination mustn't
* be used.
**********************************************************************/
#define VEC_TRANSPOSE_4(a0,a1,a2,a3,b0,b1,b2,b3) \
b0 = vec_mergeh( a0, a0 ); \
b1 = vec_mergeh( a1, a0 ); \
b2 = vec_mergeh( a2, a0 ); \
b3 = vec_mergeh( a3, a0 ); \
a0 = vec_mergeh( b0, b2 ); \
a1 = vec_mergel( b0, b2 ); \
a2 = vec_mergeh( b1, b3 ); \
a3 = vec_mergel( b1, b3 ); \
b0 = vec_mergeh( a0, a2 ); \
b1 = vec_mergel( a0, a2 ); \
b2 = vec_mergeh( a1, a3 ); \
b3 = vec_mergel( a1, a3 )
/***********************************************************************
* VEC_DIFF_H
***********************************************************************
* p1, p2: u8 *
* i1, i2, n: int
* d: s16v
*
* Loads n bytes from p1 and p2, do the diff of the high elements into
* d, increments p1 and p2 by i1 and i2 into known offset g
**********************************************************************/
#define PREP_DIFF \
LOAD_ZERO; \
vec_s16_t pix1v, pix2v;
#define VEC_DIFF_H(p1,i1,p2,i2,n,d) \
pix1v = vec_vsx_ld( 0, (int16_t *)p1 ); \
pix1v = vec_u8_to_s16( pix1v ); \
pix2v = vec_vsx_ld( 0, (int16_t *)p2 ); \
pix2v = vec_u8_to_s16( pix2v ); \
d = vec_sub( pix1v, pix2v ); \
p1 += i1; \
p2 += i2
/***********************************************************************
* VEC_DIFF_HL
***********************************************************************
* p1, p2: u8 *
* i1, i2: int
* dh, dl: s16v
*
* Loads 16 bytes from p1 and p2, do the diff of the high elements into
* dh, the diff of the low elements into dl, increments p1 and p2 by i1
* and i2
**********************************************************************/
#define VEC_DIFF_HL(p1,i1,p2,i2,dh,dl) \
pix1v = (vec_s16_t)vec_ld(0, p1); \
temp0v = vec_u8_to_s16_h( pix1v ); \
temp1v = vec_u8_to_s16_l( pix1v ); \
pix2v = vec_vsx_ld( 0, (int16_t *)p2 ); \
temp2v = vec_u8_to_s16_h( pix2v ); \
temp3v = vec_u8_to_s16_l( pix2v ); \
dh = vec_sub( temp0v, temp2v ); \
dl = vec_sub( temp1v, temp3v ); \
p1 += i1; \
p2 += i2
/***********************************************************************
* VEC_DIFF_H_8BYTE_ALIGNED
***********************************************************************
* p1, p2: u8 *
* i1, i2, n: int
* d: s16v
*
* Loads n bytes from p1 and p2, do the diff of the high elements into
* d, increments p1 and p2 by i1 and i2
* Slightly faster when we know we are loading/diffing 8bytes which
* are 8 byte aligned. Reduces need for two loads and two vec_lvsl()'s
**********************************************************************/
#define PREP_DIFF_8BYTEALIGNED \
LOAD_ZERO; \
vec_s16_t pix1v, pix2v; \
vec_u8_t pix1v8, pix2v8; \
#define VEC_DIFF_H_8BYTE_ALIGNED(p1,i1,p2,i2,n,d) \
pix1v8 = vec_vsx_ld( 0, p1 ); \
pix2v8 = vec_vsx_ld( 0, p2 ); \
pix1v = vec_u8_to_s16( pix1v8 ); \
pix2v = vec_u8_to_s16( pix2v8 ); \
d = vec_sub( pix1v, pix2v); \
p1 += i1; \
p2 += i2;
#if !HAVE_VSX
#undef vec_vsx_ld
#define vec_vsx_ld(off, src) \
vec_perm(vec_ld(off, src), vec_ld(off + 15, src), vec_lvsl(off, src))
#undef vec_vsx_st
#define vec_vsx_st(v, off, dst) \
do { \
uint8_t *_dst = (uint8_t*)(dst); \
vec_u8_t _v = (vec_u8_t)(v); \
vec_u8_t _a = vec_ld(off, _dst); \
vec_u8_t _b = vec_ld(off + 15, _dst); \
vec_u8_t _e = vec_perm(_b, _a, vec_lvsl(0, _dst)); \
vec_u8_t _m = vec_lvsr(0, _dst); \
\
vec_st(vec_perm(_v, _e, _m), off + 15, _dst); \
vec_st(vec_perm(_e, _v, _m), off, _dst); \
} while( 0 )
#endif
#ifndef __POWER9_VECTOR__
#define vec_absd( a, b ) vec_sub( vec_max( a, b ), vec_min( a, b ) )
#endif
// vec_xxpermdi is quite useful but some version of clang do not expose it
#if !HAVE_VSX || (defined(__clang__) && __clang_major__ < 6)
static const vec_u8_t xxpermdi0_perm = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
0x14, 0x15, 0x16, 0x17 };
static const vec_u8_t xxpermdi1_perm = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
0x06, 0x07, 0x18, 0x19, 0x1A, 0x1B,
0x1C, 0x1D, 0x1E, 0x1F };
static const vec_u8_t xxpermdi2_perm = { 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13,
0x14, 0x15, 0x16, 0x17 };
static const vec_u8_t xxpermdi3_perm = { 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
0x0E, 0x0F, 0x18, 0x19, 0x1A, 0x1B,
0x1C, 0x1D, 0x1E, 0x1F };
#define xxpermdi(a, b, c) vec_perm(a, b, xxpermdi##c##_perm)
#elif (defined(__GNUC__) && (__GNUC__ > 6 || (__GNUC__ == 6 && __GNUC_MINOR__ >= 3))) || \
(defined(__clang__) && __clang_major__ >= 7)
#define xxpermdi(a, b, c) vec_xxpermdi(a, b, c)
#endif
// vec_xxpermdi has its endianness bias exposed in early gcc and clang
#ifdef WORDS_BIGENDIAN
#ifndef xxpermdi
#define xxpermdi(a, b, c) vec_xxpermdi(a, b, c)
#endif
#else
#ifndef xxpermdi
#define xxpermdi(a, b, c) vec_xxpermdi(b, a, ((c >> 1) | (c & 1) << 1) ^ 3)
#endif
#endif

275
common/ppc/predict.c Normal file
View File

@@ -0,0 +1,275 @@
/*****************************************************************************
* predict.c: ppc intra prediction
*****************************************************************************
* Copyright (C) 2007-2025 x264 project
*
* Authors: Guillaume Poirier <gpoirier@mplayerhq.hu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*
* This program is also available under a commercial proprietary license.
* For more information, contact us at licensing@x264.com.
*****************************************************************************/
#include "common/common.h"
#include "ppccommon.h"
#include "predict.h"
#include "pixel.h"
#if !HIGH_BIT_DEPTH
static void predict_8x8c_p_altivec( uint8_t *src )
{
int H = 0, V = 0;
for( int i = 0; i < 4; i++ )
{
H += ( i + 1 ) * ( src[4+i - FDEC_STRIDE] - src[2 - i -FDEC_STRIDE] );
V += ( i + 1 ) * ( src[-1 +(i+4)*FDEC_STRIDE] - src[-1+(2-i)*FDEC_STRIDE] );
}
int a = 16 * ( src[-1+7*FDEC_STRIDE] + src[7 - FDEC_STRIDE] );
int b = ( 17 * H + 16 ) >> 5;
int c = ( 17 * V + 16 ) >> 5;
int i00 = a -3*b -3*c + 16;
vec_s16_u i00_u, b_u, c_u;
i00_u.s[0] = i00;
b_u.s[0] = b;
c_u.s[0] = c;
vec_u16_t val5_v = vec_splat_u16(5);
vec_s16_t i00_v, b_v, c_v;
i00_v = vec_splat(i00_u.v, 0);
b_v = vec_splat(b_u.v, 0);
c_v = vec_splat(c_u.v, 0);
vec_s16_t induc_v = (vec_s16_t) CV(0, 1, 2, 3, 4, 5, 6, 7);
vec_s16_t add_i0_b_0v = vec_mladd(induc_v, b_v, i00_v);
for( int i = 0; i < 8; ++i )
{
vec_s16_t shift_0_v = vec_sra(add_i0_b_0v, val5_v);
vec_u8_t com_sat_v = vec_packsu(shift_0_v, shift_0_v);
VEC_STORE8(com_sat_v, &src[0]);
src += FDEC_STRIDE;
add_i0_b_0v = vec_adds(add_i0_b_0v, c_v);
}
}
/****************************************************************************
* 16x16 prediction for intra luma block
****************************************************************************/
static void predict_16x16_p_altivec( uint8_t *src )
{
int H = 0, V = 0;
for( int i = 1; i <= 8; i++ )
{
H += i * ( src[7+i - FDEC_STRIDE ] - src[7-i - FDEC_STRIDE ] );
V += i * ( src[(7+i)*FDEC_STRIDE -1] - src[(7-i)*FDEC_STRIDE -1] );
}
int a = 16 * ( src[15*FDEC_STRIDE -1] + src[15 - FDEC_STRIDE] );
int b = ( 5 * H + 32 ) >> 6;
int c = ( 5 * V + 32 ) >> 6;
int i00 = a - b * 7 - c * 7 + 16;
vec_s16_u i00_u, b_u, c_u;
i00_u.s[0] = i00;
b_u.s[0] = b;
c_u.s[0] = c;
vec_u16_t val5_v = vec_splat_u16(5);
vec_s16_t i00_v, b_v, c_v;
i00_v = vec_splat(i00_u.v, 0);
b_v = vec_splat(b_u.v, 0);
c_v = vec_splat(c_u.v, 0);
vec_s16_t induc_v = (vec_s16_t) CV(0, 1, 2, 3, 4, 5, 6, 7);
vec_s16_t b8_v = vec_sl(b_v, vec_splat_u16(3));
vec_s16_t add_i0_b_0v = vec_mladd(induc_v, b_v, i00_v);
vec_s16_t add_i0_b_8v = vec_adds(b8_v, add_i0_b_0v);
for( int y = 0; y < 16; y++ )
{
vec_s16_t shift_0_v = vec_sra(add_i0_b_0v, val5_v);
vec_s16_t shift_8_v = vec_sra(add_i0_b_8v, val5_v);
vec_u8_t com_sat_v = vec_packsu(shift_0_v, shift_8_v);
vec_st( com_sat_v, 0, &src[0]);
src += FDEC_STRIDE;
add_i0_b_0v = vec_adds(add_i0_b_0v, c_v);
add_i0_b_8v = vec_adds(add_i0_b_8v, c_v);
}
}
#define PREDICT_16x16_DC_ALTIVEC(v) \
for( int i = 0; i < 16; i += 2) \
{ \
vec_st(v, 0, src); \
vec_st(v, FDEC_STRIDE, src); \
src += FDEC_STRIDE*2; \
}
static void predict_16x16_dc_altivec( uint8_t *src )
{
uint32_t dc = 0;
for( int i = 0; i < 16; i++ )
{
dc += src[-1 + i * FDEC_STRIDE];
dc += src[i - FDEC_STRIDE];
}
vec_u8_u v ; v.s[0] = (( dc + 16 ) >> 5);
vec_u8_t bc_v = vec_splat(v.v, 0);
PREDICT_16x16_DC_ALTIVEC(bc_v);
}
static void predict_16x16_dc_left_altivec( uint8_t *src )
{
uint32_t dc = 0;
for( int i = 0; i < 16; i++ )
dc += src[-1 + i * FDEC_STRIDE];
vec_u8_u v ; v.s[0] = (( dc + 8 ) >> 4);
vec_u8_t bc_v = vec_splat(v.v, 0);
PREDICT_16x16_DC_ALTIVEC(bc_v);
}
static void predict_16x16_dc_top_altivec( uint8_t *src )
{
uint32_t dc = 0;
for( int i = 0; i < 16; i++ )
dc += src[i - FDEC_STRIDE];
vec_u8_u v ; v.s[0] = (( dc + 8 ) >> 4);
vec_u8_t bc_v = vec_splat(v.v, 0);
PREDICT_16x16_DC_ALTIVEC(bc_v);
}
static void predict_16x16_dc_128_altivec( uint8_t *src )
{
/* test if generating the constant is faster than loading it.
vector unsigned int bc_v = (vector unsigned int)CV(0x80808080, 0x80808080, 0x80808080, 0x80808080);
*/
vec_u8_t bc_v = vec_vslb((vec_u8_t)vec_splat_u8(1),(vec_u8_t)vec_splat_u8(7));
PREDICT_16x16_DC_ALTIVEC(bc_v);
}
static void predict_16x16_h_altivec( uint8_t *src )
{
vec_u8_t v1 = vec_ld( -1, src );
vec_u8_t v2 = vec_ld( -1, src + FDEC_STRIDE );
vec_u8_t v3 = vec_ld( -1, src + FDEC_STRIDE * 2 );
vec_u8_t v4 = vec_ld( -1, src + FDEC_STRIDE * 3 );
vec_u8_t v5 = vec_ld( -1, src + FDEC_STRIDE * 4 );
vec_u8_t v6 = vec_ld( -1, src + FDEC_STRIDE * 5 );
vec_u8_t v7 = vec_ld( -1, src + FDEC_STRIDE * 6 );
vec_u8_t v8 = vec_ld( -1, src + FDEC_STRIDE * 7 );
vec_u8_t v9 = vec_ld( -1, src + FDEC_STRIDE * 8 );
vec_u8_t vA = vec_ld( -1, src + FDEC_STRIDE * 9 );
vec_u8_t vB = vec_ld( -1, src + FDEC_STRIDE * 10 );
vec_u8_t vC = vec_ld( -1, src + FDEC_STRIDE * 11 );
vec_u8_t vD = vec_ld( -1, src + FDEC_STRIDE * 12 );
vec_u8_t vE = vec_ld( -1, src + FDEC_STRIDE * 13 );
vec_u8_t vF = vec_ld( -1, src + FDEC_STRIDE * 14 );
vec_u8_t vG = vec_ld( -1, src + FDEC_STRIDE * 15 );
vec_u8_t v_v1 = vec_splat( v1, 15 );
vec_u8_t v_v2 = vec_splat( v2, 15 );
vec_u8_t v_v3 = vec_splat( v3, 15 );
vec_u8_t v_v4 = vec_splat( v4, 15 );
vec_u8_t v_v5 = vec_splat( v5, 15 );
vec_u8_t v_v6 = vec_splat( v6, 15 );
vec_u8_t v_v7 = vec_splat( v7, 15 );
vec_u8_t v_v8 = vec_splat( v8, 15 );
vec_u8_t v_v9 = vec_splat( v9, 15 );
vec_u8_t v_vA = vec_splat( vA, 15 );
vec_u8_t v_vB = vec_splat( vB, 15 );
vec_u8_t v_vC = vec_splat( vC, 15 );
vec_u8_t v_vD = vec_splat( vD, 15 );
vec_u8_t v_vE = vec_splat( vE, 15 );
vec_u8_t v_vF = vec_splat( vF, 15 );
vec_u8_t v_vG = vec_splat( vG, 15 );
vec_st( v_v1, 0, src );
vec_st( v_v2, 0, src + FDEC_STRIDE );
vec_st( v_v3, 0, src + FDEC_STRIDE * 2 );
vec_st( v_v4, 0, src + FDEC_STRIDE * 3 );
vec_st( v_v5, 0, src + FDEC_STRIDE * 4 );
vec_st( v_v6, 0, src + FDEC_STRIDE * 5 );
vec_st( v_v7, 0, src + FDEC_STRIDE * 6 );
vec_st( v_v8, 0, src + FDEC_STRIDE * 7 );
vec_st( v_v9, 0, src + FDEC_STRIDE * 8 );
vec_st( v_vA, 0, src + FDEC_STRIDE * 9 );
vec_st( v_vB, 0, src + FDEC_STRIDE * 10 );
vec_st( v_vC, 0, src + FDEC_STRIDE * 11 );
vec_st( v_vD, 0, src + FDEC_STRIDE * 12 );
vec_st( v_vE, 0, src + FDEC_STRIDE * 13 );
vec_st( v_vF, 0, src + FDEC_STRIDE * 14 );
vec_st( v_vG, 0, src + FDEC_STRIDE * 15 );
}
static void predict_16x16_v_altivec( uint8_t *src )
{
vec_u32_u v;
v.s[0] = *(uint32_t*)&src[ 0-FDEC_STRIDE];
v.s[1] = *(uint32_t*)&src[ 4-FDEC_STRIDE];
v.s[2] = *(uint32_t*)&src[ 8-FDEC_STRIDE];
v.s[3] = *(uint32_t*)&src[12-FDEC_STRIDE];
for( int i = 0; i < 16; i++ )
{
vec_st(v.v, 0, (uint32_t*)src);
src += FDEC_STRIDE;
}
}
#endif // !HIGH_BIT_DEPTH
/****************************************************************************
* Exported functions:
****************************************************************************/
void x264_predict_16x16_init_altivec( x264_predict_t pf[7] )
{
#if !HIGH_BIT_DEPTH
pf[I_PRED_16x16_V ] = predict_16x16_v_altivec;
pf[I_PRED_16x16_H ] = predict_16x16_h_altivec;
pf[I_PRED_16x16_DC] = predict_16x16_dc_altivec;
pf[I_PRED_16x16_P ] = predict_16x16_p_altivec;
pf[I_PRED_16x16_DC_LEFT] = predict_16x16_dc_left_altivec;
pf[I_PRED_16x16_DC_TOP ] = predict_16x16_dc_top_altivec;
pf[I_PRED_16x16_DC_128 ] = predict_16x16_dc_128_altivec;
#endif // !HIGH_BIT_DEPTH
}
void x264_predict_8x8c_init_altivec( x264_predict_t pf[7] )
{
#if !HIGH_BIT_DEPTH
pf[I_PRED_CHROMA_P] = predict_8x8c_p_altivec;
#endif // !HIGH_BIT_DEPTH
}

34
common/ppc/predict.h Normal file
View File

@@ -0,0 +1,34 @@
/*****************************************************************************
* predict.h: ppc intra prediction
*****************************************************************************
* Copyright (C) 2007-2025 x264 project
*
* Authors: Guillaume Poirier <gpoirier@mplayerhq.hu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*
* This program is also available under a commercial proprietary license.
* For more information, contact us at licensing@x264.com.
*****************************************************************************/
#ifndef X264_PPC_PREDICT_H
#define X264_PPC_PREDICT_H
#define x264_predict_16x16_init_altivec x264_template(predict_16x16_init_altivec)
void x264_predict_16x16_init_altivec( x264_predict_t pf[7] );
#define x264_predict_8x8c_init_altivec x264_template(predict_8x8c_init_altivec)
void x264_predict_8x8c_init_altivec( x264_predict_t pf[7] );
#endif /* X264_PPC_PREDICT_H */

547
common/ppc/quant.c Normal file
View File

@@ -0,0 +1,547 @@
/*****************************************************************************
* quant.c: ppc quantization
*****************************************************************************
* Copyright (C) 2007-2025 x264 project
*
* Authors: Guillaume Poirier <gpoirier@mplayerhq.hu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*
* This program is also available under a commercial proprietary license.
* For more information, contact us at licensing@x264.com.
*****************************************************************************/
#include "common/common.h"
#include "ppccommon.h"
#include "quant.h"
#if !HIGH_BIT_DEPTH
// quant of a whole 4x4 block, unrolled 2x and "pre-scheduled"
#define QUANT_16_U( idx0, idx1 ) \
{ \
temp1v = vec_ld((idx0), dct); \
temp2v = vec_ld((idx1), dct); \
mfvA = vec_ld((idx0), mf); \
mfvB = vec_ld((idx1), mf); \
biasvA = vec_ld((idx0), bias); \
biasvB = vec_ld((idx1), bias); \
mskA = vec_cmplt(temp1v, zero_s16v); \
mskB = vec_cmplt(temp2v, zero_s16v); \
coefvA = (vec_u16_t)vec_abs( temp1v ); \
coefvB = (vec_u16_t)vec_abs( temp2v ); \
coefvA = vec_adds(coefvA, biasvA); \
coefvB = vec_adds(coefvB, biasvB); \
multEvenvA = vec_mule(coefvA, mfvA); \
multOddvA = vec_mulo(coefvA, mfvA); \
multEvenvB = vec_mule(coefvB, mfvB); \
multOddvB = vec_mulo(coefvB, mfvB); \
multEvenvA = vec_sr(multEvenvA, i_qbitsv); \
multOddvA = vec_sr(multOddvA, i_qbitsv); \
multEvenvB = vec_sr(multEvenvB, i_qbitsv); \
multOddvB = vec_sr(multOddvB, i_qbitsv); \
temp1v = (vec_s16_t) vec_packs( multEvenvA, multOddvA ); \
tmpv = xxpermdi( temp1v, temp1v, 2 ); \
temp1v = vec_mergeh( temp1v, tmpv ); \
temp2v = (vec_s16_t) vec_packs( multEvenvB, multOddvB ); \
tmpv = xxpermdi( temp2v, temp2v, 2 ); \
temp2v = vec_mergeh( temp2v, tmpv ); \
temp1v = vec_xor(temp1v, mskA); \
temp2v = vec_xor(temp2v, mskB); \
temp1v = vec_adds(temp1v, vec_and(mskA, one)); \
vec_st(temp1v, (idx0), dct); \
temp2v = vec_adds(temp2v, vec_and(mskB, one)); \
nz = vec_or(nz, vec_or(temp1v, temp2v)); \
vec_st(temp2v, (idx1), dct); \
}
int x264_quant_4x4_altivec( int16_t dct[16], uint16_t mf[16], uint16_t bias[16] )
{
LOAD_ZERO;
vector bool short mskA;
vec_u32_t i_qbitsv = vec_splats( (uint32_t)16 );
vec_u16_t coefvA;
vec_u32_t multEvenvA, multOddvA;
vec_u16_t mfvA;
vec_u16_t biasvA;
vec_s16_t one = vec_splat_s16(1);
vec_s16_t nz = zero_s16v;
vector bool short mskB;
vec_u16_t coefvB;
vec_u32_t multEvenvB, multOddvB;
vec_u16_t mfvB;
vec_u16_t biasvB;
vec_s16_t temp1v, temp2v, tmpv;
QUANT_16_U( 0, 16 );
return vec_any_ne(nz, zero_s16v);
}
int x264_quant_4x4x4_altivec( dctcoef dcta[4][16], udctcoef mf[16], udctcoef bias[16] )
{
LOAD_ZERO;
vec_u32_t i_qbitsv = vec_splats( (uint32_t)16 );
vec_s16_t one = vec_splat_s16( 1 );
vec_s16_t nz0, nz1, nz2, nz3;
vector bool short mskA0;
vec_u16_t coefvA0;
vec_u32_t multEvenvA0, multOddvA0;
vec_u16_t mfvA0;
vec_u16_t biasvA0;
vector bool short mskB0;
vec_u16_t coefvB0;
vec_u32_t multEvenvB0, multOddvB0;
vec_u16_t mfvB0;
vec_u16_t biasvB0;
vector bool short mskA1;
vec_u16_t coefvA1;
vec_u32_t multEvenvA1, multOddvA1;
vec_u16_t mfvA1;
vec_u16_t biasvA1;
vector bool short mskB1;
vec_u16_t coefvB1;
vec_u32_t multEvenvB1, multOddvB1;
vec_u16_t mfvB1;
vec_u16_t biasvB1;
vector bool short mskA2;
vec_u16_t coefvA2;
vec_u32_t multEvenvA2, multOddvA2;
vec_u16_t mfvA2;
vec_u16_t biasvA2;
vector bool short mskB2;
vec_u16_t coefvB2;
vec_u32_t multEvenvB2, multOddvB2;
vec_u16_t mfvB2;
vec_u16_t biasvB2;
vector bool short mskA3;
vec_u16_t coefvA3;
vec_u32_t multEvenvA3, multOddvA3;
vec_u16_t mfvA3;
vec_u16_t biasvA3;
vector bool short mskB3;
vec_u16_t coefvB3;
vec_u32_t multEvenvB3, multOddvB3;
vec_u16_t mfvB3;
vec_u16_t biasvB3;
vec_s16_t temp1v, temp2v;
vec_s16_t tmpv0;
vec_s16_t tmpv1;
dctcoef *dct0 = dcta[0];
dctcoef *dct1 = dcta[1];
dctcoef *dct2 = dcta[2];
dctcoef *dct3 = dcta[3];
temp1v = vec_ld( 0, dct0 );
temp2v = vec_ld( 16, dct0 );
mfvA0 = vec_ld( 0, mf );
mfvB0 = vec_ld( 16, mf );
biasvA0 = vec_ld( 0, bias );
biasvB0 = vec_ld( 16, bias );
mskA0 = vec_cmplt( temp1v, zero_s16v );
mskB0 = vec_cmplt( temp2v, zero_s16v );
coefvA0 = (vec_u16_t)vec_abs( temp1v );
coefvB0 = (vec_u16_t)vec_abs( temp2v );
temp1v = vec_ld( 0, dct1 );
temp2v = vec_ld( 16, dct1 );
mfvA1 = vec_ld( 0, mf );
mfvB1 = vec_ld( 16, mf );
biasvA1 = vec_ld( 0, bias );
biasvB1 = vec_ld( 16, bias );
mskA1 = vec_cmplt( temp1v, zero_s16v );
mskB1 = vec_cmplt( temp2v, zero_s16v );
coefvA1 = (vec_u16_t)vec_abs( temp1v );
coefvB1 = (vec_u16_t)vec_abs( temp2v );
temp1v = vec_ld( 0, dct2 );
temp2v = vec_ld( 16, dct2 );
mfvA2 = vec_ld( 0, mf );
mfvB2 = vec_ld( 16, mf );
biasvA2 = vec_ld( 0, bias );
biasvB2 = vec_ld( 16, bias );
mskA2 = vec_cmplt( temp1v, zero_s16v );
mskB2 = vec_cmplt( temp2v, zero_s16v );
coefvA2 = (vec_u16_t)vec_abs( temp1v );
coefvB2 = (vec_u16_t)vec_abs( temp2v );
temp1v = vec_ld( 0, dct3 );
temp2v = vec_ld( 16, dct3 );
mfvA3 = vec_ld( 0, mf );
mfvB3 = vec_ld( 16, mf );
biasvA3 = vec_ld( 0, bias );
biasvB3 = vec_ld( 16, bias );
mskA3 = vec_cmplt( temp1v, zero_s16v );
mskB3 = vec_cmplt( temp2v, zero_s16v );
coefvA3 = (vec_u16_t)vec_abs( temp1v );
coefvB3 = (vec_u16_t)vec_abs( temp2v );
coefvA0 = vec_adds( coefvA0, biasvA0 );
coefvB0 = vec_adds( coefvB0, biasvB0 );
coefvA1 = vec_adds( coefvA1, biasvA1 );
coefvB1 = vec_adds( coefvB1, biasvB1 );
coefvA2 = vec_adds( coefvA2, biasvA2 );
coefvB2 = vec_adds( coefvB2, biasvB2 );
coefvA3 = vec_adds( coefvA3, biasvA3 );
coefvB3 = vec_adds( coefvB3, biasvB3 );
multEvenvA0 = vec_mule( coefvA0, mfvA0 );
multOddvA0 = vec_mulo( coefvA0, mfvA0 );
multEvenvB0 = vec_mule( coefvB0, mfvB0 );
multOddvB0 = vec_mulo( coefvB0, mfvB0 );
multEvenvA0 = vec_sr( multEvenvA0, i_qbitsv );
multOddvA0 = vec_sr( multOddvA0, i_qbitsv );
multEvenvB0 = vec_sr( multEvenvB0, i_qbitsv );
multOddvB0 = vec_sr( multOddvB0, i_qbitsv );
temp1v = (vec_s16_t)vec_packs( multEvenvA0, multOddvA0 );
temp2v = (vec_s16_t)vec_packs( multEvenvB0, multOddvB0 );
tmpv0 = xxpermdi( temp1v, temp1v, 2 );
tmpv1 = xxpermdi( temp2v, temp2v, 2 );
temp1v = vec_mergeh( temp1v, tmpv0 );
temp2v = vec_mergeh( temp2v, tmpv1 );
temp1v = vec_xor( temp1v, mskA0 );
temp2v = vec_xor( temp2v, mskB0 );
temp1v = vec_adds( temp1v, vec_and( mskA0, one ) );
temp2v = vec_adds( temp2v, vec_and( mskB0, one ) );
vec_st( temp1v, 0, dct0 );
vec_st( temp2v, 16, dct0 );
nz0 = vec_or( temp1v, temp2v );
multEvenvA1 = vec_mule( coefvA1, mfvA1 );
multOddvA1 = vec_mulo( coefvA1, mfvA1 );
multEvenvB1 = vec_mule( coefvB1, mfvB1 );
multOddvB1 = vec_mulo( coefvB1, mfvB1 );
multEvenvA1 = vec_sr( multEvenvA1, i_qbitsv );
multOddvA1 = vec_sr( multOddvA1, i_qbitsv );
multEvenvB1 = vec_sr( multEvenvB1, i_qbitsv );
multOddvB1 = vec_sr( multOddvB1, i_qbitsv );
temp1v = (vec_s16_t)vec_packs( multEvenvA1, multOddvA1 );
temp2v = (vec_s16_t)vec_packs( multEvenvB1, multOddvB1 );
tmpv0 = xxpermdi( temp1v, temp1v, 2 );
tmpv1 = xxpermdi( temp2v, temp2v, 2 );
temp1v = vec_mergeh( temp1v, tmpv0 );
temp2v = vec_mergeh( temp2v, tmpv1 );
temp1v = vec_xor( temp1v, mskA1 );
temp2v = vec_xor( temp2v, mskB1 );
temp1v = vec_adds( temp1v, vec_and( mskA1, one ) );
temp2v = vec_adds( temp2v, vec_and( mskB1, one ) );
vec_st( temp1v, 0, dct1 );
vec_st( temp2v, 16, dct1 );
nz1 = vec_or( temp1v, temp2v );
multEvenvA2 = vec_mule( coefvA2, mfvA2 );
multOddvA2 = vec_mulo( coefvA2, mfvA2 );
multEvenvB2 = vec_mule( coefvB2, mfvB2 );
multOddvB2 = vec_mulo( coefvB2, mfvB2 );
multEvenvA2 = vec_sr( multEvenvA2, i_qbitsv );
multOddvA2 = vec_sr( multOddvA2, i_qbitsv );
multEvenvB2 = vec_sr( multEvenvB2, i_qbitsv );
multOddvB2 = vec_sr( multOddvB2, i_qbitsv );
temp1v = (vec_s16_t)vec_packs( multEvenvA2, multOddvA2 );
temp2v = (vec_s16_t)vec_packs( multEvenvB2, multOddvB2 );
tmpv0 = xxpermdi( temp1v, temp1v, 2 );
tmpv1 = xxpermdi( temp2v, temp2v, 2 );
temp1v = vec_mergeh( temp1v, tmpv0 );
temp2v = vec_mergeh( temp2v, tmpv1 );
temp1v = vec_xor( temp1v, mskA2 );
temp2v = vec_xor( temp2v, mskB2 );
temp1v = vec_adds( temp1v, vec_and( mskA2, one ) );
temp2v = vec_adds( temp2v, vec_and( mskB2, one ) );
vec_st( temp1v, 0, dct2 );
vec_st( temp2v, 16, dct2 );
nz2 = vec_or( temp1v, temp2v );
multEvenvA3 = vec_mule( coefvA3, mfvA3 );
multOddvA3 = vec_mulo( coefvA3, mfvA3 );
multEvenvB3 = vec_mule( coefvB3, mfvB3 );
multOddvB3 = vec_mulo( coefvB3, mfvB3 );
multEvenvA3 = vec_sr( multEvenvA3, i_qbitsv );
multOddvA3 = vec_sr( multOddvA3, i_qbitsv );
multEvenvB3 = vec_sr( multEvenvB3, i_qbitsv );
multOddvB3 = vec_sr( multOddvB3, i_qbitsv );
temp1v = (vec_s16_t)vec_packs( multEvenvA3, multOddvA3 );
temp2v = (vec_s16_t)vec_packs( multEvenvB3, multOddvB3 );
tmpv0 = xxpermdi( temp1v, temp1v, 2 );
tmpv1 = xxpermdi( temp2v, temp2v, 2 );
temp1v = vec_mergeh( temp1v, tmpv0 );
temp2v = vec_mergeh( temp2v, tmpv1 );
temp1v = vec_xor( temp1v, mskA3 );
temp2v = vec_xor( temp2v, mskB3 );
temp1v = vec_adds( temp1v, vec_and( mskA3, one ) );
temp2v = vec_adds( temp2v, vec_and( mskB3, one ) );
vec_st( temp1v, 0, dct3 );
vec_st( temp2v, 16, dct3 );
nz3 = vec_or( temp1v, temp2v );
return (vec_any_ne( nz0, zero_s16v ) << 0) | (vec_any_ne( nz1, zero_s16v ) << 1) |
(vec_any_ne( nz2, zero_s16v ) << 2) | (vec_any_ne( nz3, zero_s16v ) << 3);
}
// DC quant of a whole 4x4 block, unrolled 2x and "pre-scheduled"
#define QUANT_16_U_DC( idx0, idx1 ) \
{ \
temp1v = vec_ld((idx0), dct); \
temp2v = vec_ld((idx1), dct); \
mskA = vec_cmplt(temp1v, zero_s16v); \
mskB = vec_cmplt(temp2v, zero_s16v); \
coefvA = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp1v), temp1v);\
coefvB = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp2v), temp2v);\
coefvA = vec_add(coefvA, biasv); \
coefvB = vec_add(coefvB, biasv); \
multEvenvA = vec_mule(coefvA, mfv); \
multOddvA = vec_mulo(coefvA, mfv); \
multEvenvB = vec_mule(coefvB, mfv); \
multOddvB = vec_mulo(coefvB, mfv); \
multEvenvA = vec_sr(multEvenvA, i_qbitsv); \
multOddvA = vec_sr(multOddvA, i_qbitsv); \
multEvenvB = vec_sr(multEvenvB, i_qbitsv); \
multOddvB = vec_sr(multOddvB, i_qbitsv); \
temp1v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA), vec_mergel(multEvenvA, multOddvA)); \
temp2v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvB, multOddvB), vec_mergel(multEvenvB, multOddvB)); \
temp1v = vec_xor(temp1v, mskA); \
temp2v = vec_xor(temp2v, mskB); \
temp1v = vec_add(temp1v, vec_and(mskA, one)); \
vec_st(temp1v, (idx0), dct); \
temp2v = vec_add(temp2v, vec_and(mskB, one)); \
nz = vec_or(nz, vec_or(temp1v, temp2v)); \
vec_st(temp2v, (idx1), dct); \
}
int x264_quant_4x4_dc_altivec( int16_t dct[16], int mf, int bias )
{
LOAD_ZERO;
vector bool short mskA;
vec_u32_t i_qbitsv;
vec_u16_t coefvA;
vec_u32_t multEvenvA, multOddvA;
vec_s16_t one = vec_splat_s16(1);
vec_s16_t nz = zero_s16v;
vector bool short mskB;
vec_u16_t coefvB;
vec_u32_t multEvenvB, multOddvB;
vec_s16_t temp1v, temp2v;
vec_u16_t mfv;
vec_u16_t biasv;
mfv = vec_splats( (uint16_t)mf );
i_qbitsv = vec_splats( (uint32_t) 16 );
biasv = vec_splats( (uint16_t)bias );
QUANT_16_U_DC( 0, 16 );
return vec_any_ne(nz, zero_s16v);
}
// DC quant of a whole 2x2 block
#define QUANT_4_U_DC( idx0 ) \
{ \
const vec_u16_t sel = (vec_u16_t) CV(-1,-1,-1,-1,0,0,0,0); \
temp1v = vec_ld((idx0), dct); \
mskA = vec_cmplt(temp1v, zero_s16v); \
coefvA = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp1v), temp1v);\
coefvA = vec_add(coefvA, biasv); \
multEvenvA = vec_mule(coefvA, mfv); \
multOddvA = vec_mulo(coefvA, mfv); \
multEvenvA = vec_sr(multEvenvA, i_qbitsv); \
multOddvA = vec_sr(multOddvA, i_qbitsv); \
temp2v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA), vec_mergel(multEvenvA, multOddvA)); \
temp2v = vec_xor(temp2v, mskA); \
temp2v = vec_add(temp2v, vec_and(mskA, one)); \
temp1v = vec_sel(temp1v, temp2v, sel); \
nz = vec_or(nz, temp1v); \
vec_st(temp1v, (idx0), dct); \
}
int x264_quant_2x2_dc_altivec( int16_t dct[4], int mf, int bias )
{
LOAD_ZERO;
vector bool short mskA;
vec_u32_t i_qbitsv;
vec_u16_t coefvA;
vec_u32_t multEvenvA, multOddvA;
vec_s16_t one = vec_splat_s16(1);
vec_s16_t nz = zero_s16v;
static const vec_s16_t mask2 = CV(-1, -1, -1, -1, 0, 0, 0, 0);
vec_s16_t temp1v, temp2v;
vec_u16_t mfv;
vec_u16_t biasv;
mfv = vec_splats( (uint16_t)mf );
i_qbitsv = vec_splats( (uint32_t) 16 );
biasv = vec_splats( (uint16_t)bias );
QUANT_4_U_DC(0);
return vec_any_ne(vec_and(nz, mask2), zero_s16v);
}
int x264_quant_8x8_altivec( int16_t dct[64], uint16_t mf[64], uint16_t bias[64] )
{
LOAD_ZERO;
vector bool short mskA;
vec_u32_t i_qbitsv;
vec_u16_t coefvA;
vec_u32_t multEvenvA, multOddvA;
vec_u16_t mfvA;
vec_u16_t biasvA;
vec_s16_t one = vec_splat_s16(1);
vec_s16_t nz = zero_s16v;
vector bool short mskB;
vec_u16_t coefvB;
vec_u32_t multEvenvB, multOddvB;
vec_u16_t mfvB;
vec_u16_t biasvB;
vec_s16_t temp1v, temp2v, tmpv;
i_qbitsv = vec_splats( (uint32_t)16 );
for( int i = 0; i < 4; i++ )
QUANT_16_U( i*2*16, i*2*16+16 );
return vec_any_ne(nz, zero_s16v);
}
#define DEQUANT_SHL() \
{ \
dctv = vec_ld(8*y, dct); \
mf1v = vec_ld(16*y, dequant_mf[i_mf]); \
mf2v = vec_ld(16+16*y, dequant_mf[i_mf]); \
mfv = vec_packs(mf1v, mf2v); \
\
multEvenvA = vec_mule(dctv, mfv); \
multOddvA = vec_mulo(dctv, mfv); \
dctv = (vec_s16_t) vec_packs( multEvenvA, multOddvA ); \
tmpv = xxpermdi( dctv, dctv, 2 ); \
dctv = vec_mergeh( dctv, tmpv ); \
dctv = vec_sl(dctv, i_qbitsv); \
vec_st(dctv, 8*y, dct); \
}
#ifdef WORDS_BIGENDIAN
#define VEC_MULE vec_mule
#define VEC_MULO vec_mulo
#else
#define VEC_MULE vec_mulo
#define VEC_MULO vec_mule
#endif
#define DEQUANT_SHR() \
{ \
dctv = vec_ld(8*y, dct); \
dct1v = vec_mergeh(dctv, dctv); \
dct2v = vec_mergel(dctv, dctv); \
mf1v = vec_ld(16*y, dequant_mf[i_mf]); \
mf2v = vec_ld(16+16*y, dequant_mf[i_mf]); \
\
multEvenvA = VEC_MULE(dct1v, (vec_s16_t)mf1v); \
multOddvA = VEC_MULO(dct1v, (vec_s16_t)mf1v); \
temp1v = vec_add(vec_sl(multEvenvA, sixteenv), multOddvA); \
temp1v = vec_add(temp1v, fv); \
temp1v = vec_sra(temp1v, i_qbitsv); \
\
multEvenvA = VEC_MULE(dct2v, (vec_s16_t)mf2v); \
multOddvA = VEC_MULO(dct2v, (vec_s16_t)mf2v); \
temp2v = vec_add(vec_sl(multEvenvA, sixteenv), multOddvA); \
temp2v = vec_add(temp2v, fv); \
temp2v = vec_sra(temp2v, i_qbitsv); \
\
dctv = (vec_s16_t)vec_packs(temp1v, temp2v); \
vec_st(dctv, y*8, dct); \
}
void x264_dequant_4x4_altivec( int16_t dct[16], int dequant_mf[6][16], int i_qp )
{
int i_mf = i_qp%6;
int i_qbits = i_qp/6 - 4;
vec_s16_t dctv, tmpv;
vec_s16_t dct1v, dct2v;
vec_s32_t mf1v, mf2v;
vec_s16_t mfv;
vec_s32_t multEvenvA, multOddvA;
vec_s32_t temp1v, temp2v;
if( i_qbits >= 0 )
{
vec_u16_t i_qbitsv;
i_qbitsv = vec_splats( (uint16_t) i_qbits );
for( int y = 0; y < 4; y+=2 )
DEQUANT_SHL();
}
else
{
const int f = 1 << (-i_qbits-1);
vec_s32_t fv;
fv = vec_splats( f );
vec_u32_t i_qbitsv;
i_qbitsv = vec_splats( (uint32_t)-i_qbits );
vec_u32_t sixteenv;
sixteenv = vec_splats( (uint32_t)16 );
for( int y = 0; y < 4; y+=2 )
DEQUANT_SHR();
}
}
void x264_dequant_8x8_altivec( int16_t dct[64], int dequant_mf[6][64], int i_qp )
{
int i_mf = i_qp%6;
int i_qbits = i_qp/6 - 6;
vec_s16_t dctv, tmpv;
vec_s16_t dct1v, dct2v;
vec_s32_t mf1v, mf2v;
vec_s16_t mfv;
vec_s32_t multEvenvA, multOddvA;
vec_s32_t temp1v, temp2v;
if( i_qbits >= 0 )
{
vec_u16_t i_qbitsv;
i_qbitsv = vec_splats((uint16_t)i_qbits );
for( int y = 0; y < 16; y+=2 )
DEQUANT_SHL();
}
else
{
const int f = 1 << (-i_qbits-1);
vec_s32_t fv;
fv = vec_splats( f );
vec_u32_t i_qbitsv;
i_qbitsv = vec_splats( (uint32_t)-i_qbits );
vec_u32_t sixteenv;
sixteenv = vec_splats( (uint32_t)16 );
for( int y = 0; y < 16; y+=2 )
DEQUANT_SHR();
}
}
#endif // !HIGH_BIT_DEPTH

46
common/ppc/quant.h Normal file
View File

@@ -0,0 +1,46 @@
/*****************************************************************************
* quant.h: ppc quantization
*****************************************************************************
* Copyright (C) 2007-2025 x264 project
*
* Authors: Guillaume Poirier <gpoirier@mplayerhq.hu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
*
* This program is also available under a commercial proprietary license.
* For more information, contact us at licensing@x264.com.
*****************************************************************************/
#ifndef X264_PPC_QUANT_H
#define X264_PPC_QUANT_H
#define x264_quant_4x4x4_altivec x264_template(quant_4x4x4_altivec)
int x264_quant_4x4x4_altivec( int16_t dct[4][16], uint16_t mf[16], uint16_t bias[16] );
#define x264_quant_4x4_altivec x264_template(quant_4x4_altivec)
int x264_quant_4x4_altivec( int16_t dct[16], uint16_t mf[16], uint16_t bias[16] );
#define x264_quant_8x8_altivec x264_template(quant_8x8_altivec)
int x264_quant_8x8_altivec( int16_t dct[64], uint16_t mf[64], uint16_t bias[64] );
#define x264_quant_4x4_dc_altivec x264_template(quant_4x4_dc_altivec)
int x264_quant_4x4_dc_altivec( int16_t dct[16], int mf, int bias );
#define x264_quant_2x2_dc_altivec x264_template(quant_2x2_dc_altivec)
int x264_quant_2x2_dc_altivec( int16_t dct[4], int mf, int bias );
#define x264_dequant_4x4_altivec x264_template(dequant_4x4_altivec)
void x264_dequant_4x4_altivec( int16_t dct[16], int dequant_mf[6][16], int i_qp );
#define x264_dequant_8x8_altivec x264_template(dequant_8x8_altivec)
void x264_dequant_8x8_altivec( int16_t dct[64], int dequant_mf[6][64], int i_qp );
#endif