1 /* 2 * SDL - Simple DirectMedia Layer 3 * CELL BE Support for PS3 Framebuffer 4 * Copyright (C) 2008, 2009 International Business Machines Corporation 5 * 6 * This library is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU Lesser General Public License as published 8 * by the Free Software Foundation; either version 2.1 of the License, or 9 * (at your option) any later version. 10 * 11 * This library is distributed in the hope that it will be useful, but 12 * WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with this library; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 19 * USA 20 * 21 * Martin Lowinski <lowinski [at] de [dot] ibm [ibm] com> 22 * Dirk Herrendoerfer <d.herrendoerfer [at] de [dot] ibm [dot] com> 23 * SPE code based on research by: 24 * Rene Becker 25 * Thimo Emmerich 26 */ 27 28 #include "spu_common.h" 29 30 #include <spu_intrinsics.h> 31 #include <spu_mfcio.h> 32 33 // Debugging 34 //#define DEBUG 35 36 #ifdef DEBUG 37 #define deprintf(fmt, args... ) \ 38 fprintf( stdout, fmt, ##args ); \ 39 fflush( stdout ); 40 #else 41 #define deprintf( fmt, args... ) 42 #endif 43 44 struct yuv2rgb_parms_t parms_converter __attribute__((aligned(128))); 45 46 /* A maximum of 8 lines Y, therefore 4 lines V, 4 lines U are stored 47 * there might be the need to retrieve misaligned data, adjust 48 * incoming v and u plane to be able to handle this (add 128) 49 */ 50 unsigned char y_plane[2][(MAX_HDTV_WIDTH + 128) * 4] __attribute__((aligned(128))); 51 unsigned char v_plane[2][(MAX_HDTV_WIDTH + 128) * 2] __attribute__((aligned(128))); 52 unsigned char u_plane[2][(MAX_HDTV_WIDTH + 128) * 2] __attribute__((aligned(128))); 53 54 /* A maximum of 4 lines BGRA are stored, 4 byte per pixel */ 55 unsigned char bgra[4 * MAX_HDTV_WIDTH * 4] __attribute__((aligned(128))); 56 57 /* some vectors needed by the float to int conversion */ 58 static const vector float vec_255 = { 255.0f, 255.0f, 255.0f, 255.0f }; 59 static const vector float vec_0_1 = { 0.1f, 0.1f, 0.1f, 0.1f }; 60 61 void yuv_to_rgb_w16(); 62 void yuv_to_rgb_w32(); 63 64 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); 65 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); 66 67 68 int main(unsigned long long spe_id __attribute__((unused)), unsigned long long argp __attribute__ ((unused))) 69 { 70 deprintf("[SPU] yuv2rgb_spu is up... (on SPE #%llu)\n", spe_id); 71 uint32_t ea_mfc, mbox; 72 // send ready message 73 spu_write_out_mbox(SPU_READY); 74 75 while (1) { 76 /* Check mailbox */ 77 mbox = spu_read_in_mbox(); 78 deprintf("[SPU] Message is %u\n", mbox); 79 switch (mbox) { 80 case SPU_EXIT: 81 deprintf("[SPU] fb_writer goes down...\n"); 82 return 0; 83 case SPU_START: 84 break; 85 default: 86 deprintf("[SPU] Cannot handle message\n"); 87 continue; 88 } 89 90 /* Tag Manager setup */ 91 unsigned int tag_id; 92 tag_id = mfc_multi_tag_reserve(1); 93 if (tag_id == MFC_TAG_INVALID) { 94 deprintf("[SPU] Failed to reserve mfc tags on yuv2rgb_converter\n"); 95 return 0; 96 } 97 98 /* DMA transfer for the input parameters */ 99 ea_mfc = spu_read_in_mbox(); 100 deprintf("[SPU] Message on yuv2rgb_converter is %u\n", ea_mfc); 101 spu_mfcdma32(&parms_converter, (unsigned int)ea_mfc, sizeof(struct yuv2rgb_parms_t), tag_id, MFC_GET_CMD); 102 DMA_WAIT_TAG(tag_id); 103 104 /* There are alignment issues that involve handling of special cases 105 * a width of 32 results in a width of 16 in the chrominance 106 * --> choose the proper handling to optimize the performance 107 */ 108 deprintf("[SPU] Convert %ix%i from YUV to RGB\n", parms_converter.src_pixel_width, parms_converter.src_pixel_height); 109 if (parms_converter.src_pixel_width & 0x1f) { 110 deprintf("[SPU] Using yuv_to_rgb_w16\n"); 111 yuv_to_rgb_w16(); 112 } else { 113 deprintf("[SPU] Using yuv_to_rgb_w32\n"); 114 yuv_to_rgb_w32(); 115 } 116 117 mfc_multi_tag_release(tag_id, 1); 118 deprintf("[SPU] yuv2rgb_spu... done!\n"); 119 /* Send FIN message */ 120 spu_write_out_mbox(SPU_FIN); 121 } 122 123 return 0; 124 } 125 126 127 /* 128 * float_to_char() 129 * 130 * converts a float to a character using saturated 131 * arithmetic 132 * 133 * @param s float for conversion 134 * @returns converted character 135 */ 136 inline static unsigned char float_to_char(float s) { 137 vector float vec_s = spu_splats(s); 138 vector unsigned int select_1 = spu_cmpgt(vec_0_1, vec_s); 139 vec_s = spu_sel(vec_s, vec_0_1, select_1); 140 141 vector unsigned int select_2 = spu_cmpgt(vec_s, vec_255); 142 vec_s = spu_sel(vec_s, vec_255, select_2); 143 return (unsigned char) spu_extract(vec_s,0); 144 } 145 146 147 /* 148 * vfloat_to_vuint() 149 * 150 * converts a float vector to an unsinged int vector using saturated 151 * arithmetic 152 * 153 * @param vec_s float vector for conversion 154 * @returns converted unsigned int vector 155 */ 156 inline static vector unsigned int vfloat_to_vuint(vector float vec_s) { 157 vector unsigned int select_1 = spu_cmpgt(vec_0_1, vec_s); 158 vec_s = spu_sel(vec_s, vec_0_1, select_1); 159 160 vector unsigned int select_2 = spu_cmpgt(vec_s, vec_255); 161 vec_s = spu_sel(vec_s, vec_255, select_2); 162 return spu_convtu(vec_s,0); 163 } 164 165 166 void yuv_to_rgb_w16() { 167 // Pixel dimensions of the picture 168 uint32_t width, height; 169 170 // Extract parameters 171 width = parms_converter.src_pixel_width; 172 height = parms_converter.src_pixel_height; 173 174 // Plane data management 175 // Y 176 unsigned char* ram_addr_y = parms_converter.y_plane; 177 // V 178 unsigned char* ram_addr_v = parms_converter.v_plane; 179 // U 180 unsigned char* ram_addr_u = parms_converter.u_plane; 181 182 // BGRA 183 unsigned char* ram_addr_bgra = parms_converter.dstBuffer; 184 185 // Strides 186 unsigned int stride_y = width; 187 unsigned int stride_vu = width>>1; 188 189 // Buffer management 190 unsigned int buf_idx = 0; 191 unsigned int size_4lines_y = stride_y<<2; 192 unsigned int size_2lines_y = stride_y<<1; 193 unsigned int size_2lines_vu = stride_vu<<1; 194 195 // 2*width*4byte_per_pixel 196 unsigned int size_2lines_bgra = width<<3; 197 198 199 // start double-buffered processing 200 // 4 lines y 201 spu_mfcdma32(y_plane[buf_idx], (unsigned int) ram_addr_y, size_4lines_y, RETR_BUF+buf_idx, MFC_GET_CMD); 202 203 // 2 lines v 204 spu_mfcdma32(v_plane[buf_idx], (unsigned int) ram_addr_v, size_2lines_vu, RETR_BUF+buf_idx, MFC_GET_CMD); 205 206 // 2 lines u 207 spu_mfcdma32(u_plane[buf_idx], (unsigned int) ram_addr_u, size_2lines_vu, RETR_BUF+buf_idx, MFC_GET_CMD); 208 209 // Wait for these transfers to be completed 210 DMA_WAIT_TAG((RETR_BUF + buf_idx)); 211 212 unsigned int i; 213 for(i=0; i<(height>>2)-1; i++) { 214 215 buf_idx^=1; 216 217 // 4 lines y 218 spu_mfcdma32(y_plane[buf_idx], (unsigned int) ram_addr_y+size_4lines_y, size_4lines_y, RETR_BUF+buf_idx, MFC_GET_CMD); 219 220 // 2 lines v 221 spu_mfcdma32(v_plane[buf_idx], (unsigned int) ram_addr_v+size_2lines_vu, size_2lines_vu, RETR_BUF+buf_idx, MFC_GET_CMD); 222 223 // 2 lines u 224 spu_mfcdma32(u_plane[buf_idx], (unsigned int) ram_addr_u+size_2lines_vu, size_2lines_vu, RETR_BUF+buf_idx, MFC_GET_CMD); 225 226 DMA_WAIT_TAG((RETR_BUF + buf_idx)); 227 228 buf_idx^=1; 229 230 231 // Convert YUV to BGRA, store it back (first two lines) 232 yuv_to_rgb_w16_line(y_plane[buf_idx], v_plane[buf_idx], u_plane[buf_idx], bgra, width); 233 234 // Next two lines 235 yuv_to_rgb_w16_line(y_plane[buf_idx] + size_2lines_y, 236 v_plane[buf_idx] + stride_vu, 237 u_plane[buf_idx] + stride_vu, 238 bgra + size_2lines_bgra, 239 width); 240 241 // Wait for previous storing transfer to be completed 242 DMA_WAIT_TAG(STR_BUF); 243 244 // Store converted lines in two steps->max transfer size 16384 245 spu_mfcdma32(bgra, (unsigned int) ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD); 246 ram_addr_bgra += size_2lines_bgra; 247 spu_mfcdma32(bgra+size_2lines_bgra, (unsigned int) ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD); 248 ram_addr_bgra += size_2lines_bgra; 249 250 // Move 4 lines 251 ram_addr_y += size_4lines_y; 252 ram_addr_v += size_2lines_vu; 253 ram_addr_u += size_2lines_vu; 254 255 buf_idx^=1; 256 } 257 258 // Convert YUV to BGRA, store it back (first two lines) 259 yuv_to_rgb_w16_line(y_plane[buf_idx], v_plane[buf_idx], u_plane[buf_idx], bgra, width); 260 261 // Next two lines 262 yuv_to_rgb_w16_line(y_plane[buf_idx] + size_2lines_y, 263 v_plane[buf_idx] + stride_vu, 264 u_plane[buf_idx] + stride_vu, 265 bgra + size_2lines_bgra, 266 width); 267 268 // Wait for previous storing transfer to be completed 269 DMA_WAIT_TAG(STR_BUF); 270 spu_mfcdma32(bgra, (unsigned int) ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD); 271 ram_addr_bgra += size_2lines_bgra; 272 spu_mfcdma32(bgra+size_2lines_bgra, (unsigned int) ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD); 273 274 // wait for previous storing transfer to be completed 275 DMA_WAIT_TAG(STR_BUF); 276 277 } 278 279 280 void yuv_to_rgb_w32() { 281 // Pixel dimensions of the picture 282 uint32_t width, height; 283 284 // Extract parameters 285 width = parms_converter.src_pixel_width; 286 height = parms_converter.src_pixel_height; 287 288 // Plane data management 289 // Y 290 unsigned char* ram_addr_y = parms_converter.y_plane; 291 // V 292 unsigned char* ram_addr_v = parms_converter.v_plane; 293 // U 294 unsigned char* ram_addr_u = parms_converter.u_plane; 295 296 // BGRA 297 unsigned char* ram_addr_bgra = parms_converter.dstBuffer; 298 299 // Strides 300 unsigned int stride_y = width; 301 unsigned int stride_vu = width>>1; 302 303 // Buffer management 304 unsigned int buf_idx = 0; 305 unsigned int size_4lines_y = stride_y<<2; 306 unsigned int size_2lines_y = stride_y<<1; 307 unsigned int size_2lines_vu = stride_vu<<1; 308 309 // 2*width*4byte_per_pixel 310 unsigned int size_2lines_bgra = width<<3; 311 312 // start double-buffered processing 313 // 4 lines y 314 spu_mfcdma32(y_plane[buf_idx], (unsigned int) ram_addr_y, size_4lines_y, RETR_BUF + buf_idx, MFC_GET_CMD); 315 // 2 lines v 316 spu_mfcdma32(v_plane[buf_idx], (unsigned int) ram_addr_v, size_2lines_vu, RETR_BUF + buf_idx, MFC_GET_CMD); 317 // 2 lines u 318 spu_mfcdma32(u_plane[buf_idx], (unsigned int) ram_addr_u, size_2lines_vu, RETR_BUF + buf_idx, MFC_GET_CMD); 319 320 // Wait for these transfers to be completed 321 DMA_WAIT_TAG((RETR_BUF + buf_idx)); 322 323 unsigned int i; 324 for(i=0; i < (height>>2)-1; i++) { 325 buf_idx^=1; 326 // 4 lines y 327 spu_mfcdma32(y_plane[buf_idx], (unsigned int) ram_addr_y+size_4lines_y, size_4lines_y, RETR_BUF + buf_idx, MFC_GET_CMD); 328 deprintf("4lines = %d\n", size_4lines_y); 329 // 2 lines v 330 spu_mfcdma32(v_plane[buf_idx], (unsigned int) ram_addr_v+size_2lines_vu, size_2lines_vu, RETR_BUF + buf_idx, MFC_GET_CMD); 331 deprintf("2lines = %d\n", size_2lines_vu); 332 // 2 lines u 333 spu_mfcdma32(u_plane[buf_idx], (unsigned int) ram_addr_u+size_2lines_vu, size_2lines_vu, RETR_BUF + buf_idx, MFC_GET_CMD); 334 deprintf("2lines = %d\n", size_2lines_vu); 335 336 DMA_WAIT_TAG((RETR_BUF + buf_idx)); 337 338 buf_idx^=1; 339 340 // Convert YUV to BGRA, store it back (first two lines) 341 yuv_to_rgb_w32_line(y_plane[buf_idx], v_plane[buf_idx], u_plane[buf_idx], bgra, width); 342 343 // Next two lines 344 yuv_to_rgb_w32_line(y_plane[buf_idx] + size_2lines_y, 345 v_plane[buf_idx] + stride_vu, 346 u_plane[buf_idx] + stride_vu, 347 bgra + size_2lines_bgra, 348 width); 349 350 // Wait for previous storing transfer to be completed 351 DMA_WAIT_TAG(STR_BUF); 352 353 // Store converted lines in two steps->max transfer size 16384 354 spu_mfcdma32(bgra, (unsigned int)ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD); 355 ram_addr_bgra += size_2lines_bgra; 356 spu_mfcdma32(bgra + size_2lines_bgra, (unsigned int)ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD); 357 ram_addr_bgra += size_2lines_bgra; 358 359 // Move 4 lines 360 ram_addr_y += size_4lines_y; 361 ram_addr_v += size_2lines_vu; 362 ram_addr_u += size_2lines_vu; 363 364 buf_idx^=1; 365 } 366 367 // Convert YUV to BGRA, store it back (first two lines) 368 yuv_to_rgb_w32_line(y_plane[buf_idx], v_plane[buf_idx], u_plane[buf_idx], bgra, width); 369 370 // Next two lines 371 yuv_to_rgb_w32_line(y_plane[buf_idx] + size_2lines_y, 372 v_plane[buf_idx] + stride_vu, 373 u_plane[buf_idx] + stride_vu, 374 bgra + size_2lines_bgra, 375 width); 376 377 // Wait for previous storing transfer to be completed 378 DMA_WAIT_TAG(STR_BUF); 379 spu_mfcdma32(bgra, (unsigned int) ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD); 380 ram_addr_bgra += size_2lines_bgra; 381 spu_mfcdma32(bgra + size_2lines_bgra, (unsigned int) ram_addr_bgra, size_2lines_bgra, STR_BUF, MFC_PUT_CMD); 382 383 // Wait for previous storing transfer to be completed 384 DMA_WAIT_TAG(STR_BUF); 385 } 386 387 388 /* Some vectors needed by the yuv 2 rgb conversion algorithm */ 389 const vector float vec_minus_128 = { -128.0f, -128.0f, -128.0f, -128.0f }; 390 const vector unsigned char vec_null = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 391 const vector unsigned char vec_char2int_first = { 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x13 }; 392 const vector unsigned char vec_char2int_second = { 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x17 }; 393 const vector unsigned char vec_char2int_third = { 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x00, 0x00, 0x1B }; 394 const vector unsigned char vec_char2int_fourth = { 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x1D, 0x00, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x00, 0x1F }; 395 396 const vector float vec_R_precalc_coeff = {1.403f, 1.403f, 1.403f, 1.403f}; 397 const vector float vec_Gu_precalc_coeff = {-0.344f, -0.344f, -0.344f, -0.344f}; 398 const vector float vec_Gv_precalc_coeff = {-0.714f, -0.714f, -0.714f, -0.714f}; 399 const vector float vec_B_precalc_coeff = {1.773f, 1.773f, 1.773f, 1.773f}; 400 401 const vector unsigned int vec_alpha = { 255 << 24, 255 << 24, 255 << 24, 255 << 24 }; 402 403 const vector unsigned char vec_select_floats_upper = { 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x04, 0x05, 0x06, 0x07 }; 404 const vector unsigned char vec_select_floats_lower = { 0x08, 0x09, 0x0A, 0x0B, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x0C, 0x0D, 0x0E, 0x0F }; 405 406 407 /* 408 * yuv_to_rgb_w16() 409 * 410 * processes to line of yuv-input, width has to be a multiple of 16 411 * two lines of yuv are taken as input 412 * 413 * @param y_addr address of the y plane in local store 414 * @param v_addr address of the v plane in local store 415 * @param u_addr address of the u plane in local store 416 * @param bgra_addr_ address of the bgra output buffer 417 * @param width the width in pixel 418 */ 419 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) { 420 // each pixel is stored as an integer 421 unsigned int* bgra_addr = (unsigned int*) bgra_addr_; 422 423 unsigned int x; 424 for(x = 0; x < width; x+=2) { 425 // Gehe zweischrittig durch die zeile, da jeder u und v wert fuer 4 pixel(zwei hoch, zwei breit) gilt 426 const unsigned char Y_1 = *(y_addr + x); 427 const unsigned char Y_2 = *(y_addr + x + 1); 428 const unsigned char Y_3 = *(y_addr + x + width); 429 const unsigned char Y_4 = *(y_addr + x + width + 1); 430 const unsigned char U = *(u_addr + (x >> 1)); 431 const unsigned char V = *(v_addr + (x >> 1)); 432 433 float V_minus_128 = (float)((float)V - 128.0f); 434 float U_minus_128 = (float)((float)U - 128.0f); 435 436 float R_precalculate = 1.403f * V_minus_128; 437 float G_precalculate = -(0.344f * U_minus_128 + 0.714f * V_minus_128); 438 float B_precalculate = 1.773f * U_minus_128; 439 440 const unsigned char R_1 = float_to_char((Y_1 + R_precalculate)); 441 const unsigned char R_2 = float_to_char((Y_2 + R_precalculate)); 442 const unsigned char R_3 = float_to_char((Y_3 + R_precalculate)); 443 const unsigned char R_4 = float_to_char((Y_4 + R_precalculate)); 444 const unsigned char G_1 = float_to_char((Y_1 + G_precalculate)); 445 const unsigned char G_2 = float_to_char((Y_2 + G_precalculate)); 446 const unsigned char G_3 = float_to_char((Y_3 + G_precalculate)); 447 const unsigned char G_4 = float_to_char((Y_4 + G_precalculate)); 448 const unsigned char B_1 = float_to_char((Y_1 + B_precalculate)); 449 const unsigned char B_2 = float_to_char((Y_2 + B_precalculate)); 450 const unsigned char B_3 = float_to_char((Y_3 + B_precalculate)); 451 const unsigned char B_4 = float_to_char((Y_4 + B_precalculate)); 452 453 *(bgra_addr + x) = (B_1 << 0)| (G_1 << 8) | (R_1 << 16) | (255 << 24); 454 *(bgra_addr + x + 1) = (B_2 << 0)| (G_2 << 8) | (R_2 << 16) | (255 << 24); 455 *(bgra_addr + x + width) = (B_3 << 0)| (G_3 << 8) | (R_3 << 16) | (255 << 24); 456 *(bgra_addr + x + width + 1) = (B_4 << 0)| (G_4 << 8) | (R_4 << 16) | (255 << 24); 457 } 458 } 459 460 461 /* 462 * yuv_to_rgb_w32() 463 * 464 * processes to line of yuv-input, width has to be a multiple of 32 465 * two lines of yuv are taken as input 466 * 467 * @param y_addr address of the y plane in local store 468 * @param v_addr address of the v plane in local store 469 * @param u_addr address of the u plane in local store 470 * @param bgra_addr_ address of the bgra output buffer 471 * @param width the width in pixel 472 */ 473 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) { 474 // each pixel is stored as an integer 475 unsigned int* bgra_addr = (unsigned int*) bgra_addr_; 476 477 unsigned int x; 478 for(x = 0; x < width; x+=32) { 479 // Gehe zweischrittig durch die zeile, da jeder u und v wert fuer 4 pixel(zwei hoch, zwei breit) gilt 480 481 const vector unsigned char vchar_Y_1 = *((vector unsigned char*)(y_addr + x)); 482 const vector unsigned char vchar_Y_2 = *((vector unsigned char*)(y_addr + x + 16)); 483 const vector unsigned char vchar_Y_3 = *((vector unsigned char*)(y_addr + x + width)); 484 const vector unsigned char vchar_Y_4 = *((vector unsigned char*)(y_addr + x + width + 16)); 485 const vector unsigned char vchar_U = *((vector unsigned char*)(u_addr + (x >> 1))); 486 const vector unsigned char vchar_V = *((vector unsigned char*)(v_addr + (x >> 1))); 487 488 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); 489 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); 490 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); 491 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); 492 493 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); 494 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); 495 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); 496 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); 497 498 vector float Y_1 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_1, vec_char2int_first), 0); 499 vector float Y_2 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_1, vec_char2int_second), 0); 500 vector float Y_3 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_1, vec_char2int_third), 0); 501 vector float Y_4 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_1, vec_char2int_fourth), 0); 502 vector float Y_5 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_2, vec_char2int_first), 0); 503 vector float Y_6 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_2, vec_char2int_second), 0); 504 vector float Y_7 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_2, vec_char2int_third), 0); 505 vector float Y_8 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_2, vec_char2int_fourth), 0); 506 vector float Y_9 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_3, vec_char2int_first), 0); 507 vector float Y_10 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_3, vec_char2int_second), 0); 508 vector float Y_11 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_3, vec_char2int_third), 0); 509 vector float Y_12 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_3, vec_char2int_fourth), 0); 510 vector float Y_13 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_4, vec_char2int_first), 0); 511 vector float Y_14 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_4, vec_char2int_second), 0); 512 vector float Y_15 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_4, vec_char2int_third), 0); 513 vector float Y_16 = spu_convtf((vector unsigned int)spu_shuffle(vec_null, vchar_Y_4, vec_char2int_fourth), 0); 514 515 const vector float R1a_precalculate = spu_mul(vec_R_precalc_coeff, vfloat_V_1); 516 const vector float R2a_precalculate = spu_mul(vec_R_precalc_coeff, vfloat_V_2); 517 const vector float R3a_precalculate = spu_mul(vec_R_precalc_coeff, vfloat_V_3); 518 const vector float R4a_precalculate = spu_mul(vec_R_precalc_coeff, vfloat_V_4); 519 520 const vector float R1_precalculate = spu_shuffle(R1a_precalculate, R1a_precalculate, vec_select_floats_upper); 521 const vector float R2_precalculate = spu_shuffle(R1a_precalculate, R1a_precalculate, vec_select_floats_lower); 522 const vector float R3_precalculate = spu_shuffle(R2a_precalculate, R2a_precalculate, vec_select_floats_upper); 523 const vector float R4_precalculate = spu_shuffle(R2a_precalculate, R2a_precalculate, vec_select_floats_lower); 524 const vector float R5_precalculate = spu_shuffle(R3a_precalculate, R3a_precalculate, vec_select_floats_upper); 525 const vector float R6_precalculate = spu_shuffle(R3a_precalculate, R3a_precalculate, vec_select_floats_lower); 526 const vector float R7_precalculate = spu_shuffle(R4a_precalculate, R4a_precalculate, vec_select_floats_upper); 527 const vector float R8_precalculate = spu_shuffle(R4a_precalculate, R4a_precalculate, vec_select_floats_lower); 528 529 530 const vector float G1a_precalculate = spu_madd(vec_Gu_precalc_coeff, vfloat_U_1, spu_mul(vfloat_V_1, vec_Gv_precalc_coeff)); 531 const vector float G2a_precalculate = spu_madd(vec_Gu_precalc_coeff, vfloat_U_2, spu_mul(vfloat_V_2, vec_Gv_precalc_coeff)); 532 const vector float G3a_precalculate = spu_madd(vec_Gu_precalc_coeff, vfloat_U_3, spu_mul(vfloat_V_3, vec_Gv_precalc_coeff)); 533 const vector float G4a_precalculate = spu_madd(vec_Gu_precalc_coeff, vfloat_U_4, spu_mul(vfloat_V_4, vec_Gv_precalc_coeff)); 534 535 const vector float G1_precalculate = spu_shuffle(G1a_precalculate, G1a_precalculate, vec_select_floats_upper); 536 const vector float G2_precalculate = spu_shuffle(G1a_precalculate, G1a_precalculate, vec_select_floats_lower); 537 const vector float G3_precalculate = spu_shuffle(G2a_precalculate, G2a_precalculate, vec_select_floats_upper); 538 const vector float G4_precalculate = spu_shuffle(G2a_precalculate, G2a_precalculate, vec_select_floats_lower); 539 const vector float G5_precalculate = spu_shuffle(G3a_precalculate, G3a_precalculate, vec_select_floats_upper); 540 const vector float G6_precalculate = spu_shuffle(G3a_precalculate, G3a_precalculate, vec_select_floats_lower); 541 const vector float G7_precalculate = spu_shuffle(G4a_precalculate, G4a_precalculate, vec_select_floats_upper); 542 const vector float G8_precalculate = spu_shuffle(G4a_precalculate, G4a_precalculate, vec_select_floats_lower); 543 544 545 const vector float B1a_precalculate = spu_mul(vec_B_precalc_coeff, vfloat_U_1); 546 const vector float B2a_precalculate = spu_mul(vec_B_precalc_coeff, vfloat_U_2); 547 const vector float B3a_precalculate = spu_mul(vec_B_precalc_coeff, vfloat_U_3); 548 const vector float B4a_precalculate = spu_mul(vec_B_precalc_coeff, vfloat_U_4); 549 550 const vector float B1_precalculate = spu_shuffle(B1a_precalculate, B1a_precalculate, vec_select_floats_upper); 551 const vector float B2_precalculate = spu_shuffle(B1a_precalculate, B1a_precalculate, vec_select_floats_lower); 552 const vector float B3_precalculate = spu_shuffle(B2a_precalculate, B2a_precalculate, vec_select_floats_upper); 553 const vector float B4_precalculate = spu_shuffle(B2a_precalculate, B2a_precalculate, vec_select_floats_lower); 554 const vector float B5_precalculate = spu_shuffle(B3a_precalculate, B3a_precalculate, vec_select_floats_upper); 555 const vector float B6_precalculate = spu_shuffle(B3a_precalculate, B3a_precalculate, vec_select_floats_lower); 556 const vector float B7_precalculate = spu_shuffle(B4a_precalculate, B4a_precalculate, vec_select_floats_upper); 557 const vector float B8_precalculate = spu_shuffle(B4a_precalculate, B4a_precalculate, vec_select_floats_lower); 558 559 560 const vector unsigned int R_1 = vfloat_to_vuint(spu_add( Y_1, R1_precalculate)); 561 const vector unsigned int R_2 = vfloat_to_vuint(spu_add( Y_2, R2_precalculate)); 562 const vector unsigned int R_3 = vfloat_to_vuint(spu_add( Y_3, R3_precalculate)); 563 const vector unsigned int R_4 = vfloat_to_vuint(spu_add( Y_4, R4_precalculate)); 564 const vector unsigned int R_5 = vfloat_to_vuint(spu_add( Y_5, R5_precalculate)); 565 const vector unsigned int R_6 = vfloat_to_vuint(spu_add( Y_6, R6_precalculate)); 566 const vector unsigned int R_7 = vfloat_to_vuint(spu_add( Y_7, R7_precalculate)); 567 const vector unsigned int R_8 = vfloat_to_vuint(spu_add( Y_8, R8_precalculate)); 568 const vector unsigned int R_9 = vfloat_to_vuint(spu_add( Y_9, R1_precalculate)); 569 const vector unsigned int R_10 = vfloat_to_vuint(spu_add(Y_10, R2_precalculate)); 570 const vector unsigned int R_11 = vfloat_to_vuint(spu_add(Y_11, R3_precalculate)); 571 const vector unsigned int R_12 = vfloat_to_vuint(spu_add(Y_12, R4_precalculate)); 572 const vector unsigned int R_13 = vfloat_to_vuint(spu_add(Y_13, R5_precalculate)); 573 const vector unsigned int R_14 = vfloat_to_vuint(spu_add(Y_14, R6_precalculate)); 574 const vector unsigned int R_15 = vfloat_to_vuint(spu_add(Y_15, R7_precalculate)); 575 const vector unsigned int R_16 = vfloat_to_vuint(spu_add(Y_16, R8_precalculate)); 576 577 const vector unsigned int G_1 = vfloat_to_vuint(spu_add( Y_1, G1_precalculate)); 578 const vector unsigned int G_2 = vfloat_to_vuint(spu_add( Y_2, G2_precalculate)); 579 const vector unsigned int G_3 = vfloat_to_vuint(spu_add( Y_3, G3_precalculate)); 580 const vector unsigned int G_4 = vfloat_to_vuint(spu_add( Y_4, G4_precalculate)); 581 const vector unsigned int G_5 = vfloat_to_vuint(spu_add( Y_5, G5_precalculate)); 582 const vector unsigned int G_6 = vfloat_to_vuint(spu_add( Y_6, G6_precalculate)); 583 const vector unsigned int G_7 = vfloat_to_vuint(spu_add( Y_7, G7_precalculate)); 584 const vector unsigned int G_8 = vfloat_to_vuint(spu_add( Y_8, G8_precalculate)); 585 const vector unsigned int G_9 = vfloat_to_vuint(spu_add( Y_9, G1_precalculate)); 586 const vector unsigned int G_10 = vfloat_to_vuint(spu_add(Y_10, G2_precalculate)); 587 const vector unsigned int G_11 = vfloat_to_vuint(spu_add(Y_11, G3_precalculate)); 588 const vector unsigned int G_12 = vfloat_to_vuint(spu_add(Y_12, G4_precalculate)); 589 const vector unsigned int G_13 = vfloat_to_vuint(spu_add(Y_13, G5_precalculate)); 590 const vector unsigned int G_14 = vfloat_to_vuint(spu_add(Y_14, G6_precalculate)); 591 const vector unsigned int G_15 = vfloat_to_vuint(spu_add(Y_15, G7_precalculate)); 592 const vector unsigned int G_16 = vfloat_to_vuint(spu_add(Y_16, G8_precalculate)); 593 594 const vector unsigned int B_1 = vfloat_to_vuint(spu_add( Y_1, B1_precalculate)); 595 const vector unsigned int B_2 = vfloat_to_vuint(spu_add( Y_2, B2_precalculate)); 596 const vector unsigned int B_3 = vfloat_to_vuint(spu_add( Y_3, B3_precalculate)); 597 const vector unsigned int B_4 = vfloat_to_vuint(spu_add( Y_4, B4_precalculate)); 598 const vector unsigned int B_5 = vfloat_to_vuint(spu_add( Y_5, B5_precalculate)); 599 const vector unsigned int B_6 = vfloat_to_vuint(spu_add( Y_6, B6_precalculate)); 600 const vector unsigned int B_7 = vfloat_to_vuint(spu_add( Y_7, B7_precalculate)); 601 const vector unsigned int B_8 = vfloat_to_vuint(spu_add( Y_8, B8_precalculate)); 602 const vector unsigned int B_9 = vfloat_to_vuint(spu_add( Y_9, B1_precalculate)); 603 const vector unsigned int B_10 = vfloat_to_vuint(spu_add(Y_10, B2_precalculate)); 604 const vector unsigned int B_11 = vfloat_to_vuint(spu_add(Y_11, B3_precalculate)); 605 const vector unsigned int B_12 = vfloat_to_vuint(spu_add(Y_12, B4_precalculate)); 606 const vector unsigned int B_13 = vfloat_to_vuint(spu_add(Y_13, B5_precalculate)); 607 const vector unsigned int B_14 = vfloat_to_vuint(spu_add(Y_14, B6_precalculate)); 608 const vector unsigned int B_15 = vfloat_to_vuint(spu_add(Y_15, B7_precalculate)); 609 const vector unsigned int B_16 = vfloat_to_vuint(spu_add(Y_16, B8_precalculate)); 610 611 *((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))); 612 *((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))); 613 *((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))); 614 *((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))); 615 *((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))); 616 *((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))); 617 *((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))); 618 *((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))); 619 *((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))); 620 *((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))); 621 *((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))); 622 *((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))); 623 *((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))); 624 *((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))); 625 *((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))); 626 *((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))); 627 } 628 } 629 630
