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 scale_parms_t parms __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 /* temp-buffer for scaling: 4 lines Y, therefore 2 lines V, 2 lines U */ 55 unsigned char scaled_y_plane[2][MAX_HDTV_WIDTH*2] __attribute__((aligned(128))); 56 unsigned char scaled_v_plane[2][MAX_HDTV_WIDTH/2] __attribute__((aligned(128))); 57 unsigned char scaled_u_plane[2][MAX_HDTV_WIDTH/2] __attribute__((aligned(128))); 58 59 /* some vectors needed by the float to int conversion */ 60 static const vector float vec_255 = { 255.0f, 255.0f, 255.0f, 255.0f }; 61 static const vector float vec_0_1 = { 0.1f, 0.1f, 0.1f, 0.1f }; 62 63 void bilinear_scale_line_w8(unsigned char* src, unsigned char* dst_, unsigned int dst_width, vector float vf_x_scale, vector float vf_NSweight, unsigned int src_linestride); 64 void bilinear_scale_line_w16(unsigned char* src, unsigned char* dst_, unsigned int dst_width, vector float vf_x_scale, vector float vf_NSweight, unsigned int src_linestride); 65 66 void scale_srcw16_dstw16(); 67 void scale_srcw16_dstw32(); 68 void scale_srcw32_dstw16(); 69 void scale_srcw32_dstw32(); 70 71 int main( unsigned long long spe_id __attribute__((unused)), unsigned long long argp ) 72 { 73 deprintf("[SPU] bilin_scaler_spu is up... (on SPE #%llu)\n", spe_id); 74 /* DMA transfer for the input parameters */ 75 spu_mfcdma32(&parms, (unsigned int)argp, sizeof(struct scale_parms_t), TAG_INIT, MFC_GET_CMD); 76 DMA_WAIT_TAG(TAG_INIT); 77 78 deprintf("[SPU] Scale %ux%u to %ux%u\n", parms.src_pixel_width, parms.src_pixel_height, 79 parms.dst_pixel_width, parms.dst_pixel_height); 80 81 if(parms.src_pixel_width & 0x1f) { 82 if(parms.dst_pixel_width & 0x1F) { 83 deprintf("[SPU] Using scale_srcw16_dstw16\n"); 84 scale_srcw16_dstw16(); 85 } else { 86 deprintf("[SPU] Using scale_srcw16_dstw32\n"); 87 scale_srcw16_dstw32(); 88 } 89 } else { 90 if(parms.dst_pixel_width & 0x1F) { 91 deprintf("[SPU] Using scale_srcw32_dstw16\n"); 92 scale_srcw32_dstw16(); 93 } else { 94 deprintf("[SPU] Using scale_srcw32_dstw32\n"); 95 scale_srcw32_dstw32(); 96 } 97 } 98 deprintf("[SPU] bilin_scaler_spu... done!\n"); 99 100 return 0; 101 } 102 103 104 /* 105 * vfloat_to_vuint() 106 * 107 * converts a float vector to an unsinged int vector using saturated 108 * arithmetic 109 * 110 * @param vec_s float vector for conversion 111 * @returns converted unsigned int vector 112 */ 113 inline static vector unsigned int vfloat_to_vuint(vector float vec_s) { 114 vector unsigned int select_1 = spu_cmpgt(vec_0_1, vec_s); 115 vec_s = spu_sel(vec_s, vec_0_1, select_1); 116 117 vector unsigned int select_2 = spu_cmpgt(vec_s, vec_255); 118 vec_s = spu_sel(vec_s, vec_255, select_2); 119 return spu_convtu(vec_s,0); 120 } 121 122 123 /* 124 * scale_srcw16_dstw16() 125 * 126 * processes an input image of width 16 127 * scaling is done to a width 16 128 * result stored in RAM 129 */ 130 void scale_srcw16_dstw16() { 131 // extract parameters 132 unsigned char* dst_addr = (unsigned char *)parms.dstBuffer; 133 134 unsigned int src_width = parms.src_pixel_width; 135 unsigned int src_height = parms.src_pixel_height; 136 unsigned int dst_width = parms.dst_pixel_width; 137 unsigned int dst_height = parms.dst_pixel_height; 138 139 // YVU 140 unsigned int src_linestride_y = src_width; 141 unsigned int src_dbl_linestride_y = src_width<<1; 142 unsigned int src_linestride_vu = src_width>>1; 143 unsigned int src_dbl_linestride_vu = src_width; 144 145 // scaled YVU 146 unsigned int scaled_src_linestride_y = dst_width; 147 148 // ram addresses 149 unsigned char* src_addr_y = parms.y_plane; 150 unsigned char* src_addr_v = parms.v_plane; 151 unsigned char* src_addr_u = parms.u_plane; 152 153 // for handling misalignment, addresses are precalculated 154 unsigned char* precalc_src_addr_v = src_addr_v; 155 unsigned char* precalc_src_addr_u = src_addr_u; 156 157 unsigned int dst_picture_size = dst_width*dst_height; 158 159 // Sizes for destination 160 unsigned int dst_dbl_linestride_y = dst_width<<1; 161 unsigned int dst_dbl_linestride_vu = dst_width>>1; 162 163 // Perform address calculation for Y, V and U in main memory with dst_addr as base 164 unsigned char* dst_addr_main_memory_y = dst_addr; 165 unsigned char* dst_addr_main_memory_v = dst_addr + dst_picture_size; 166 unsigned char* dst_addr_main_memory_u = dst_addr_main_memory_v +(dst_picture_size>>2); 167 168 // calculate scale factors 169 vector float vf_x_scale = spu_splats( (float)src_width/(float)dst_width ); 170 float y_scale = (float)src_height/(float)dst_height; 171 172 // double buffered processing 173 // buffer switching 174 unsigned int curr_src_idx = 0; 175 unsigned int curr_dst_idx = 0; 176 unsigned int next_src_idx, next_dst_idx; 177 178 // 2 lines y as output, upper and lowerline 179 unsigned int curr_interpl_y_upper = 0; 180 unsigned int next_interpl_y_upper; 181 unsigned int curr_interpl_y_lower, next_interpl_y_lower; 182 // only 1 line v/u output, both planes have the same dimension 183 unsigned int curr_interpl_vu = 0; 184 unsigned int next_interpl_vu; 185 186 // weights, calculated in every loop iteration 187 vector float vf_curr_NSweight_y_upper = { 0.0f, 0.0f, 0.0f, 0.0f }; 188 vector float vf_next_NSweight_y_upper; 189 vector float vf_curr_NSweight_y_lower, vf_next_NSweight_y_lower; 190 vector float vf_curr_NSweight_vu = { 0.0f, 0.0f, 0.0f, 0.0f }; 191 vector float vf_next_NSweight_vu; 192 193 // line indices for the src picture 194 float curr_src_y_upper = 0.0f, next_src_y_upper; 195 float curr_src_y_lower, next_src_y_lower; 196 float curr_src_vu = 0.0f, next_src_vu; 197 198 // line indices for the dst picture 199 unsigned int dst_y=0, dst_vu=0; 200 201 // offset for the v and u plane to handle misalignement 202 unsigned int curr_lsoff_v = 0, next_lsoff_v; 203 unsigned int curr_lsoff_u = 0, next_lsoff_u; 204 205 // calculate lower line indices 206 curr_src_y_lower = ((float)curr_interpl_y_upper+1)*y_scale; 207 curr_interpl_y_lower = (unsigned int)curr_src_y_lower; 208 // lower line weight 209 vf_curr_NSweight_y_lower = spu_splats( curr_src_y_lower-(float)curr_interpl_y_lower ); 210 211 212 // start partially double buffered processing 213 // get initial data, 2 sets of y, 1 set v, 1 set u 214 mfc_get( y_plane[curr_src_idx], (unsigned int) src_addr_y, src_dbl_linestride_y, RETR_BUF, 0, 0 ); 215 mfc_get( y_plane[curr_src_idx]+src_dbl_linestride_y, 216 (unsigned int) src_addr_y+(curr_interpl_y_lower*src_linestride_y), 217 src_dbl_linestride_y, 218 RETR_BUF, 219 0, 0 ); 220 mfc_get( v_plane[curr_src_idx], (unsigned int) src_addr_v, src_dbl_linestride_vu, RETR_BUF, 0, 0 ); 221 mfc_get( u_plane[curr_src_idx], (unsigned int) src_addr_u, src_dbl_linestride_vu, RETR_BUF, 0, 0 ); 222 223 /* iteration loop 224 * within each iteration 4 lines y, 2 lines v, 2 lines u are retrieved 225 * the scaled output is 2 lines y, 1 line v, 1 line u 226 * the yuv2rgb-converted output is stored to RAM 227 */ 228 for( dst_vu=0; dst_vu<(dst_height>>1)-1; dst_vu++ ) { 229 dst_y = dst_vu<<1; 230 231 // calculate next indices 232 next_src_vu = ((float)dst_vu+1)*y_scale; 233 next_src_y_upper = ((float)dst_y+2)*y_scale; 234 next_src_y_lower = ((float)dst_y+3)*y_scale; 235 236 next_interpl_vu = (unsigned int) next_src_vu; 237 next_interpl_y_upper = (unsigned int) next_src_y_upper; 238 next_interpl_y_lower = (unsigned int) next_src_y_lower; 239 240 // calculate weight NORTH-SOUTH 241 vf_next_NSweight_vu = spu_splats( next_src_vu-(float)next_interpl_vu ); 242 vf_next_NSweight_y_upper = spu_splats( next_src_y_upper-(float)next_interpl_y_upper ); 243 vf_next_NSweight_y_lower = spu_splats( next_src_y_lower-(float)next_interpl_y_lower ); 244 245 // get next lines 246 next_src_idx = curr_src_idx^1; 247 next_dst_idx = curr_dst_idx^1; 248 249 // 4 lines y 250 mfc_get( y_plane[next_src_idx], 251 (unsigned int) src_addr_y+(next_interpl_y_upper*src_linestride_y), 252 src_dbl_linestride_y, 253 RETR_BUF+next_src_idx, 254 0, 0 ); 255 mfc_get( y_plane[next_src_idx]+src_dbl_linestride_y, 256 (unsigned int) src_addr_y+(next_interpl_y_lower*src_linestride_y), 257 src_dbl_linestride_y, 258 RETR_BUF+next_src_idx, 259 0, 0 ); 260 261 // 2 lines v 262 precalc_src_addr_v = src_addr_v+(next_interpl_vu*src_linestride_vu); 263 next_lsoff_v = ((unsigned int)precalc_src_addr_v)&0x0F; 264 mfc_get( v_plane[next_src_idx], 265 ((unsigned int) precalc_src_addr_v)&0xFFFFFFF0, 266 src_dbl_linestride_vu+(next_lsoff_v<<1), 267 RETR_BUF+next_src_idx, 268 0, 0 ); 269 // 2 lines u 270 precalc_src_addr_u = src_addr_u+(next_interpl_vu*src_linestride_vu); 271 next_lsoff_u = ((unsigned int)precalc_src_addr_u)&0x0F; 272 mfc_get( u_plane[next_src_idx], 273 ((unsigned int) precalc_src_addr_u)&0xFFFFFFF0, 274 src_dbl_linestride_vu+(next_lsoff_v<<1), 275 RETR_BUF+next_src_idx, 276 0, 0 ); 277 278 DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) ); 279 280 // scaling 281 // work line y_upper 282 bilinear_scale_line_w16( y_plane[curr_src_idx], 283 scaled_y_plane[curr_src_idx], 284 dst_width, 285 vf_x_scale, 286 vf_curr_NSweight_y_upper, 287 src_linestride_y ); 288 // work line y_lower 289 bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y, 290 scaled_y_plane[curr_src_idx]+scaled_src_linestride_y, 291 dst_width, 292 vf_x_scale, 293 vf_curr_NSweight_y_lower, 294 src_linestride_y ); 295 // work line v 296 bilinear_scale_line_w8( v_plane[curr_src_idx]+curr_lsoff_v, 297 scaled_v_plane[curr_src_idx], 298 dst_width>>1, 299 vf_x_scale, 300 vf_curr_NSweight_vu, 301 src_linestride_vu ); 302 // work line u 303 bilinear_scale_line_w8( u_plane[curr_src_idx]+curr_lsoff_u, 304 scaled_u_plane[curr_src_idx], 305 dst_width>>1, 306 vf_x_scale, 307 vf_curr_NSweight_vu, 308 src_linestride_vu ); 309 310 311 // Store the result back to main memory into a destination buffer in YUV format 312 //--------------------------------------------------------------------------------------------- 313 DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) ); 314 315 // Perform three DMA transfers to 3 different locations in the main memory! 316 // dst_width: Pixel width of destination image 317 // dst_addr: Destination address in main memory 318 // dst_vu: Counter which is incremented one by one 319 // dst_y: Counter which is twice larger than dst_vu (dst_y = 2*dst_vu) 320 mfc_put( scaled_y_plane[curr_src_idx], // What from local store (addr) 321 (unsigned int)dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y), // Destination in main memory (addr) 322 dst_dbl_linestride_y, // Two Y lines (depending on the widht of the destination resolution) 323 STR_BUF+curr_dst_idx, // Tag 324 0, 0 ); 325 326 mfc_put( scaled_v_plane[curr_src_idx], // What from local store (addr) 327 (unsigned int)dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 328 dst_dbl_linestride_vu, // Two V lines (depending on the widht of the destination resolution) 329 STR_BUF+curr_dst_idx, // Tag 330 0, 0 ); 331 332 mfc_put( scaled_u_plane[curr_src_idx], // What from local store (addr) 333 (unsigned int)dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 334 dst_dbl_linestride_vu, // Two U lines (depending on the widht of the destination resolution) 335 STR_BUF+curr_dst_idx, // Tag 336 0, 0 ); 337 //--------------------------------------------------------------------------------------------- 338 339 340 // update for next cycle 341 curr_src_idx = next_src_idx; 342 curr_dst_idx = next_dst_idx; 343 344 curr_interpl_y_upper = next_interpl_y_upper; 345 curr_interpl_y_lower = next_interpl_y_lower; 346 curr_interpl_vu = next_interpl_vu; 347 348 vf_curr_NSweight_y_upper = vf_curr_NSweight_y_upper; 349 vf_curr_NSweight_y_lower = vf_curr_NSweight_y_lower; 350 vf_curr_NSweight_vu = vf_next_NSweight_vu; 351 352 curr_src_y_upper = next_src_y_upper; 353 curr_src_y_lower = next_src_y_lower; 354 curr_src_vu = next_src_vu; 355 356 curr_lsoff_v = next_lsoff_v; 357 curr_lsoff_u = next_lsoff_u; 358 } 359 360 361 362 DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) ); 363 364 // scaling 365 // work line y_upper 366 bilinear_scale_line_w16( y_plane[curr_src_idx], 367 scaled_y_plane[curr_src_idx], 368 dst_width, 369 vf_x_scale, 370 vf_curr_NSweight_y_upper, 371 src_linestride_y ); 372 // work line y_lower 373 bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y, 374 scaled_y_plane[curr_src_idx]+scaled_src_linestride_y, 375 dst_width, 376 vf_x_scale, 377 vf_curr_NSweight_y_lower, 378 src_linestride_y ); 379 // work line v 380 bilinear_scale_line_w8( v_plane[curr_src_idx]+curr_lsoff_v, 381 scaled_v_plane[curr_src_idx], 382 dst_width>>1, 383 vf_x_scale, 384 vf_curr_NSweight_vu, 385 src_linestride_vu ); 386 // work line u 387 bilinear_scale_line_w8( u_plane[curr_src_idx]+curr_lsoff_u, 388 scaled_u_plane[curr_src_idx], 389 dst_width>>1, 390 vf_x_scale, 391 vf_curr_NSweight_vu, 392 src_linestride_vu ); 393 394 395 // Store the result back to main memory into a destination buffer in YUV format 396 //--------------------------------------------------------------------------------------------- 397 DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) ); 398 399 // Perform three DMA transfers to 3 different locations in the main memory! 400 // dst_width: Pixel width of destination image 401 // dst_addr: Destination address in main memory 402 // dst_vu: Counter which is incremented one by one 403 // dst_y: Counter which is twice larger than dst_vu (dst_y = 2*dst_vu) 404 mfc_put( scaled_y_plane[curr_src_idx], // What from local store (addr) 405 (unsigned int)dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y), // Destination in main memory (addr) 406 dst_dbl_linestride_y, // Two Y lines (depending on the widht of the destination resolution) 407 STR_BUF+curr_dst_idx, // Tag 408 0, 0 ); 409 410 mfc_put( scaled_v_plane[curr_src_idx], // What from local store (addr) 411 (unsigned int)dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 412 dst_dbl_linestride_vu, // Two V lines (depending on the widht of the destination resolution) 413 STR_BUF+curr_dst_idx, // Tag 414 0, 0 ); 415 416 mfc_put( scaled_u_plane[curr_src_idx], // What from local store (addr) 417 (unsigned int)dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 418 dst_dbl_linestride_vu, // Two U lines (depending on the widht of the destination resolution) 419 STR_BUF+curr_dst_idx, // Tag 420 0, 0 ); 421 422 // wait for completion 423 DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) ); 424 //--------------------------------------------------------------------------------------------- 425 } 426 427 428 /* 429 * scale_srcw16_dstw32() 430 * 431 * processes an input image of width 16 432 * scaling is done to a width 32 433 * yuv2rgb conversion on a width of 32 434 * result stored in RAM 435 */ 436 void scale_srcw16_dstw32() { 437 // extract parameters 438 unsigned char* dst_addr = (unsigned char *)parms.dstBuffer; 439 440 unsigned int src_width = parms.src_pixel_width; 441 unsigned int src_height = parms.src_pixel_height; 442 unsigned int dst_width = parms.dst_pixel_width; 443 unsigned int dst_height = parms.dst_pixel_height; 444 445 // YVU 446 unsigned int src_linestride_y = src_width; 447 unsigned int src_dbl_linestride_y = src_width<<1; 448 unsigned int src_linestride_vu = src_width>>1; 449 unsigned int src_dbl_linestride_vu = src_width; 450 // scaled YVU 451 unsigned int scaled_src_linestride_y = dst_width; 452 453 // ram addresses 454 unsigned char* src_addr_y = parms.y_plane; 455 unsigned char* src_addr_v = parms.v_plane; 456 unsigned char* src_addr_u = parms.u_plane; 457 458 unsigned int dst_picture_size = dst_width*dst_height; 459 460 // Sizes for destination 461 unsigned int dst_dbl_linestride_y = dst_width<<1; 462 unsigned int dst_dbl_linestride_vu = dst_width>>1; 463 464 // Perform address calculation for Y, V and U in main memory with dst_addr as base 465 unsigned char* dst_addr_main_memory_y = dst_addr; 466 unsigned char* dst_addr_main_memory_v = dst_addr + dst_picture_size; 467 unsigned char* dst_addr_main_memory_u = dst_addr_main_memory_v +(dst_picture_size>>2); 468 469 470 // for handling misalignment, addresses are precalculated 471 unsigned char* precalc_src_addr_v = src_addr_v; 472 unsigned char* precalc_src_addr_u = src_addr_u; 473 474 // calculate scale factors 475 vector float vf_x_scale = spu_splats( (float)src_width/(float)dst_width ); 476 float y_scale = (float)src_height/(float)dst_height; 477 478 // double buffered processing 479 // buffer switching 480 unsigned int curr_src_idx = 0; 481 unsigned int curr_dst_idx = 0; 482 unsigned int next_src_idx, next_dst_idx; 483 484 // 2 lines y as output, upper and lowerline 485 unsigned int curr_interpl_y_upper = 0; 486 unsigned int next_interpl_y_upper; 487 unsigned int curr_interpl_y_lower, next_interpl_y_lower; 488 // only 1 line v/u output, both planes have the same dimension 489 unsigned int curr_interpl_vu = 0; 490 unsigned int next_interpl_vu; 491 492 // weights, calculated in every loop iteration 493 vector float vf_curr_NSweight_y_upper = { 0.0f, 0.0f, 0.0f, 0.0f }; 494 vector float vf_next_NSweight_y_upper; 495 vector float vf_curr_NSweight_y_lower, vf_next_NSweight_y_lower; 496 vector float vf_curr_NSweight_vu = { 0.0f, 0.0f, 0.0f, 0.0f }; 497 vector float vf_next_NSweight_vu; 498 499 // line indices for the src picture 500 float curr_src_y_upper = 0.0f, next_src_y_upper; 501 float curr_src_y_lower, next_src_y_lower; 502 float curr_src_vu = 0.0f, next_src_vu; 503 504 // line indices for the dst picture 505 unsigned int dst_y=0, dst_vu=0; 506 507 // offset for the v and u plane to handle misalignement 508 unsigned int curr_lsoff_v = 0, next_lsoff_v; 509 unsigned int curr_lsoff_u = 0, next_lsoff_u; 510 511 // calculate lower line idices 512 curr_src_y_lower = ((float)curr_interpl_y_upper+1)*y_scale; 513 curr_interpl_y_lower = (unsigned int)curr_src_y_lower; 514 // lower line weight 515 vf_curr_NSweight_y_lower = spu_splats( curr_src_y_lower-(float)curr_interpl_y_lower ); 516 517 518 // start partially double buffered processing 519 // get initial data, 2 sets of y, 1 set v, 1 set u 520 mfc_get( y_plane[curr_src_idx], (unsigned int) src_addr_y, src_dbl_linestride_y, RETR_BUF, 0, 0 ); 521 mfc_get( y_plane[curr_src_idx]+src_dbl_linestride_y, 522 (unsigned int) src_addr_y+(curr_interpl_y_lower*src_linestride_y), 523 src_dbl_linestride_y, 524 RETR_BUF, 525 0, 0 ); 526 mfc_get( v_plane[curr_src_idx], (unsigned int) src_addr_v, src_dbl_linestride_vu, RETR_BUF, 0, 0 ); 527 mfc_get( u_plane[curr_src_idx], (unsigned int) src_addr_u, src_dbl_linestride_vu, RETR_BUF, 0, 0 ); 528 529 // iteration loop 530 // within each iteration 4 lines y, 2 lines v, 2 lines u are retrieved 531 // the scaled output is 2 lines y, 1 line v, 1 line u 532 // the yuv2rgb-converted output is stored to RAM 533 for( dst_vu=0; dst_vu<(dst_height>>1)-1; dst_vu++ ) { 534 dst_y = dst_vu<<1; 535 536 // calculate next indices 537 next_src_vu = ((float)dst_vu+1)*y_scale; 538 next_src_y_upper = ((float)dst_y+2)*y_scale; 539 next_src_y_lower = ((float)dst_y+3)*y_scale; 540 541 next_interpl_vu = (unsigned int) next_src_vu; 542 next_interpl_y_upper = (unsigned int) next_src_y_upper; 543 next_interpl_y_lower = (unsigned int) next_src_y_lower; 544 545 // calculate weight NORTH-SOUTH 546 vf_next_NSweight_vu = spu_splats( next_src_vu-(float)next_interpl_vu ); 547 vf_next_NSweight_y_upper = spu_splats( next_src_y_upper-(float)next_interpl_y_upper ); 548 vf_next_NSweight_y_lower = spu_splats( next_src_y_lower-(float)next_interpl_y_lower ); 549 550 // get next lines 551 next_src_idx = curr_src_idx^1; 552 next_dst_idx = curr_dst_idx^1; 553 554 // 4 lines y 555 mfc_get( y_plane[next_src_idx], 556 (unsigned int) src_addr_y+(next_interpl_y_upper*src_linestride_y), 557 src_dbl_linestride_y, 558 RETR_BUF+next_src_idx, 559 0, 0 ); 560 mfc_get( y_plane[next_src_idx]+src_dbl_linestride_y, 561 (unsigned int) src_addr_y+(next_interpl_y_lower*src_linestride_y), 562 src_dbl_linestride_y, 563 RETR_BUF+next_src_idx, 564 0, 0 ); 565 566 // 2 lines v 567 precalc_src_addr_v = src_addr_v+(next_interpl_vu*src_linestride_vu); 568 next_lsoff_v = ((unsigned int)precalc_src_addr_v)&0x0F; 569 mfc_get( v_plane[next_src_idx], 570 ((unsigned int) precalc_src_addr_v)&0xFFFFFFF0, 571 src_dbl_linestride_vu+(next_lsoff_v<<1), 572 RETR_BUF+next_src_idx, 573 0, 0 ); 574 // 2 lines u 575 precalc_src_addr_u = src_addr_u+(next_interpl_vu*src_linestride_vu); 576 next_lsoff_u = ((unsigned int)precalc_src_addr_u)&0x0F; 577 mfc_get( u_plane[next_src_idx], 578 ((unsigned int) precalc_src_addr_u)&0xFFFFFFF0, 579 src_dbl_linestride_vu+(next_lsoff_v<<1), 580 RETR_BUF+next_src_idx, 581 0, 0 ); 582 583 DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) ); 584 585 // scaling 586 // work line y_upper 587 bilinear_scale_line_w16( y_plane[curr_src_idx], 588 scaled_y_plane[curr_src_idx], 589 dst_width, 590 vf_x_scale, 591 vf_curr_NSweight_y_upper, 592 src_linestride_y ); 593 // work line y_lower 594 bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y, 595 scaled_y_plane[curr_src_idx]+scaled_src_linestride_y, 596 dst_width, 597 vf_x_scale, 598 vf_curr_NSweight_y_lower, 599 src_linestride_y ); 600 // work line v 601 bilinear_scale_line_w8( v_plane[curr_src_idx]+curr_lsoff_v, 602 scaled_v_plane[curr_src_idx], 603 dst_width>>1, 604 vf_x_scale, 605 vf_curr_NSweight_vu, 606 src_linestride_vu ); 607 // work line u 608 bilinear_scale_line_w8( u_plane[curr_src_idx]+curr_lsoff_u, 609 scaled_u_plane[curr_src_idx], 610 dst_width>>1, 611 vf_x_scale, 612 vf_curr_NSweight_vu, 613 src_linestride_vu ); 614 615 //--------------------------------------------------------------------------------------------- 616 DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) ); 617 618 // Perform three DMA transfers to 3 different locations in the main memory! 619 // dst_width: Pixel width of destination image 620 // dst_addr: Destination address in main memory 621 // dst_vu: Counter which is incremented one by one 622 // dst_y: Counter which is twice larger than dst_vu (dst_y = 2*dst_vu) 623 624 mfc_put( scaled_y_plane[curr_src_idx], // What from local store (addr) 625 (unsigned int) dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y), // Destination in main memory (addr) 626 dst_dbl_linestride_y, // Two Y lines (depending on the widht of the destination resolution) 627 STR_BUF+curr_dst_idx, // Tag 628 0, 0 ); 629 630 mfc_put( scaled_v_plane[curr_src_idx], // What from local store (addr) 631 (unsigned int) dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 632 dst_dbl_linestride_vu, // Two V lines (depending on the widht of the destination resolution) 633 STR_BUF+curr_dst_idx, // Tag 634 0, 0 ); 635 636 mfc_put( scaled_u_plane[curr_src_idx], // What from local store (addr) 637 (unsigned int) dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 638 dst_dbl_linestride_vu, // Two U lines (depending on the widht of the destination resolution) 639 STR_BUF+curr_dst_idx, // Tag 640 0, 0 ); 641 //--------------------------------------------------------------------------------------------- 642 643 644 // update for next cycle 645 curr_src_idx = next_src_idx; 646 curr_dst_idx = next_dst_idx; 647 648 curr_interpl_y_upper = next_interpl_y_upper; 649 curr_interpl_y_lower = next_interpl_y_lower; 650 curr_interpl_vu = next_interpl_vu; 651 652 vf_curr_NSweight_y_upper = vf_curr_NSweight_y_upper; 653 vf_curr_NSweight_y_lower = vf_curr_NSweight_y_lower; 654 vf_curr_NSweight_vu = vf_next_NSweight_vu; 655 656 curr_src_y_upper = next_src_y_upper; 657 curr_src_y_lower = next_src_y_lower; 658 curr_src_vu = next_src_vu; 659 660 curr_lsoff_v = next_lsoff_v; 661 curr_lsoff_u = next_lsoff_u; 662 } 663 664 665 666 DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) ); 667 668 // scaling 669 // work line y_upper 670 bilinear_scale_line_w16( y_plane[curr_src_idx], 671 scaled_y_plane[curr_src_idx], 672 dst_width, 673 vf_x_scale, 674 vf_curr_NSweight_y_upper, 675 src_linestride_y ); 676 // work line y_lower 677 bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y, 678 scaled_y_plane[curr_src_idx]+scaled_src_linestride_y, 679 dst_width, 680 vf_x_scale, 681 vf_curr_NSweight_y_lower, 682 src_linestride_y ); 683 // work line v 684 bilinear_scale_line_w8( v_plane[curr_src_idx]+curr_lsoff_v, 685 scaled_v_plane[curr_src_idx], 686 dst_width>>1, 687 vf_x_scale, 688 vf_curr_NSweight_vu, 689 src_linestride_vu ); 690 // work line u 691 bilinear_scale_line_w8( u_plane[curr_src_idx]+curr_lsoff_u, 692 scaled_u_plane[curr_src_idx], 693 dst_width>>1, 694 vf_x_scale, 695 vf_curr_NSweight_vu, 696 src_linestride_vu ); 697 698 //--------------------------------------------------------------------------------------------- 699 DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) ); 700 701 // Perform three DMA transfers to 3 different locations in the main memory! 702 // dst_width: Pixel width of destination image 703 // dst_addr: Destination address in main memory 704 // dst_vu: Counter which is incremented one by one 705 // dst_y: Counter which is twice larger than dst_vu (dst_y = 2*dst_vu) 706 707 mfc_put( scaled_y_plane[curr_src_idx], // What from local store (addr) 708 (unsigned int) dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y), // Destination in main memory (addr) 709 dst_dbl_linestride_y, // Two Y lines (depending on the widht of the destination resolution) 710 STR_BUF+curr_dst_idx, // Tag 711 0, 0 ); 712 713 mfc_put( scaled_v_plane[curr_src_idx], // What from local store (addr) 714 (unsigned int) dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 715 dst_dbl_linestride_vu, // Two V lines (depending on the widht of the destination resolution) 716 STR_BUF+curr_dst_idx, // Tag 717 0, 0 ); 718 719 mfc_put( scaled_u_plane[curr_src_idx], // What from local store (addr) 720 (unsigned int) dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 721 dst_dbl_linestride_vu, // Two U lines (depending on the widht of the destination resolution) 722 STR_BUF+curr_dst_idx, // Tag 723 0, 0 ); 724 725 // wait for completion 726 DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) ); 727 //--------------------------------------------------------------------------------------------- 728 } 729 730 731 /* 732 * scale_srcw32_dstw16() 733 * 734 * processes an input image of width 32 735 * scaling is done to a width 16 736 * yuv2rgb conversion on a width of 16 737 * result stored in RAM 738 */ 739 void scale_srcw32_dstw16() { 740 // extract parameters 741 unsigned char* dst_addr = (unsigned char *)parms.dstBuffer; 742 743 unsigned int src_width = parms.src_pixel_width; 744 unsigned int src_height = parms.src_pixel_height; 745 unsigned int dst_width = parms.dst_pixel_width; 746 unsigned int dst_height = parms.dst_pixel_height; 747 748 // YVU 749 unsigned int src_linestride_y = src_width; 750 unsigned int src_dbl_linestride_y = src_width<<1; 751 unsigned int src_linestride_vu = src_width>>1; 752 unsigned int src_dbl_linestride_vu = src_width; 753 // scaled YVU 754 unsigned int scaled_src_linestride_y = dst_width; 755 756 // ram addresses 757 unsigned char* src_addr_y = parms.y_plane; 758 unsigned char* src_addr_v = parms.v_plane; 759 unsigned char* src_addr_u = parms.u_plane; 760 761 unsigned int dst_picture_size = dst_width*dst_height; 762 763 // Sizes for destination 764 unsigned int dst_dbl_linestride_y = dst_width<<1; 765 unsigned int dst_dbl_linestride_vu = dst_width>>1; 766 767 // Perform address calculation for Y, V and U in main memory with dst_addr as base 768 unsigned char* dst_addr_main_memory_y = dst_addr; 769 unsigned char* dst_addr_main_memory_v = dst_addr + dst_picture_size; 770 unsigned char* dst_addr_main_memory_u = dst_addr_main_memory_v +(dst_picture_size>>2); 771 772 // calculate scale factors 773 vector float vf_x_scale = spu_splats( (float)src_width/(float)dst_width ); 774 float y_scale = (float)src_height/(float)dst_height; 775 776 // double buffered processing 777 // buffer switching 778 unsigned int curr_src_idx = 0; 779 unsigned int curr_dst_idx = 0; 780 unsigned int next_src_idx, next_dst_idx; 781 782 // 2 lines y as output, upper and lowerline 783 unsigned int curr_interpl_y_upper = 0; 784 unsigned int next_interpl_y_upper; 785 unsigned int curr_interpl_y_lower, next_interpl_y_lower; 786 // only 1 line v/u output, both planes have the same dimension 787 unsigned int curr_interpl_vu = 0; 788 unsigned int next_interpl_vu; 789 790 // weights, calculated in every loop iteration 791 vector float vf_curr_NSweight_y_upper = { 0.0f, 0.0f, 0.0f, 0.0f }; 792 vector float vf_next_NSweight_y_upper; 793 vector float vf_curr_NSweight_y_lower, vf_next_NSweight_y_lower; 794 vector float vf_curr_NSweight_vu = { 0.0f, 0.0f, 0.0f, 0.0f }; 795 vector float vf_next_NSweight_vu; 796 797 // line indices for the src picture 798 float curr_src_y_upper = 0.0f, next_src_y_upper; 799 float curr_src_y_lower, next_src_y_lower; 800 float curr_src_vu = 0.0f, next_src_vu; 801 802 // line indices for the dst picture 803 unsigned int dst_y=0, dst_vu=0; 804 805 // calculate lower line idices 806 curr_src_y_lower = ((float)curr_interpl_y_upper+1)*y_scale; 807 curr_interpl_y_lower = (unsigned int)curr_src_y_lower; 808 // lower line weight 809 vf_curr_NSweight_y_lower = spu_splats( curr_src_y_lower-(float)curr_interpl_y_lower ); 810 811 812 // start partially double buffered processing 813 // get initial data, 2 sets of y, 1 set v, 1 set u 814 mfc_get( y_plane[curr_src_idx], (unsigned int) src_addr_y, src_dbl_linestride_y, RETR_BUF, 0, 0 ); 815 mfc_get( y_plane[curr_src_idx]+src_dbl_linestride_y, 816 (unsigned int) src_addr_y+(curr_interpl_y_lower*src_linestride_y), 817 src_dbl_linestride_y, 818 RETR_BUF, 819 0, 0 ); 820 mfc_get( v_plane[curr_src_idx], (unsigned int) src_addr_v, src_dbl_linestride_vu, RETR_BUF, 0, 0 ); 821 mfc_get( u_plane[curr_src_idx], (unsigned int) src_addr_u, src_dbl_linestride_vu, RETR_BUF, 0, 0 ); 822 823 // iteration loop 824 // within each iteration 4 lines y, 2 lines v, 2 lines u are retrieved 825 // the scaled output is 2 lines y, 1 line v, 1 line u 826 // the yuv2rgb-converted output is stored to RAM 827 for( dst_vu=0; dst_vu<(dst_height>>1)-1; dst_vu++ ) { 828 dst_y = dst_vu<<1; 829 830 // calculate next indices 831 next_src_vu = ((float)dst_vu+1)*y_scale; 832 next_src_y_upper = ((float)dst_y+2)*y_scale; 833 next_src_y_lower = ((float)dst_y+3)*y_scale; 834 835 next_interpl_vu = (unsigned int) next_src_vu; 836 next_interpl_y_upper = (unsigned int) next_src_y_upper; 837 next_interpl_y_lower = (unsigned int) next_src_y_lower; 838 839 // calculate weight NORTH-SOUTH 840 vf_next_NSweight_vu = spu_splats( next_src_vu-(float)next_interpl_vu ); 841 vf_next_NSweight_y_upper = spu_splats( next_src_y_upper-(float)next_interpl_y_upper ); 842 vf_next_NSweight_y_lower = spu_splats( next_src_y_lower-(float)next_interpl_y_lower ); 843 844 // get next lines 845 next_src_idx = curr_src_idx^1; 846 next_dst_idx = curr_dst_idx^1; 847 848 // 4 lines y 849 mfc_get( y_plane[next_src_idx], 850 (unsigned int) src_addr_y+(next_interpl_y_upper*src_linestride_y), 851 src_dbl_linestride_y, 852 RETR_BUF+next_src_idx, 853 0, 0 ); 854 mfc_get( y_plane[next_src_idx]+src_dbl_linestride_y, 855 (unsigned int) src_addr_y+(next_interpl_y_lower*src_linestride_y), 856 src_dbl_linestride_y, 857 RETR_BUF+next_src_idx, 858 0, 0 ); 859 860 // 2 lines v 861 mfc_get( v_plane[next_src_idx], 862 (unsigned int) src_addr_v+(next_interpl_vu*src_linestride_vu), 863 src_dbl_linestride_vu, 864 RETR_BUF+next_src_idx, 865 0, 0 ); 866 // 2 lines u 867 mfc_get( u_plane[next_src_idx], 868 (unsigned int) src_addr_u+(next_interpl_vu*src_linestride_vu), 869 src_dbl_linestride_vu, 870 RETR_BUF+next_src_idx, 871 0, 0 ); 872 873 DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) ); 874 875 // scaling 876 // work line y_upper 877 bilinear_scale_line_w16( y_plane[curr_src_idx], 878 scaled_y_plane[curr_src_idx], 879 dst_width, 880 vf_x_scale, 881 vf_curr_NSweight_y_upper, 882 src_linestride_y ); 883 // work line y_lower 884 bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y, 885 scaled_y_plane[curr_src_idx]+scaled_src_linestride_y, 886 dst_width, 887 vf_x_scale, 888 vf_curr_NSweight_y_lower, 889 src_linestride_y ); 890 // work line v 891 bilinear_scale_line_w16( v_plane[curr_src_idx], 892 scaled_v_plane[curr_src_idx], 893 dst_width>>1, 894 vf_x_scale, 895 vf_curr_NSweight_vu, 896 src_linestride_vu ); 897 // work line u 898 bilinear_scale_line_w16( u_plane[curr_src_idx], 899 scaled_u_plane[curr_src_idx], 900 dst_width>>1, 901 vf_x_scale, 902 vf_curr_NSweight_vu, 903 src_linestride_vu ); 904 905 //--------------------------------------------------------------------------------------------- 906 DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) ); 907 908 // Perform three DMA transfers to 3 different locations in the main memory! 909 // dst_width: Pixel width of destination image 910 // dst_addr: Destination address in main memory 911 // dst_vu: Counter which is incremented one by one 912 // dst_y: Counter which is twice larger than dst_vu (dst_y = 2*dst_vu) 913 914 mfc_put( scaled_y_plane[curr_src_idx], // What from local store (addr) 915 (unsigned int) dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y), // Destination in main memory (addr) 916 dst_dbl_linestride_y, // Two Y lines (depending on the widht of the destination resolution) 917 STR_BUF+curr_dst_idx, // Tag 918 0, 0 ); 919 920 mfc_put( scaled_v_plane[curr_src_idx], // What from local store (addr) 921 (unsigned int) dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 922 dst_dbl_linestride_vu, // Two V lines (depending on the widht of the destination resolution) 923 STR_BUF+curr_dst_idx, // Tag 924 0, 0 ); 925 926 mfc_put( scaled_u_plane[curr_src_idx], // What from local store (addr) 927 (unsigned int) dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 928 dst_dbl_linestride_vu, // Two U lines (depending on the widht of the destination resolution) 929 STR_BUF+curr_dst_idx, // Tag 930 0, 0 ); 931 //--------------------------------------------------------------------------------------------- 932 933 934 // update for next cycle 935 curr_src_idx = next_src_idx; 936 curr_dst_idx = next_dst_idx; 937 938 curr_interpl_y_upper = next_interpl_y_upper; 939 curr_interpl_y_lower = next_interpl_y_lower; 940 curr_interpl_vu = next_interpl_vu; 941 942 vf_curr_NSweight_y_upper = vf_curr_NSweight_y_upper; 943 vf_curr_NSweight_y_lower = vf_curr_NSweight_y_lower; 944 vf_curr_NSweight_vu = vf_next_NSweight_vu; 945 946 curr_src_y_upper = next_src_y_upper; 947 curr_src_y_lower = next_src_y_lower; 948 curr_src_vu = next_src_vu; 949 } 950 951 952 953 DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) ); 954 955 // scaling 956 // work line y_upper 957 bilinear_scale_line_w16( y_plane[curr_src_idx], 958 scaled_y_plane[curr_src_idx], 959 dst_width, 960 vf_x_scale, 961 vf_curr_NSweight_y_upper, 962 src_linestride_y ); 963 // work line y_lower 964 bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y, 965 scaled_y_plane[curr_src_idx]+scaled_src_linestride_y, 966 dst_width, 967 vf_x_scale, 968 vf_curr_NSweight_y_lower, 969 src_linestride_y ); 970 // work line v 971 bilinear_scale_line_w16( v_plane[curr_src_idx], 972 scaled_v_plane[curr_src_idx], 973 dst_width>>1, 974 vf_x_scale, 975 vf_curr_NSweight_vu, 976 src_linestride_vu ); 977 // work line u 978 bilinear_scale_line_w16( u_plane[curr_src_idx], 979 scaled_u_plane[curr_src_idx], 980 dst_width>>1, 981 vf_x_scale, 982 vf_curr_NSweight_vu, 983 src_linestride_vu ); 984 985 986 //--------------------------------------------------------------------------------------------- 987 DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) ); 988 989 // Perform three DMA transfers to 3 different locations in the main memory! 990 // dst_width: Pixel width of destination image 991 // dst_addr: Destination address in main memory 992 // dst_vu: Counter which is incremented one by one 993 // dst_y: Counter which is twice larger than dst_vu (dst_y = 2*dst_vu) 994 995 mfc_put( scaled_y_plane[curr_src_idx], // What from local store (addr) 996 (unsigned int) dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y), // Destination in main memory (addr) 997 dst_dbl_linestride_y, // Two Y lines (depending on the widht of the destination resolution) 998 STR_BUF+curr_dst_idx, // Tag 999 0, 0 ); 1000 1001 mfc_put( scaled_v_plane[curr_src_idx], // What from local store (addr) 1002 (unsigned int) dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 1003 dst_dbl_linestride_vu, // Two V lines (depending on the widht of the destination resolution) 1004 STR_BUF+curr_dst_idx, // Tag 1005 0, 0 ); 1006 1007 mfc_put( scaled_u_plane[curr_src_idx], // What from local store (addr) 1008 (unsigned int) dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 1009 dst_dbl_linestride_vu, // Two U lines (depending on the widht of the destination resolution) 1010 STR_BUF+curr_dst_idx, // Tag 1011 0, 0 ); 1012 1013 // wait for completion 1014 DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) ); 1015 //--------------------------------------------------------------------------------------------- 1016 } 1017 1018 1019 /** 1020 * scale_srcw32_dstw32() 1021 * 1022 * processes an input image of width 32 1023 * scaling is done to a width 32 1024 * yuv2rgb conversion on a width of 32 1025 * result stored in RAM 1026 */ 1027 void scale_srcw32_dstw32() { 1028 // extract parameters 1029 unsigned char* dst_addr = (unsigned char *)parms.dstBuffer; 1030 1031 unsigned int src_width = parms.src_pixel_width; 1032 unsigned int src_height = parms.src_pixel_height; 1033 unsigned int dst_width = parms.dst_pixel_width; 1034 unsigned int dst_height = parms.dst_pixel_height; 1035 1036 // YVU 1037 unsigned int src_linestride_y = src_width; 1038 unsigned int src_dbl_linestride_y = src_width<<1; 1039 unsigned int src_linestride_vu = src_width>>1; 1040 unsigned int src_dbl_linestride_vu = src_width; 1041 1042 // scaled YVU 1043 unsigned int scaled_src_linestride_y = dst_width; 1044 1045 // ram addresses 1046 unsigned char* src_addr_y = parms.y_plane; 1047 unsigned char* src_addr_v = parms.v_plane; 1048 unsigned char* src_addr_u = parms.u_plane; 1049 1050 unsigned int dst_picture_size = dst_width*dst_height; 1051 1052 // Sizes for destination 1053 unsigned int dst_dbl_linestride_y = dst_width<<1; 1054 unsigned int dst_dbl_linestride_vu = dst_width>>1; 1055 1056 // Perform address calculation for Y, V and U in main memory with dst_addr as base 1057 unsigned char* dst_addr_main_memory_y = dst_addr; 1058 unsigned char* dst_addr_main_memory_v = dst_addr + dst_picture_size; 1059 unsigned char* dst_addr_main_memory_u = dst_addr_main_memory_v +(dst_picture_size>>2); 1060 1061 // calculate scale factors 1062 vector float vf_x_scale = spu_splats( (float)src_width/(float)dst_width ); 1063 float y_scale = (float)src_height/(float)dst_height; 1064 1065 // double buffered processing 1066 // buffer switching 1067 unsigned int curr_src_idx = 0; 1068 unsigned int curr_dst_idx = 0; 1069 unsigned int next_src_idx, next_dst_idx; 1070 1071 // 2 lines y as output, upper and lowerline 1072 unsigned int curr_interpl_y_upper = 0; 1073 unsigned int next_interpl_y_upper; 1074 unsigned int curr_interpl_y_lower, next_interpl_y_lower; 1075 // only 1 line v/u output, both planes have the same dimension 1076 unsigned int curr_interpl_vu = 0; 1077 unsigned int next_interpl_vu; 1078 1079 // weights, calculated in every loop iteration 1080 vector float vf_curr_NSweight_y_upper = { 0.0f, 0.0f, 0.0f, 0.0f }; 1081 vector float vf_next_NSweight_y_upper; 1082 vector float vf_curr_NSweight_y_lower, vf_next_NSweight_y_lower; 1083 vector float vf_curr_NSweight_vu = { 0.0f, 0.0f, 0.0f, 0.0f }; 1084 vector float vf_next_NSweight_vu; 1085 1086 // line indices for the src picture 1087 float curr_src_y_upper = 0.0f, next_src_y_upper; 1088 float curr_src_y_lower, next_src_y_lower; 1089 float curr_src_vu = 0.0f, next_src_vu; 1090 1091 // line indices for the dst picture 1092 unsigned int dst_y=0, dst_vu=0; 1093 1094 // calculate lower line idices 1095 curr_src_y_lower = ((float)curr_interpl_y_upper+1)*y_scale; 1096 curr_interpl_y_lower = (unsigned int)curr_src_y_lower; 1097 // lower line weight 1098 vf_curr_NSweight_y_lower = spu_splats( curr_src_y_lower-(float)curr_interpl_y_lower ); 1099 1100 1101 // start partially double buffered processing 1102 // get initial data, 2 sets of y, 1 set v, 1 set u 1103 mfc_get( y_plane[curr_src_idx], (unsigned int) src_addr_y, src_dbl_linestride_y, RETR_BUF, 0, 0 ); 1104 mfc_get( y_plane[curr_src_idx]+src_dbl_linestride_y, 1105 (unsigned int) src_addr_y+(curr_interpl_y_lower*src_linestride_y), 1106 src_dbl_linestride_y, 1107 RETR_BUF, 1108 0, 0 ); 1109 mfc_get( v_plane[curr_src_idx], (unsigned int) src_addr_v, src_dbl_linestride_vu, RETR_BUF, 0, 0 ); 1110 mfc_get( u_plane[curr_src_idx], (unsigned int) src_addr_u, src_dbl_linestride_vu, RETR_BUF, 0, 0 ); 1111 1112 // iteration loop 1113 // within each iteration 4 lines y, 2 lines v, 2 lines u are retrieved 1114 // the scaled output is 2 lines y, 1 line v, 1 line u 1115 // the yuv2rgb-converted output is stored to RAM 1116 for( dst_vu=0; dst_vu<(dst_height>>1)-1; dst_vu++ ) { 1117 dst_y = dst_vu<<1; 1118 1119 // calculate next indices 1120 next_src_vu = ((float)dst_vu+1)*y_scale; 1121 next_src_y_upper = ((float)dst_y+2)*y_scale; 1122 next_src_y_lower = ((float)dst_y+3)*y_scale; 1123 1124 next_interpl_vu = (unsigned int) next_src_vu; 1125 next_interpl_y_upper = (unsigned int) next_src_y_upper; 1126 next_interpl_y_lower = (unsigned int) next_src_y_lower; 1127 1128 // calculate weight NORTH-SOUTH 1129 vf_next_NSweight_vu = spu_splats( next_src_vu-(float)next_interpl_vu ); 1130 vf_next_NSweight_y_upper = spu_splats( next_src_y_upper-(float)next_interpl_y_upper ); 1131 vf_next_NSweight_y_lower = spu_splats( next_src_y_lower-(float)next_interpl_y_lower ); 1132 1133 // get next lines 1134 next_src_idx = curr_src_idx^1; 1135 next_dst_idx = curr_dst_idx^1; 1136 1137 // 4 lines y 1138 mfc_get( y_plane[next_src_idx], 1139 (unsigned int) src_addr_y+(next_interpl_y_upper*src_linestride_y), 1140 src_dbl_linestride_y, 1141 RETR_BUF+next_src_idx, 1142 0, 0 ); 1143 mfc_get( y_plane[next_src_idx]+src_dbl_linestride_y, 1144 (unsigned int) src_addr_y+(next_interpl_y_lower*src_linestride_y), 1145 src_dbl_linestride_y, 1146 RETR_BUF+next_src_idx, 1147 0, 0 ); 1148 1149 // 2 lines v 1150 mfc_get( v_plane[next_src_idx], 1151 (unsigned int) src_addr_v+(next_interpl_vu*src_linestride_vu), 1152 src_dbl_linestride_vu, 1153 RETR_BUF+next_src_idx, 1154 0, 0 ); 1155 // 2 lines u 1156 mfc_get( u_plane[next_src_idx], 1157 (unsigned int) src_addr_u+(next_interpl_vu*src_linestride_vu), 1158 src_dbl_linestride_vu, 1159 RETR_BUF+next_src_idx, 1160 0, 0 ); 1161 1162 DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) ); 1163 1164 // scaling 1165 // work line y_upper 1166 bilinear_scale_line_w16( y_plane[curr_src_idx], 1167 scaled_y_plane[curr_src_idx], 1168 dst_width, 1169 vf_x_scale, 1170 vf_curr_NSweight_y_upper, 1171 src_linestride_y ); 1172 // work line y_lower 1173 bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y, 1174 scaled_y_plane[curr_src_idx]+scaled_src_linestride_y, 1175 dst_width, 1176 vf_x_scale, 1177 vf_curr_NSweight_y_lower, 1178 src_linestride_y ); 1179 // work line v 1180 bilinear_scale_line_w16( v_plane[curr_src_idx], 1181 scaled_v_plane[curr_src_idx], 1182 dst_width>>1, 1183 vf_x_scale, 1184 vf_curr_NSweight_vu, 1185 src_linestride_vu ); 1186 // work line u 1187 bilinear_scale_line_w16( u_plane[curr_src_idx], 1188 scaled_u_plane[curr_src_idx], 1189 dst_width>>1, 1190 vf_x_scale, 1191 vf_curr_NSweight_vu, 1192 src_linestride_vu ); 1193 1194 1195 1196 // Store the result back to main memory into a destination buffer in YUV format 1197 //--------------------------------------------------------------------------------------------- 1198 DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) ); 1199 1200 // Perform three DMA transfers to 3 different locations in the main memory! 1201 // dst_width: Pixel width of destination image 1202 // dst_addr: Destination address in main memory 1203 // dst_vu: Counter which is incremented one by one 1204 // dst_y: Counter which is twice larger than dst_vu (dst_y = 2*dst_vu) 1205 1206 mfc_put( scaled_y_plane[curr_src_idx], // What from local store (addr) 1207 (unsigned int) dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y), // Destination in main memory (addr) 1208 dst_dbl_linestride_y, // Two Y lines (depending on the widht of the destination resolution) 1209 STR_BUF+curr_dst_idx, // Tag 1210 0, 0 ); 1211 1212 mfc_put( scaled_v_plane[curr_src_idx], // What from local store (addr) 1213 (unsigned int) dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 1214 dst_dbl_linestride_vu, // Two V lines (depending on the widht of the destination resolution) 1215 STR_BUF+curr_dst_idx, // Tag 1216 0, 0 ); 1217 1218 mfc_put( scaled_u_plane[curr_src_idx], // What from local store (addr) 1219 (unsigned int) dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 1220 dst_dbl_linestride_vu, // Two U lines (depending on the widht of the destination resolution) 1221 STR_BUF+curr_dst_idx, // Tag 1222 0, 0 ); 1223 //--------------------------------------------------------------------------------------------- 1224 1225 1226 // update for next cycle 1227 curr_src_idx = next_src_idx; 1228 curr_dst_idx = next_dst_idx; 1229 1230 curr_interpl_y_upper = next_interpl_y_upper; 1231 curr_interpl_y_lower = next_interpl_y_lower; 1232 curr_interpl_vu = next_interpl_vu; 1233 1234 vf_curr_NSweight_y_upper = vf_curr_NSweight_y_upper; 1235 vf_curr_NSweight_y_lower = vf_curr_NSweight_y_lower; 1236 vf_curr_NSweight_vu = vf_next_NSweight_vu; 1237 1238 curr_src_y_upper = next_src_y_upper; 1239 curr_src_y_lower = next_src_y_lower; 1240 curr_src_vu = next_src_vu; 1241 } 1242 1243 1244 1245 DMA_WAIT_TAG( (RETR_BUF+curr_src_idx) ); 1246 1247 // scaling 1248 // work line y_upper 1249 bilinear_scale_line_w16( y_plane[curr_src_idx], 1250 scaled_y_plane[curr_src_idx], 1251 dst_width, 1252 vf_x_scale, 1253 vf_curr_NSweight_y_upper, 1254 src_linestride_y ); 1255 // work line y_lower 1256 bilinear_scale_line_w16( y_plane[curr_src_idx]+src_dbl_linestride_y, 1257 scaled_y_plane[curr_src_idx]+scaled_src_linestride_y, 1258 dst_width, 1259 vf_x_scale, 1260 vf_curr_NSweight_y_lower, 1261 src_linestride_y ); 1262 // work line v 1263 bilinear_scale_line_w16( v_plane[curr_src_idx], 1264 scaled_v_plane[curr_src_idx], 1265 dst_width>>1, 1266 vf_x_scale, 1267 vf_curr_NSweight_vu, 1268 src_linestride_vu ); 1269 // work line u 1270 bilinear_scale_line_w16( u_plane[curr_src_idx], 1271 scaled_u_plane[curr_src_idx], 1272 dst_width>>1, 1273 vf_x_scale, 1274 vf_curr_NSweight_vu, 1275 src_linestride_vu ); 1276 1277 1278 // Store the result back to main memory into a destination buffer in YUV format 1279 //--------------------------------------------------------------------------------------------- 1280 DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) ); 1281 1282 // Perform three DMA transfers to 3 different locations in the main memory! 1283 // dst_width: Pixel width of destination image 1284 // dst_addr: Destination address in main memory 1285 // dst_vu: Counter which is incremented one by one 1286 // dst_y: Counter which is twice larger than dst_vu (dst_y = 2*dst_vu) 1287 1288 mfc_put( scaled_y_plane[curr_src_idx], // What from local store (addr) 1289 (unsigned int) dst_addr_main_memory_y + (dst_vu*dst_dbl_linestride_y), // Destination in main memory (addr) 1290 dst_dbl_linestride_y, // Two Y lines (depending on the widht of the destination resolution) 1291 STR_BUF+curr_dst_idx, // Tag 1292 0, 0 ); 1293 1294 mfc_put( scaled_v_plane[curr_src_idx], // What from local store (addr) 1295 (unsigned int) dst_addr_main_memory_v + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 1296 dst_dbl_linestride_vu, // Two V lines (depending on the widht of the destination resolution) 1297 STR_BUF+curr_dst_idx, // Tag 1298 0, 0 ); 1299 1300 mfc_put( scaled_u_plane[curr_src_idx], // What from local store (addr) 1301 (unsigned int) dst_addr_main_memory_u + (dst_vu*dst_dbl_linestride_vu), // Destination in main memory (addr) 1302 dst_dbl_linestride_vu, // Two U lines (depending on the widht of the destination resolution) 1303 STR_BUF+curr_dst_idx, // Tag 1304 0, 0 ); 1305 1306 // wait for completion 1307 DMA_WAIT_TAG( (STR_BUF+curr_dst_idx) ); 1308 //--------------------------------------------------------------------------------------------- 1309 } 1310 1311 1312 /* 1313 * bilinear_scale_line_w8() 1314 * 1315 * processes a line of yuv-input, width has to be a multiple of 8 1316 * scaled yuv-output is written to local store buffer 1317 * 1318 * @param src buffer for 2 lines input 1319 * @param dst_ buffer for 1 line output 1320 * @param dst_width the width of the destination line 1321 * @param vf_x_scale a float vector, at each entry is the x_scale-factor 1322 * @param vf_NSweight a float vector, at each position is the weight NORTH/SOUTH for the current line 1323 * @param src_linestride the stride of the srcline 1324 */ 1325 void bilinear_scale_line_w8( unsigned char* src, unsigned char* dst_, unsigned int dst_width, vector float vf_x_scale, vector float vf_NSweight, unsigned int src_linestride ) { 1326 1327 unsigned char* dst = dst_; 1328 1329 unsigned int dst_x; 1330 for( dst_x=0; dst_x<dst_width; dst_x+=8) { 1331 // address calculation for loading the 4 surrounding pixel of each calculated 1332 // destination pixel 1333 vector unsigned int vui_dst_x_tmp = spu_splats( dst_x ); 1334 // lower range->first 4 pixel 1335 // upper range->next 4 pixel 1336 vector unsigned int vui_inc_dst_x_lower_range = { 0, 1, 2, 3 }; 1337 vector unsigned int vui_inc_dst_x_upper_range = { 4, 5, 6, 7 }; 1338 vector unsigned int vui_dst_x_lower_range = spu_add( vui_dst_x_tmp, vui_inc_dst_x_lower_range ); 1339 vector unsigned int vui_dst_x_upper_range = spu_add( vui_dst_x_tmp, vui_inc_dst_x_upper_range ); 1340 1341 // calculate weight EAST-WEST 1342 vector float vf_dst_x_lower_range = spu_convtf( vui_dst_x_lower_range, 0 ); 1343 vector float vf_dst_x_upper_range = spu_convtf( vui_dst_x_upper_range, 0 ); 1344 vector float vf_src_x_lower_range = spu_mul( vf_dst_x_lower_range, vf_x_scale ); 1345 vector float vf_src_x_upper_range = spu_mul( vf_dst_x_upper_range, vf_x_scale ); 1346 vector unsigned int vui_interpl_x_lower_range = spu_convtu( vf_src_x_lower_range, 0 ); 1347 vector unsigned int vui_interpl_x_upper_range = spu_convtu( vf_src_x_upper_range, 0 ); 1348 vector float vf_interpl_x_lower_range = spu_convtf( vui_interpl_x_lower_range, 0 ); 1349 vector float vf_interpl_x_upper_range = spu_convtf( vui_interpl_x_upper_range, 0 ); 1350 vector float vf_EWweight_lower_range = spu_sub( vf_src_x_lower_range, vf_interpl_x_lower_range ); 1351 vector float vf_EWweight_upper_range = spu_sub( vf_src_x_upper_range, vf_interpl_x_upper_range ); 1352 1353 // calculate address offset 1354 // 1355 // pixel NORTH WEST 1356 vector unsigned int vui_off_pixelNW_lower_range = vui_interpl_x_lower_range; 1357 vector unsigned int vui_off_pixelNW_upper_range = vui_interpl_x_upper_range; 1358 1359 // pixel NORTH EAST-->(offpixelNW+1) 1360 vector unsigned int vui_add_1 = { 1, 1, 1, 1 }; 1361 vector unsigned int vui_off_pixelNE_lower_range = spu_add( vui_off_pixelNW_lower_range, vui_add_1 ); 1362 vector unsigned int vui_off_pixelNE_upper_range = spu_add( vui_off_pixelNW_upper_range, vui_add_1 ); 1363 1364 // SOUTH-WEST-->(offpixelNW+src_linestride) 1365 vector unsigned int vui_srclinestride = spu_splats( src_linestride ); 1366 vector unsigned int vui_off_pixelSW_lower_range = spu_add( vui_srclinestride, vui_off_pixelNW_lower_range ); 1367 vector unsigned int vui_off_pixelSW_upper_range = spu_add( vui_srclinestride, vui_off_pixelNW_upper_range ); 1368 1369 // SOUTH-EAST-->(offpixelNW+src_linestride+1) 1370 vector unsigned int vui_off_pixelSE_lower_range = spu_add( vui_srclinestride, vui_off_pixelNE_lower_range ); 1371 vector unsigned int vui_off_pixelSE_upper_range = spu_add( vui_srclinestride, vui_off_pixelNE_upper_range ); 1372 1373 // calculate each address 1374 vector unsigned int vui_src_ls = spu_splats( (unsigned int) src ); 1375 vector unsigned int vui_addr_pixelNW_lower_range = spu_add( vui_src_ls, vui_off_pixelNW_lower_range ); 1376 vector unsigned int vui_addr_pixelNW_upper_range = spu_add( vui_src_ls, vui_off_pixelNW_upper_range ); 1377 vector unsigned int vui_addr_pixelNE_lower_range = spu_add( vui_src_ls, vui_off_pixelNE_lower_range ); 1378 vector unsigned int vui_addr_pixelNE_upper_range = spu_add( vui_src_ls, vui_off_pixelNE_upper_range ); 1379 1380 vector unsigned int vui_addr_pixelSW_lower_range = spu_add( vui_src_ls, vui_off_pixelSW_lower_range ); 1381 vector unsigned int vui_addr_pixelSW_upper_range = spu_add( vui_src_ls, vui_off_pixelSW_upper_range ); 1382 vector unsigned int vui_addr_pixelSE_lower_range = spu_add( vui_src_ls, vui_off_pixelSE_lower_range ); 1383 vector unsigned int vui_addr_pixelSE_upper_range = spu_add( vui_src_ls, vui_off_pixelSE_upper_range ); 1384 1385 // get each pixel 1386 // 1387 // scalar load, afterwards insertion into the right position 1388 // NORTH WEST 1389 vector unsigned char null_vector = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 1390 vector unsigned char vuc_pixel_NW_lower_range = spu_insert( 1391 *((unsigned char*) spu_extract( vui_addr_pixelNW_lower_range, 0 )), null_vector, 3 ); 1392 vuc_pixel_NW_lower_range = spu_insert( 1393 *((unsigned char*) spu_extract( vui_addr_pixelNW_lower_range, 1 )), 1394 vuc_pixel_NW_lower_range, 7 ); 1395 vuc_pixel_NW_lower_range = spu_insert( 1396 *((unsigned char*) spu_extract( vui_addr_pixelNW_lower_range, 2 )), 1397 vuc_pixel_NW_lower_range, 11 ); 1398 vuc_pixel_NW_lower_range = spu_insert( 1399 *((unsigned char*) spu_extract( vui_addr_pixelNW_lower_range, 3 )), 1400 vuc_pixel_NW_lower_range, 15 ); 1401 1402 vector unsigned char vuc_pixel_NW_upper_range = spu_insert( 1403 *((unsigned char*) spu_extract( vui_addr_pixelNW_upper_range, 0 )), null_vector, 3 ); 1404 vuc_pixel_NW_upper_range = spu_insert( 1405 *((unsigned char*) spu_extract( vui_addr_pixelNW_upper_range, 1 )), 1406 vuc_pixel_NW_upper_range, 7 ); 1407 vuc_pixel_NW_upper_range = spu_insert( 1408 *((unsigned char*) spu_extract( vui_addr_pixelNW_upper_range, 2 )), 1409 vuc_pixel_NW_upper_range, 11 ); 1410 vuc_pixel_NW_upper_range = spu_insert( 1411 *((unsigned char*) spu_extract( vui_addr_pixelNW_upper_range, 3 )), 1412 vuc_pixel_NW_upper_range, 15 ); 1413 1414 // NORTH EAST 1415 vector unsigned char vuc_pixel_NE_lower_range = spu_insert( 1416 *((unsigned char*) spu_extract( vui_addr_pixelNE_lower_range, 0 )), null_vector, 3 ); 1417 vuc_pixel_NE_lower_range = spu_insert( 1418 *((unsigned char*) spu_extract( vui_addr_pixelNE_lower_range, 1 )), 1419 vuc_pixel_NE_lower_range, 7 ); 1420 vuc_pixel_NE_lower_range = spu_insert( 1421 *((unsigned char*) spu_extract( vui_addr_pixelNE_lower_range, 2 )), 1422 vuc_pixel_NE_lower_range, 11 ); 1423 vuc_pixel_NE_lower_range = spu_insert( 1424 *((unsigned char*) spu_extract( vui_addr_pixelNE_lower_range, 3 )), 1425 vuc_pixel_NE_lower_range, 15 ); 1426 1427 vector unsigned char vuc_pixel_NE_upper_range = spu_insert( 1428 *((unsigned char*) spu_extract( vui_addr_pixelNE_upper_range, 0 )), null_vector, 3 ); 1429 vuc_pixel_NE_upper_range = spu_insert( 1430 *((unsigned char*) spu_extract( vui_addr_pixelNE_upper_range, 1 )), 1431 vuc_pixel_NE_upper_range, 7 ); 1432 vuc_pixel_NE_upper_range = spu_insert( 1433 *((unsigned char*) spu_extract( vui_addr_pixelNE_upper_range, 2 )), 1434 vuc_pixel_NE_upper_range, 11 ); 1435 vuc_pixel_NE_upper_range = spu_insert( 1436 *((unsigned char*) spu_extract( vui_addr_pixelNE_upper_range, 3 )), 1437 vuc_pixel_NE_upper_range, 15 ); 1438 1439 1440 // SOUTH WEST 1441 vector unsigned char vuc_pixel_SW_lower_range = spu_insert( 1442 *((unsigned char*) spu_extract( vui_addr_pixelSW_lower_range, 0 )), null_vector, 3 ); 1443 vuc_pixel_SW_lower_range = spu_insert( 1444 *((unsigned char*) spu_extract( vui_addr_pixelSW_lower_range, 1 )), 1445 vuc_pixel_SW_lower_range, 7 ); 1446 vuc_pixel_SW_lower_range = spu_insert( 1447 *((unsigned char*) spu_extract( vui_addr_pixelSW_lower_range, 2 )), 1448 vuc_pixel_SW_lower_range, 11 ); 1449 vuc_pixel_SW_lower_range = spu_insert( 1450 *((unsigned char*) spu_extract( vui_addr_pixelSW_lower_range, 3 )), 1451 vuc_pixel_SW_lower_range, 15 ); 1452 1453 vector unsigned char vuc_pixel_SW_upper_range = spu_insert( 1454 *((unsigned char*) spu_extract( vui_addr_pixelSW_upper_range, 0 )), null_vector, 3 ); 1455 vuc_pixel_SW_upper_range = spu_insert( 1456 *((unsigned char*) spu_extract( vui_addr_pixelSW_upper_range, 1 )), 1457 vuc_pixel_SW_upper_range, 7 ); 1458 vuc_pixel_SW_upper_range = spu_insert( 1459 *((unsigned char*) spu_extract( vui_addr_pixelSW_upper_range, 2 )), 1460 vuc_pixel_SW_upper_range, 11 ); 1461 vuc_pixel_SW_upper_range = spu_insert( 1462 *((unsigned char*) spu_extract( vui_addr_pixelSW_upper_range, 3 )), 1463 vuc_pixel_SW_upper_range, 15 ); 1464 1465 // SOUTH EAST 1466 vector unsigned char vuc_pixel_SE_lower_range = spu_insert( 1467 *((unsigned char*) spu_extract( vui_addr_pixelSE_lower_range, 0 )), null_vector, 3 ); 1468 vuc_pixel_SE_lower_range = spu_insert( 1469 *((unsigned char*) spu_extract( vui_addr_pixelSE_lower_range, 1 )), 1470 vuc_pixel_SE_lower_range, 7 ); 1471 vuc_pixel_SE_lower_range = spu_insert( 1472 *((unsigned char*) spu_extract( vui_addr_pixelSE_lower_range, 2 )), 1473 vuc_pixel_SE_lower_range, 11 ); 1474 vuc_pixel_SE_lower_range = spu_insert( 1475 *((unsigned char*) spu_extract( vui_addr_pixelSE_lower_range, 3 )), 1476 vuc_pixel_SE_lower_range, 15 ); 1477 1478 vector unsigned char vuc_pixel_SE_upper_range = spu_insert( 1479 *((unsigned char*) spu_extract( vui_addr_pixelSE_upper_range, 0 )), null_vector, 3 ); 1480 vuc_pixel_SE_upper_range = spu_insert( 1481 *((unsigned char*) spu_extract( vui_addr_pixelSE_upper_range, 1 )), 1482 vuc_pixel_SE_upper_range, 7 ); 1483 vuc_pixel_SE_upper_range = spu_insert( 1484 *((unsigned char*) spu_extract( vui_addr_pixelSE_upper_range, 2 )), 1485 vuc_pixel_SE_upper_range, 11 ); 1486 vuc_pixel_SE_upper_range = spu_insert( 1487 *((unsigned char*) spu_extract( vui_addr_pixelSE_upper_range, 3 )), 1488 vuc_pixel_SE_upper_range, 15 ); 1489 1490 1491 // convert to float 1492 vector float vf_pixel_NW_lower_range = spu_convtf( (vector unsigned int) vuc_pixel_NW_lower_range, 0 ); 1493 vector float vf_pixel_NW_upper_range = spu_convtf( (vector unsigned int) vuc_pixel_NW_upper_range, 0 ); 1494 1495 vector float vf_pixel_SW_lower_range = spu_convtf( (vector unsigned int) vuc_pixel_SW_lower_range, 0 ); 1496 vector float vf_pixel_SW_upper_range = spu_convtf( (vector unsigned int) vuc_pixel_SW_upper_range, 0 ); 1497 1498 vector float vf_pixel_NE_lower_range = spu_convtf( (vector unsigned int) vuc_pixel_NE_lower_range, 0 ); 1499 vector float vf_pixel_NE_upper_range = spu_convtf( (vector unsigned int) vuc_pixel_NE_upper_range, 0 ); 1500 1501 vector float vf_pixel_SE_lower_range = spu_convtf( (vector unsigned int) vuc_pixel_SE_lower_range, 0 ); 1502 vector float vf_pixel_SE_upper_range = spu_convtf( (vector unsigned int) vuc_pixel_SE_upper_range, 0 ); 1503 1504 1505 1506 // first linear interpolation: EWtop 1507 // EWtop = NW + EWweight*(NE-NW) 1508 // 1509 // lower range 1510 vector float vf_EWtop_lower_range_tmp = spu_sub( vf_pixel_NE_lower_range, vf_pixel_NW_lower_range ); 1511 vector float vf_EWtop_lower_range = spu_madd( vf_EWweight_lower_range, 1512 vf_EWtop_lower_range_tmp, 1513 vf_pixel_NW_lower_range ); 1514 1515 // upper range 1516 vector float vf_EWtop_upper_range_tmp = spu_sub( vf_pixel_NE_upper_range, vf_pixel_NW_upper_range ); 1517 vector float vf_EWtop_upper_range = spu_madd( vf_EWweight_upper_range, 1518 vf_EWtop_upper_range_tmp, 1519 vf_pixel_NW_upper_range ); 1520 1521 1522 1523 // second linear interpolation: EWbottom 1524 // EWbottom = SW + EWweight*(SE-SW) 1525 // 1526 // lower range 1527 vector float vf_EWbottom_lower_range_tmp = spu_sub( vf_pixel_SE_lower_range, vf_pixel_SW_lower_range ); 1528 vector float vf_EWbottom_lower_range = spu_madd( vf_EWweight_lower_range, 1529 vf_EWbottom_lower_range_tmp, 1530 vf_pixel_SW_lower_range ); 1531 1532 // upper range 1533 vector float vf_EWbottom_upper_range_tmp = spu_sub( vf_pixel_SE_upper_range, vf_pixel_SW_upper_range ); 1534 vector float vf_EWbottom_upper_range = spu_madd( vf_EWweight_upper_range, 1535 vf_EWbottom_upper_range_tmp, 1536 vf_pixel_SW_upper_range ); 1537 1538 1539 1540 // third linear interpolation: the bilinear interpolated value 1541 // result = EWtop + NSweight*(EWbottom-EWtop); 1542 // 1543 // lower range 1544 vector float vf_result_lower_range_tmp = spu_sub( vf_EWbottom_lower_range, vf_EWtop_lower_range ); 1545 vector float vf_result_lower_range = spu_madd( vf_NSweight, 1546 vf_result_lower_range_tmp, 1547 vf_EWtop_lower_range ); 1548 1549 // upper range 1550 vector float vf_result_upper_range_tmp = spu_sub( vf_EWbottom_upper_range, vf_EWtop_upper_range ); 1551 vector float vf_result_upper_range = spu_madd( vf_NSweight, 1552 vf_result_upper_range_tmp, 1553 vf_EWtop_upper_range ); 1554 1555 1556 // convert back: using saturated arithmetic 1557 vector unsigned int vui_result_lower_range = vfloat_to_vuint( vf_result_lower_range ); 1558 vector unsigned int vui_result_upper_range = vfloat_to_vuint( vf_result_upper_range ); 1559 1560 // merge results->lower,upper 1561 vector unsigned char vuc_mask_merge_result = { 0x03, 0x07, 0x0B, 0x0F, 1562 0x13, 0x17, 0x1B, 0x1F, 1563 0x00, 0x00, 0x00, 0x00, 1564 0x00, 0x00, 0x00, 0x00 }; 1565 1566 vector unsigned char vuc_result = spu_shuffle( (vector unsigned char) vui_result_lower_range, 1567 (vector unsigned char) vui_result_upper_range, 1568 vuc_mask_merge_result ); 1569 1570 // partial storing 1571 vector unsigned char vuc_mask_out = { 0x00, 0x00, 0x00, 0x00, 1572 0x00, 0x00, 0x00, 0x00, 1573 0xFF, 0xFF, 0xFF, 0xFF, 1574 0xFF, 0xFF, 0xFF, 0xFF }; 1575 1576 1577 // get currently stored data 1578 vector unsigned char vuc_orig = *((vector unsigned char*)dst); 1579 1580 // clear currently stored data 1581 vuc_orig = spu_and( vuc_orig, 1582 spu_rlqwbyte( vuc_mask_out, ((unsigned int)dst)&0x0F) ); 1583 1584 // rotate result according to storing address 1585 vuc_result = spu_rlqwbyte( vuc_result, ((unsigned int)dst)&0x0F ); 1586 1587 // store result 1588 *((vector unsigned char*)dst) = spu_or( vuc_result, 1589 vuc_orig ); 1590 dst += 8; 1591 } 1592 } 1593 1594 1595 /* 1596 * bilinear_scale_line_w16() 1597 * 1598 * processes a line of yuv-input, width has to be a multiple of 16 1599 * scaled yuv-output is written to local store buffer 1600 * 1601 * @param src buffer for 2 lines input 1602 * @param dst_ buffer for 1 line output 1603 * @param dst_width the width of the destination line 1604 * @param vf_x_scale a float vector, at each entry is the x_scale-factor 1605 * @param vf_NSweight a float vector, at each position is the weight NORTH/SOUTH for the current line 1606 * @param src_linestride the stride of the srcline 1607 */ 1608 void bilinear_scale_line_w16( unsigned char* src, unsigned char* dst_, unsigned int dst_width, vector float vf_x_scale, vector float vf_NSweight, unsigned int src_linestride ) { 1609 1610 unsigned char* dst = dst_; 1611 1612 unsigned int dst_x; 1613 for( dst_x=0; dst_x<dst_width; dst_x+=16) { 1614 // address calculation for loading the 4 surrounding pixel of each calculated 1615 // destination pixel 1616 vector unsigned int vui_dst_x_tmp = spu_splats( dst_x ); 1617 // parallelised processing 1618 // first range->pixel 1 2 3 4 1619 // second range->pixel 5 6 7 8 1620 // third range->pixel 9 10 11 12 1621 // fourth range->pixel 13 14 15 16 1622 vector unsigned int vui_inc_dst_x_first_range = { 0, 1, 2, 3 }; 1623 vector unsigned int vui_inc_dst_x_second_range = { 4, 5, 6, 7 }; 1624 vector unsigned int vui_inc_dst_x_third_range = { 8, 9, 10, 11 }; 1625 vector unsigned int vui_inc_dst_x_fourth_range = { 12, 13, 14, 15 }; 1626 vector unsigned int vui_dst_x_first_range = spu_add( vui_dst_x_tmp, vui_inc_dst_x_first_range ); 1627 vector unsigned int vui_dst_x_second_range = spu_add( vui_dst_x_tmp, vui_inc_dst_x_second_range ); 1628 vector unsigned int vui_dst_x_third_range = spu_add( vui_dst_x_tmp, vui_inc_dst_x_third_range ); 1629 vector unsigned int vui_dst_x_fourth_range = spu_add( vui_dst_x_tmp, vui_inc_dst_x_fourth_range ); 1630 1631 // calculate weight EAST-WEST 1632 vector float vf_dst_x_first_range = spu_convtf( vui_dst_x_first_range, 0 ); 1633 vector float vf_dst_x_second_range = spu_convtf( vui_dst_x_second_range, 0 ); 1634 vector float vf_dst_x_third_range = spu_convtf( vui_dst_x_third_range, 0 ); 1635 vector float vf_dst_x_fourth_range = spu_convtf( vui_dst_x_fourth_range, 0 ); 1636 vector float vf_src_x_first_range = spu_mul( vf_dst_x_first_range, vf_x_scale ); 1637 vector float vf_src_x_second_range = spu_mul( vf_dst_x_second_range, vf_x_scale ); 1638 vector float vf_src_x_third_range = spu_mul( vf_dst_x_third_range, vf_x_scale ); 1639 vector float vf_src_x_fourth_range = spu_mul( vf_dst_x_fourth_range, vf_x_scale ); 1640 vector unsigned int vui_interpl_x_first_range = spu_convtu( vf_src_x_first_range, 0 ); 1641 vector unsigned int vui_interpl_x_second_range = spu_convtu( vf_src_x_second_range, 0 ); 1642 vector unsigned int vui_interpl_x_third_range = spu_convtu( vf_src_x_third_range, 0 ); 1643 vector unsigned int vui_interpl_x_fourth_range = spu_convtu( vf_src_x_fourth_range, 0 ); 1644 vector float vf_interpl_x_first_range = spu_convtf( vui_interpl_x_first_range, 0 ); 1645 vector float vf_interpl_x_second_range = spu_convtf( vui_interpl_x_second_range, 0 ); 1646 vector float vf_interpl_x_third_range = spu_convtf( vui_interpl_x_third_range, 0 ); 1647 vector float vf_interpl_x_fourth_range = spu_convtf( vui_interpl_x_fourth_range, 0 ); 1648 vector float vf_EWweight_first_range = spu_sub( vf_src_x_first_range, vf_interpl_x_first_range ); 1649 vector float vf_EWweight_second_range = spu_sub( vf_src_x_second_range, vf_interpl_x_second_range ); 1650 vector float vf_EWweight_third_range = spu_sub( vf_src_x_third_range, vf_interpl_x_third_range ); 1651 vector float vf_EWweight_fourth_range = spu_sub( vf_src_x_fourth_range, vf_interpl_x_fourth_range ); 1652 1653 // calculate address offset 1654 // 1655 // pixel NORTH WEST 1656 vector unsigned int vui_off_pixelNW_first_range = vui_interpl_x_first_range; 1657 vector unsigned int vui_off_pixelNW_second_range = vui_interpl_x_second_range; 1658 vector unsigned int vui_off_pixelNW_third_range = vui_interpl_x_third_range; 1659 vector unsigned int vui_off_pixelNW_fourth_range = vui_interpl_x_fourth_range; 1660 1661 // pixel NORTH EAST-->(offpixelNW+1) 1662 vector unsigned int vui_add_1 = { 1, 1, 1, 1 }; 1663 vector unsigned int vui_off_pixelNE_first_range = spu_add( vui_off_pixelNW_first_range, vui_add_1 ); 1664 vector unsigned int vui_off_pixelNE_second_range = spu_add( vui_off_pixelNW_second_range, vui_add_1 ); 1665 vector unsigned int vui_off_pixelNE_third_range = spu_add( vui_off_pixelNW_third_range, vui_add_1 ); 1666 vector unsigned int vui_off_pixelNE_fourth_range = spu_add( vui_off_pixelNW_fourth_range, vui_add_1 ); 1667 1668 // SOUTH-WEST-->(offpixelNW+src_linestride) 1669 vector unsigned int vui_srclinestride = spu_splats( src_linestride ); 1670 vector unsigned int vui_off_pixelSW_first_range = spu_add( vui_srclinestride, vui_off_pixelNW_first_range ); 1671 vector unsigned int vui_off_pixelSW_second_range = spu_add( vui_srclinestride, vui_off_pixelNW_second_range ); 1672 vector unsigned int vui_off_pixelSW_third_range = spu_add( vui_srclinestride, vui_off_pixelNW_third_range ); 1673 vector unsigned int vui_off_pixelSW_fourth_range = spu_add( vui_srclinestride, vui_off_pixelNW_fourth_range ); 1674 1675 // SOUTH-EAST-->(offpixelNW+src_linestride+1) 1676 vector unsigned int vui_off_pixelSE_first_range = spu_add( vui_srclinestride, vui_off_pixelNE_first_range ); 1677 vector unsigned int vui_off_pixelSE_second_range = spu_add( vui_srclinestride, vui_off_pixelNE_second_range ); 1678 vector unsigned int vui_off_pixelSE_third_range = spu_add( vui_srclinestride, vui_off_pixelNE_third_range ); 1679 vector unsigned int vui_off_pixelSE_fourth_range = spu_add( vui_srclinestride, vui_off_pixelNE_fourth_range ); 1680 1681 // calculate each address 1682 vector unsigned int vui_src_ls = spu_splats( (unsigned int) src ); 1683 vector unsigned int vui_addr_pixelNW_first_range = spu_add( vui_src_ls, vui_off_pixelNW_first_range ); 1684 vector unsigned int vui_addr_pixelNW_second_range = spu_add( vui_src_ls, vui_off_pixelNW_second_range ); 1685 vector unsigned int vui_addr_pixelNW_third_range = spu_add( vui_src_ls, vui_off_pixelNW_third_range ); 1686 vector unsigned int vui_addr_pixelNW_fourth_range = spu_add( vui_src_ls, vui_off_pixelNW_fourth_range ); 1687 1688 vector unsigned int vui_addr_pixelNE_first_range = spu_add( vui_src_ls, vui_off_pixelNE_first_range ); 1689 vector unsigned int vui_addr_pixelNE_second_range = spu_add( vui_src_ls, vui_off_pixelNE_second_range ); 1690 vector unsigned int vui_addr_pixelNE_third_range = spu_add( vui_src_ls, vui_off_pixelNE_third_range ); 1691 vector unsigned int vui_addr_pixelNE_fourth_range = spu_add( vui_src_ls, vui_off_pixelNE_fourth_range ); 1692 1693 vector unsigned int vui_addr_pixelSW_first_range = spu_add( vui_src_ls, vui_off_pixelSW_first_range ); 1694 vector unsigned int vui_addr_pixelSW_second_range = spu_add( vui_src_ls, vui_off_pixelSW_second_range ); 1695 vector unsigned int vui_addr_pixelSW_third_range = spu_add( vui_src_ls, vui_off_pixelSW_third_range ); 1696 vector unsigned int vui_addr_pixelSW_fourth_range = spu_add( vui_src_ls, vui_off_pixelSW_fourth_range ); 1697 1698 vector unsigned int vui_addr_pixelSE_first_range = spu_add( vui_src_ls, vui_off_pixelSE_first_range ); 1699 vector unsigned int vui_addr_pixelSE_second_range = spu_add( vui_src_ls, vui_off_pixelSE_second_range ); 1700 vector unsigned int vui_addr_pixelSE_third_range = spu_add( vui_src_ls, vui_off_pixelSE_third_range ); 1701 vector unsigned int vui_addr_pixelSE_fourth_range = spu_add( vui_src_ls, vui_off_pixelSE_fourth_range ); 1702 1703 1704 // get each pixel 1705 // 1706 // scalar load, afterwards insertion into the right position 1707 // NORTH WEST 1708 // first range 1709 vector unsigned char null_vector = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 1710 vector unsigned char vuc_pixel_NW_first_range = spu_insert( 1711 *((unsigned char*) spu_extract( vui_addr_pixelNW_first_range, 0 )), null_vector, 3 ); 1712 vuc_pixel_NW_first_range = spu_insert( 1713 *((unsigned char*) spu_extract( vui_addr_pixelNW_first_range, 1 )), 1714 vuc_pixel_NW_first_range, 7 ); 1715 vuc_pixel_NW_first_range = spu_insert( 1716 *((unsigned char*) spu_extract( vui_addr_pixelNW_first_range, 2 )), 1717 vuc_pixel_NW_first_range, 11 ); 1718 vuc_pixel_NW_first_range = spu_insert( 1719 *((unsigned char*) spu_extract( vui_addr_pixelNW_first_range, 3 )), 1720 vuc_pixel_NW_first_range, 15 ); 1721 // second range 1722 vector unsigned char vuc_pixel_NW_second_range = spu_insert( 1723 *((unsigned char*) spu_extract( vui_addr_pixelNW_second_range, 0 )), null_vector, 3 ); 1724 vuc_pixel_NW_second_range = spu_insert( 1725 *((unsigned char*) spu_extract( vui_addr_pixelNW_second_range, 1 )), 1726 vuc_pixel_NW_second_range, 7 ); 1727 vuc_pixel_NW_second_range = spu_insert( 1728 *((unsigned char*) spu_extract( vui_addr_pixelNW_second_range, 2 )), 1729 vuc_pixel_NW_second_range, 11 ); 1730 vuc_pixel_NW_second_range = spu_insert( 1731 *((unsigned char*) spu_extract( vui_addr_pixelNW_second_range, 3 )), 1732 vuc_pixel_NW_second_range, 15 ); 1733 // third range 1734 vector unsigned char vuc_pixel_NW_third_range = spu_insert( 1735 *((unsigned char*) spu_extract( vui_addr_pixelNW_third_range, 0 )), null_vector, 3 ); 1736 vuc_pixel_NW_third_range = spu_insert( 1737 *((unsigned char*) spu_extract( vui_addr_pixelNW_third_range, 1 )), 1738 vuc_pixel_NW_third_range, 7 ); 1739 vuc_pixel_NW_third_range = spu_insert( 1740 *((unsigned char*) spu_extract( vui_addr_pixelNW_third_range, 2 )), 1741 vuc_pixel_NW_third_range, 11 ); 1742 vuc_pixel_NW_third_range = spu_insert( 1743 *((unsigned char*) spu_extract( vui_addr_pixelNW_third_range, 3 )), 1744 vuc_pixel_NW_third_range, 15 ); 1745 // fourth range 1746 vector unsigned char vuc_pixel_NW_fourth_range = spu_insert( 1747 *((unsigned char*) spu_extract( vui_addr_pixelNW_fourth_range, 0 )), null_vector, 3 ); 1748 vuc_pixel_NW_fourth_range = spu_insert( 1749 *((unsigned char*) spu_extract( vui_addr_pixelNW_fourth_range, 1 )), 1750 vuc_pixel_NW_fourth_range, 7 ); 1751 vuc_pixel_NW_fourth_range = spu_insert( 1752 *((unsigned char*) spu_extract( vui_addr_pixelNW_fourth_range, 2 )), 1753 vuc_pixel_NW_fourth_range, 11 ); 1754 vuc_pixel_NW_fourth_range = spu_insert( 1755 *((unsigned char*) spu_extract( vui_addr_pixelNW_fourth_range, 3 )), 1756 vuc_pixel_NW_fourth_range, 15 ); 1757 1758 // NORTH EAST 1759 // first range 1760 vector unsigned char vuc_pixel_NE_first_range = spu_insert( 1761 *((unsigned char*) spu_extract( vui_addr_pixelNE_first_range, 0 )), null_vector, 3 ); 1762 vuc_pixel_NE_first_range = spu_insert( 1763 *((unsigned char*) spu_extract( vui_addr_pixelNE_first_range, 1 )), 1764 vuc_pixel_NE_first_range, 7 ); 1765 vuc_pixel_NE_first_range = spu_insert( 1766 *((unsigned char*) spu_extract( vui_addr_pixelNE_first_range, 2 )), 1767 vuc_pixel_NE_first_range, 11 ); 1768 vuc_pixel_NE_first_range = spu_insert( 1769 *((unsigned char*) spu_extract( vui_addr_pixelNE_first_range, 3 )), 1770 vuc_pixel_NE_first_range, 15 ); 1771 // second range 1772 vector unsigned char vuc_pixel_NE_second_range = spu_insert( 1773 *((unsigned char*) spu_extract( vui_addr_pixelNE_second_range, 0 )), null_vector, 3 ); 1774 vuc_pixel_NE_second_range = spu_insert( 1775 *((unsigned char*) spu_extract( vui_addr_pixelNE_second_range, 1 )), 1776 vuc_pixel_NE_second_range, 7 ); 1777 vuc_pixel_NE_second_range = spu_insert( 1778 *((unsigned char*) spu_extract( vui_addr_pixelNE_second_range, 2 )), 1779 vuc_pixel_NE_second_range, 11 ); 1780 vuc_pixel_NE_second_range = spu_insert( 1781 *((unsigned char*) spu_extract( vui_addr_pixelNE_second_range, 3 )), 1782 vuc_pixel_NE_second_range, 15 ); 1783 // third range 1784 vector unsigned char vuc_pixel_NE_third_range = spu_insert( 1785 *((unsigned char*) spu_extract( vui_addr_pixelNE_third_range, 0 )), null_vector, 3 ); 1786 vuc_pixel_NE_third_range = spu_insert( 1787 *((unsigned char*) spu_extract( vui_addr_pixelNE_third_range, 1 )), 1788 vuc_pixel_NE_third_range, 7 ); 1789 vuc_pixel_NE_third_range = spu_insert( 1790 *((unsigned char*) spu_extract( vui_addr_pixelNE_third_range, 2 )), 1791 vuc_pixel_NE_third_range, 11 ); 1792 vuc_pixel_NE_third_range = spu_insert( 1793 *((unsigned char*) spu_extract( vui_addr_pixelNE_third_range, 3 )), 1794 vuc_pixel_NE_third_range, 15 ); 1795 // fourth range 1796 vector unsigned char vuc_pixel_NE_fourth_range = spu_insert( 1797 *((unsigned char*) spu_extract( vui_addr_pixelNE_fourth_range, 0 )), null_vector, 3 ); 1798 vuc_pixel_NE_fourth_range = spu_insert( 1799 *((unsigned char*) spu_extract( vui_addr_pixelNE_fourth_range, 1 )), 1800 vuc_pixel_NE_fourth_range, 7 ); 1801 vuc_pixel_NE_fourth_range = spu_insert( 1802 *((unsigned char*) spu_extract( vui_addr_pixelNE_fourth_range, 2 )), 1803 vuc_pixel_NE_fourth_range, 11 ); 1804 vuc_pixel_NE_fourth_range = spu_insert( 1805 *((unsigned char*) spu_extract( vui_addr_pixelNE_fourth_range, 3 )), 1806 vuc_pixel_NE_fourth_range, 15 ); 1807 1808 // SOUTH WEST 1809 // first range 1810 vector unsigned char vuc_pixel_SW_first_range = spu_insert( 1811 *((unsigned char*) spu_extract( vui_addr_pixelSW_first_range, 0 )), null_vector, 3 ); 1812 vuc_pixel_SW_first_range = spu_insert( 1813 *((unsigned char*) spu_extract( vui_addr_pixelSW_first_range, 1 )), 1814 vuc_pixel_SW_first_range, 7 ); 1815 vuc_pixel_SW_first_range = spu_insert( 1816 *((unsigned char*) spu_extract( vui_addr_pixelSW_first_range, 2 )), 1817 vuc_pixel_SW_first_range, 11 ); 1818 vuc_pixel_SW_first_range = spu_insert( 1819 *((unsigned char*) spu_extract( vui_addr_pixelSW_first_range, 3 )), 1820 vuc_pixel_SW_first_range, 15 ); 1821 // second range 1822 vector unsigned char vuc_pixel_SW_second_range = spu_insert( 1823 *((unsigned char*) spu_extract( vui_addr_pixelSW_second_range, 0 )), null_vector, 3 ); 1824 vuc_pixel_SW_second_range = spu_insert( 1825 *((unsigned char*) spu_extract( vui_addr_pixelSW_second_range, 1 )), 1826 vuc_pixel_SW_second_range, 7 ); 1827 vuc_pixel_SW_second_range = spu_insert( 1828 *((unsigned char*) spu_extract( vui_addr_pixelSW_second_range, 2 )), 1829 vuc_pixel_SW_second_range, 11 ); 1830 vuc_pixel_SW_second_range = spu_insert( 1831 *((unsigned char*) spu_extract( vui_addr_pixelSW_second_range, 3 )), 1832 vuc_pixel_SW_second_range, 15 ); 1833 // third range 1834 vector unsigned char vuc_pixel_SW_third_range = spu_insert( 1835 *((unsigned char*) spu_extract( vui_addr_pixelSW_third_range, 0 )), null_vector, 3 ); 1836 vuc_pixel_SW_third_range = spu_insert( 1837 *((unsigned char*) spu_extract( vui_addr_pixelSW_third_range, 1 )), 1838 vuc_pixel_SW_third_range, 7 ); 1839 vuc_pixel_SW_third_range = spu_insert( 1840 *((unsigned char*) spu_extract( vui_addr_pixelSW_third_range, 2 )), 1841 vuc_pixel_SW_third_range, 11 ); 1842 vuc_pixel_SW_third_range = spu_insert( 1843 *((unsigned char*) spu_extract( vui_addr_pixelSW_third_range, 3 )), 1844 vuc_pixel_SW_third_range, 15 ); 1845 // fourth range 1846 vector unsigned char vuc_pixel_SW_fourth_range = spu_insert( 1847 *((unsigned char*) spu_extract( vui_addr_pixelSW_fourth_range, 0 )), null_vector, 3 ); 1848 vuc_pixel_SW_fourth_range = spu_insert( 1849 *((unsigned char*) spu_extract( vui_addr_pixelSW_fourth_range, 1 )), 1850 vuc_pixel_SW_fourth_range, 7 ); 1851 vuc_pixel_SW_fourth_range = spu_insert( 1852 *((unsigned char*) spu_extract( vui_addr_pixelSW_fourth_range, 2 )), 1853 vuc_pixel_SW_fourth_range, 11 ); 1854 vuc_pixel_SW_fourth_range = spu_insert( 1855 *((unsigned char*) spu_extract( vui_addr_pixelSW_fourth_range, 3 )), 1856 vuc_pixel_SW_fourth_range, 15 ); 1857 1858 // NORTH EAST 1859 // first range 1860 vector unsigned char vuc_pixel_SE_first_range = spu_insert( 1861 *((unsigned char*) spu_extract( vui_addr_pixelSE_first_range, 0 )), null_vector, 3 ); 1862 vuc_pixel_SE_first_range = spu_insert( 1863 *((unsigned char*) spu_extract( vui_addr_pixelSE_first_range, 1 )), 1864 vuc_pixel_SE_first_range, 7 ); 1865 vuc_pixel_SE_first_range = spu_insert( 1866 *((unsigned char*) spu_extract( vui_addr_pixelSE_first_range, 2 )), 1867 vuc_pixel_SE_first_range, 11 ); 1868 vuc_pixel_SE_first_range = spu_insert( 1869 *((unsigned char*) spu_extract( vui_addr_pixelSE_first_range, 3 )), 1870 vuc_pixel_SE_first_range, 15 ); 1871 // second range 1872 vector unsigned char vuc_pixel_SE_second_range = spu_insert( 1873 *((unsigned char*) spu_extract( vui_addr_pixelSE_second_range, 0 )), null_vector, 3 ); 1874 vuc_pixel_SE_second_range = spu_insert( 1875 *((unsigned char*) spu_extract( vui_addr_pixelSE_second_range, 1 )), 1876 vuc_pixel_SE_second_range, 7 ); 1877 vuc_pixel_SE_second_range = spu_insert( 1878 *((unsigned char*) spu_extract( vui_addr_pixelSE_second_range, 2 )), 1879 vuc_pixel_SE_second_range, 11 ); 1880 vuc_pixel_SE_second_range = spu_insert( 1881 *((unsigned char*) spu_extract( vui_addr_pixelSE_second_range, 3 )), 1882 vuc_pixel_SE_second_range, 15 ); 1883 // third range 1884 vector unsigned char vuc_pixel_SE_third_range = spu_insert( 1885 *((unsigned char*) spu_extract( vui_addr_pixelSE_third_range, 0 )), null_vector, 3 ); 1886 vuc_pixel_SE_third_range = spu_insert( 1887 *((unsigned char*) spu_extract( vui_addr_pixelSE_third_range, 1 )), 1888 vuc_pixel_SE_third_range, 7 ); 1889 vuc_pixel_SE_third_range = spu_insert( 1890 *((unsigned char*) spu_extract( vui_addr_pixelSE_third_range, 2 )), 1891 vuc_pixel_SE_third_range, 11 ); 1892 vuc_pixel_SE_third_range = spu_insert( 1893 *((unsigned char*) spu_extract( vui_addr_pixelSE_third_range, 3 )), 1894 vuc_pixel_SE_third_range, 15 ); 1895 // fourth range 1896 vector unsigned char vuc_pixel_SE_fourth_range = spu_insert( 1897 *((unsigned char*) spu_extract( vui_addr_pixelSE_fourth_range, 0 )), null_vector, 3 ); 1898 vuc_pixel_SE_fourth_range = spu_insert( 1899 *((unsigned char*) spu_extract( vui_addr_pixelSE_fourth_range, 1 )), 1900 vuc_pixel_SE_fourth_range, 7 ); 1901 vuc_pixel_SE_fourth_range = spu_insert( 1902 *((unsigned char*) spu_extract( vui_addr_pixelSE_fourth_range, 2 )), 1903 vuc_pixel_SE_fourth_range, 11 ); 1904 vuc_pixel_SE_fourth_range = spu_insert( 1905 *((unsigned char*) spu_extract( vui_addr_pixelSE_fourth_range, 3 )), 1906 vuc_pixel_SE_fourth_range, 15 ); 1907 1908 1909 1910 // convert to float 1911 vector float vf_pixel_NW_first_range = spu_convtf( (vector unsigned int) vuc_pixel_NW_first_range, 0 ); 1912 vector float vf_pixel_NW_second_range = spu_convtf( (vector unsigned int) vuc_pixel_NW_second_range, 0 ); 1913 vector float vf_pixel_NW_third_range = spu_convtf( (vector unsigned int) vuc_pixel_NW_third_range, 0 ); 1914 vector float vf_pixel_NW_fourth_range = spu_convtf( (vector unsigned int) vuc_pixel_NW_fourth_range, 0 ); 1915 1916 vector float vf_pixel_NE_first_range = spu_convtf( (vector unsigned int) vuc_pixel_NE_first_range, 0 ); 1917 vector float vf_pixel_NE_second_range = spu_convtf( (vector unsigned int) vuc_pixel_NE_second_range, 0 ); 1918 vector float vf_pixel_NE_third_range = spu_convtf( (vector unsigned int) vuc_pixel_NE_third_range, 0 ); 1919 vector float vf_pixel_NE_fourth_range = spu_convtf( (vector unsigned int) vuc_pixel_NE_fourth_range, 0 ); 1920 1921 vector float vf_pixel_SW_first_range = spu_convtf( (vector unsigned int) vuc_pixel_SW_first_range, 0 ); 1922 vector float vf_pixel_SW_second_range = spu_convtf( (vector unsigned int) vuc_pixel_SW_second_range, 0 ); 1923 vector float vf_pixel_SW_third_range = spu_convtf( (vector unsigned int) vuc_pixel_SW_third_range, 0 ); 1924 vector float vf_pixel_SW_fourth_range = spu_convtf( (vector unsigned int) vuc_pixel_SW_fourth_range, 0 ); 1925 1926 vector float vf_pixel_SE_first_range = spu_convtf( (vector unsigned int) vuc_pixel_SE_first_range, 0 ); 1927 vector float vf_pixel_SE_second_range = spu_convtf( (vector unsigned int) vuc_pixel_SE_second_range, 0 ); 1928 vector float vf_pixel_SE_third_range = spu_convtf( (vector unsigned int) vuc_pixel_SE_third_range, 0 ); 1929 vector float vf_pixel_SE_fourth_range = spu_convtf( (vector unsigned int) vuc_pixel_SE_fourth_range, 0 ); 1930 1931 // first linear interpolation: EWtop 1932 // EWtop = NW + EWweight*(NE-NW) 1933 // 1934 // first range 1935 vector float vf_EWtop_first_range_tmp = spu_sub( vf_pixel_NE_first_range, vf_pixel_NW_first_range ); 1936 vector float vf_EWtop_first_range = spu_madd( vf_EWweight_first_range, 1937 vf_EWtop_first_range_tmp, 1938 vf_pixel_NW_first_range ); 1939 1940 // second range 1941 vector float vf_EWtop_second_range_tmp = spu_sub( vf_pixel_NE_second_range, vf_pixel_NW_second_range ); 1942 vector float vf_EWtop_second_range = spu_madd( vf_EWweight_second_range, 1943 vf_EWtop_second_range_tmp, 1944 vf_pixel_NW_second_range ); 1945 1946 // third range 1947 vector float vf_EWtop_third_range_tmp = spu_sub( vf_pixel_NE_third_range, vf_pixel_NW_third_range ); 1948 vector float vf_EWtop_third_range = spu_madd( vf_EWweight_third_range, 1949 vf_EWtop_third_range_tmp, 1950 vf_pixel_NW_third_range ); 1951 1952 // fourth range 1953 vector float vf_EWtop_fourth_range_tmp = spu_sub( vf_pixel_NE_fourth_range, vf_pixel_NW_fourth_range ); 1954 vector float vf_EWtop_fourth_range = spu_madd( vf_EWweight_fourth_range, 1955 vf_EWtop_fourth_range_tmp, 1956 vf_pixel_NW_fourth_range ); 1957 1958 1959 1960 // second linear interpolation: EWbottom 1961 // EWbottom = SW + EWweight*(SE-SW) 1962 // 1963 // first range 1964 vector float vf_EWbottom_first_range_tmp = spu_sub( vf_pixel_SE_first_range, vf_pixel_SW_first_range ); 1965 vector float vf_EWbottom_first_range = spu_madd( vf_EWweight_first_range, 1966 vf_EWbottom_first_range_tmp, 1967 vf_pixel_SW_first_range ); 1968 1969 // second range 1970 vector float vf_EWbottom_second_range_tmp = spu_sub( vf_pixel_SE_second_range, vf_pixel_SW_second_range ); 1971 vector float vf_EWbottom_second_range = spu_madd( vf_EWweight_second_range, 1972 vf_EWbottom_second_range_tmp, 1973 vf_pixel_SW_second_range ); 1974 // first range 1975 vector float vf_EWbottom_third_range_tmp = spu_sub( vf_pixel_SE_third_range, vf_pixel_SW_third_range ); 1976 vector float vf_EWbottom_third_range = spu_madd( vf_EWweight_third_range, 1977 vf_EWbottom_third_range_tmp, 1978 vf_pixel_SW_third_range ); 1979 1980 // first range 1981 vector float vf_EWbottom_fourth_range_tmp = spu_sub( vf_pixel_SE_fourth_range, vf_pixel_SW_fourth_range ); 1982 vector float vf_EWbottom_fourth_range = spu_madd( vf_EWweight_fourth_range, 1983 vf_EWbottom_fourth_range_tmp, 1984 vf_pixel_SW_fourth_range ); 1985 1986 1987 1988 // third linear interpolation: the bilinear interpolated value 1989 // result = EWtop + NSweight*(EWbottom-EWtop); 1990 // 1991 // first range 1992 vector float vf_result_first_range_tmp = spu_sub( vf_EWbottom_first_range, vf_EWtop_first_range ); 1993 vector float vf_result_first_range = spu_madd( vf_NSweight, 1994 vf_result_first_range_tmp, 1995 vf_EWtop_first_range ); 1996 1997 // second range 1998 vector float vf_result_second_range_tmp = spu_sub( vf_EWbottom_second_range, vf_EWtop_second_range ); 1999 vector float vf_result_second_range = spu_madd( vf_NSweight, 2000 vf_result_second_range_tmp, 2001 vf_EWtop_second_range ); 2002 2003 // third range 2004 vector float vf_result_third_range_tmp = spu_sub( vf_EWbottom_third_range, vf_EWtop_third_range ); 2005 vector float vf_result_third_range = spu_madd( vf_NSweight, 2006 vf_result_third_range_tmp, 2007 vf_EWtop_third_range ); 2008 2009 // fourth range 2010 vector float vf_result_fourth_range_tmp = spu_sub( vf_EWbottom_fourth_range, vf_EWtop_fourth_range ); 2011 vector float vf_result_fourth_range = spu_madd( vf_NSweight, 2012 vf_result_fourth_range_tmp, 2013 vf_EWtop_fourth_range ); 2014 2015 2016 2017 // convert back: using saturated arithmetic 2018 vector unsigned int vui_result_first_range = vfloat_to_vuint( vf_result_first_range ); 2019 vector unsigned int vui_result_second_range = vfloat_to_vuint( vf_result_second_range ); 2020 vector unsigned int vui_result_third_range = vfloat_to_vuint( vf_result_third_range ); 2021 vector unsigned int vui_result_fourth_range = vfloat_to_vuint( vf_result_fourth_range ); 2022 2023 // merge results->lower,upper 2024 vector unsigned char vuc_mask_merge_result_first_second = { 0x03, 0x07, 0x0B, 0x0F, 2025 0x13, 0x17, 0x1B, 0x1F, 2026 0x00, 0x00, 0x00, 0x00, 2027 0x00, 0x00, 0x00, 0x00 }; 2028 2029 vector unsigned char vuc_mask_merge_result_third_fourth = { 0x00, 0x00, 0x00, 0x00, 2030 0x00, 0x00, 0x00, 0x00, 2031 0x03, 0x07, 0x0B, 0x0F, 2032 0x13, 0x17, 0x1B, 0x1F }; 2033 2034 vector unsigned char vuc_result_first_second = 2035 spu_shuffle( (vector unsigned char) vui_result_first_range, 2036 (vector unsigned char) vui_result_second_range, 2037 vuc_mask_merge_result_first_second ); 2038 2039 vector unsigned char vuc_result_third_fourth = 2040 spu_shuffle( (vector unsigned char) vui_result_third_range, 2041 (vector unsigned char) vui_result_fourth_range, 2042 vuc_mask_merge_result_third_fourth ); 2043 2044 // store result 2045 *((vector unsigned char*)dst) = spu_or( vuc_result_first_second, 2046 vuc_result_third_fourth ); 2047 dst += 16; 2048 } 2049 } 2050 2051
