/*

* SDL - Simple DirectMedia Layer

* CELL BE Support for PS3 Framebuffer

* Copyright (C) 2008, 2009 International Business Machines Corporation

*

* This library is free software; you can redistribute it and/or modify it

* under the terms of the GNU Lesser General Public License as published

* by the Free Software Foundation; either version 2.1 of the License, or

* (at your option) any later version.

*

* This library 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

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the Free Software

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301

* USA

*

* Martin Lowinski <lowinski [at] de [dot] ibm [ibm] com>

* Dirk Herrendoerfer <d.herrendoerfer [at] de [dot] ibm [dot] com>

* SPE code based on research by:

* Rene Becker

* Thimo Emmerich

*/

#include "spu_common.h"

#include <spu_intrinsics.h>

#include <spu_mfcio.h>

// Debugging

//#define DEBUG

#ifdef DEBUG

#define deprintf(fmt, args... ) \

fprintf( stdout, fmt, ##args ); \

fflush( stdout );

#else

#define deprintf( fmt, args... )

#endif

struct yuv2rgb_parms_t parms_converter __attribute__((aligned(128)));

/* A maximum of 8 lines Y, therefore 4 lines V, 4 lines U are stored

* there might be the need to retrieve misaligned data, adjust

* incoming v and u plane to be able to handle this (add 128)

*/

unsigned char y_plane[2][(MAX_HDTV_WIDTH + 128) * 4] __attribute__((aligned(128)));

unsigned char v_plane[2][(MAX_HDTV_WIDTH + 128) * 2] __attribute__((aligned(128)));

unsigned char u_plane[2][(MAX_HDTV_WIDTH + 128) * 2] __attribute__((aligned(128)));

/* A maximum of 4 lines BGRA are stored, 4 byte per pixel */

unsigned char bgra[4 * MAX_HDTV_WIDTH * 4] __attribute__((aligned(128)));

/* some vectors needed by the float to int conversion */

static const vector float vec_255 = { 255.0f, 255.0f, 255.0f, 255.0f };

static const vector float vec_0_1 = { 0.1f, 0.1f, 0.1f, 0.1f };

void yuv_to_rgb_w16();

void yuv_to_rgb_w32();

void yuv_to_rgb_w16_line(unsigned char* y_addr, unsigned char* v_addr, unsigned char* u_addr, unsigned char* bgra_addr, unsigned int width);

void yuv_to_rgb_w32_line(unsigned char* y_addr, unsigned char* v_addr, unsigned char* u_addr, unsigned char* bgra_addr_, unsigned int width);

int main(unsigned long long spe_id __attribute__((unused)), unsigned long long argp __attribute__ ((unused)))

{

deprintf("[SPU] yuv2rgb_spu is up... (on SPE #%llu)\n", spe_id);

uint32_t ea_mfc, mbox;

// send ready message

spu_write_out_mbox(SPU_READY);

while (1) {

/* Check mailbox */

mbox = spu_read_in_mbox();

deprintf("[SPU] Message is %u\n", mbox);

switch (mbox) {

case SPU_EXIT:

deprintf("[SPU] fb_writer goes down...\n");

return 0;

case SPU_START:

break;

default:

deprintf("[SPU] Cannot handle message\n");

continue;

}

/* Tag Manager setup */

unsigned int tag_id;

tag_id = mfc_multi_tag_reserve(1);

if (tag_id == MFC_TAG_INVALID) {

deprintf("[SPU] Failed to reserve mfc tags on yuv2rgb_converter\n");

return 0;

}

/* DMA transfer for the input parameters */

ea_mfc = spu_read_in_mbox();

deprintf("[SPU] Message on yuv2rgb_converter is %u\n", ea_mfc);

spu_mfcdma32(&parms_converter, (unsigned int)ea_mfc, sizeof(struct yuv2rgb_parms_t), tag_id, MFC_GET_CMD);

DMA_WAIT_TAG(tag_id);

/* There are alignment issues that involve handling of special cases

* a width of 32 results in a width of 16 in the chrominance

* --> choose the proper handling to optimize the performance

*/

deprintf("[SPU] Convert %ix%i from YUV to RGB\n", parms_converter.src_pixel_width, parms_converter.src_pixel_height);

if (parms_converter.src_pixel_width & 0x1f) {

deprintf("[SPU] Using yuv_to_rgb_w16\n");

yuv_to_rgb_w16();

} else {

deprintf("[SPU] Using yuv_to_rgb_w32\n");

yuv_to_rgb_w32();

}

mfc_multi_tag_release(tag_id, 1);

deprintf("[SPU] yuv2rgb_spu... done!\n");

/* Send FIN message */

spu_write_out_mbox(SPU_FIN);

}

return 0;

}

/*

* float_to_char()

*

* converts a float to a character using saturated

* arithmetic

*

* @param s float for conversion

* @returns converted character

*/

inline static unsigned char float_to_char(float s) {

vector float vec_s = spu_splats(s);

vector unsigned int select_1 = spu_cmpgt(vec_0_1, vec_s);

vec_s = spu_sel(vec_s, vec_0_1, select_1);

vector unsigned int select_2 = spu_cmpgt(vec_s, vec_255);

vec_s = spu_sel(vec_s, vec_255, select_2);

return (unsigned char) spu_extract(vec_s,0);

}

/*

* vfloat_to_vuint()

*

* converts a float vector to an unsinged int vector using saturated

* arithmetic

*

* @param vec_s float vector for conversion

* @returns converted unsigned int vector

*/

inline static vector unsigned int vfloat_to_vuint(vector float vec_s) {

vector unsigned int select_1 = spu_cmpgt(vec_0_1, vec_s);

vec_s = spu_sel(vec_s, vec_0_1, select_1);

vector unsigned int select_2 = spu_cmpgt(vec_s, vec_255);

vec_s = spu_sel(vec_s, vec_255, select_2);

return spu_convtu(vec_s,0);

}

void yuv_to_rgb_w16() {

// Pixel dimensions of the picture

uint32_t width, height;

// Extract parameters

width = parms_converter.src_pixel_width;

height = parms_converter.src_pixel_height;

// Plane data management

// Y

unsigned char* ram_addr_y = parms_converter.y_plane;

// V

unsigned char* ram_addr_v = parms_converter.v_plane;

// U

unsigned char* ram_addr_u = parms_converter.u_plane;

// BGRA

unsigned char* ram_addr_bgra = parms_converter.dstBuffer;

// Strides

unsigned int stride_y = width;

unsigned int stride_vu = width>>1;

// Buffer management

unsigned int buf_idx = 0;

unsigned int size_4lines_y = stride_y<<2;

unsigned int size_2lines_y = stride_y<<1;

unsigned int size_2lines_vu = stride_vu<<1;

// 2*width*4byte_per_pixel

unsigned int size_2lines_bgra = width<<3;

// start double-buffered processing

// 4 lines y

spu_mfcdma32(y_plane[buf_idx], (unsigned int) ram_addr_y, size_4lines_y, RETR_BUF+buf_idx, MFC_GET_CMD);

// 2 lines v

spu_mfcdma32(v_plane[buf_idx], (unsigned int) ram_addr_v, size_2lines_vu, RETR_BUF+buf_idx, MFC_GET_CMD);

// 2 lines u

spu_mfcdma32(u_plane[buf_idx], (unsigned int) ram_addr_u, size_2lines_vu, RETR_BUF+buf_idx, MFC_GET_CMD);

// Wait for these transfers to be completed

DMA_WAIT_TAG((RETR_BUF + buf_idx));

unsigned int i;

for(i=0; i<(height>>2)-1; i++) {

buf_idx^=1;

// 4 lines y

spu_mfcdma32(y_plane[buf_idx], (unsigned int) ram_addr_y+size_4lines_y, size_4lines_y, RETR_BUF+buf_idx, MFC_GET_CMD);

// 2 lines v

spu_mfcdma32(v_plane[buf_idx], (unsigned int) ram_addr_v+size_2lines_vu, size_2lines_vu, RETR_BUF+buf_idx, MFC_GET_CMD);

// 2 lines u

spu_mfcdma32(u_plane[buf_idx], (unsigned int) ram_addr_u+size_2lines_vu, size_2lines_vu, RETR_BUF+buf_idx, MFC_GET_CMD);

DMA_WAIT_TAG((RETR_BUF + buf_idx));

buf_idx^=1;

// Convert YUV to BGRA, store it back (first two lines)

yuv_to_rgb_w16_line(y_plane[buf_idx], v_plane[buf_idx], u_plane[buf_idx], bgra, width);

// Next two lines

yuv_to_rgb_w16_line(y_plane[buf_idx] + size_2lines_y,

v_plane[buf_idx] + stride_vu,

u_plane[buf_idx] + stride_vu,

bgra + size_2lines_bgra,

width);

// Wait for previous storing transfer to be completed

DMA_WAIT_TAG(STR_BUF);

// Store converted lines in two steps->max transfer size 16384

spu_mfcdma32(bgra, (unsigned int) ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD);

ram_addr_bgra += size_2lines_bgra;

spu_mfcdma32(bgra+size_2lines_bgra, (unsigned int) ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD);

ram_addr_bgra += size_2lines_bgra;

// Move 4 lines

ram_addr_y += size_4lines_y;

ram_addr_v += size_2lines_vu;

ram_addr_u += size_2lines_vu;

buf_idx^=1;

}

// Convert YUV to BGRA, store it back (first two lines)

yuv_to_rgb_w16_line(y_plane[buf_idx], v_plane[buf_idx], u_plane[buf_idx], bgra, width);

// Next two lines

yuv_to_rgb_w16_line(y_plane[buf_idx] + size_2lines_y,

v_plane[buf_idx] + stride_vu,

u_plane[buf_idx] + stride_vu,

bgra + size_2lines_bgra,

width);

// Wait for previous storing transfer to be completed

DMA_WAIT_TAG(STR_BUF);

spu_mfcdma32(bgra, (unsigned int) ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD);

ram_addr_bgra += size_2lines_bgra;

spu_mfcdma32(bgra+size_2lines_bgra, (unsigned int) ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD);

// wait for previous storing transfer to be completed

DMA_WAIT_TAG(STR_BUF);

}

void yuv_to_rgb_w32() {

// Pixel dimensions of the picture

uint32_t width, height;

// Extract parameters

width = parms_converter.src_pixel_width;

height = parms_converter.src_pixel_height;

// Plane data management

// Y

unsigned char* ram_addr_y = parms_converter.y_plane;

// V

unsigned char* ram_addr_v = parms_converter.v_plane;

// U

unsigned char* ram_addr_u = parms_converter.u_plane;

// BGRA

unsigned char* ram_addr_bgra = parms_converter.dstBuffer;

// Strides

unsigned int stride_y = width;

unsigned int stride_vu = width>>1;

// Buffer management

unsigned int buf_idx = 0;

unsigned int size_4lines_y = stride_y<<2;

unsigned int size_2lines_y = stride_y<<1;

unsigned int size_2lines_vu = stride_vu<<1;

// 2*width*4byte_per_pixel

unsigned int size_2lines_bgra = width<<3;

// start double-buffered processing

// 4 lines y

spu_mfcdma32(y_plane[buf_idx], (unsigned int) ram_addr_y, size_4lines_y, RETR_BUF + buf_idx, MFC_GET_CMD);

// 2 lines v

spu_mfcdma32(v_plane[buf_idx], (unsigned int) ram_addr_v, size_2lines_vu, RETR_BUF + buf_idx, MFC_GET_CMD);

// 2 lines u

spu_mfcdma32(u_plane[buf_idx], (unsigned int) ram_addr_u, size_2lines_vu, RETR_BUF + buf_idx, MFC_GET_CMD);

// Wait for these transfers to be completed

DMA_WAIT_TAG((RETR_BUF + buf_idx));

unsigned int i;

for(i=0; i < (height>>2)-1; i++) {

buf_idx^=1;

// 4 lines y

spu_mfcdma32(y_plane[buf_idx], (unsigned int) ram_addr_y+size_4lines_y, size_4lines_y, RETR_BUF + buf_idx, MFC_GET_CMD);

deprintf("4lines = %d\n", size_4lines_y);

// 2 lines v

spu_mfcdma32(v_plane[buf_idx], (unsigned int) ram_addr_v+size_2lines_vu, size_2lines_vu, RETR_BUF + buf_idx, MFC_GET_CMD);

deprintf("2lines = %d\n", size_2lines_vu);

// 2 lines u

spu_mfcdma32(u_plane[buf_idx], (unsigned int) ram_addr_u+size_2lines_vu, size_2lines_vu, RETR_BUF + buf_idx, MFC_GET_CMD);

deprintf("2lines = %d\n", size_2lines_vu);

DMA_WAIT_TAG((RETR_BUF + buf_idx));

buf_idx^=1;

// Convert YUV to BGRA, store it back (first two lines)

yuv_to_rgb_w32_line(y_plane[buf_idx], v_plane[buf_idx], u_plane[buf_idx], bgra, width);

// Next two lines

yuv_to_rgb_w32_line(y_plane[buf_idx] + size_2lines_y,

v_plane[buf_idx] + stride_vu,

u_plane[buf_idx] + stride_vu,

bgra + size_2lines_bgra,

width);

// Wait for previous storing transfer to be completed

DMA_WAIT_TAG(STR_BUF);

// Store converted lines in two steps->max transfer size 16384

spu_mfcdma32(bgra, (unsigned int)ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD);

ram_addr_bgra += size_2lines_bgra;

spu_mfcdma32(bgra + size_2lines_bgra, (unsigned int)ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD);

ram_addr_bgra += size_2lines_bgra;

// Move 4 lines

ram_addr_y += size_4lines_y;

ram_addr_v += size_2lines_vu;

ram_addr_u += size_2lines_vu;

buf_idx^=1;

}

// Convert YUV to BGRA, store it back (first two lines)

yuv_to_rgb_w32_line(y_plane[buf_idx], v_plane[buf_idx], u_plane[buf_idx], bgra, width);

// Next two lines

yuv_to_rgb_w32_line(y_plane[buf_idx] + size_2lines_y,

v_plane[buf_idx] + stride_vu,

u_plane[buf_idx] + stride_vu,

bgra + size_2lines_bgra,

width);

// Wait for previous storing transfer to be completed

DMA_WAIT_TAG(STR_BUF);

spu_mfcdma32(bgra, (unsigned int) ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD);

ram_addr_bgra += size_2lines_bgra;

spu_mfcdma32(bgra + size_2lines_bgra, (unsigned int) ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD);

// Wait for previous storing transfer to be completed

DMA_WAIT_TAG(STR_BUF);

}

/* Some vectors needed by the yuv 2 rgb conversion algorithm */

const vector float vec_minus_128 = { -128.0f, -128.0f, -128.0f, -128.0f };

const vector unsigned char vec_null = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

const vector unsigned char vec_char2int_first = { 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x13 };

const vector unsigned char vec_char2int_second = { 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x17 };

const vector unsigned char vec_char2int_third = { 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x1B };

const vector unsigned char vec_char2int_fourth = { 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x1F };

const vector float vec_R_precalc_coeff = {1.403f, 1.403f, 1.403f, 1.403f};

const vector float vec_Gu_precalc_coeff = {-0.344f, -0.344f, -0.344f, -0.344f};

const vector float vec_Gv_precalc_coeff = {-0.714f, -0.714f, -0.714f, -0.714f};

const vector float vec_B_precalc_coeff = {1.773f, 1.773f, 1.773f, 1.773f};

const vector unsigned int vec_alpha = { 255 << 24, 255 << 24, 255 << 24, 255 << 24 };

const vector unsigned char vec_select_floats_upper = { 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x04, 0x05, 0x06, 0x07 };

const vector unsigned char vec_select_floats_lower = { 0x08, 0x09, 0x0A, 0x0B, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x0C, 0x0D, 0x0E, 0x0F };

/*

* yuv_to_rgb_w16()

*

* processes to line of yuv-input, width has to be a multiple of 16

* two lines of yuv are taken as input

*

* @param y_addr address of the y plane in local store

* @param v_addr address of the v plane in local store

* @param u_addr address of the u plane in local store

* @param bgra_addr_ address of the bgra output buffer

* @param width the width in pixel

*/

void yuv_to_rgb_w16_line(unsigned char* y_addr, unsigned char* v_addr, unsigned char* u_addr, unsigned char* bgra_addr_, unsigned int width) {

// each pixel is stored as an integer

unsigned int* bgra_addr = (unsigned int*) bgra_addr_;

unsigned int x;

for(x = 0; x < width; x+=2) {

// Gehe zweischrittig durch die zeile, da jeder u und v wert fuer 4 pixel(zwei hoch, zwei breit) gilt

const unsigned char Y_1 = *(y_addr + x);

const unsigned char Y_2 = *(y_addr + x + 1);

const unsigned char Y_3 = *(y_addr + x + width);

const unsigned char Y_4 = *(y_addr + x + width + 1);

const unsigned char U = *(u_addr + (x >> 1));

const unsigned char V = *(v_addr + (x >> 1));

float V_minus_128 = (float)((float)V - 128.0f);

float U_minus_128 = (float)((float)U - 128.0f);

float R_precalculate = 1.403f * V_minus_128;

float G_precalculate = -(0.344f * U_minus_128 + 0.714f * V_minus_128);

float B_precalculate = 1.773f * U_minus_128;

const unsigned char R_1 = float_to_char((Y_1 + R_precalculate));

const unsigned char R_2 = float_to_char((Y_2 + R_precalculate));

const unsigned char R_3 = float_to_char((Y_3 + R_precalculate));

const unsigned char R_4 = float_to_char((Y_4 + R_precalculate));

const unsigned char G_1 = float_to_char((Y_1 + G_precalculate));

const unsigned char G_2 = float_to_char((Y_2 + G_precalculate));

const unsigned char G_3 = float_to_char((Y_3 + G_precalculate));

const unsigned char G_4 = float_to_char((Y_4 + G_precalculate));

const unsigned char B_1 = float_to_char((Y_1 + B_precalculate));

const unsigned char B_2 = float_to_char((Y_2 + B_precalculate));

const unsigned char B_3 = float_to_char((Y_3 + B_precalculate));

const unsigned char B_4 = float_to_char((Y_4 + B_precalculate));

*(bgra_addr + x) = (B_1 << 0)| (G_1 << 8) | (R_1 << 16) | (255 << 24);

*(bgra_addr + x + 1) = (B_2 << 0)| (G_2 << 8) | (R_2 << 16) | (255 << 24);

*(bgra_addr + x + width) = (B_3 << 0)| (G_3 << 8) | (R_3 << 16) | (255 << 24);

*(bgra_addr + x + width + 1) = (B_4 << 0)| (G_4 << 8) | (R_4 << 16) | (255 << 24);

}

}

/*

* yuv_to_rgb_w32()

*

* processes to line of yuv-input, width has to be a multiple of 32

* two lines of yuv are taken as input

*

* @param y_addr address of the y plane in local store

* @param v_addr address of the v plane in local store

* @param u_addr address of the u plane in local store

* @param bgra_addr_ address of the bgra output buffer

* @param width the width in pixel

*/

void yuv_to_rgb_w32_line(unsigned char* y_addr, unsigned char* v_addr, unsigned char* u_addr, unsigned char* bgra_addr_, unsigned int width) {

// each pixel is stored as an integer

unsigned int* bgra_addr = (unsigned int*) bgra_addr_;

unsigned int x;

for(x = 0; x < width; x+=32) {

// Gehe zweischrittig durch die zeile, da jeder u und v wert fuer 4 pixel(zwei hoch, zwei breit) gilt

const vector unsigned char vchar_Y_1 = *((vector unsigned char*)(y_addr + x));

const vector unsigned char vchar_Y_2 = *((vector unsigned char*)(y_addr + x + 16));

const vector unsigned char vchar_Y_3 = *((vector unsigned char*)(y_addr + x + width));

const vector unsigned char vchar_Y_4 = *((vector unsigned char*)(y_addr + x + width + 16));

const vector unsigned char vchar_U = *((vector unsigned char*)(u_addr + (x >> 1)));

const vector unsigned char vchar_V = *((vector unsigned char*)(v_addr + (x >> 1)));

const vector float vfloat_U_1 = spu_add(spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_U, vec_char2int_first), 0),vec_minus_128);

const vector float vfloat_U_2 = spu_add(spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_U, vec_char2int_second), 0),vec_minus_128);

const vector float vfloat_U_3 = spu_add(spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_U, vec_char2int_third), 0),vec_minus_128);

const vector float vfloat_U_4 = spu_add(spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_U, vec_char2int_fourth), 0),vec_minus_128);

const vector float vfloat_V_1 = spu_add(spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_V, vec_char2int_first), 0),vec_minus_128);

const vector float vfloat_V_2 = spu_add(spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_V, vec_char2int_second), 0),vec_minus_128);

const vector float vfloat_V_3 = spu_add(spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_V, vec_char2int_third), 0),vec_minus_128);

const vector float vfloat_V_4 = spu_add(spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_V, vec_char2int_fourth), 0),vec_minus_128);

vector float Y_1 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_1, vec_char2int_first), 0);

vector float Y_2 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_1, vec_char2int_second), 0);

vector float Y_3 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_1, vec_char2int_third), 0);

vector float Y_4 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_1, vec_char2int_fourth), 0);

vector float Y_5 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_2, vec_char2int_first), 0);

vector float Y_6 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_2, vec_char2int_second), 0);

vector float Y_7 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_2, vec_char2int_third), 0);

vector float Y_8 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_2, vec_char2int_fourth), 0);

vector float Y_9 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_3, vec_char2int_first), 0);

vector float Y_10 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_3, vec_char2int_second), 0);

vector float Y_11 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_3, vec_char2int_third), 0);

vector float Y_12 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_3, vec_char2int_fourth), 0);

vector float Y_13 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_4, vec_char2int_first), 0);

vector float Y_14 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_4, vec_char2int_second), 0);

vector float Y_15 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_4, vec_char2int_third), 0);

vector float Y_16 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_4, vec_char2int_fourth), 0);

const vector float R1a_precalculate = spu_mul(vec_R_precalc_coeff, vfloat_V_1);

const vector float R2a_precalculate = spu_mul(vec_R_precalc_coeff, vfloat_V_2);

const vector float R3a_precalculate = spu_mul(vec_R_precalc_coeff, vfloat_V_3);

const vector float R4a_precalculate = spu_mul(vec_R_precalc_coeff, vfloat_V_4);

const vector float R1_precalculate = spu_shuffle(R1a_precalculate, R1a_precalculate, vec_select_floats_upper);

const vector float R2_precalculate = spu_shuffle(R1a_precalculate, R1a_precalculate, vec_select_floats_lower);

const vector float R3_precalculate = spu_shuffle(R2a_precalculate, R2a_precalculate, vec_select_floats_upper);

const vector float R4_precalculate = spu_shuffle(R2a_precalculate, R2a_precalculate, vec_select_floats_lower);

const vector float R5_precalculate = spu_shuffle(R3a_precalculate, R3a_precalculate, vec_select_floats_upper);

const vector float R6_precalculate = spu_shuffle(R3a_precalculate, R3a_precalculate, vec_select_floats_lower);

const vector float R7_precalculate = spu_shuffle(R4a_precalculate, R4a_precalculate, vec_select_floats_upper);

const vector float R8_precalculate = spu_shuffle(R4a_precalculate, R4a_precalculate, vec_select_floats_lower);

const vector float G1a_precalculate = spu_madd(vec_Gu_precalc_coeff, vfloat_U_1, spu_mul(vfloat_V_1, vec_Gv_precalc_coeff));

const vector float G2a_precalculate = spu_madd(vec_Gu_precalc_coeff, vfloat_U_2, spu_mul(vfloat_V_2, vec_Gv_precalc_coeff));

const vector float G3a_precalculate = spu_madd(vec_Gu_precalc_coeff, vfloat_U_3, spu_mul(vfloat_V_3, vec_Gv_precalc_coeff));

const vector float G4a_precalculate = spu_madd(vec_Gu_precalc_coeff, vfloat_U_4, spu_mul(vfloat_V_4, vec_Gv_precalc_coeff));

const vector float G1_precalculate = spu_shuffle(G1a_precalculate, G1a_precalculate, vec_select_floats_upper);

const vector float G2_precalculate = spu_shuffle(G1a_precalculate, G1a_precalculate, vec_select_floats_lower);

const vector float G3_precalculate = spu_shuffle(G2a_precalculate, G2a_precalculate, vec_select_floats_upper);

const vector float G4_precalculate = spu_shuffle(G2a_precalculate, G2a_precalculate, vec_select_floats_lower);

const vector float G5_precalculate = spu_shuffle(G3a_precalculate, G3a_precalculate, vec_select_floats_upper);

const vector float G6_precalculate = spu_shuffle(G3a_precalculate, G3a_precalculate, vec_select_floats_lower);

const vector float G7_precalculate = spu_shuffle(G4a_precalculate, G4a_precalculate, vec_select_floats_upper);

const vector float G8_precalculate = spu_shuffle(G4a_precalculate, G4a_precalculate, vec_select_floats_lower);

const vector float B1a_precalculate = spu_mul(vec_B_precalc_coeff, vfloat_U_1);

const vector float B2a_precalculate = spu_mul(vec_B_precalc_coeff, vfloat_U_2);

const vector float B3a_precalculate = spu_mul(vec_B_precalc_coeff, vfloat_U_3);

const vector float B4a_precalculate = spu_mul(vec_B_precalc_coeff, vfloat_U_4);

const vector float B1_precalculate = spu_shuffle(B1a_precalculate, B1a_precalculate, vec_select_floats_upper);

const vector float B2_precalculate = spu_shuffle(B1a_precalculate, B1a_precalculate, vec_select_floats_lower);

const vector float B3_precalculate = spu_shuffle(B2a_precalculate, B2a_precalculate, vec_select_floats_upper);

const vector float B4_precalculate = spu_shuffle(B2a_precalculate, B2a_precalculate, vec_select_floats_lower);

const vector float B5_precalculate = spu_shuffle(B3a_precalculate, B3a_precalculate, vec_select_floats_upper);

const vector float B6_precalculate = spu_shuffle(B3a_precalculate, B3a_precalculate, vec_select_floats_lower);

const vector float B7_precalculate = spu_shuffle(B4a_precalculate, B4a_precalculate, vec_select_floats_upper);

const vector float B8_precalculate = spu_shuffle(B4a_precalculate, B4a_precalculate, vec_select_floats_lower);

const vector unsigned int R_1 = vfloat_to_vuint(spu_add( Y_1, R1_precalculate));

const vector unsigned int R_2 = vfloat_to_vuint(spu_add( Y_2, R2_precalculate));

const vector unsigned int R_3 = vfloat_to_vuint(spu_add( Y_3, R3_precalculate));

const vector unsigned int R_4 = vfloat_to_vuint(spu_add( Y_4, R4_precalculate));

const vector unsigned int R_5 = vfloat_to_vuint(spu_add( Y_5, R5_precalculate));

const vector unsigned int R_6 = vfloat_to_vuint(spu_add( Y_6, R6_precalculate));

const vector unsigned int R_7 = vfloat_to_vuint(spu_add( Y_7, R7_precalculate));

const vector unsigned int R_8 = vfloat_to_vuint(spu_add( Y_8, R8_precalculate));

const vector unsigned int R_9 = vfloat_to_vuint(spu_add( Y_9, R1_precalculate));

const vector unsigned int R_10 = vfloat_to_vuint(spu_add(Y_10, R2_precalculate));

const vector unsigned int R_11 = vfloat_to_vuint(spu_add(Y_11, R3_precalculate));

const vector unsigned int R_12 = vfloat_to_vuint(spu_add(Y_12, R4_precalculate));

const vector unsigned int R_13 = vfloat_to_vuint(spu_add(Y_13, R5_precalculate));

const vector unsigned int R_14 = vfloat_to_vuint(spu_add(Y_14, R6_precalculate));

const vector unsigned int R_15 = vfloat_to_vuint(spu_add(Y_15, R7_precalculate));

const vector unsigned int R_16 = vfloat_to_vuint(spu_add(Y_16, R8_precalculate));

const vector unsigned int G_1 = vfloat_to_vuint(spu_add( Y_1, G1_precalculate));

const vector unsigned int G_2 = vfloat_to_vuint(spu_add( Y_2, G2_precalculate));

const vector unsigned int G_3 = vfloat_to_vuint(spu_add( Y_3, G3_precalculate));

const vector unsigned int G_4 = vfloat_to_vuint(spu_add( Y_4, G4_precalculate));

const vector unsigned int G_5 = vfloat_to_vuint(spu_add( Y_5, G5_precalculate));

const vector unsigned int G_6 = vfloat_to_vuint(spu_add( Y_6, G6_precalculate));

const vector unsigned int G_7 = vfloat_to_vuint(spu_add( Y_7, G7_precalculate));

const vector unsigned int G_8 = vfloat_to_vuint(spu_add( Y_8, G8_precalculate));

const vector unsigned int G_9 = vfloat_to_vuint(spu_add( Y_9, G1_precalculate));

const vector unsigned int G_10 = vfloat_to_vuint(spu_add(Y_10, G2_precalculate));

const vector unsigned int G_11 = vfloat_to_vuint(spu_add(Y_11, G3_precalculate));

const vector unsigned int G_12 = vfloat_to_vuint(spu_add(Y_12, G4_precalculate));

const vector unsigned int G_13 = vfloat_to_vuint(spu_add(Y_13, G5_precalculate));

const vector unsigned int G_14 = vfloat_to_vuint(spu_add(Y_14, G6_precalculate));

const vector unsigned int G_15 = vfloat_to_vuint(spu_add(Y_15, G7_precalculate));

const vector unsigned int G_16 = vfloat_to_vuint(spu_add(Y_16, G8_precalculate));

const vector unsigned int B_1 = vfloat_to_vuint(spu_add( Y_1, B1_precalculate));

const vector unsigned int B_2 = vfloat_to_vuint(spu_add( Y_2, B2_precalculate));

const vector unsigned int B_3 = vfloat_to_vuint(spu_add( Y_3, B3_precalculate));

const vector unsigned int B_4 = vfloat_to_vuint(spu_add( Y_4, B4_precalculate));

const vector unsigned int B_5 = vfloat_to_vuint(spu_add( Y_5, B5_precalculate));

const vector unsigned int B_6 = vfloat_to_vuint(spu_add( Y_6, B6_precalculate));

const vector unsigned int B_7 = vfloat_to_vuint(spu_add( Y_7, B7_precalculate));

const vector unsigned int B_8 = vfloat_to_vuint(spu_add( Y_8, B8_precalculate));

const vector unsigned int B_9 = vfloat_to_vuint(spu_add( Y_9, B1_precalculate));

const vector unsigned int B_10 = vfloat_to_vuint(spu_add(Y_10, B2_precalculate));

const vector unsigned int B_11 = vfloat_to_vuint(spu_add(Y_11, B3_precalculate));

const vector unsigned int B_12 = vfloat_to_vuint(spu_add(Y_12, B4_precalculate));

const vector unsigned int B_13 = vfloat_to_vuint(spu_add(Y_13, B5_precalculate));

const vector unsigned int B_14 = vfloat_to_vuint(spu_add(Y_14, B6_precalculate));

const vector unsigned int B_15 = vfloat_to_vuint(spu_add(Y_15, B7_precalculate));

const vector unsigned int B_16 = vfloat_to_vuint(spu_add(Y_16, B8_precalculate));

*((vector unsigned int*)(bgra_addr + x)) = spu_or(spu_or(vec_alpha, B_1), spu_or(spu_slqwbyte( R_1, 2),spu_slqwbyte(G_1, 1)));

*((vector unsigned int*)(bgra_addr + x + 4)) = spu_or(spu_or(vec_alpha, B_2), spu_or(spu_slqwbyte( R_2, 2),spu_slqwbyte(G_2, 1)));

*((vector unsigned int*)(bgra_addr + x + 8)) = spu_or(spu_or(vec_alpha, B_3), spu_or(spu_slqwbyte( R_3, 2),spu_slqwbyte(G_3, 1)));

*((vector unsigned int*)(bgra_addr + x + 12)) = spu_or(spu_or(vec_alpha, B_4), spu_or(spu_slqwbyte( R_4, 2),spu_slqwbyte(G_4, 1)));

*((vector unsigned int*)(bgra_addr + x + 16)) = spu_or(spu_or(vec_alpha, B_5), spu_or(spu_slqwbyte( R_5, 2),spu_slqwbyte(G_5, 1)));

*((vector unsigned int*)(bgra_addr + x + 20)) = spu_or(spu_or(vec_alpha, B_6), spu_or(spu_slqwbyte( R_6, 2),spu_slqwbyte(G_6, 1)));

*((vector unsigned int*)(bgra_addr + x + 24)) = spu_or(spu_or(vec_alpha, B_7), spu_or(spu_slqwbyte( R_7, 2),spu_slqwbyte(G_7, 1)));

*((vector unsigned int*)(bgra_addr + x + 28)) = spu_or(spu_or(vec_alpha, B_8), spu_or(spu_slqwbyte( R_8, 2),spu_slqwbyte(G_8, 1)));

*((vector unsigned int*)(bgra_addr + x + width)) = spu_or(spu_or(vec_alpha, B_9), spu_or(spu_slqwbyte( R_9, 2),spu_slqwbyte(G_9, 1)));

*((vector unsigned int*)(bgra_addr + x + width + 4)) = spu_or(spu_or(vec_alpha, B_10), spu_or(spu_slqwbyte(R_10, 2),spu_slqwbyte(G_10, 1)));

*((vector unsigned int*)(bgra_addr + x + width + 8)) = spu_or(spu_or(vec_alpha, B_11), spu_or(spu_slqwbyte(R_11, 2),spu_slqwbyte(G_11, 1)));

*((vector unsigned int*)(bgra_addr + x + width + 12)) = spu_or(spu_or(vec_alpha, B_12), spu_or(spu_slqwbyte(R_12, 2),spu_slqwbyte(G_12, 1)));

*((vector unsigned int*)(bgra_addr + x + width + 16)) = spu_or(spu_or(vec_alpha, B_13), spu_or(spu_slqwbyte(R_13, 2),spu_slqwbyte(G_13, 1)));

*((vector unsigned int*)(bgra_addr + x + width + 20)) = spu_or(spu_or(vec_alpha, B_14), spu_or(spu_slqwbyte(R_14, 2),spu_slqwbyte(G_14, 1)));

*((vector unsigned int*)(bgra_addr + x + width + 24)) = spu_or(spu_or(vec_alpha, B_15), spu_or(spu_slqwbyte(R_15, 2),spu_slqwbyte(G_15, 1)));

*((vector unsigned int*)(bgra_addr + x + width + 28)) = spu_or(spu_or(vec_alpha, B_16), spu_or(spu_slqwbyte(R_16, 2),spu_slqwbyte(G_16, 1)));

}

}