diff options
Diffstat (limited to 'apps/plugins/sdl/src/video/ps3/spulibs/bilin_scaler.c')
-rw-r--r-- | apps/plugins/sdl/src/video/ps3/spulibs/bilin_scaler.c | 2050 |
1 files changed, 2050 insertions, 0 deletions
diff --git a/apps/plugins/sdl/src/video/ps3/spulibs/bilin_scaler.c b/apps/plugins/sdl/src/video/ps3/spulibs/bilin_scaler.c new file mode 100644 index 0000000000..be9b5c6e8d --- /dev/null +++ b/apps/plugins/sdl/src/video/ps3/spulibs/bilin_scaler.c | |||
@@ -0,0 +1,2050 @@ | |||
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 | |||