diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericopenlibs/liboil/src/jpeg/zigzag8x8_c.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/genericopenlibs/liboil/src/jpeg/zigzag8x8_c.c Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,339 @@ +/* + * LIBOIL - Library of Optimized Inner Loops + * Copyright (c) 2003,2004 David A. Schleef + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +//Portions Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include "jpeg.h" + +/** + * oil_zigzag8x8_s16: + * @d_8x8: + * @ds: + * @s_8x8: + * @ss: + * + * Reorders an 8x8 block using a zig-zag pattern. The zig-zag pattern + * is described in the JPEG specification. + * + * FIXME: describe zigzag pattern + */ +OIL_DEFINE_CLASS (zigzag8x8_s16, + "int16_t *d_8x8, int ds, int16_t *s_8x8, int ss"); +/** + * oil_unzigzag8x8_s16: + * @d_8x8: + * @ds: + * @s_8x8: + * @ss: + * + * Reorders an 8x8 block to reverse the zig-zag reordering of + * @oil_zigzag8x8_s16. + */ +OIL_DEFINE_CLASS (unzigzag8x8_s16, + "int16_t *d_8x8, int ds, int16_t *s_8x8, int ss"); + + + +#define BLOCK8x8_S16(ptr, stride, row, column) \ + (*((int16_t *)((void *)ptr + stride*row) + column)) + +static const unsigned char zigzag_order[64] = { + 0, + 8, 1, + 2, 9, 16, + 24, 17, 10, 3, + 4, 11, 18, 25, 32, + 40, 33, 26, 19, 12, 5, + 6, 13, 20, 27, 34, 41, 48, + 56, 49, 42, 35, 28, 21, 14, 7, + 15, 22, 29, 36, 43, 50, 57, + 58, 51, 44, 37, 30, 23, + 31, 38, 45, 52, 59, + 60, 53, 46, 39, + 47, 54, 61, + 62, 55, + 63 +}; + +static const unsigned char unzigzag_order[64] = { + 0, 1, 5, 6, 14, 15, 27, 28, + 2, 4, 7, 13, 16, 26, 29, 42, + 3, 8, 12, 17, 25, 30, 41, 43, + 9, 11, 18, 24, 31, 40, 44, 53, + 10, 19, 23, 32, 39, 45, 52, 54, + 20, 22, 33, 38, 46, 51, 55, 60, + 21, 34, 37, 47, 50, 56, 59, 61, + 35, 36, 48, 49, 57, 58, 62, 63, +}; + + +static void +zigzag8x8_s16_ref(int16_t *dest, int dstr, int16_t *src, int sstr) +{ + int i,j; + unsigned int z; + + for(j=0;j<8;j++){ + for(i=0;i<8;i++){ + z = zigzag_order[j*8+i]; + OIL_GET(dest,j*dstr +i*sizeof(int16_t), int16_t) = + OIL_GET(src, sstr*(z>>3)+(z&7)*sizeof(int16_t), + int16_t); + } + } +} +OIL_DEFINE_IMPL_REF (zigzag8x8_s16_ref, zigzag8x8_s16); + +static void +unzigzag8x8_s16_ref (int16_t *dest, int dstr, int16_t *src, int sstr) +{ + int i,j; + unsigned int z; + + for(i=0;i<8;i++){ + for(j=0;j<8;j++){ + z = unzigzag_order[i*8+j]; + OIL_GET(dest,j*dstr +i*sizeof(int16_t), int16_t) = + OIL_GET(src, sstr*(z>>3)+(z&7)*sizeof(int16_t), + int16_t); + } + } +} +OIL_DEFINE_IMPL_REF (unzigzag8x8_s16_ref, unzigzag8x8_s16); + + +static void +zigzag8x8_s16_unroll (int16_t *dest, int dstr, int16_t *src, int sstr) +{ +#define ACK(x,y) \ + OIL_GET(dest, ((x)>>3) * dstr + ((x)&7) * sizeof(int16_t), int16_t) = \ + OIL_GET(src, ((y)>>3) * sstr + ((y)&7) * sizeof(int16_t), int16_t); + + ACK(0, 0); + ACK(1, 8); + ACK(2, 1); + ACK(3, 2); + ACK(4, 9); + ACK(5, 16); + ACK(6, 24); + ACK(7, 17); + ACK(8, 10); + ACK(9, 3); + ACK(10, 4); + ACK(11, 11); + ACK(12, 18); + ACK(13, 25); + ACK(14, 32); + ACK(15, 40); + ACK(16, 33); + ACK(17, 26); + ACK(18, 19); + ACK(19, 12); + ACK(20, 5); + ACK(21, 6); + ACK(22, 13); + ACK(23, 20); + ACK(24, 27); + ACK(25, 34); + ACK(26, 41); + ACK(27, 48); + ACK(28, 56); + ACK(29, 49); + ACK(30, 42); + ACK(31, 35); + ACK(32, 28); + ACK(33, 21); + ACK(34, 14); + ACK(35, 7); + ACK(36, 15); + ACK(37, 22); + ACK(38, 29); + ACK(39, 36); + ACK(40, 43); + ACK(41, 50); + ACK(42, 57); + ACK(43, 58); + ACK(44, 51); + ACK(45, 44); + ACK(46, 37); + ACK(47, 30); + ACK(48, 23); + ACK(49, 31); + ACK(50, 38); + ACK(51, 45); + ACK(52, 52); + ACK(53, 59); + ACK(54, 60); + ACK(55, 53); + ACK(56, 46); + ACK(57, 39); + ACK(58, 47); + ACK(59, 54); + ACK(60, 61); + ACK(61, 62); + ACK(62, 55); + ACK(63, 63); +} +OIL_DEFINE_IMPL (zigzag8x8_s16_unroll, zigzag8x8_s16); + +static void +unzigzag8x8_s16_unroll (int16_t *dest, int dstr, int16_t *src, int sstr) +{ + ACK(0, 0) + ACK(1, 2) + ACK(2, 3) + ACK(3, 9) + ACK(4, 10) + ACK(5, 20) + ACK(6, 21) + ACK(7, 35) + ACK(8, 1) + ACK(9, 4) + ACK(10, 8) + ACK(11, 11) + ACK(12, 19) + ACK(13, 22) + ACK(14, 34) + ACK(15, 36) + ACK(16, 5) + ACK(17, 7) + ACK(18, 12) + ACK(19, 18) + ACK(20, 23) + ACK(21, 33) + ACK(22, 37) + ACK(23, 48) + ACK(24, 6) + ACK(25, 13) + ACK(26, 17) + ACK(27, 24) + ACK(28, 32) + ACK(29, 38) + ACK(30, 47) + ACK(31, 49) + ACK(32, 14) + ACK(33, 16) + ACK(34, 25) + ACK(35, 31) + ACK(36, 39) + ACK(37, 46) + ACK(38, 50) + ACK(39, 57) + ACK(40, 15) + ACK(41, 26) + ACK(42, 30) + ACK(43, 40) + ACK(44, 45) + ACK(45, 51) + ACK(46, 56) + ACK(47, 58) + ACK(48, 27) + ACK(49, 29) + ACK(50, 41) + ACK(51, 44) + ACK(52, 52) + ACK(53, 55) + ACK(54, 59) + ACK(55, 62) + ACK(56, 28) + ACK(57, 42) + ACK(58, 43) + ACK(59, 53) + ACK(60, 54) + ACK(61, 60) + ACK(62, 61) + ACK(63, 63) +} +OIL_DEFINE_IMPL (unzigzag8x8_s16_unroll, unzigzag8x8_s16); + + +#ifdef __SYMBIAN32__ + +OilFunctionClass* __oil_function_class_zigzag8x8_s16() { + return &_oil_function_class_zigzag8x8_s16; +} +#endif + +#ifdef __SYMBIAN32__ + +OilFunctionClass* __oil_function_class_unzigzag8x8_s16() { + return &_oil_function_class_unzigzag8x8_s16; +} +#endif + + + +#ifdef __SYMBIAN32__ + +OilFunctionImpl* __oil_function_impl_zigzag8x8_s16_ref() { + return &_oil_function_impl_zigzag8x8_s16_ref; +} +#endif + +#ifdef __SYMBIAN32__ + +OilFunctionImpl* __oil_function_impl_unzigzag8x8_s16_ref() { + return &_oil_function_impl_unzigzag8x8_s16_ref; +} +#endif + +#ifdef __SYMBIAN32__ + +OilFunctionImpl* __oil_function_impl_zigzag8x8_s16_unroll() { + return &_oil_function_impl_zigzag8x8_s16_unroll; +} +#endif + +#ifdef __SYMBIAN32__ + +OilFunctionImpl* __oil_function_impl_unzigzag8x8_s16_unroll() { + return &_oil_function_impl_unzigzag8x8_s16_unroll; +} +#endif + + + +#ifdef __SYMBIAN32__ + +EXPORT_C void** _oil_function_class_ptr_zigzag8x8_s16 () { + oil_function_class_ptr_zigzag8x8_s16 = __oil_function_class_zigzag8x8_s16(); + return &oil_function_class_ptr_zigzag8x8_s16->func; + } +#endif + +#ifdef __SYMBIAN32__ + +EXPORT_C void** _oil_function_class_ptr_unzigzag8x8_s16 () { + oil_function_class_ptr_unzigzag8x8_s16 = __oil_function_class_unzigzag8x8_s16(); + return &oil_function_class_ptr_unzigzag8x8_s16->func; + } +#endif +