nengel@2: /*
nengel@2:  * Copyright (c) 2009 TUDelft 
nengel@2:  * 
nengel@2:  * Cell Parallel SPU - 2DWave Macroblock Decoding. 
nengel@2:  */
nengel@2: 
nengel@2: /**
nengel@2:  * @file libavcodec/cell/spu/h264_main_spu.c
nengel@2:  * Cell Parallel SPU - 2DWave Macroblock Decoding
nengel@2:  * @author C C Chi <c.c.chi@student.tudelft.nl>
nengel@2:  * 
nengel@2:  * SIMD SPU kernels 
nengel@2:  * H.264/AVC motion compensation
nengel@2:  * @author Mauricio Alvarez <alvarez@ac.upc.edu>
nengel@2:  * @author Albert Paradis <apar7632@hotmail.com>
nengel@2:  */ 
nengel@2: 
nengel@2: 
nengel@2: #include "dsputil_spu.h"
nengel@2: #include "h264_idct_spu.h"
nengel@2: #include "h264_deblock_spu.h"
nengel@2: #include "types_spu.h"
nengel@2: #include "libavutil/intreadwrite.h"
nengel@2: 
nengel@2: #include <stdio.h>
nengel@2: #include <spu_intrinsics.h>
nengel@2: #include <spu_mfcio.h>
nengel@2: #include <assert.h>
nengel@2: 
nengel@2: //Luma interpolation
nengel@2: #define PUT_OP_U8_SPU(d, s, dst) (void) dst; d = s
nengel@2: #define AVG_OP_U8_SPU(d, s, dst) d = spu_avg(dst, s)
nengel@2: 
nengel@2: #define OP_U8_SPU                          PUT_OP_U8_SPU
nengel@2: #define PREFIX_h264_qpel16_h_lowpass_spu   put_h264_qpel16_h_lowpass_spu
nengel@2: #define PREFIX_h264_qpel16_v_lowpass_spu   put_h264_qpel16_v_lowpass_spu
nengel@2: #define PREFIX_h264_qpel16_hv_lowpass_spu  put_h264_qpel16_hv_lowpass_spu
nengel@2: #define PREFIX_h264_qpel8_h_lowpass_spu    put_h264_qpel8_h_lowpass_spu
nengel@2: #define PREFIX_h264_qpel8_v_lowpass_spu    put_h264_qpel8_v_lowpass_spu
nengel@2: #define PREFIX_h264_qpel8_hv_lowpass_spu   put_h264_qpel8_hv_lowpass_spu
nengel@2: #define PREFIX_h264_qpel4_h_lowpass_spu    put_h264_qpel4_h_lowpass_spu
nengel@2: #define PREFIX_h264_qpel4_v_lowpass_spu    put_h264_qpel4_v_lowpass_spu
nengel@2: #define PREFIX_h264_qpel4_hv_lowpass_spu   put_h264_qpel4_hv_lowpass_spu
nengel@2: #include "h264_luma_template_spu.c"
nengel@2: #undef OP_U8_SPU                          
nengel@2: #undef PREFIX_h264_qpel16_h_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel16_v_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel16_hv_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel8_h_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel8_v_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel8_hv_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel4_h_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel4_v_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel4_hv_lowpass_spu
nengel@2: 
nengel@2: #define OP_U8_SPU                          AVG_OP_U8_SPU
nengel@2: #define PREFIX_h264_qpel16_h_lowpass_spu   avg_h264_qpel16_h_lowpass_spu
nengel@2: #define PREFIX_h264_qpel16_v_lowpass_spu   avg_h264_qpel16_v_lowpass_spu
nengel@2: #define PREFIX_h264_qpel16_hv_lowpass_spu  avg_h264_qpel16_hv_lowpass_spu
nengel@2: #define PREFIX_h264_qpel8_h_lowpass_spu    avg_h264_qpel8_h_lowpass_spu
nengel@2: #define PREFIX_h264_qpel8_v_lowpass_spu    avg_h264_qpel8_v_lowpass_spu
nengel@2: #define PREFIX_h264_qpel8_hv_lowpass_spu   avg_h264_qpel8_hv_lowpass_spu
nengel@2: #define PREFIX_h264_qpel4_h_lowpass_spu    avg_h264_qpel4_h_lowpass_spu
nengel@2: #define PREFIX_h264_qpel4_v_lowpass_spu    avg_h264_qpel4_v_lowpass_spu
nengel@2: #define PREFIX_h264_qpel4_hv_lowpass_spu   avg_h264_qpel4_hv_lowpass_spu
nengel@2: #include "h264_luma_template_spu.c"
nengel@2: #undef OP_U8_SPU                          
nengel@2: #undef PREFIX_h264_qpel16_h_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel16_v_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel16_hv_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel8_h_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel8_v_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel8_hv_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel4_h_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel4_v_lowpass_spu
nengel@2: #undef PREFIX_h264_qpel4_hv_lowpass_spu
nengel@2: 
nengel@2: #define H264_MC(OPNAME, SIZE, CODETYPE) \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc00_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     OPNAME ## pixels ## SIZE ## _ ## CODETYPE(dst, src, dst_stride, STRIDE_Y, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc10_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){ \
nengel@2:     DECLARE_ALIGNED_16(uint8_t, half[16*16]);\
nengel@2:     put_h264_qpel ## SIZE ## _h_lowpass_ ## CODETYPE(half, src, 16, h);\
nengel@2:     OPNAME ## pixels ## SIZE ## _l2_ ## CODETYPE(dst, src, half, dst_stride, STRIDE_Y, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc20_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     OPNAME ## h264_qpel ## SIZE ## _h_lowpass_ ## CODETYPE(dst, src, dst_stride, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc30_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, half[16*16]);\
nengel@2:     put_h264_qpel ## SIZE ## _h_lowpass_ ## CODETYPE(half, src, 16, h);\
nengel@2:     OPNAME ## pixels ## SIZE ## _l2_ ## CODETYPE(dst, src+1, half, dst_stride, STRIDE_Y, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc01_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, half[16*16]);\
nengel@2:     put_h264_qpel ## SIZE ## _v_lowpass_ ## CODETYPE(half, src, 16, h);\
nengel@2:     OPNAME ## pixels ## SIZE ## _l2_ ## CODETYPE(dst, src, half, dst_stride, STRIDE_Y, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc02_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     OPNAME ## h264_qpel ## SIZE ## _v_lowpass_ ## CODETYPE(dst, src, dst_stride, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc03_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, half[16*16]);\
nengel@2:     put_h264_qpel ## SIZE ## _v_lowpass_ ## CODETYPE(half, src, 16, h);\
nengel@2:     OPNAME ## pixels ## SIZE ## _l2_ ## CODETYPE(dst, src+STRIDE_Y, half, dst_stride, STRIDE_Y, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc11_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfH[16*16]);\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfV[16*16]);\
nengel@2:     put_h264_qpel ## SIZE ## _h_lowpass_ ## CODETYPE(halfH, src, 16, h);\
nengel@2:     put_h264_qpel ## SIZE ## _v_lowpass_ ## CODETYPE(halfV, src, 16, h);\
nengel@2:     OPNAME ## pixels ## SIZE ## _l2_ ## CODETYPE(dst, halfH, halfV, dst_stride, 16, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc31_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfH[16*16]);\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfV[16*16]);\
nengel@2:     put_h264_qpel ## SIZE ## _h_lowpass_ ## CODETYPE(halfH, src, 16, h);\
nengel@2:     put_h264_qpel ## SIZE ## _v_lowpass_ ## CODETYPE(halfV, src+1, 16, h);\
nengel@2:     OPNAME ## pixels ## SIZE ## _l2_ ## CODETYPE(dst, halfH, halfV, dst_stride, 16, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc13_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfH[16*16]);\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfV[16*16]);\
nengel@2:     put_h264_qpel ## SIZE ## _h_lowpass_ ## CODETYPE(halfH, src + STRIDE_Y, 16, h);\
nengel@2:     put_h264_qpel ## SIZE ## _v_lowpass_ ## CODETYPE(halfV, src, 16, h);\
nengel@2:     OPNAME ## pixels ## SIZE ## _l2_ ## CODETYPE(dst, halfH, halfV, dst_stride, 16, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc33_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfH[16*16]);\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfV[16*16]);\
nengel@2:     put_h264_qpel ## SIZE ## _h_lowpass_ ## CODETYPE(halfH, src + STRIDE_Y, 16, h);\
nengel@2:     put_h264_qpel ## SIZE ## _v_lowpass_ ## CODETYPE(halfV, src+1, 16, h);\
nengel@2:     OPNAME ## pixels ## SIZE ## _l2_ ## CODETYPE(dst, halfH, halfV, dst_stride, 16, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc22_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     DECLARE_ALIGNED_16(int16_t, tmp[16*(16+8)]);\
nengel@2:     OPNAME ## h264_qpel ## SIZE ## _hv_lowpass_ ## CODETYPE(dst, tmp, src, dst_stride, 16, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc21_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfH[16*16]);\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfHV[16*16]);\
nengel@2:     DECLARE_ALIGNED_16(int16_t, tmp[16*(16+8)]);\
nengel@2:     put_h264_qpel ## SIZE ## _h_lowpass_ ## CODETYPE(halfH, src, 16, h);\
nengel@2:     put_h264_qpel ## SIZE ## _hv_lowpass_ ## CODETYPE(halfHV, tmp, src, 16, 16, h);\
nengel@2:     OPNAME ## pixels ## SIZE ## _l2_ ## CODETYPE(dst, halfH, halfHV, dst_stride, 16, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc23_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfH[16*16]);\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfHV[16*16]);\
nengel@2:     DECLARE_ALIGNED_16(int16_t, tmp[16*(16+8)]);\
nengel@2:     put_h264_qpel ## SIZE ## _h_lowpass_ ## CODETYPE(halfH, src + STRIDE_Y, 16, h);\
nengel@2:     put_h264_qpel ## SIZE ## _hv_lowpass_ ## CODETYPE(halfHV, tmp, src, 16, 16, h);\
nengel@2:     OPNAME ## pixels ## SIZE ## _l2_ ## CODETYPE(dst, halfH, halfHV, dst_stride, 16, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc12_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfV[16*16]);\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfHV[16*16]);\
nengel@2:     DECLARE_ALIGNED_16(int16_t, tmp[16*(16+8)]);\
nengel@2:     put_h264_qpel ## SIZE ## _v_lowpass_ ## CODETYPE(halfV, src, 16, h);\
nengel@2:     put_h264_qpel ## SIZE ## _hv_lowpass_ ## CODETYPE(halfHV, tmp, src, 16, 16, h);\
nengel@2:     OPNAME ## pixels ## SIZE ## _l2_ ## CODETYPE(dst, halfV, halfHV, dst_stride, 16, h);\
nengel@2: }\
nengel@2: \
nengel@2: static void OPNAME ## h264_qpel ## SIZE ## _mc32_ ## CODETYPE(uint8_t *dst, uint8_t *src, int dst_stride, int h){\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfV[16*16]);\
nengel@2:     DECLARE_ALIGNED_16(uint8_t, halfHV[16*16]);\
nengel@2:     DECLARE_ALIGNED_16(int16_t, tmp[16*(16+8)]);\
nengel@2:     put_h264_qpel ## SIZE ## _v_lowpass_ ## CODETYPE(halfV, src+1, 16, h);\
nengel@2:     put_h264_qpel ## SIZE ## _hv_lowpass_ ## CODETYPE(halfHV, tmp, src, 16, 16, h);\
nengel@2:     OPNAME ## pixels ## SIZE ## _l2_ ## CODETYPE(dst, halfV, halfHV, dst_stride, 16, h);\
nengel@2: }\
nengel@2: 
nengel@2: 
nengel@2: /**************************/
nengel@2: /* put pixels functions   */
nengel@2: /*************************/
nengel@2: 
nengel@2: static void put_pixels16_l2_spu( uint8_t * dst, const uint8_t * src1,
nengel@2:                                     const uint8_t * src2, int dst_stride,
nengel@2:                                     int src_stride1, int h)
nengel@2: {
nengel@2:   int i;
nengel@2: 
nengel@2:   const int perm_src1 = (unsigned int) src1 & 15;
nengel@2: 
nengel@2:   for (i=0; i<h; i++){
nengel@2:       //unaligned load of src1
nengel@2:       const vuint8_t srctmpa1 = *(vuint8_t *)(src1);
nengel@2:       const vuint8_t srctmpa2 = *(vuint8_t *)(src1+16);
nengel@2:       const vuint8_t srca= spu_or(spu_slqwbyte(srctmpa1, perm_src1), spu_rlmaskqwbyte(srctmpa2, perm_src1-16));
nengel@2: 
nengel@2:       //aligned load of src2
nengel@2:       const vuint8_t srcb = *(vuint8_t *)(src2);
nengel@2: 
nengel@2:       //average and rounding
nengel@2:       const vuint8_t avgc = spu_avg(srca,srcb);
nengel@2: 
nengel@2:       // 16x16 dest luma blocks are always aligned
nengel@2:       *(vuint8_t *)dst=avgc;
nengel@2: 
nengel@2:       src1 +=src_stride1;
nengel@2:       src2 +=16;
nengel@2:       dst  +=dst_stride;
nengel@2:   }
nengel@2: }
nengel@2: 
nengel@2: static void avg_pixels16_l2_spu( uint8_t * dst, const uint8_t * src1,
nengel@2:                                     const uint8_t * src2, int dst_stride,
nengel@2:                                     int src_stride1, int h)
nengel@2: {
nengel@2:   int i;
nengel@2: 
nengel@2:   const int perm_src1 = (unsigned int) src1 & 15;
nengel@2: 
nengel@2:   for (i=0; i<h; i++){
nengel@2:       //unaligned load of src1
nengel@2:       const vuint8_t srctmpa1 = *(vuint8_t *)(src1);
nengel@2:       const vuint8_t srctmpa2 = *(vuint8_t *)(src1+16);
nengel@2:       const vuint8_t srca= spu_or(spu_slqwbyte(srctmpa1, perm_src1), spu_rlmaskqwbyte(srctmpa2, perm_src1-16));
nengel@2: 
nengel@2:       //aligned load of src2
nengel@2:       const vuint8_t srcb = *(vuint8_t *)(src2);
nengel@2: 
nengel@2:       //average and rounding
nengel@2:       const vuint8_t avgc = spu_avg(spu_avg(srca,srcb), *(vuint8_t *)dst);
nengel@2: 
nengel@2:       // 16x16 dest luma blocks are always aligned
nengel@2:       *(vuint8_t *)dst=avgc;
nengel@2: 
nengel@2:       src1 +=src_stride1;
nengel@2:       src2 +=16;
nengel@2:       dst  +=dst_stride;
nengel@2:   }
nengel@2: }
nengel@2: 
nengel@2: // next one assumes that ((line_size % 16) == 0)
nengel@2: void put_pixels16_spu(uint8_t *dst, const uint8_t *src, int dst_stride, int src_stride, int h)
nengel@2: {
nengel@2:     register vector unsigned char pixelsv1, pixelsv2;
nengel@2:     register vector unsigned char pixelsv1B, pixelsv2B;
nengel@2:     register vector unsigned char pixelsv1C, pixelsv2C;
nengel@2:     register vector unsigned char pixelsv1D, pixelsv2D;
nengel@2: 
nengel@2:     const int perm = (unsigned int) src & 15;
nengel@2:     int i;
nengel@2: 	register int line_size   = src_stride;
nengel@2:     register int line_size_2 = line_size << 1;
nengel@2:     register int line_size_3 = line_size + line_size_2;
nengel@2:     register int line_size_4 = line_size << 2;
nengel@2: 
nengel@2:     register int dst_stride_2 = dst_stride << 1;
nengel@2:     register int dst_stride_3 = dst_stride_2 + dst_stride;
nengel@2:     register int dst_stride_4 = dst_stride << 2;
nengel@2: 
nengel@2:     for(i=0; i<h; i+=4) {
nengel@2:       pixelsv1 = *(vuint8_t *)(src);
nengel@2:       pixelsv2 = *(vuint8_t *)(src+16);
nengel@2:       pixelsv1B = *(vuint8_t *)(src + line_size);
nengel@2:       pixelsv2B = *(vuint8_t *)(src+16 + line_size);
nengel@2:       pixelsv1C = *(vuint8_t *)(src + line_size_2);
nengel@2:       pixelsv2C = *(vuint8_t *)(src+16 + line_size_2);
nengel@2:       pixelsv1D = *(vuint8_t *)(src + line_size_3);
nengel@2:       pixelsv2D = *(vuint8_t *)(src+16 + line_size_3);
nengel@2: 
nengel@2:       *(vuint8_t *) dst                 = spu_or(spu_slqwbyte(pixelsv1, perm), spu_rlmaskqwbyte(pixelsv2, perm-16));
nengel@2:       *(vuint8_t *)(dst +   dst_stride) = spu_or(spu_slqwbyte(pixelsv1B, perm), spu_rlmaskqwbyte(pixelsv2B, perm-16));
nengel@2:       *(vuint8_t *)(dst + dst_stride_2) = spu_or(spu_slqwbyte(pixelsv1C, perm), spu_rlmaskqwbyte(pixelsv2C, perm-16));
nengel@2:       *(vuint8_t *)(dst + dst_stride_3) = spu_or(spu_slqwbyte(pixelsv1D, perm), spu_rlmaskqwbyte(pixelsv2D, perm-16));
nengel@2: 
nengel@2:       src+= line_size_4;
nengel@2:       dst+= dst_stride_4;
nengel@2:     }
nengel@2: }
nengel@2: 
nengel@2: // next one assumes that ((line_size % 16) == 0)
nengel@2: void avg_pixels16_spu(uint8_t *dst, const uint8_t *src, int dst_stride, int src_stride, int h)
nengel@2: {
nengel@2:     register vector unsigned char pixelsv1, pixelsv2;
nengel@2:     register vector unsigned char pixelsv1B, pixelsv2B;
nengel@2:     register vector unsigned char pixelsv1C, pixelsv2C;
nengel@2:     register vector unsigned char pixelsv1D, pixelsv2D;
nengel@2: 
nengel@2:     const int perm = (unsigned int) src & 15;
nengel@2:     int i;
nengel@2: 	register int line_size   = src_stride;
nengel@2:     register int line_size_2 = line_size << 1;
nengel@2:     register int line_size_3 = line_size + line_size_2;
nengel@2:     register int line_size_4 = line_size << 2;
nengel@2: 
nengel@2:     register int dst_stride_2 = dst_stride << 1;
nengel@2:     register int dst_stride_3 = dst_stride_2 + dst_stride;
nengel@2:     register int dst_stride_4 = dst_stride << 2;
nengel@2: 
nengel@2: 
nengel@2:     for(i=0; i<h; i+=4) {
nengel@2:       pixelsv1 = *(vuint8_t *)(src);
nengel@2:       pixelsv2 = *(vuint8_t *)(src+16);
nengel@2:       pixelsv1B = *(vuint8_t *)(src + line_size);
nengel@2:       pixelsv2B = *(vuint8_t *)(src+16 + line_size);
nengel@2:       pixelsv1C = *(vuint8_t *)(src + line_size_2);
nengel@2:       pixelsv2C = *(vuint8_t *)(src+16 + line_size_2);
nengel@2:       pixelsv1D = *(vuint8_t *)(src + line_size_3);
nengel@2:       pixelsv2D = *(vuint8_t *)(src+16 + line_size_3);
nengel@2: 
nengel@2:       *(vuint8_t *)dst = spu_avg(spu_or(spu_slqwbyte(pixelsv1, perm), spu_rlmaskqwbyte(pixelsv2, perm-16)), *(vuint8_t *)dst);
nengel@2:       *(vuint8_t *)(dst + dst_stride) = spu_avg(spu_or(spu_slqwbyte(pixelsv1B, perm), spu_rlmaskqwbyte(pixelsv2B, perm-16)), *(vuint8_t *)(dst+dst_stride));
nengel@2:       *(vuint8_t *)(dst + dst_stride_2) = spu_avg(spu_or(spu_slqwbyte(pixelsv1C, perm), spu_rlmaskqwbyte(pixelsv2C, perm-16)), *(vuint8_t *)(dst+dst_stride_2));
nengel@2:       *(vuint8_t *)(dst + dst_stride_3) = spu_avg(spu_or(spu_slqwbyte(pixelsv1D, perm), spu_rlmaskqwbyte(pixelsv2D, perm-16)), *(vuint8_t *)(dst+dst_stride_3));
nengel@2: 
nengel@2:       src+= line_size_4;
nengel@2:       dst+= dst_stride_4;
nengel@2:     }
nengel@2: }
nengel@2: 
nengel@2: void put_pixels8_l2_spu(uint8_t * dst, const uint8_t * src1, const uint8_t * src2,
nengel@2: 				   int dst_stride, int src_stride1, int h)
nengel@2: {
nengel@2:   int i;
nengel@2: 
nengel@2:   const int perm_src1 = (unsigned int) src1 & 15;
nengel@2:   const int shift_dst = (unsigned int) dst & 15;
nengel@2: 
nengel@2:   // 8x dest luma blocks are aligned or desaligned by 8
nengel@2:   vuint8_t dstmask;
nengel@2:   const vuint8_t dst8mask1= {0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
nengel@2:   const vuint8_t dst8mask2= {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17};
nengel@2: 
nengel@2:   if(shift_dst==0){
nengel@2:     dstmask = dst8mask1;
nengel@2:   }
nengel@2:   else{
nengel@2:     dstmask = dst8mask2;
nengel@2:   }
nengel@2: 
nengel@2:   for (i=0; i<h; i++){
nengel@2:       //unaligned load of src1
nengel@2:       const vuint8_t srctmpa1 = *(vuint8_t *)(src1);
nengel@2:       const vuint8_t srctmpa2 = *(vuint8_t *)(src1+16);
nengel@2:       const vuint8_t srca= spu_or(spu_slqwbyte(srctmpa1, perm_src1), spu_rlmaskqwbyte(srctmpa2, perm_src1-16));
nengel@2: 
nengel@2:       //aligned load of src2
nengel@2:       const vuint8_t srcb = *(vuint8_t *)(src2);
nengel@2: 
nengel@2:       //average and rounding
nengel@2:       const vuint8_t avgc = spu_avg(srca,srcb);
nengel@2: 
nengel@2:       const vuint8_t dst1 = *(vuint8_t *)dst;
nengel@2: 
nengel@2:       const vuint8_t davgc = spu_shuffle(dst1, avgc, dstmask);
nengel@2: 
nengel@2:       *(vuint8_t *)dst=davgc;
nengel@2: 
nengel@2:       src1 +=src_stride1;
nengel@2:       src2 +=16;
nengel@2:       dst  +=dst_stride;
nengel@2:   }
nengel@2: }
nengel@2: 
nengel@2: void avg_pixels8_l2_spu(uint8_t * dst, const uint8_t * src1, const uint8_t * src2,
nengel@2: 				   int dst_stride, int src_stride1, int h)
nengel@2: {
nengel@2:   int i;
nengel@2: 
nengel@2:   const int perm_src1 = (unsigned int) src1 & 15;
nengel@2:   const int shift_dst = (unsigned int) dst & 15;
nengel@2: 
nengel@2:   // 8x dest luma blocks are aligned or desaligned by 8
nengel@2:   vuint8_t dstmask;
nengel@2:   const vuint8_t dst8mask1= {0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
nengel@2:   const vuint8_t dst8mask2= {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17};
nengel@2: 
nengel@2:   if(shift_dst==0){
nengel@2:     dstmask = dst8mask1;
nengel@2:   }
nengel@2:   else{
nengel@2:     dstmask = dst8mask2;
nengel@2:   }
nengel@2: 
nengel@2:   for (i=0; i<h; i++){
nengel@2:       //unaligned load of src1
nengel@2:       const vuint8_t srctmpa1 = *(vuint8_t *)(src1);
nengel@2:       const vuint8_t srctmpa2 = *(vuint8_t *)(src1+16);
nengel@2:       const vuint8_t srca= spu_or(spu_slqwbyte(srctmpa1, perm_src1), spu_rlmaskqwbyte(srctmpa2, perm_src1-16));
nengel@2: 
nengel@2:       //aligned load of src2
nengel@2:       const vuint8_t srcb = *(vuint8_t *)(src2);
nengel@2: 
nengel@2:       //average and rounding
nengel@2:       const vuint8_t avgc = spu_avg(srca,srcb);
nengel@2: 
nengel@2:       const vuint8_t dst1 = *(vuint8_t *)dst;
nengel@2: 
nengel@2:       const vuint8_t davgc1 = spu_shuffle(dst1, avgc, dstmask);
nengel@2: 
nengel@2:       const vuint8_t davgc = spu_avg(dst1,davgc1);
nengel@2: 
nengel@2:       *(vuint8_t *)dst=davgc;
nengel@2: 
nengel@2:       src1 +=src_stride1;
nengel@2:       src2 +=16;
nengel@2:       dst  +=dst_stride;
nengel@2:   }
nengel@2: }
nengel@2: 
nengel@2: // next one assumes that ((line_size % 16) == 0)
nengel@2: void put_pixels8_spu(uint8_t *dst, const uint8_t *src, int dst_stride, int src_stride, int h)
nengel@2: {
nengel@2:     register vector unsigned char pixelsv1A, pixelsv2A;
nengel@2:     register vector unsigned char pixelsv1B, pixelsv2B;
nengel@2:     register vector unsigned char pixelsv1C, pixelsv2C;
nengel@2:     register vector unsigned char pixelsv1D, pixelsv2D;
nengel@2: 
nengel@2:     const int perm = (unsigned int) src & 15;
nengel@2:     const int shift_dst = (unsigned int) dst & 15;
nengel@2: 
nengel@2:     // 8x dest luma blocks are aligned or desaligned by 8
nengel@2:     vuint8_t dstmask;
nengel@2:     const vuint8_t dst8mask1= {0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
nengel@2:     const vuint8_t dst8mask2= {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17};
nengel@2: 
nengel@2:     if(shift_dst==0){
nengel@2:       dstmask = dst8mask1;
nengel@2:     }
nengel@2:     else{
nengel@2:       dstmask = dst8mask2;
nengel@2:     }
nengel@2: 
nengel@2:     int i;
nengel@2: 	register int line_size   = src_stride;
nengel@2:     register int line_size_2 = line_size << 1;
nengel@2:     register int line_size_3 = line_size + line_size_2;
nengel@2:     register int line_size_4 = line_size << 2;
nengel@2: 
nengel@2:     register int dst_stride_2 = dst_stride << 1;
nengel@2:     register int dst_stride_3 = dst_stride_2 + dst_stride;
nengel@2:     register int dst_stride_4 = dst_stride << 2;
nengel@2: 
nengel@2:     for(i=0; i<h; i+=4) {
nengel@2:       pixelsv1A = *(vuint8_t *)(src);
nengel@2:       pixelsv2A = *(vuint8_t *)(src+16);
nengel@2:       pixelsv1B = *(vuint8_t *)(src + line_size);
nengel@2:       pixelsv2B = *(vuint8_t *)(src+16 + line_size);
nengel@2:       pixelsv1C = *(vuint8_t *)(src + line_size_2);
nengel@2:       pixelsv2C = *(vuint8_t *)(src+16 + line_size_2);
nengel@2:       pixelsv1D = *(vuint8_t *)(src + line_size_3);
nengel@2:       pixelsv2D = *(vuint8_t *)(src+16 + line_size_3);
nengel@2: 
nengel@2:       const vuint8_t block1 = *(vuint8_t *)dst;
nengel@2:       const vuint8_t put1 = spu_shuffle(block1, spu_or(spu_slqwbyte(pixelsv1A, perm), spu_rlmaskqwbyte(pixelsv2A, perm-16)), dstmask);
nengel@2:       const vuint8_t block2 = *(vuint8_t *)(dst+dst_stride);
nengel@2:       const vuint8_t put2 = spu_shuffle(block2, spu_or(spu_slqwbyte(pixelsv1B, perm), spu_rlmaskqwbyte(pixelsv2B, perm-16)), dstmask);
nengel@2:       const vuint8_t block3 = *(vuint8_t *)(dst+2*dst_stride);
nengel@2:       const vuint8_t put3 = spu_shuffle(block3, spu_or(spu_slqwbyte(pixelsv1C, perm), spu_rlmaskqwbyte(pixelsv2C, perm-16)), dstmask);
nengel@2:       const vuint8_t block4 = *(vuint8_t *)(dst+3*dst_stride);
nengel@2:       const vuint8_t put4 = spu_shuffle(block4, spu_or(spu_slqwbyte(pixelsv1D, perm), spu_rlmaskqwbyte(pixelsv2D, perm-16)), dstmask);
nengel@2: 
nengel@2:       *(vuint8_t *) dst = put1;
nengel@2:       *(vuint8_t *)(dst + dst_stride) = put2;
nengel@2:       *(vuint8_t *)(dst + dst_stride_2) = put3;
nengel@2:       *(vuint8_t *)(dst + dst_stride_3) = put4;
nengel@2: 
nengel@2:       src += line_size_4;
nengel@2:       dst += dst_stride_4;
nengel@2:     }
nengel@2: }
nengel@2: 
nengel@2: // next one assumes that ((line_size % 16) == 0)
nengel@2: void avg_pixels8_spu(uint8_t *dst, const uint8_t *src, int dst_stride, int src_stride, int h)
nengel@2: {
nengel@2:     register vector unsigned char pixelsv1A, pixelsv2A;
nengel@2:     register vector unsigned char pixelsv1B, pixelsv2B;
nengel@2:     register vector unsigned char pixelsv1C, pixelsv2C;
nengel@2:     register vector unsigned char pixelsv1D, pixelsv2D;
nengel@2: 
nengel@2:     const int perm = (unsigned int) src & 15;
nengel@2:     const int shift_dst = (unsigned int) dst & 15;
nengel@2: 
nengel@2:     // 8x dest luma blocks are aligned or desaligned by 8
nengel@2:     vuint8_t dstmask;
nengel@2:     const vuint8_t dst8mask1= {0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
nengel@2:     const vuint8_t dst8mask2= {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17};
nengel@2: 
nengel@2:     if(shift_dst==0){
nengel@2:       dstmask = dst8mask1;
nengel@2:     }
nengel@2:     else{
nengel@2:       dstmask = dst8mask2;
nengel@2:     }
nengel@2: 
nengel@2:     int i;
nengel@2: 	register int line_size   = src_stride;
nengel@2:     register int line_size_2 = line_size << 1;
nengel@2:     register int line_size_3 = line_size + line_size_2;
nengel@2:     register int line_size_4 = line_size << 2;
nengel@2: 
nengel@2: 	register int dst_stride_2 = dst_stride << 1;
nengel@2:     register int dst_stride_3 = dst_stride_2 + dst_stride;
nengel@2:     register int dst_stride_4 = dst_stride << 2;
nengel@2: 
nengel@2:     for(i=0; i<h; i+=4) {
nengel@2:       pixelsv1A = *(vuint8_t *)(src);
nengel@2:       pixelsv2A = *(vuint8_t *)(src+16);
nengel@2:       pixelsv1B = *(vuint8_t *)(src + line_size);
nengel@2:       pixelsv2B = *(vuint8_t *)(src+16 + line_size);
nengel@2:       pixelsv1C = *(vuint8_t *)(src + line_size_2);
nengel@2:       pixelsv2C = *(vuint8_t *)(src+16 + line_size_2);
nengel@2:       pixelsv1D = *(vuint8_t *)(src + line_size_3);
nengel@2:       pixelsv2D = *(vuint8_t *)(src+16 + line_size_3);
nengel@2: 
nengel@2:       const vuint8_t block1 = *(vuint8_t *) dst;
nengel@2:       const vuint8_t put1a = spu_shuffle(block1, spu_or(spu_slqwbyte(pixelsv1A, perm), spu_rlmaskqwbyte(pixelsv2A, perm-16)), dstmask);
nengel@2:       const vuint8_t put1 = spu_avg(block1,put1a);
nengel@2: 
nengel@2:       const vuint8_t block2 = *(vuint8_t *)(dst + dst_stride);
nengel@2:       const vuint8_t put2a = spu_shuffle(block2, spu_or(spu_slqwbyte(pixelsv1B, perm), spu_rlmaskqwbyte(pixelsv2B, perm-16)), dstmask);
nengel@2:       const vuint8_t put2 = spu_avg(block2,put2a);
nengel@2: 
nengel@2:       const vuint8_t block3 = *(vuint8_t *)(dst + dst_stride_2);
nengel@2:       const vuint8_t put3a = spu_shuffle(block3, spu_or(spu_slqwbyte(pixelsv1C, perm), spu_rlmaskqwbyte(pixelsv2C, perm-16)), dstmask);
nengel@2:       const vuint8_t put3 = spu_avg(block3,put3a);
nengel@2: 
nengel@2:       const vuint8_t block4 = *(vuint8_t *)(dst + dst_stride_3);
nengel@2:       const vuint8_t put4a = spu_shuffle(block4, spu_or(spu_slqwbyte(pixelsv1D, perm), spu_rlmaskqwbyte(pixelsv2D, perm-16)), dstmask);
nengel@2:       const vuint8_t put4 = spu_avg(block4,put4a);
nengel@2: 
nengel@2:       *(vuint8_t *) dst = put1;
nengel@2:       *(vuint8_t *)(dst + dst_stride) = put2;
nengel@2:       *(vuint8_t *)(dst + dst_stride_2) = put3;
nengel@2:       *(vuint8_t *)(dst + dst_stride_3) = put4;
nengel@2: 
nengel@2:       src+= line_size_4;
nengel@2:       dst+= dst_stride_4;
nengel@2:     }
nengel@2: }
nengel@2: 
nengel@2: void put_pixels4_l2_spu(uint8_t * dst, const uint8_t * src1, const uint8_t * src2,
nengel@2: 				   int dst_stride, int src_stride1, int h)
nengel@2: {
nengel@2:   int i;
nengel@2: 
nengel@2:   const int perm_src1 = (unsigned int) src1 & 15;
nengel@2:   const int shift_dst = (unsigned int) dst & 15;
nengel@2: 
nengel@2:   // 4x dest luma blocks are desaligned by 0, 4, 8, or 12
nengel@2:   vuint8_t dstmask = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
nengel@2:   const vuint8_t dstmask0=  {0x10,0x11,0x12,0x13,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
nengel@2:   const vuint8_t dstmask4=  {0x00,0x01,0x02,0x03,0x10,0x11,0x12,0x13,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
nengel@2:   const vuint8_t dstmask8=  {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x10,0x11,0x12,0x13,0x0C,0x0D,0x0E,0x0F};
nengel@2:   const vuint8_t dstmask12= {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x10,0x11,0x12,0x13};
nengel@2: 
nengel@2:   switch(shift_dst){
nengel@2:     case 0:  dstmask = dstmask0;
nengel@2:              break;
nengel@2:     case 4:  dstmask = dstmask4;
nengel@2:              break;
nengel@2:     case 8:  dstmask = dstmask8;
nengel@2:              break;
nengel@2:     case 12: dstmask = dstmask12;
nengel@2:              break;
nengel@2:   }
nengel@2: 
nengel@2:   for (i=0; i<h; i++){
nengel@2:       //unaligned load of src1
nengel@2:       const vuint8_t srctmpa1 = *(vuint8_t *)(src1);
nengel@2:       const vuint8_t srctmpa2 = *(vuint8_t *)(src1+16);
nengel@2:       const vuint8_t srca= spu_or(spu_slqwbyte(srctmpa1, perm_src1), spu_rlmaskqwbyte(srctmpa2, perm_src1-16));
nengel@2: 
nengel@2:       //aligned load of src2
nengel@2:       const vuint8_t srcb = *(vuint8_t *)(src2);
nengel@2: 
nengel@2:       //average and rounding
nengel@2:       const vuint8_t avgc = spu_avg(srca,srcb);
nengel@2: 
nengel@2:       const vuint8_t dst1 = *(vuint8_t *)dst;
nengel@2: 
nengel@2:       const vuint8_t davgc = spu_shuffle(dst1, avgc, dstmask);
nengel@2: 
nengel@2:       *(vuint8_t *)dst=davgc;
nengel@2: 
nengel@2:       src1 +=src_stride1;
nengel@2:       src2 +=16;
nengel@2:       dst  +=dst_stride;
nengel@2:   }
nengel@2: }
nengel@2: 
nengel@2: void avg_pixels4_l2_spu(uint8_t * dst, const uint8_t * src1, const uint8_t * src2,
nengel@2: 				   int dst_stride, int src_stride1, int h)
nengel@2: {
nengel@2:   int i;
nengel@2: 
nengel@2:   const int perm_src1 = (unsigned int) src1 & 15;
nengel@2:   const int shift_dst = (unsigned int) dst & 15;
nengel@2: 
nengel@2:   // 4x dest luma blocks are desaligned by 0, 4, 8, or 12
nengel@2:   vuint8_t dstmask = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
nengel@2:   const vuint8_t dstmask0=  {0x10,0x11,0x12,0x13,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
nengel@2:   const vuint8_t dstmask4=  {0x00,0x01,0x02,0x03,0x10,0x11,0x12,0x13,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
nengel@2:   const vuint8_t dstmask8=  {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x10,0x11,0x12,0x13,0x0C,0x0D,0x0E,0x0F};
nengel@2:   const vuint8_t dstmask12= {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x10,0x11,0x12,0x13};
nengel@2: 
nengel@2:   switch(shift_dst){
nengel@2:     case 0:  dstmask = dstmask0;
nengel@2:              break;
nengel@2:     case 4:  dstmask = dstmask4;
nengel@2:              break;
nengel@2:     case 8:  dstmask = dstmask8;
nengel@2:              break;
nengel@2:     case 12: dstmask = dstmask12;
nengel@2:              break;
nengel@2:   }
nengel@2: 
nengel@2:   for (i=0; i<h; i++){
nengel@2:       //unaligned load of src1
nengel@2:       const vuint8_t srctmpa1 = *(vuint8_t *)(src1);
nengel@2:       const vuint8_t srctmpa2 = *(vuint8_t *)(src1+16);
nengel@2:       const vuint8_t srca= spu_or(spu_slqwbyte(srctmpa1, perm_src1), spu_rlmaskqwbyte(srctmpa2, perm_src1-16));
nengel@2: 
nengel@2:       //aligned load of src2
nengel@2:       const vuint8_t srcb = *(vuint8_t *)(src2);
nengel@2: 
nengel@2:       //average and rounding
nengel@2:       const vuint8_t avgc = spu_avg(srca,srcb);
nengel@2: 
nengel@2:       const vuint8_t dst1 = *(vuint8_t *)dst;
nengel@2: 
nengel@2:       const vuint8_t davgc1 = spu_shuffle(dst1, avgc, dstmask);
nengel@2: 
nengel@2:       const vuint8_t davgc = spu_avg(dst1,davgc1);
nengel@2: 
nengel@2:       *(vuint8_t *)dst=davgc;
nengel@2: 
nengel@2:       src1 +=src_stride1;
nengel@2:       src2 +=16;
nengel@2:       dst  +=dst_stride;
nengel@2:   }
nengel@2: }
nengel@2: 
nengel@2: // next one assumes that ((line_size % 16) == 0)
nengel@2: void put_pixels4_spu(uint8_t *dst, const uint8_t *src, int dst_stride, int src_stride, int h)
nengel@2: {
nengel@2:     register vector unsigned char pixelsv1A, pixelsv2A;
nengel@2:     register vector unsigned char pixelsv1B, pixelsv2B;
nengel@2:     register vector unsigned char pixelsv1C, pixelsv2C;
nengel@2:     register vector unsigned char pixelsv1D, pixelsv2D;
nengel@2: 
nengel@2:     const int perm = (unsigned int) src & 15;
nengel@2:     const int shift_dst = (unsigned int) dst & 15;
nengel@2: 
nengel@2:     // 4x dest luma blocks are desaligned by 0, 4, 8, or 12
nengel@2:     vuint8_t dstmask = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
nengel@2:     const vuint8_t dstmask0=  {0x10,0x11,0x12,0x13,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
nengel@2:     const vuint8_t dstmask4=  {0x00,0x01,0x02,0x03,0x10,0x11,0x12,0x13,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
nengel@2:     const vuint8_t dstmask8=  {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x10,0x11,0x12,0x13,0x0C,0x0D,0x0E,0x0F};
nengel@2:     const vuint8_t dstmask12= {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x10,0x11,0x12,0x13};
nengel@2: 
nengel@2:     switch(shift_dst){
nengel@2:       case 0:  dstmask = dstmask0;
nengel@2:                break;
nengel@2:       case 4:  dstmask = dstmask4;
nengel@2:                break;
nengel@2:       case 8:  dstmask = dstmask8;
nengel@2:                break;
nengel@2:       case 12: dstmask = dstmask12;
nengel@2:                break;
nengel@2:     }
nengel@2: 
nengel@2:     int i;
nengel@2: 	register int line_size   = src_stride;
nengel@2:     register int line_size_2 = line_size << 1;
nengel@2:     register int line_size_3 = line_size + line_size_2;
nengel@2:     register int line_size_4 = line_size << 2;
nengel@2: 
nengel@2: 	register int dst_stride_2 = dst_stride << 1;
nengel@2:     register int dst_stride_3 = dst_stride_2 + dst_stride;
nengel@2:     register int dst_stride_4 = dst_stride << 2;
nengel@2: 
nengel@2:     for(i=0; i<h; i+=4) {
nengel@2: 	  pixelsv1A = *(vuint8_t *)(src);
nengel@2:       pixelsv2A = *(vuint8_t *)(src+16);
nengel@2:       pixelsv1B = *(vuint8_t *)(src + line_size);
nengel@2:       pixelsv2B = *(vuint8_t *)(src+16 + line_size);
nengel@2:       pixelsv1C = *(vuint8_t *)(src + line_size_2);
nengel@2:       pixelsv2C = *(vuint8_t *)(src+16 + line_size_2);
nengel@2:       pixelsv1D = *(vuint8_t *)(src + line_size_3);
nengel@2:       pixelsv2D = *(vuint8_t *)(src+16 + line_size_3);
nengel@2: 
nengel@2:       const vuint8_t block1 = *(vuint8_t *)dst;
nengel@2:       const vuint8_t put1 = spu_shuffle(block1, spu_or(spu_slqwbyte(pixelsv1A, perm), spu_rlmaskqwbyte(pixelsv2A, perm-16)), dstmask);
nengel@2:       const vuint8_t block2 = *(vuint8_t *)(dst+dst_stride);
nengel@2:       const vuint8_t put2 = spu_shuffle(block2, spu_or(spu_slqwbyte(pixelsv1B, perm), spu_rlmaskqwbyte(pixelsv2B, perm-16)), dstmask);
nengel@2:       const vuint8_t block3 = *(vuint8_t *)(dst+dst_stride_2);
nengel@2:       const vuint8_t put3 = spu_shuffle(block3, spu_or(spu_slqwbyte(pixelsv1C, perm), spu_rlmaskqwbyte(pixelsv2C, perm-16)), dstmask);
nengel@2:       const vuint8_t block4 = *(vuint8_t *)(dst+dst_stride_3);
nengel@2:       const vuint8_t put4 = spu_shuffle(block4, spu_or(spu_slqwbyte(pixelsv1D, perm), spu_rlmaskqwbyte(pixelsv2D, perm-16)), dstmask);
nengel@2: 
nengel@2:       *(vuint8_t *) dst = put1;
nengel@2:       *(vuint8_t *)(dst + dst_stride) = put2;
nengel@2:       *(vuint8_t *)(dst + dst_stride_2) = put3;
nengel@2:       *(vuint8_t *)(dst + dst_stride_3) = put4;
nengel@2: 
nengel@2:       src += line_size_4;
nengel@2:       dst += dst_stride_4;
nengel@2:     }
nengel@2: }
nengel@2: 
nengel@2: // next one assumes that ((line_size % 16) == 0)
nengel@2: void avg_pixels4_spu(uint8_t *dst, const uint8_t *src, int dst_stride, int src_stride, int h)
nengel@2: {
nengel@2:     register vector unsigned char pixelsv1A, pixelsv2A;
nengel@2:     register vector unsigned char pixelsv1B, pixelsv2B;
nengel@2:     register vector unsigned char pixelsv1C, pixelsv2C;
nengel@2:     register vector unsigned char pixelsv1D, pixelsv2D;
nengel@2: 
nengel@2:     const int perm = (unsigned int) src & 15;
nengel@2:     const int shift_dst = (unsigned int) dst & 15;
nengel@2: 
nengel@2:     // 4x dest luma blocks are desaligned by 0, 4, 8, or 12
nengel@2:     vuint8_t dstmask = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
nengel@2:     const vuint8_t dstmask0=  {0x10,0x11,0x12,0x13,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
nengel@2:     const vuint8_t dstmask4=  {0x00,0x01,0x02,0x03,0x10,0x11,0x12,0x13,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
nengel@2:     const vuint8_t dstmask8=  {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x10,0x11,0x12,0x13,0x0C,0x0D,0x0E,0x0F};
nengel@2:     const vuint8_t dstmask12= {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x10,0x11,0x12,0x13};
nengel@2: 
nengel@2:     switch(shift_dst){
nengel@2:       case 0:  dstmask = dstmask0;
nengel@2:                break;
nengel@2:       case 4:  dstmask = dstmask4;
nengel@2:                break;
nengel@2:       case 8:  dstmask = dstmask8;
nengel@2:                break;
nengel@2:       case 12: dstmask = dstmask12;
nengel@2:                break;
nengel@2:     }
nengel@2: 
nengel@2:     int i;
nengel@2: 	register int line_size   = src_stride;
nengel@2:     register int line_size_2 = line_size << 1;
nengel@2:     register int line_size_3 = line_size + line_size_2;
nengel@2:     register int line_size_4 = line_size << 2;
nengel@2: 
nengel@2: 	register int dst_stride_2 = dst_stride << 1;
nengel@2:     register int dst_stride_3 = dst_stride_2 + dst_stride;
nengel@2:     register int dst_stride_4 = dst_stride << 2;
nengel@2: 
nengel@2:     for(i=0; i<h; i+=4) {
nengel@2: 	  pixelsv1A = *(vuint8_t *)(src);
nengel@2:       pixelsv2A = *(vuint8_t *)(src+16);
nengel@2:       pixelsv1B = *(vuint8_t *)(src + line_size);
nengel@2:       pixelsv2B = *(vuint8_t *)(src+16 + line_size);
nengel@2:       pixelsv1C = *(vuint8_t *)(src + line_size_2);
nengel@2:       pixelsv2C = *(vuint8_t *)(src+16 + line_size_2);
nengel@2:       pixelsv1D = *(vuint8_t *)(src + line_size_3);
nengel@2:       pixelsv2D = *(vuint8_t *)(src+16 + line_size_3);
nengel@2: 
nengel@2:       const vuint8_t block1 = *(vuint8_t *) dst;
nengel@2:       const vuint8_t put1a = spu_shuffle(block1, spu_or(spu_slqwbyte(pixelsv1A, perm), spu_rlmaskqwbyte(pixelsv2A, perm-16)), dstmask);
nengel@2:       const vuint8_t put1 = spu_avg(block1,put1a);
nengel@2: 
nengel@2:       const vuint8_t block2 = *(vuint8_t *)(dst + dst_stride);
nengel@2:       const vuint8_t put2a = spu_shuffle(block2, spu_or(spu_slqwbyte(pixelsv1B, perm), spu_rlmaskqwbyte(pixelsv2B, perm-16)), dstmask);
nengel@2:       const vuint8_t put2 = spu_avg(block2,put2a);
nengel@2: 
nengel@2:       const vuint8_t block3 = *(vuint8_t *)(dst + dst_stride_2);
nengel@2:       const vuint8_t put3a = spu_shuffle(block3, spu_or(spu_slqwbyte(pixelsv1C, perm), spu_rlmaskqwbyte(pixelsv2C, perm-16)), dstmask);
nengel@2:       const vuint8_t put3 = spu_avg(block3,put3a);
nengel@2: 
nengel@2:       const vuint8_t block4 = *(vuint8_t *)(dst + dst_stride_3);
nengel@2:       const vuint8_t put4a = spu_shuffle(block4, spu_or(spu_slqwbyte(pixelsv1D, perm), spu_rlmaskqwbyte(pixelsv2D, perm-16)), dstmask);
nengel@2:       const vuint8_t put4 = spu_avg(block4,put4a);
nengel@2: 
nengel@2:       *(vuint8_t *) dst = put1;
nengel@2:       *(vuint8_t *)(dst + dst_stride) = put2;
nengel@2:       *(vuint8_t *)(dst + dst_stride_2) = put3;
nengel@2:       *(vuint8_t *)(dst + dst_stride_3) = put4;
nengel@2: 
nengel@2:       src+= line_size_4;
nengel@2:       dst+= dst_stride_4;
nengel@2:     }
nengel@2: }
nengel@2: 
nengel@2: /* Here we create all the interpolation modes H.264 motion compensation stage for luma */
nengel@2:   H264_MC(put_, 16, spu)
nengel@2:   H264_MC(put_, 8, spu)
nengel@2:   H264_MC(put_, 4, spu)
nengel@2: 
nengel@2:   H264_MC(avg_, 16, spu)
nengel@2:   H264_MC(avg_, 8, spu)
nengel@2:   H264_MC(avg_, 4, spu)
nengel@2: 
nengel@2: 
nengel@2: //Chroma interpolation:
nengel@2: 
nengel@2: #define OP_U8_SPU                          PUT_OP_U8_SPU
nengel@2: #define PREFIX_h264_chroma_mc8_spu         put_h264_chroma_mc8_spu
nengel@2: #define PREFIX_h264_chroma_mc4_spu         put_h264_chroma_mc4_spu
nengel@2: #define PREFIX_h264_chroma_mc2_spu         put_h264_chroma_mc2_spu
nengel@2: #include "h264_chroma_template_spu.c"
nengel@2: #undef OP_U8_SPU
nengel@2: #undef PREFIX_h264_chroma_mc8_spu
nengel@2: #undef PREFIX_h264_chroma_mc4_spu
nengel@2: #undef PREFIX_h264_chroma_mc2_spu
nengel@2: 
nengel@2: #define OP_U8_SPU                          AVG_OP_U8_SPU
nengel@2: #define PREFIX_h264_chroma_mc8_spu         avg_h264_chroma_mc8_spu
nengel@2: #define PREFIX_h264_chroma_mc4_spu         avg_h264_chroma_mc4_spu
nengel@2: #define PREFIX_h264_chroma_mc2_spu         avg_h264_chroma_mc2_spu
nengel@2: #include "h264_chroma_template_spu.c"
nengel@2: #undef OP_U8_SPU
nengel@2: #undef PREFIX_h264_chroma_mc8_spu
nengel@2: #undef PREFIX_h264_chroma_mc4_spu
nengel@2: #undef PREFIX_h264_chroma_mc2_spu
nengel@2: 
nengel@2: // Weight and Biweight functions
nengel@2: 
nengel@2: #define op_scale1(x)  dst[x] = av_clip_uint8( (dst[x]*weight + offset) >> log2_denom )
nengel@2: #define op_scale2(x)  dst[x] = av_clip_uint8( (src[x]*weights + dst[x]*weightd + offset) >> (log2_denom+1))
nengel@2: #define H264_WEIGHT(W,H) \
nengel@2: static void weight_h264_pixels ## W ## x ## H ## _c(uint8_t *dst, int stride, int log2_denom, int weight, int offset){ \
nengel@2:     int y; \
nengel@2:     offset <<= log2_denom; \
nengel@2:     if(log2_denom) offset += 1<<(log2_denom-1); \
nengel@2:     for(y=0; y<H; y++, dst += stride){ \
nengel@2:         op_scale1(0); \
nengel@2:         op_scale1(1); \
nengel@2:         if(W==2) continue; \
nengel@2:         op_scale1(2); \
nengel@2:         op_scale1(3); \
nengel@2:         if(W==4) continue; \
nengel@2:         op_scale1(4); \
nengel@2:         op_scale1(5); \
nengel@2:         op_scale1(6); \
nengel@2:         op_scale1(7); \
nengel@2:         if(W==8) continue; \
nengel@2:         op_scale1(8); \
nengel@2:         op_scale1(9); \
nengel@2:         op_scale1(10); \
nengel@2:         op_scale1(11); \
nengel@2:         op_scale1(12); \
nengel@2:         op_scale1(13); \
nengel@2:         op_scale1(14); \
nengel@2:         op_scale1(15); \
nengel@2:     } \
nengel@2: } \
nengel@2: static void biweight_h264_pixels ## W ## x ## H ## _c(uint8_t *dst, uint8_t *src, int dst_stride, int src_stride, int log2_denom, int weightd, int weights, int offset){ \
nengel@2:     int y; \
nengel@2:     offset = ((offset + 1) | 1) << log2_denom; \
nengel@2:     for(y=0; y<H; y++, dst += dst_stride, src += src_stride){ \
nengel@2:         op_scale2(0); \
nengel@2:         op_scale2(1); \
nengel@2:         if(W==2) continue; \
nengel@2:         op_scale2(2); \
nengel@2:         op_scale2(3); \
nengel@2:         if(W==4) continue; \
nengel@2:         op_scale2(4); \
nengel@2:         op_scale2(5); \
nengel@2:         op_scale2(6); \
nengel@2:         op_scale2(7); \
nengel@2:         if(W==8) continue; \
nengel@2:         op_scale2(8); \
nengel@2:         op_scale2(9); \
nengel@2:         op_scale2(10); \
nengel@2:         op_scale2(11); \
nengel@2:         op_scale2(12); \
nengel@2:         op_scale2(13); \
nengel@2:         op_scale2(14); \
nengel@2:         op_scale2(15); \
nengel@2:     } \
nengel@2: }
nengel@2: 
nengel@2: H264_WEIGHT(16,16)
nengel@2: H264_WEIGHT(16,8)
nengel@2: H264_WEIGHT(8,16)
nengel@2: H264_WEIGHT(8,8)
nengel@2: H264_WEIGHT(8,4)
nengel@2: H264_WEIGHT(4,8)
nengel@2: H264_WEIGHT(4,4)
nengel@2: H264_WEIGHT(4,2)
nengel@2: H264_WEIGHT(2,4)
nengel@2: H264_WEIGHT(2,2)
nengel@2: 
nengel@2: #undef op_scale1
nengel@2: #undef op_scale2
nengel@2: #undef H264_WEIGHT
nengel@2: 
nengel@2: /////////////////////////////////////////////////////////////////////////////////////////
nengel@2: 
nengel@2: static inline void h264_loop_filter_luma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
nengel@2: {
nengel@2:     int i, d;
nengel@2:     for( i = 0; i < 4; i++ ) {
nengel@2:         if( tc0[i] < 0 ) {
nengel@2:             pix += 4*ystride;
nengel@2:             continue;
nengel@2:         }
nengel@2:         for( d = 0; d < 4; d++ ) {
nengel@2:             const int p0 = pix[-1*xstride];
nengel@2:             const int p1 = pix[-2*xstride];
nengel@2:             const int p2 = pix[-3*xstride];
nengel@2:             const int q0 = pix[0];
nengel@2:             const int q1 = pix[1*xstride];
nengel@2:             const int q2 = pix[2*xstride];
nengel@2: 
nengel@2:             if( FFABS( p0 - q0 ) < alpha &&
nengel@2:                 FFABS( p1 - p0 ) < beta &&
nengel@2:                 FFABS( q1 - q0 ) < beta ) {
nengel@2: 
nengel@2:                 int tc = tc0[i];
nengel@2:                 int i_delta;
nengel@2: 
nengel@2:                 if( FFABS( p2 - p0 ) < beta ) {
nengel@2:                     pix[-2*xstride] = p1 + av_clip( (( p2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - p1, -tc0[i], tc0[i] );
nengel@2:                     tc++;
nengel@2:                 }
nengel@2:                 if( FFABS( q2 - q0 ) < beta ) {
nengel@2:                     pix[   xstride] = q1 + av_clip( (( q2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - q1, -tc0[i], tc0[i] );
nengel@2:                     tc++;
nengel@2:                 }
nengel@2: 
nengel@2:                 i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
nengel@2:                 pix[-xstride] = av_clip_uint8( p0 + i_delta );    /* p0' */
nengel@2:                 pix[0]        = av_clip_uint8( q0 - i_delta );    /* q0' */
nengel@2:             }
nengel@2:             pix += ystride;
nengel@2:         }
nengel@2:     }
nengel@2: }
nengel@2: static void h264_v_loop_filter_luma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
nengel@2: {
nengel@2:     h264_loop_filter_luma_c(pix, stride, 1, alpha, beta, tc0);
nengel@2: }
nengel@2: static void h264_h_loop_filter_luma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
nengel@2: {
nengel@2:     h264_loop_filter_luma_c(pix, 1, stride, alpha, beta, tc0);
nengel@2: }
nengel@2: 
nengel@2: static inline void h264_loop_filter_luma_intra_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta)
nengel@2: {
nengel@2:     int d;
nengel@2:     for( d = 0; d < 16; d++ ) {
nengel@2:         const int p2 = pix[-3*xstride];
nengel@2:         const int p1 = pix[-2*xstride];
nengel@2:         const int p0 = pix[-1*xstride];
nengel@2: 
nengel@2:         const int q0 = pix[ 0*xstride];
nengel@2:         const int q1 = pix[ 1*xstride];
nengel@2:         const int q2 = pix[ 2*xstride];
nengel@2: 
nengel@2:         if( FFABS( p0 - q0 ) < alpha &&
nengel@2:             FFABS( p1 - p0 ) < beta &&
nengel@2:             FFABS( q1 - q0 ) < beta ) {
nengel@2: 
nengel@2:             if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
nengel@2:                 if( FFABS( p2 - p0 ) < beta)
nengel@2:                 {
nengel@2:                     const int p3 = pix[-4*xstride];
nengel@2:                     /* p0', p1', p2' */
nengel@2:                     pix[-1*xstride] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
nengel@2:                     pix[-2*xstride] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
nengel@2:                     pix[-3*xstride] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
nengel@2:                 } else {
nengel@2:                     /* p0' */
nengel@2:                     pix[-1*xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
nengel@2:                 }
nengel@2:                 if( FFABS( q2 - q0 ) < beta)
nengel@2:                 {
nengel@2:                     const int q3 = pix[3*xstride];
nengel@2:                     /* q0', q1', q2' */
nengel@2:                     pix[0*xstride] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
nengel@2:                     pix[1*xstride] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
nengel@2:                     pix[2*xstride] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
nengel@2:                 } else {
nengel@2:                     /* q0' */
nengel@2:                     pix[0*xstride] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
nengel@2:                 }
nengel@2:             }else{
nengel@2:                 /* p0', q0' */
nengel@2:                 pix[-1*xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
nengel@2:                 pix[ 0*xstride] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
nengel@2:             }
nengel@2:         }
nengel@2:         pix += ystride;
nengel@2:     }
nengel@2: }
nengel@2: static void h264_v_loop_filter_luma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
nengel@2: {
nengel@2:     h264_loop_filter_luma_intra_c(pix, stride, 1, alpha, beta);
nengel@2: }
nengel@2: static void h264_h_loop_filter_luma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
nengel@2: {
nengel@2:     h264_loop_filter_luma_intra_c(pix, 1, stride, alpha, beta);
nengel@2: }
nengel@2: 
nengel@2: static inline void h264_loop_filter_chroma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
nengel@2: {
nengel@2:     int i, d;
nengel@2:     for( i = 0; i < 4; i++ ) {
nengel@2:         const int tc = tc0[i];
nengel@2:         if( tc <= 0 ) {
nengel@2:             pix += 2*ystride;
nengel@2:             continue;
nengel@2:         }
nengel@2:         for( d = 0; d < 2; d++ ) {
nengel@2:             const int p0 = pix[-1*xstride];
nengel@2:             const int p1 = pix[-2*xstride];
nengel@2:             const int q0 = pix[0];
nengel@2:             const int q1 = pix[1*xstride];
nengel@2: 
nengel@2:             if( FFABS( p0 - q0 ) < alpha &&
nengel@2:                 FFABS( p1 - p0 ) < beta &&
nengel@2:                 FFABS( q1 - q0 ) < beta ) {
nengel@2: 
nengel@2:                 int delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
nengel@2: 
nengel@2:                 pix[-xstride] = av_clip_uint8( p0 + delta );    /* p0' */
nengel@2:                 pix[0]        = av_clip_uint8( q0 - delta );    /* q0' */
nengel@2:             }
nengel@2:             pix += ystride;
nengel@2:         }
nengel@2:     }
nengel@2: }
nengel@2: static void h264_v_loop_filter_chroma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
nengel@2: {
nengel@2:     h264_loop_filter_chroma_c(pix, stride, 1, alpha, beta, tc0);
nengel@2: }
nengel@2: static void h264_h_loop_filter_chroma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
nengel@2: {
nengel@2:     h264_loop_filter_chroma_c(pix, 1, stride, alpha, beta, tc0);
nengel@2: }
nengel@2: 
nengel@2: static inline void h264_loop_filter_chroma_intra_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta)
nengel@2: {
nengel@2:     int d;
nengel@2:     for( d = 0; d < 8; d++ ) {
nengel@2:         const int p0 = pix[-1*xstride];
nengel@2:         const int p1 = pix[-2*xstride];
nengel@2:         const int q0 = pix[0];
nengel@2:         const int q1 = pix[1*xstride];
nengel@2: 
nengel@2:         if( FFABS( p0 - q0 ) < alpha &&
nengel@2:             FFABS( p1 - p0 ) < beta &&
nengel@2:             FFABS( q1 - q0 ) < beta ) {
nengel@2: 
nengel@2:             pix[-xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;   /* p0' */
nengel@2:             pix[0]        = ( 2*q1 + q0 + p1 + 2 ) >> 2;   /* q0' */
nengel@2:         }
nengel@2:         pix += ystride;
nengel@2:     }
nengel@2: }
nengel@2: static void h264_v_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
nengel@2: {
nengel@2:     h264_loop_filter_chroma_intra_c(pix, stride, 1, alpha, beta);
nengel@2: }
nengel@2: static void h264_h_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
nengel@2: {
nengel@2:     h264_loop_filter_chroma_intra_c(pix, 1, stride, alpha, beta);
nengel@2: }
nengel@2: 
nengel@2: 
nengel@2: void dsputil_h264_init_cell(DSPContext_spu* c) {
nengel@2: 
nengel@2: 	c->h264_v_loop_filter_luma= h264_v_loop_filter_luma_c;
nengel@2:     c->h264_h_loop_filter_luma= h264_h_loop_filter_luma_c;
nengel@2:     c->h264_v_loop_filter_luma_intra= h264_v_loop_filter_luma_intra_c;
nengel@2:     c->h264_h_loop_filter_luma_intra= h264_h_loop_filter_luma_intra_c;
nengel@2:     c->h264_v_loop_filter_chroma= h264_v_loop_filter_chroma_c;
nengel@2:     c->h264_h_loop_filter_chroma= h264_h_loop_filter_chroma_c;
nengel@2:     c->h264_v_loop_filter_chroma_intra= h264_v_loop_filter_chroma_intra_c;
nengel@2:     c->h264_h_loop_filter_chroma_intra= h264_h_loop_filter_chroma_intra_c;
nengel@2: 
nengel@2:     c->h264_idct_add[0] = h264_idct8_add_spu;
nengel@2:     c->h264_idct_add[1] = h264_idct4_add_spu;
nengel@2: 
nengel@2: 
nengel@2:     c->put_h264_chroma_pixels_tab[0] = put_h264_chroma_mc8_spu;
nengel@2:     c->put_h264_chroma_pixels_tab[1] = put_h264_chroma_mc4_spu;
nengel@2:     c->put_h264_chroma_pixels_tab[2] = put_h264_chroma_mc2_spu;
nengel@2:     c->avg_h264_chroma_pixels_tab[0] = avg_h264_chroma_mc8_spu;
nengel@2:     c->avg_h264_chroma_pixels_tab[1] = avg_h264_chroma_mc4_spu;
nengel@2:     c->avg_h264_chroma_pixels_tab[2] = avg_h264_chroma_mc2_spu;
nengel@2: 
nengel@2:     c->weight_h264_pixels_tab[0]= weight_h264_pixels16x16_c;
nengel@2:     c->weight_h264_pixels_tab[1]= weight_h264_pixels16x8_c;
nengel@2:     c->weight_h264_pixels_tab[2]= weight_h264_pixels8x16_c;
nengel@2:     c->weight_h264_pixels_tab[3]= weight_h264_pixels8x8_c;
nengel@2:     c->weight_h264_pixels_tab[4]= weight_h264_pixels8x4_c;
nengel@2:     c->weight_h264_pixels_tab[5]= weight_h264_pixels4x8_c;
nengel@2:     c->weight_h264_pixels_tab[6]= weight_h264_pixels4x4_c;
nengel@2:     c->weight_h264_pixels_tab[7]= weight_h264_pixels4x2_c;
nengel@2:     c->weight_h264_pixels_tab[8]= weight_h264_pixels2x4_c;
nengel@2:     c->weight_h264_pixels_tab[9]= weight_h264_pixels2x2_c;
nengel@2:     c->biweight_h264_pixels_tab[0]= biweight_h264_pixels16x16_c;
nengel@2:     c->biweight_h264_pixels_tab[1]= biweight_h264_pixels16x8_c;
nengel@2:     c->biweight_h264_pixels_tab[2]= biweight_h264_pixels8x16_c;
nengel@2:     c->biweight_h264_pixels_tab[3]= biweight_h264_pixels8x8_c;
nengel@2:     c->biweight_h264_pixels_tab[4]= biweight_h264_pixels8x4_c;
nengel@2:     c->biweight_h264_pixels_tab[5]= biweight_h264_pixels4x8_c;
nengel@2:     c->biweight_h264_pixels_tab[6]= biweight_h264_pixels4x4_c;
nengel@2:     c->biweight_h264_pixels_tab[7]= biweight_h264_pixels4x2_c;
nengel@2:     c->biweight_h264_pixels_tab[8]= biweight_h264_pixels2x4_c;
nengel@2:     c->biweight_h264_pixels_tab[9]= biweight_h264_pixels2x2_c;
nengel@2: 
nengel@2: 
nengel@2: #define dspfunc(PFX, IDX, NUM) \
nengel@2:     c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_spu; \
nengel@2:     c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_spu
nengel@2: 
nengel@2:     dspfunc(put_h264_qpel, 0, 16);
nengel@2:     dspfunc(put_h264_qpel, 1, 8);
nengel@2:     dspfunc(put_h264_qpel, 2, 4);
nengel@2: 
nengel@2:     dspfunc(avg_h264_qpel, 0, 16);
nengel@2:     dspfunc(avg_h264_qpel, 1, 8);
nengel@2:     dspfunc(avg_h264_qpel, 2, 4);
nengel@2: 
nengel@2: #undef dspfunc
nengel@2: 
nengel@2: 
nengel@2: }