|
1 /* |
|
2 * LIBOIL - Library of Optimized Inner Loops |
|
3 * Copyright (c) 2003,2004 David A. Schleef <ds@schleef.org> |
|
4 * All rights reserved. |
|
5 * |
|
6 * Redistribution and use in source and binary forms, with or without |
|
7 * modification, are permitted provided that the following conditions |
|
8 * are met: |
|
9 * 1. Redistributions of source code must retain the above copyright |
|
10 * notice, this list of conditions and the following disclaimer. |
|
11 * 2. Redistributions in binary form must reproduce the above copyright |
|
12 * notice, this list of conditions and the following disclaimer in the |
|
13 * documentation and/or other materials provided with the distribution. |
|
14 * |
|
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
|
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
|
17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, |
|
19 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
|
20 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
|
21 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
|
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
|
23 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING |
|
24 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
|
25 * POSSIBILITY OF SUCH DAMAGE. |
|
26 */ |
|
27 //Portions Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. |
|
28 |
|
29 #ifdef HAVE_CONFIG_H |
|
30 #include "config.h" |
|
31 #endif |
|
32 |
|
33 #include <liboil/liboil.h> |
|
34 #include <liboil/liboilfunction.h> |
|
35 #include <liboil/liboiltest.h> |
|
36 |
|
37 |
|
38 #define AYUV(a,y,u,v) (((a)<<24) | ((y)<<16) | ((u)<<8) | (v)) |
|
39 #define AYUV_A(color) (((color)>>24)&0xff) |
|
40 #define AYUV_Y(color) (((color)>>16)&0xff) |
|
41 #define AYUV_U(color) (((color)>>8)&0xff) |
|
42 #define AYUV_V(color) (((color)>>0)&0xff) |
|
43 |
|
44 |
|
45 /** |
|
46 * oil_yuyv2ayuv: |
|
47 * @d_n: |
|
48 * @s_n: |
|
49 * n: |
|
50 * |
|
51 * Converts pixels in YUYV format to AYUV. Note that only approximately |
|
52 * half of the source array is used. Alpha values are set to 255. |
|
53 */ |
|
54 OIL_DEFINE_CLASS (yuyv2ayuv, "uint32_t *d_n, uint32_t *s_n, int n"); |
|
55 /** |
|
56 * oil_yvyu2ayuv: |
|
57 * @d_n: |
|
58 * @s_n: |
|
59 * n: |
|
60 * |
|
61 * Converts pixels in YVYU format to AYUV. Note that only approximately |
|
62 * half of the source array is used. Alpha values are set to 255. |
|
63 */ |
|
64 OIL_DEFINE_CLASS (yvyu2ayuv, "uint32_t *d_n, uint32_t *s_n, int n"); |
|
65 /** |
|
66 * oil_uyvy2ayuv: |
|
67 * @d_n: |
|
68 * @s_n: |
|
69 * n: |
|
70 * |
|
71 * Converts pixels in UYVY format to AYUV. Note that only approximately |
|
72 * half of the source array is used. Alpha values are set to 255. |
|
73 */ |
|
74 OIL_DEFINE_CLASS (uyvy2ayuv, "uint32_t *d_n, uint32_t *s_n, int n"); |
|
75 |
|
76 /** |
|
77 * oil_ayuv2yuyv: |
|
78 * @d_n: |
|
79 * @s_n: |
|
80 * n: |
|
81 * |
|
82 * Converts pixels in AYUV format to YUYV. Note that only approximately |
|
83 * half of the destination array is written. Alpha values are ignored. |
|
84 */ |
|
85 OIL_DEFINE_CLASS (ayuv2yuyv, "uint32_t *d_n, uint32_t *s_n, int n"); |
|
86 /** |
|
87 * oil_ayuv2yvyu: |
|
88 * @d_n: |
|
89 * @s_n: |
|
90 * n: |
|
91 * |
|
92 * Converts pixels in AYUV format to YVYU. Note that only approximately |
|
93 * half of the destination array is written. Alpha values are ignored. |
|
94 */ |
|
95 OIL_DEFINE_CLASS (ayuv2yvyu, "uint32_t *d_n, uint32_t *s_n, int n"); |
|
96 /** |
|
97 * oil_ayuv2uyvy: |
|
98 * @d_n: |
|
99 * @s_n: |
|
100 * n: |
|
101 * |
|
102 * Converts pixels in AYUV format to UYVY. Note that only approximately |
|
103 * half of the destination array is written. Alpha values are ignored. |
|
104 */ |
|
105 OIL_DEFINE_CLASS (ayuv2uyvy, "uint32_t *d_n, uint32_t *s_n, int n"); |
|
106 /** |
|
107 * oil_packyuyv: |
|
108 * @d: |
|
109 * @s1_nx2: |
|
110 * @s2: |
|
111 * @s3: |
|
112 * n: |
|
113 * |
|
114 * Packs pixels in separate Y, U, and V arrays to YUYV. |
|
115 */ |
|
116 OIL_DEFINE_CLASS (packyuyv, |
|
117 "uint32_t *d, uint8_t *s1_nx2, uint8_t *s2, uint8_t *s3, int n"); |
|
118 /** |
|
119 * oil_unpackyuyv: |
|
120 * @d1_nx2: |
|
121 * @d2: |
|
122 * @d3: |
|
123 * @s: |
|
124 * n: |
|
125 * |
|
126 * Unpacks YUYV pixels into separate Y, U, and V arrays; |
|
127 */ |
|
128 OIL_DEFINE_CLASS (unpackyuyv, |
|
129 "uint8_t *d1_nx2, uint8_t *d2, uint8_t *d3, uint32_t *s int n"); |
|
130 |
|
131 |
|
132 static void |
|
133 yuyv2ayuv_ref (uint32_t *dest, uint32_t *s, int n) |
|
134 { |
|
135 uint8_t *src = (uint8_t *)s; |
|
136 int i; |
|
137 |
|
138 for(i=0;i<n/2;i++){ |
|
139 dest[i*2 + 0] = AYUV(0xff, src[i*4 + 0], src[i*4 + 1], src[i*4 + 3]); |
|
140 dest[i*2 + 1] = AYUV(0xff, src[i*4 + 2], src[i*4 + 1], src[i*4 + 3]); |
|
141 } |
|
142 if (n&1) { |
|
143 dest[n-1] = AYUV(0xff, src[i*4 + 0], src[i*4 + 1], src[i*4 + 3]); |
|
144 } |
|
145 } |
|
146 OIL_DEFINE_IMPL_REF (yuyv2ayuv_ref, yuyv2ayuv); |
|
147 |
|
148 static void |
|
149 yvyu2ayuv_ref (uint32_t *dest, uint32_t *s, int n) |
|
150 { |
|
151 uint8_t *src = (uint8_t *)s; |
|
152 int i; |
|
153 |
|
154 for(i=0;i<n/2;i++){ |
|
155 dest[i*2 + 0] = AYUV(0xff, src[i*4 + 0], src[i*4 + 3], src[i*4 + 1]); |
|
156 dest[i*2 + 1] = AYUV(0xff, src[i*4 + 2], src[i*4 + 3], src[i*4 + 1]); |
|
157 } |
|
158 if (n&1) { |
|
159 dest[n-1] = AYUV(0xff, src[i*4 + 0], src[i*4 + 3], src[i*4 + 1]); |
|
160 } |
|
161 } |
|
162 OIL_DEFINE_IMPL_REF (yvyu2ayuv_ref, yvyu2ayuv); |
|
163 |
|
164 static void |
|
165 uyvy2ayuv_ref (uint32_t *dest, uint32_t *s, int n) |
|
166 { |
|
167 uint8_t *src = (uint8_t *)s; |
|
168 int i; |
|
169 |
|
170 for(i=0;i<n/2;i++){ |
|
171 dest[i*2 + 0] = AYUV(0xff, src[i*4 + 1], src[i*4 + 0], src[i*4 + 2]); |
|
172 dest[i*2 + 1] = AYUV(0xff, src[i*4 + 3], src[i*4 + 0], src[i*4 + 2]); |
|
173 } |
|
174 if (n&1) { |
|
175 dest[n-1] = AYUV(0xff, src[i*4 + 1], src[i*4 + 0], src[i*4 + 2]); |
|
176 } |
|
177 } |
|
178 OIL_DEFINE_IMPL_REF (uyvy2ayuv_ref, uyvy2ayuv); |
|
179 |
|
180 |
|
181 |
|
182 static void |
|
183 ayuv2yuyv_ref (uint32_t *d, uint32_t *src, int n) |
|
184 { |
|
185 uint8_t *dest = (uint8_t *)d; |
|
186 int i; |
|
187 |
|
188 for(i=0;i<n/2;i++){ |
|
189 dest[i*4 + 0] = AYUV_Y(src[i*2 + 0]); |
|
190 dest[i*4 + 1] = (AYUV_U(src[i*2 + 0]) + AYUV_U(src[i*2] + 1))/2; |
|
191 dest[i*4 + 2] = AYUV_Y(src[i*2 + 1]); |
|
192 dest[i*4 + 3] = (AYUV_V(src[i*2 + 0]) + AYUV_V(src[i*2] + 1))/2; |
|
193 } |
|
194 if (n&1) { |
|
195 dest[(n/2)*4 + 0] = AYUV_Y(src[n-1]); |
|
196 dest[(n/2)*4 + 1] = AYUV_U(src[n-1]); |
|
197 dest[(n/2)*4 + 2] = 0; |
|
198 dest[(n/2)*4 + 3] = AYUV_V(src[n-1]); |
|
199 } |
|
200 } |
|
201 OIL_DEFINE_IMPL_REF (ayuv2yuyv_ref, ayuv2yuyv); |
|
202 |
|
203 static void |
|
204 ayuv2yvyu_ref (uint32_t *d, uint32_t *src, int n) |
|
205 { |
|
206 uint8_t *dest = (uint8_t *)d; |
|
207 int i; |
|
208 |
|
209 for(i=0;i<n/2;i++){ |
|
210 dest[i*4 + 0] = AYUV_Y(src[i*2 + 0]); |
|
211 dest[i*4 + 1] = (AYUV_V(src[i*2 + 0]) + AYUV_V(src[i*2] + 1))/2; |
|
212 dest[i*4 + 2] = AYUV_Y(src[i*2 + 1]); |
|
213 dest[i*4 + 3] = (AYUV_U(src[i*2 + 0]) + AYUV_U(src[i*2] + 1))/2; |
|
214 } |
|
215 if (n&1) { |
|
216 dest[(n/2)*4 + 0] = AYUV_Y(src[n-1]); |
|
217 dest[(n/2)*4 + 1] = AYUV_V(src[n-1]); |
|
218 dest[(n/2)*4 + 2] = 0; |
|
219 dest[(n/2)*4 + 3] = AYUV_U(src[n-1]); |
|
220 } |
|
221 } |
|
222 OIL_DEFINE_IMPL_REF (ayuv2yvyu_ref, ayuv2yvyu); |
|
223 |
|
224 static void |
|
225 ayuv2uyvy_ref (uint32_t *d, uint32_t *src, int n) |
|
226 { |
|
227 uint8_t *dest = (uint8_t *)d; |
|
228 int i; |
|
229 |
|
230 for(i=0;i<n/2;i++){ |
|
231 dest[i*4 + 0] = (AYUV_U(src[i*2 + 0]) + AYUV_U(src[i*2] + 1))/2; |
|
232 dest[i*4 + 1] = AYUV_Y(src[i*2 + 0]); |
|
233 dest[i*4 + 2] = (AYUV_V(src[i*2 + 0]) + AYUV_V(src[i*2] + 1))/2; |
|
234 dest[i*4 + 3] = AYUV_Y(src[i*2 + 1]); |
|
235 } |
|
236 if (n&1) { |
|
237 dest[(n/2)*4 + 0] = AYUV_U(src[n-1]); |
|
238 dest[(n/2)*4 + 1] = AYUV_Y(src[n-1]); |
|
239 dest[(n/2)*4 + 2] = AYUV_V(src[n-1]); |
|
240 dest[(n/2)*4 + 3] = 0; |
|
241 } |
|
242 } |
|
243 OIL_DEFINE_IMPL_REF (ayuv2uyvy_ref, ayuv2uyvy); |
|
244 |
|
245 static void |
|
246 packyuyv_ref (uint32_t *d, uint8_t *s1_nx2, uint8_t *s2, uint8_t *s3, int n) |
|
247 { |
|
248 int i; |
|
249 uint8_t *dest = (uint8_t *)d; |
|
250 |
|
251 for(i=0;i<n;i++){ |
|
252 dest[i*4 + 0] = s1_nx2[i*2+0]; |
|
253 dest[i*4 + 2] = s1_nx2[i*2+1]; |
|
254 dest[i*4 + 1] = s2[i]; |
|
255 dest[i*4 + 3] = s3[i]; |
|
256 } |
|
257 } |
|
258 OIL_DEFINE_IMPL_REF (packyuyv_ref, packyuyv); |
|
259 |
|
260 static void |
|
261 unpackyuyv_ref (uint8_t *d1_nx2, uint8_t *d2, uint8_t *d3, uint32_t *s, int n) |
|
262 { |
|
263 int i; |
|
264 uint8_t *src = (uint8_t *)s; |
|
265 |
|
266 for(i=0;i<n;i++){ |
|
267 d1_nx2[i*2+0] = src[i*4 + 0]; |
|
268 d1_nx2[i*2+1] = src[i*4 + 2]; |
|
269 d2[i] = src[i*4 + 1]; |
|
270 d3[i] = src[i*4 + 3]; |
|
271 } |
|
272 } |
|
273 OIL_DEFINE_IMPL_REF (unpackyuyv_ref, unpackyuyv); |
|
274 |
|
275 |
|
276 |
|
277 #ifdef __SYMBIAN32__ |
|
278 |
|
279 OilFunctionClass* __oil_function_class_yuyv2ayuv() { |
|
280 return &_oil_function_class_yuyv2ayuv; |
|
281 } |
|
282 #endif |
|
283 |
|
284 #ifdef __SYMBIAN32__ |
|
285 |
|
286 OilFunctionClass* __oil_function_class_yvyu2ayuv() { |
|
287 return &_oil_function_class_yvyu2ayuv; |
|
288 } |
|
289 #endif |
|
290 |
|
291 #ifdef __SYMBIAN32__ |
|
292 |
|
293 OilFunctionClass* __oil_function_class_uyvy2ayuv() { |
|
294 return &_oil_function_class_uyvy2ayuv; |
|
295 } |
|
296 #endif |
|
297 |
|
298 #ifdef __SYMBIAN32__ |
|
299 |
|
300 OilFunctionClass* __oil_function_class_ayuv2yuyv() { |
|
301 return &_oil_function_class_ayuv2yuyv; |
|
302 } |
|
303 #endif |
|
304 |
|
305 #ifdef __SYMBIAN32__ |
|
306 |
|
307 OilFunctionClass* __oil_function_class_ayuv2yvyu() { |
|
308 return &_oil_function_class_ayuv2yvyu; |
|
309 } |
|
310 #endif |
|
311 |
|
312 #ifdef __SYMBIAN32__ |
|
313 |
|
314 OilFunctionClass* __oil_function_class_ayuv2uyvy() { |
|
315 return &_oil_function_class_ayuv2uyvy; |
|
316 } |
|
317 #endif |
|
318 |
|
319 #ifdef __SYMBIAN32__ |
|
320 |
|
321 OilFunctionClass* __oil_function_class_packyuyv() { |
|
322 return &_oil_function_class_packyuyv; |
|
323 } |
|
324 #endif |
|
325 |
|
326 #ifdef __SYMBIAN32__ |
|
327 |
|
328 OilFunctionClass* __oil_function_class_unpackyuyv() { |
|
329 return &_oil_function_class_unpackyuyv; |
|
330 } |
|
331 #endif |
|
332 |
|
333 |
|
334 |
|
335 #ifdef __SYMBIAN32__ |
|
336 |
|
337 OilFunctionImpl* __oil_function_impl_yuyv2ayuv_ref() { |
|
338 return &_oil_function_impl_yuyv2ayuv_ref; |
|
339 } |
|
340 #endif |
|
341 |
|
342 #ifdef __SYMBIAN32__ |
|
343 |
|
344 OilFunctionImpl* __oil_function_impl_yvyu2ayuv_ref() { |
|
345 return &_oil_function_impl_yvyu2ayuv_ref; |
|
346 } |
|
347 #endif |
|
348 |
|
349 #ifdef __SYMBIAN32__ |
|
350 |
|
351 OilFunctionImpl* __oil_function_impl_uyvy2ayuv_ref() { |
|
352 return &_oil_function_impl_uyvy2ayuv_ref; |
|
353 } |
|
354 #endif |
|
355 |
|
356 #ifdef __SYMBIAN32__ |
|
357 |
|
358 OilFunctionImpl* __oil_function_impl_ayuv2yuyv_ref() { |
|
359 return &_oil_function_impl_ayuv2yuyv_ref; |
|
360 } |
|
361 #endif |
|
362 |
|
363 #ifdef __SYMBIAN32__ |
|
364 |
|
365 OilFunctionImpl* __oil_function_impl_ayuv2yvyu_ref() { |
|
366 return &_oil_function_impl_ayuv2yvyu_ref; |
|
367 } |
|
368 #endif |
|
369 |
|
370 #ifdef __SYMBIAN32__ |
|
371 |
|
372 OilFunctionImpl* __oil_function_impl_ayuv2uyvy_ref() { |
|
373 return &_oil_function_impl_ayuv2uyvy_ref; |
|
374 } |
|
375 #endif |
|
376 |
|
377 #ifdef __SYMBIAN32__ |
|
378 |
|
379 OilFunctionImpl* __oil_function_impl_packyuyv_ref() { |
|
380 return &_oil_function_impl_packyuyv_ref; |
|
381 } |
|
382 #endif |
|
383 |
|
384 #ifdef __SYMBIAN32__ |
|
385 |
|
386 OilFunctionImpl* __oil_function_impl_unpackyuyv_ref() { |
|
387 return &_oil_function_impl_unpackyuyv_ref; |
|
388 } |
|
389 #endif |
|
390 |
|
391 |
|
392 |
|
393 #ifdef __SYMBIAN32__ |
|
394 |
|
395 EXPORT_C void** _oil_function_class_ptr_yuyv2ayuv () { |
|
396 oil_function_class_ptr_yuyv2ayuv = __oil_function_class_yuyv2ayuv(); |
|
397 return &oil_function_class_ptr_yuyv2ayuv->func; |
|
398 } |
|
399 #endif |
|
400 |
|
401 #ifdef __SYMBIAN32__ |
|
402 |
|
403 EXPORT_C void** _oil_function_class_ptr_yvyu2ayuv () { |
|
404 oil_function_class_ptr_yvyu2ayuv = __oil_function_class_yvyu2ayuv(); |
|
405 return &oil_function_class_ptr_yvyu2ayuv->func; |
|
406 } |
|
407 #endif |
|
408 |
|
409 #ifdef __SYMBIAN32__ |
|
410 |
|
411 EXPORT_C void** _oil_function_class_ptr_uyvy2ayuv () { |
|
412 oil_function_class_ptr_uyvy2ayuv = __oil_function_class_uyvy2ayuv(); |
|
413 return &oil_function_class_ptr_uyvy2ayuv->func; |
|
414 } |
|
415 #endif |
|
416 |
|
417 #ifdef __SYMBIAN32__ |
|
418 |
|
419 EXPORT_C void** _oil_function_class_ptr_ayuv2yuyv () { |
|
420 oil_function_class_ptr_ayuv2yuyv = __oil_function_class_ayuv2yuyv(); |
|
421 return &oil_function_class_ptr_ayuv2yuyv->func; |
|
422 } |
|
423 #endif |
|
424 |
|
425 #ifdef __SYMBIAN32__ |
|
426 |
|
427 EXPORT_C void** _oil_function_class_ptr_ayuv2yvyu () { |
|
428 oil_function_class_ptr_ayuv2yvyu = __oil_function_class_ayuv2yvyu(); |
|
429 return &oil_function_class_ptr_ayuv2yvyu->func; |
|
430 } |
|
431 #endif |
|
432 |
|
433 #ifdef __SYMBIAN32__ |
|
434 |
|
435 EXPORT_C void** _oil_function_class_ptr_ayuv2uyvy () { |
|
436 oil_function_class_ptr_ayuv2uyvy = __oil_function_class_ayuv2uyvy(); |
|
437 return &oil_function_class_ptr_ayuv2uyvy->func; |
|
438 } |
|
439 #endif |
|
440 |
|
441 #ifdef __SYMBIAN32__ |
|
442 |
|
443 EXPORT_C void** _oil_function_class_ptr_packyuyv () { |
|
444 oil_function_class_ptr_packyuyv = __oil_function_class_packyuyv(); |
|
445 return &oil_function_class_ptr_packyuyv->func; |
|
446 } |
|
447 #endif |
|
448 |
|
449 #ifdef __SYMBIAN32__ |
|
450 |
|
451 EXPORT_C void** _oil_function_class_ptr_unpackyuyv () { |
|
452 oil_function_class_ptr_unpackyuyv = __oil_function_class_unpackyuyv(); |
|
453 return &oil_function_class_ptr_unpackyuyv->func; |
|
454 } |
|
455 #endif |
|
456 |