/***************************************************************************** * ppccommon.h: h264 encoder ***************************************************************************** * Copyright (C) 2003 Laurent Aimar * $Id: ppccommon.h,v 1.1 2004/06/03 19:27:07 fenrir Exp $ * * Authors: Eric Petit * * 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., 59 Temple Place - Suite 330, Boston, MA 02111, USA. *****************************************************************************/ /*********************************************************************** * For constant vectors, use parentheses on OS X and braces on Linux **********************************************************************/ #ifdef SYS_MACOSX #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 typedef union { unsigned int s[4]; vector unsigned int v; } vect_int_u; typedef union { unsigned short s[8]; vector unsigned short v; } vect_ushort_u; typedef union { signed short s[8]; vector signed short v; } vect_sshort_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 **********************************************************************/ #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 ) #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 ) /*********************************************************************** * PREP_LOAD: declares two vectors required to perform unaligned loads * VEC_LOAD: loads n bytes from u8 * p into vector v of type t **********************************************************************/ #define PREP_LOAD \ vec_u8_t _hv, _lv #define VEC_LOAD( p, v, n, t ) \ _hv = vec_ld( 0, p ); \ v = (t) vec_lvsl( 0, p ); \ _lv = vec_ld( n - 1, p ); \ v = (t) vec_perm( _hv, _lv, (vec_u8_t) v ) /*********************************************************************** * PREP_STORE##n: declares required vectors to store n bytes to a * potentially unaligned address * VEC_STORE##n: stores n bytes from vector v to address p **********************************************************************/ #define PREP_STORE16 \ vec_u8_t _tmp1v, _tmp2v \ #define VEC_STORE16( v, p ) \ _hv = vec_ld( 0, p ); \ _tmp2v = vec_lvsl( 0, p ); \ _lv = vec_ld( 15, p ); \ _tmp1v = vec_perm( _lv, _hv, _tmp2v ); \ _tmp2v = vec_lvsr( 0, p ); \ _lv = vec_perm( (vec_u8_t) v, _tmp1v, _tmp2v ); \ vec_st( _lv, 15, (uint8_t *) p ); \ _hv = vec_perm( _tmp1v, (vec_u8_t) v, _tmp2v ); \ vec_st( _hv, 0, (uint8_t *) p ) #define PREP_STORE8 \ PREP_STORE16; \ vec_u8_t _tmp3v, _tmp4v; \ const vec_u8_t sel_h = \ (vec_u8_t) CV(-1,-1,-1,-1,-1,-1,-1,-1,0,0,0,0,0,0,0,0) #define PREP_STORE8_HL \ PREP_STORE8; \ const vec_u8_t sel_l = \ (vec_u8_t) CV(0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1) #define VEC_STORE8 VEC_STORE8_H #define VEC_STORE8_H( v, p ) \ _tmp3v = vec_lvsr( 0, (uint8_t *) p ); \ _tmp4v = vec_perm( (vec_u8_t) v, (vec_u8_t) v, _tmp3v ); \ _lv = vec_ld( 7, (uint8_t *) p ); \ _tmp1v = vec_perm( sel_h, zero_u8v, _tmp3v ); \ _lv = vec_sel( _lv, _tmp4v, _tmp1v ); \ vec_st( _lv, 7, (uint8_t *) p ); \ _hv = vec_ld( 0, (uint8_t *) p ); \ _tmp2v = vec_perm( zero_u8v, sel_h, _tmp3v ); \ _hv = vec_sel( _hv, _tmp4v, _tmp2v ); \ vec_st( _hv, 0, (uint8_t *) p ) #define VEC_STORE8_L( v, p ) \ _tmp3v = vec_lvsr( 8, (uint8_t *) p ); \ _tmp4v = vec_perm( (vec_u8_t) v, (vec_u8_t) v, _tmp3v ); \ _lv = vec_ld( 7, (uint8_t *) p ); \ _tmp1v = vec_perm( sel_l, zero_u8v, _tmp3v ); \ _lv = vec_sel( _lv, _tmp4v, _tmp1v ); \ vec_st( _lv, 7, (uint8_t *) p ); \ _hv = vec_ld( 0, (uint8_t *) p ); \ _tmp2v = vec_perm( zero_u8v, sel_l, _tmp3v ); \ _hv = vec_sel( _hv, _tmp4v, _tmp2v ); \ vec_st( _hv, 0, (uint8_t *) p ) #define PREP_STORE4 \ PREP_STORE16; \ vec_u8_t _tmp3v; \ const vec_u8_t sel = \ (vec_u8_t) CV(-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0) #define VEC_STORE4( v, p ) \ _tmp3v = vec_lvsr( 0, p ); \ v = vec_perm( v, v, _tmp3v ); \ _lv = vec_ld( 3, p ); \ _tmp1v = vec_perm( sel, zero_u8v, _tmp3v ); \ _lv = vec_sel( _lv, v, _tmp1v ); \ vec_st( _lv, 3, p ); \ _hv = vec_ld( 0, p ); \ _tmp2v = vec_perm( zero_u8v, sel, _tmp3v ); \ _hv = vec_sel( _hv, v, _tmp2v ); \ vec_st( _hv, 0, p ) /*********************************************************************** * 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 **********************************************************************/ #define PREP_DIFF \ LOAD_ZERO; \ PREP_LOAD; \ vec_s16_t pix1v, pix2v; #define VEC_DIFF_H(p1,i1,p2,i2,n,d) \ VEC_LOAD( p1, pix1v, n, vec_s16_t ); \ pix1v = vec_u8_to_s16( pix1v ); \ VEC_LOAD( p2, pix2v, n, vec_s16_t ); \ 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) \ VEC_LOAD( p1, pix1v, 16, vec_s16_t ); \ temp0v = vec_u8_to_s16_h( pix1v ); \ temp1v = vec_u8_to_s16_l( pix1v ); \ VEC_LOAD( p2, pix2v, 16, vec_s16_t ); \ 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; \ vec_u8_t permPix1, permPix2; \ permPix1 = vec_lvsl(0, pix1); \ permPix2 = vec_lvsl(0, pix2); \ #define VEC_DIFF_H_8BYTE_ALIGNED(p1,i1,p2,i2,n,d) \ pix1v8 = vec_perm(vec_ld(0,p1), zero_u8v, permPix1); \ pix2v8 = vec_perm(vec_ld(0, p2), zero_u8v, permPix2); \ pix1v = vec_u8_to_s16( pix1v8 ); \ pix2v = vec_u8_to_s16( pix2v8 ); \ d = vec_sub( pix1v, pix2v); \ p1 += i1; \ p2 += i2;