diff options
author | David Walter Seikel | 2013-01-13 17:29:19 +1000 |
---|---|---|
committer | David Walter Seikel | 2013-01-13 17:29:19 +1000 |
commit | 07274513e984f0b5544586c74508ccd16e7dcafa (patch) | |
tree | b32ff2a9136fbc1a4a6a0ed1e4d79cde0f5f16d9 /libraries/evas/src/lib/engines/common/evas_convert_rgb_32.c | |
parent | Added Irrlicht 1.8, but without all the Windows binaries. (diff) | |
download | SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.zip SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.tar.gz SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.tar.bz2 SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.tar.xz |
Remove EFL, since it's been released now.
Diffstat (limited to 'libraries/evas/src/lib/engines/common/evas_convert_rgb_32.c')
-rw-r--r-- | libraries/evas/src/lib/engines/common/evas_convert_rgb_32.c | 625 |
1 files changed, 0 insertions, 625 deletions
diff --git a/libraries/evas/src/lib/engines/common/evas_convert_rgb_32.c b/libraries/evas/src/lib/engines/common/evas_convert_rgb_32.c deleted file mode 100644 index 0401a4a..0000000 --- a/libraries/evas/src/lib/engines/common/evas_convert_rgb_32.c +++ /dev/null | |||
@@ -1,625 +0,0 @@ | |||
1 | #include "evas_common.h" | ||
2 | #include "evas_convert_rgb_32.h" | ||
3 | |||
4 | #ifdef BUILD_CONVERT_32_RGB_8888 | ||
5 | #ifdef BUILD_CONVERT_32_RGB_ROT0 | ||
6 | void | ||
7 | evas_common_convert_rgba_to_32bpp_rgb_8888 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
8 | { | ||
9 | DATA32 *src_ptr; | ||
10 | DATA32 *dst_ptr; | ||
11 | int y; | ||
12 | Gfx_Func_Copy func; | ||
13 | |||
14 | dst_ptr = (DATA32 *)dst; | ||
15 | src_ptr = src; | ||
16 | |||
17 | func = evas_common_draw_func_copy_get(w, 0); | ||
18 | |||
19 | for (y = 0; y < h; y++) | ||
20 | { | ||
21 | func(src_ptr, dst_ptr, w); | ||
22 | src_ptr += w + src_jump; | ||
23 | dst_ptr += w + dst_jump; | ||
24 | } | ||
25 | return; | ||
26 | } | ||
27 | #endif | ||
28 | #endif | ||
29 | |||
30 | #ifdef BUILD_CONVERT_32_RGB_8888 | ||
31 | #ifdef BUILD_CONVERT_32_RGB_ROT180 | ||
32 | void | ||
33 | evas_common_convert_rgba_to_32bpp_rgb_8888_rot_180 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
34 | { | ||
35 | DATA32 *src_ptr; | ||
36 | DATA32 *dst_ptr; | ||
37 | int x, y; | ||
38 | |||
39 | dst_ptr = (DATA32 *)dst; | ||
40 | |||
41 | CONVERT_LOOP_START_ROT_180(); | ||
42 | |||
43 | *dst_ptr = *src_ptr; | ||
44 | |||
45 | CONVERT_LOOP_END_ROT_180(); | ||
46 | return; | ||
47 | } | ||
48 | #endif | ||
49 | #endif | ||
50 | |||
51 | #ifdef TILE_ROTATE | ||
52 | #define FAST_SIMPLE_ROTATE(suffix, pix_type) \ | ||
53 | static void \ | ||
54 | blt_rotated_90_trivial_##suffix(pix_type *dst, \ | ||
55 | int dst_stride, \ | ||
56 | const pix_type *src, \ | ||
57 | int src_stride, \ | ||
58 | int w, \ | ||
59 | int h) \ | ||
60 | { \ | ||
61 | int x, y; \ | ||
62 | for (y = 0; y < h; y++) \ | ||
63 | { \ | ||
64 | const pix_type *s = src + (h - y - 1); \ | ||
65 | pix_type *d = dst + (dst_stride * y); \ | ||
66 | for (x = 0; x < w; x++) \ | ||
67 | { \ | ||
68 | *d++ = *s; \ | ||
69 | s += src_stride; \ | ||
70 | } \ | ||
71 | } \ | ||
72 | } \ | ||
73 | static void \ | ||
74 | blt_rotated_270_trivial_##suffix(pix_type *dst, \ | ||
75 | int dst_stride, \ | ||
76 | const pix_type *src, \ | ||
77 | int src_stride, \ | ||
78 | int w, \ | ||
79 | int h) \ | ||
80 | { \ | ||
81 | int x, y; \ | ||
82 | for (y = 0; y < h; y++) \ | ||
83 | { \ | ||
84 | const pix_type *s = src + (src_stride * (w - 1)) + y; \ | ||
85 | pix_type *d = dst + (dst_stride * y); \ | ||
86 | for (x = 0; x < w; x++) \ | ||
87 | { \ | ||
88 | *d++ = *s; \ | ||
89 | s -= src_stride; \ | ||
90 | } \ | ||
91 | } \ | ||
92 | } \ | ||
93 | static void \ | ||
94 | blt_rotated_90_##suffix(pix_type *dst, \ | ||
95 | int dst_stride, \ | ||
96 | const pix_type *src, \ | ||
97 | int src_stride, \ | ||
98 | int w, \ | ||
99 | int h) \ | ||
100 | { \ | ||
101 | int x, leading_pixels = 0, trailing_pixels = 0; \ | ||
102 | const int TILE_SIZE = TILE_CACHE_LINE_SIZE / sizeof(pix_type); \ | ||
103 | if ((uintptr_t)dst & (TILE_CACHE_LINE_SIZE - 1)) \ | ||
104 | { \ | ||
105 | leading_pixels = TILE_SIZE - \ | ||
106 | (((uintptr_t)dst & (TILE_CACHE_LINE_SIZE - 1)) / sizeof(pix_type)); \ | ||
107 | if (leading_pixels > w) \ | ||
108 | leading_pixels = w; \ | ||
109 | blt_rotated_90_trivial_##suffix(dst, \ | ||
110 | dst_stride, \ | ||
111 | src, \ | ||
112 | src_stride, \ | ||
113 | leading_pixels, \ | ||
114 | h); \ | ||
115 | dst += leading_pixels; \ | ||
116 | src += leading_pixels * src_stride; \ | ||
117 | w -= leading_pixels; \ | ||
118 | } \ | ||
119 | if ((uintptr_t)(dst + w) & (TILE_CACHE_LINE_SIZE - 1)) \ | ||
120 | { \ | ||
121 | trailing_pixels = (((uintptr_t)(dst + w) & \ | ||
122 | (TILE_CACHE_LINE_SIZE - 1)) / sizeof(pix_type)); \ | ||
123 | if (trailing_pixels > w) \ | ||
124 | trailing_pixels = w; \ | ||
125 | w -= trailing_pixels; \ | ||
126 | } \ | ||
127 | for (x = 0; x < w; x += TILE_SIZE) \ | ||
128 | { \ | ||
129 | blt_rotated_90_trivial_##suffix(dst + x, \ | ||
130 | dst_stride, \ | ||
131 | src + (src_stride * x), \ | ||
132 | src_stride, \ | ||
133 | TILE_SIZE, \ | ||
134 | h); \ | ||
135 | } \ | ||
136 | if (trailing_pixels) \ | ||
137 | blt_rotated_90_trivial_##suffix(dst + w, \ | ||
138 | dst_stride, \ | ||
139 | src + (w * src_stride), \ | ||
140 | src_stride, \ | ||
141 | trailing_pixels, \ | ||
142 | h); \ | ||
143 | } \ | ||
144 | static void \ | ||
145 | blt_rotated_270_##suffix(pix_type *dst, \ | ||
146 | int dst_stride, \ | ||
147 | const pix_type *src, \ | ||
148 | int src_stride, \ | ||
149 | int w, \ | ||
150 | int h) \ | ||
151 | { \ | ||
152 | int x, leading_pixels = 0, trailing_pixels = 0; \ | ||
153 | const int TILE_SIZE = TILE_CACHE_LINE_SIZE / sizeof(pix_type); \ | ||
154 | if ((uintptr_t)dst & (TILE_CACHE_LINE_SIZE - 1)) \ | ||
155 | { \ | ||
156 | leading_pixels = TILE_SIZE - \ | ||
157 | (((uintptr_t)dst & (TILE_CACHE_LINE_SIZE - 1)) / sizeof(pix_type)); \ | ||
158 | if (leading_pixels > w) \ | ||
159 | leading_pixels = w; \ | ||
160 | blt_rotated_270_trivial_##suffix(dst, \ | ||
161 | dst_stride, \ | ||
162 | src + (src_stride * (w - leading_pixels)), \ | ||
163 | src_stride, \ | ||
164 | leading_pixels, \ | ||
165 | h); \ | ||
166 | dst += leading_pixels; \ | ||
167 | w -= leading_pixels; \ | ||
168 | } \ | ||
169 | if ((uintptr_t)(dst + w) & (TILE_CACHE_LINE_SIZE - 1)) \ | ||
170 | { \ | ||
171 | trailing_pixels = (((uintptr_t)(dst + w) & \ | ||
172 | (TILE_CACHE_LINE_SIZE - 1)) / sizeof(pix_type)); \ | ||
173 | if (trailing_pixels > w) \ | ||
174 | trailing_pixels = w; \ | ||
175 | w -= trailing_pixels; \ | ||
176 | src += trailing_pixels * src_stride; \ | ||
177 | } \ | ||
178 | for (x = 0; x < w; x += TILE_SIZE) \ | ||
179 | { \ | ||
180 | blt_rotated_270_trivial_##suffix(dst + x, \ | ||
181 | dst_stride, \ | ||
182 | src + (src_stride * (w - x - TILE_SIZE)), \ | ||
183 | src_stride, \ | ||
184 | TILE_SIZE, \ | ||
185 | h); \ | ||
186 | } \ | ||
187 | if (trailing_pixels) \ | ||
188 | blt_rotated_270_trivial_##suffix(dst + w, \ | ||
189 | dst_stride, \ | ||
190 | src - (trailing_pixels * src_stride), \ | ||
191 | src_stride, \ | ||
192 | trailing_pixels, \ | ||
193 | h); \ | ||
194 | } | ||
195 | |||
196 | FAST_SIMPLE_ROTATE(8888, DATA8) | ||
197 | #endif | ||
198 | |||
199 | |||
200 | #ifdef BUILD_CONVERT_32_RGB_8888 | ||
201 | #ifdef BUILD_CONVERT_32_RGB_ROT270 | ||
202 | void | ||
203 | evas_common_convert_rgba_to_32bpp_rgb_8888_rot_270 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
204 | { | ||
205 | #ifdef TILE_ROTATE | ||
206 | blt_rotated_270_8888((DATA8 *)dst, dst_jump+w, (const DATA8 *)src, src_jump+h, w, h) ; | ||
207 | #else | ||
208 | DATA32 *src_ptr; | ||
209 | DATA32 *dst_ptr; | ||
210 | int x, y; | ||
211 | |||
212 | dst_ptr = (DATA32 *)dst; | ||
213 | |||
214 | CONVERT_LOOP_START_ROT_270(); | ||
215 | |||
216 | *dst_ptr = *src_ptr; | ||
217 | |||
218 | CONVERT_LOOP_END_ROT_270(); | ||
219 | #endif | ||
220 | return; | ||
221 | } | ||
222 | #endif | ||
223 | #endif | ||
224 | |||
225 | #ifdef BUILD_CONVERT_32_RGB_8888 | ||
226 | #ifdef BUILD_CONVERT_32_RGB_ROT90 | ||
227 | void | ||
228 | evas_common_convert_rgba_to_32bpp_rgb_8888_rot_90 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
229 | { | ||
230 | # ifndef BUILD_NEON | ||
231 | # ifdef TILE_ROTATE | ||
232 | blt_rotated_90_8888((DATA8 *)dst, dst_jump+w, (const DATA8 *)src, src_jump+h, w, h) ; | ||
233 | # else | ||
234 | DATA32 *src_ptr; | ||
235 | DATA32 *dst_ptr; | ||
236 | int x, y; | ||
237 | |||
238 | dst_ptr = (DATA32 *)dst; | ||
239 | CONVERT_LOOP_START_ROT_90(); | ||
240 | |||
241 | *dst_ptr = *src_ptr; | ||
242 | |||
243 | CONVERT_LOOP_END_ROT_90(); | ||
244 | # endif | ||
245 | |||
246 | # else | ||
247 | |||
248 | # ifdef TILE_ROTATE | ||
249 | blt_rotated_90_8888((DATA8 *)dst, dst_jump+w, (const DATA8 *)src, src_jump+h, w, h) ; | ||
250 | # else | ||
251 | if ((w & 1) || (h & 1)) | ||
252 | { | ||
253 | /* Rarely (if ever) if ever: so slow path is fine */ | ||
254 | DATA32 *src_ptr; | ||
255 | DATA32 *dst_ptr; | ||
256 | int x, y; | ||
257 | |||
258 | dst_ptr = (DATA32 *)dst; | ||
259 | CONVERT_LOOP_START_ROT_90(); | ||
260 | |||
261 | *dst_ptr = *src_ptr; | ||
262 | |||
263 | CONVERT_LOOP_END_ROT_90(); | ||
264 | } | ||
265 | else | ||
266 | { | ||
267 | # define AP "convert_rgba32_rot_90_" | ||
268 | asm volatile ( | ||
269 | ".fpu neon \n\t" | ||
270 | " mov %[s1], %[src] \n\t" | ||
271 | " add %[s1], %[s1], %[h],lsl #2 \n\t" | ||
272 | " sub %[s1], #8 \n\t" | ||
273 | |||
274 | " mov %[s2], %[src] \n\t" | ||
275 | " add %[s2], %[s2], %[h], lsl #3 \n\t" | ||
276 | " add %[s2], %[s2], %[sjmp], lsr #1 \n\t" | ||
277 | " sub %[s2], #8 \n\t" | ||
278 | |||
279 | " mov %[d1], %[dst] \n\t" | ||
280 | |||
281 | " add %[d2], %[d1], %[djmp] \n\t" | ||
282 | " add %[d2], %[d2], %[w], lsl #2 \n\t" | ||
283 | |||
284 | " mov %[sadv], %[h], lsl #3 \n\t" | ||
285 | " add %[sadv], %[sadv], %[sjmp], lsl #1\n\t" | ||
286 | |||
287 | " mov %[y], #0 \n\t" | ||
288 | " mov %[x], #0 \n\t" | ||
289 | AP"loop: \n\t" | ||
290 | " vld1.u32 d0, [%[s1]] \n\t" | ||
291 | " vld1.u32 d1, [%[s2]] \n\t" | ||
292 | " add %[x], #2 \n\t" | ||
293 | " add %[s1], %[sadv] \n\t" | ||
294 | " add %[s2], %[sadv] \n\t" | ||
295 | " vtrn.u32 d0, d1 \n\t" | ||
296 | " cmp %[x], %[w] \n\t" | ||
297 | " vst1.u32 d1, [%[d1]]! \n\t" | ||
298 | " vst1.u32 d0, [%[d2]]! \n\t" | ||
299 | " blt "AP"loop \n\t" | ||
300 | |||
301 | " mov %[x], #0 \n\t" | ||
302 | " add %[d1], %[djmp] \n\t" | ||
303 | " add %[d1], %[d1], %[w], lsl #2 \n\t" | ||
304 | " add %[d2], %[djmp] \n\t" | ||
305 | " add %[d2], %[d2], %[w], lsl #2 \n\t" | ||
306 | |||
307 | " mov %[s1], %[src] \n\t" | ||
308 | " add %[s1], %[s1], %[h], lsl #2 \n\t" | ||
309 | " sub %[s1], %[s1], %[y], lsl #2 \n\t" | ||
310 | " sub %[s1], #16 \n\t" | ||
311 | |||
312 | " add %[s2], %[s1], %[h], lsl #2 \n\t" | ||
313 | " add %[s2], %[s2], %[sjmp], lsl #2 \n\t" | ||
314 | |||
315 | " add %[y], #2 \n\t" | ||
316 | |||
317 | " cmp %[y], %[h] \n\t" | ||
318 | " blt "AP"loop \n\t" | ||
319 | |||
320 | : // Out | ||
321 | : [s1] "r" (1), | ||
322 | [s2] "r" (11), | ||
323 | [d1] "r" (2), | ||
324 | [d2] "r" (12), | ||
325 | [src] "r" (src), | ||
326 | [dst] "r" (dst), | ||
327 | [x] "r" (3), | ||
328 | [y] "r" (4), | ||
329 | [w] "r" (w), | ||
330 | [h] "r" (h), | ||
331 | [sadv] "r" (5), | ||
332 | [sjmp] "r" (src_jump * 4), | ||
333 | [djmp] "r" (dst_jump * 4 * 2) | ||
334 | : "d0", "d1", "memory", "cc"// Clober | ||
335 | |||
336 | |||
337 | ); | ||
338 | } | ||
339 | # undef AP | ||
340 | # endif | ||
341 | # endif | ||
342 | return; | ||
343 | } | ||
344 | #endif | ||
345 | #endif | ||
346 | |||
347 | #ifdef BUILD_CONVERT_32_RGBX_8888 | ||
348 | #ifdef BUILD_CONVERT_32_RGB_ROT0 | ||
349 | void | ||
350 | evas_common_convert_rgba_to_32bpp_rgbx_8888 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
351 | { | ||
352 | DATA32 *src_ptr; | ||
353 | DATA32 *dst_ptr; | ||
354 | int x, y; | ||
355 | |||
356 | dst_ptr = (DATA32 *)dst; | ||
357 | |||
358 | CONVERT_LOOP_START_ROT_0(); | ||
359 | |||
360 | // *dst_ptr = (R_VAL(src_ptr) << 24) | (G_VAL(src_ptr) << 16) | (B_VAL(src_ptr) << 8); | ||
361 | *dst_ptr = (*src_ptr << 8); | ||
362 | |||
363 | CONVERT_LOOP_END_ROT_0(); | ||
364 | return; | ||
365 | } | ||
366 | #endif | ||
367 | #endif | ||
368 | |||
369 | #ifdef BUILD_CONVERT_32_RGBX_8888 | ||
370 | #ifdef BUILD_CONVERT_32_RGB_ROT180 | ||
371 | void | ||
372 | evas_common_convert_rgba_to_32bpp_rgbx_8888_rot_180 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
373 | { | ||
374 | DATA32 *src_ptr; | ||
375 | DATA32 *dst_ptr; | ||
376 | int x, y; | ||
377 | |||
378 | dst_ptr = (DATA32 *)dst; | ||
379 | |||
380 | CONVERT_LOOP_START_ROT_180(); | ||
381 | |||
382 | // *dst_ptr = (R_VAL(src_ptr) << 24) | (G_VAL(src_ptr) << 16) | (B_VAL(src_ptr) << 8); | ||
383 | *dst_ptr = (*src_ptr << 8); | ||
384 | |||
385 | CONVERT_LOOP_END_ROT_180(); | ||
386 | return; | ||
387 | } | ||
388 | #endif | ||
389 | #endif | ||
390 | |||
391 | #ifdef BUILD_CONVERT_32_RGBX_8888 | ||
392 | #ifdef BUILD_CONVERT_32_RGB_ROT270 | ||
393 | void | ||
394 | evas_common_convert_rgba_to_32bpp_rgbx_8888_rot_270 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
395 | { | ||
396 | DATA32 *src_ptr; | ||
397 | DATA32 *dst_ptr; | ||
398 | int x, y; | ||
399 | |||
400 | dst_ptr = (DATA32 *)dst; | ||
401 | |||
402 | CONVERT_LOOP_START_ROT_270(); | ||
403 | |||
404 | // *dst_ptr = (R_VAL(src_ptr) << 24) | (G_VAL(src_ptr) << 16) | (B_VAL(src_ptr) << 8); | ||
405 | *dst_ptr = (*src_ptr << 8); | ||
406 | |||
407 | CONVERT_LOOP_END_ROT_270(); | ||
408 | return; | ||
409 | } | ||
410 | #endif | ||
411 | #endif | ||
412 | |||
413 | #ifdef BUILD_CONVERT_32_RGBX_8888 | ||
414 | #ifdef BUILD_CONVERT_32_RGB_ROT90 | ||
415 | void | ||
416 | evas_common_convert_rgba_to_32bpp_rgbx_8888_rot_90 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
417 | { | ||
418 | DATA32 *src_ptr; | ||
419 | DATA32 *dst_ptr; | ||
420 | int x, y; | ||
421 | |||
422 | dst_ptr = (DATA32 *)dst; | ||
423 | |||
424 | CONVERT_LOOP_START_ROT_90(); | ||
425 | |||
426 | // *dst_ptr = (R_VAL(src_ptr) << 24) | (G_VAL(src_ptr) << 16) | (B_VAL(src_ptr) << 8); | ||
427 | *dst_ptr = (*src_ptr << 8); | ||
428 | |||
429 | CONVERT_LOOP_END_ROT_90(); | ||
430 | return; | ||
431 | } | ||
432 | #endif | ||
433 | #endif | ||
434 | |||
435 | #ifdef BUILD_CONVERT_32_BGR_8888 | ||
436 | #ifdef BUILD_CONVERT_32_RGB_ROT0 | ||
437 | void | ||
438 | evas_common_convert_rgba_to_32bpp_bgr_8888 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
439 | { | ||
440 | DATA32 *src_ptr; | ||
441 | DATA32 *dst_ptr; | ||
442 | int x, y; | ||
443 | |||
444 | dst_ptr = (DATA32 *)dst; | ||
445 | |||
446 | CONVERT_LOOP_START_ROT_0(); | ||
447 | |||
448 | *dst_ptr = (B_VAL(src_ptr) << 16) | (G_VAL(src_ptr) << 8) | (R_VAL(src_ptr)); | ||
449 | |||
450 | CONVERT_LOOP_END_ROT_0(); | ||
451 | return; | ||
452 | } | ||
453 | #endif | ||
454 | #endif | ||
455 | |||
456 | #ifdef BUILD_CONVERT_32_BGR_8888 | ||
457 | #ifdef BUILD_CONVERT_32_RGB_ROT180 | ||
458 | void | ||
459 | evas_common_convert_rgba_to_32bpp_bgr_8888_rot_180 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
460 | { | ||
461 | DATA32 *src_ptr; | ||
462 | DATA32 *dst_ptr; | ||
463 | int x, y; | ||
464 | |||
465 | dst_ptr = (DATA32 *)dst; | ||
466 | |||
467 | CONVERT_LOOP_START_ROT_180(); | ||
468 | |||
469 | *dst_ptr = (B_VAL(src_ptr) << 16) | (G_VAL(src_ptr) << 8) | (R_VAL(src_ptr)); | ||
470 | |||
471 | CONVERT_LOOP_END_ROT_180(); | ||
472 | return; | ||
473 | } | ||
474 | #endif | ||
475 | #endif | ||
476 | |||
477 | #ifdef BUILD_CONVERT_32_BGR_8888 | ||
478 | #ifdef BUILD_CONVERT_32_RGB_ROT270 | ||
479 | void | ||
480 | evas_common_convert_rgba_to_32bpp_bgr_8888_rot_270 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
481 | { | ||
482 | DATA32 *src_ptr; | ||
483 | DATA32 *dst_ptr; | ||
484 | int x, y; | ||
485 | |||
486 | dst_ptr = (DATA32 *)dst; | ||
487 | |||
488 | CONVERT_LOOP_START_ROT_270(); | ||
489 | |||
490 | *dst_ptr = (B_VAL(src_ptr) << 16) | (G_VAL(src_ptr) << 8) | (R_VAL(src_ptr)); | ||
491 | |||
492 | CONVERT_LOOP_END_ROT_270(); | ||
493 | return; | ||
494 | } | ||
495 | #endif | ||
496 | #endif | ||
497 | |||
498 | #ifdef BUILD_CONVERT_32_BGR_8888 | ||
499 | #ifdef BUILD_CONVERT_32_RGB_ROT90 | ||
500 | void | ||
501 | evas_common_convert_rgba_to_32bpp_bgr_8888_rot_90 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
502 | { | ||
503 | DATA32 *src_ptr; | ||
504 | DATA32 *dst_ptr; | ||
505 | int x, y; | ||
506 | |||
507 | dst_ptr = (DATA32 *)dst; | ||
508 | |||
509 | CONVERT_LOOP_START_ROT_90(); | ||
510 | |||
511 | *dst_ptr = (B_VAL(src_ptr) << 16) | (G_VAL(src_ptr) << 8) | (R_VAL(src_ptr)); | ||
512 | |||
513 | CONVERT_LOOP_END_ROT_90(); | ||
514 | return; | ||
515 | } | ||
516 | #endif | ||
517 | #endif | ||
518 | |||
519 | #ifdef BUILD_CONVERT_32_BGRX_8888 | ||
520 | #ifdef BUILD_CONVERT_32_RGB_ROT0 | ||
521 | void | ||
522 | evas_common_convert_rgba_to_32bpp_bgrx_8888 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
523 | { | ||
524 | DATA32 *src_ptr; | ||
525 | DATA32 *dst_ptr; | ||
526 | int x, y; | ||
527 | |||
528 | dst_ptr = (DATA32 *)dst; | ||
529 | |||
530 | CONVERT_LOOP_START_ROT_0(); | ||
531 | |||
532 | *dst_ptr = (B_VAL(src_ptr) << 24) | (G_VAL(src_ptr) << 16) | (R_VAL(src_ptr) << 8); | ||
533 | |||
534 | CONVERT_LOOP_END_ROT_0(); | ||
535 | return; | ||
536 | } | ||
537 | #endif | ||
538 | #endif | ||
539 | |||
540 | #ifdef BUILD_CONVERT_32_BGRX_8888 | ||
541 | #ifdef BUILD_CONVERT_32_RGB_ROT180 | ||
542 | void | ||
543 | evas_common_convert_rgba_to_32bpp_bgrx_8888_rot_180 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
544 | { | ||
545 | DATA32 *src_ptr; | ||
546 | DATA32 *dst_ptr; | ||
547 | int x, y; | ||
548 | |||
549 | dst_ptr = (DATA32 *)dst; | ||
550 | |||
551 | CONVERT_LOOP_START_ROT_180(); | ||
552 | |||
553 | *dst_ptr = (B_VAL(src_ptr) << 24) | (G_VAL(src_ptr) << 16) | (R_VAL(src_ptr) << 8); | ||
554 | |||
555 | CONVERT_LOOP_END_ROT_180(); | ||
556 | return; | ||
557 | } | ||
558 | #endif | ||
559 | #endif | ||
560 | |||
561 | #ifdef BUILD_CONVERT_32_BGRX_8888 | ||
562 | #ifdef BUILD_CONVERT_32_RGB_ROT270 | ||
563 | void | ||
564 | evas_common_convert_rgba_to_32bpp_bgrx_8888_rot_270 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
565 | { | ||
566 | DATA32 *src_ptr; | ||
567 | DATA32 *dst_ptr; | ||
568 | int x, y; | ||
569 | |||
570 | dst_ptr = (DATA32 *)dst; | ||
571 | |||
572 | CONVERT_LOOP_START_ROT_270(); | ||
573 | |||
574 | *dst_ptr = (B_VAL(src_ptr) << 24) | (G_VAL(src_ptr) << 16) | (R_VAL(src_ptr) << 8); | ||
575 | |||
576 | CONVERT_LOOP_END_ROT_270(); | ||
577 | return; | ||
578 | } | ||
579 | #endif | ||
580 | #endif | ||
581 | |||
582 | #ifdef BUILD_CONVERT_32_BGRX_8888 | ||
583 | #ifdef BUILD_CONVERT_32_RGB_ROT90 | ||
584 | void | ||
585 | evas_common_convert_rgba_to_32bpp_bgrx_8888_rot_90 (DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
586 | { | ||
587 | DATA32 *src_ptr; | ||
588 | DATA32 *dst_ptr; | ||
589 | int x, y; | ||
590 | |||
591 | dst_ptr = (DATA32 *)dst; | ||
592 | |||
593 | CONVERT_LOOP_START_ROT_90(); | ||
594 | |||
595 | *dst_ptr = (B_VAL(src_ptr) << 24) | (G_VAL(src_ptr) << 16) | (R_VAL(src_ptr) << 8); | ||
596 | |||
597 | CONVERT_LOOP_END_ROT_90(); | ||
598 | return; | ||
599 | } | ||
600 | #endif | ||
601 | #endif | ||
602 | |||
603 | #ifdef BUILD_CONVERT_32_RGB_666 | ||
604 | #ifdef BUILD_CONVERT_32_RGB_ROT0 | ||
605 | void | ||
606 | evas_common_convert_rgba_to_32bpp_rgb_666(DATA32 *src, DATA8 *dst, int src_jump, int dst_jump, int w, int h, int dith_x __UNUSED__, int dith_y __UNUSED__, DATA8 *pal __UNUSED__) | ||
607 | { | ||
608 | DATA32 *src_ptr; | ||
609 | DATA32 *dst_ptr; | ||
610 | int x, y; | ||
611 | |||
612 | dst_ptr = (DATA32 *)dst; | ||
613 | |||
614 | CONVERT_LOOP_START_ROT_0(); | ||
615 | |||
616 | *dst_ptr = | ||
617 | (((R_VAL(src_ptr) << 12) | (B_VAL(src_ptr) >> 2)) & 0x03f03f) | | ||
618 | ((G_VAL(src_ptr) << 4) & 0x000fc0); | ||
619 | |||
620 | CONVERT_LOOP_END_ROT_0(); | ||
621 | return; | ||
622 | } | ||
623 | #endif | ||
624 | #endif | ||
625 | |||