--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericopenlibs/liboil/src/jpeg/zigzag8x8_c.c Tue Aug 31 16:54:36 2010 +0300
@@ -0,0 +1,339 @@
+/*
+ * LIBOIL - Library of Optimized Inner Loops
+ * Copyright (c) 2003,2004 David A. Schleef <ds@schleef.org>
+ * 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 <liboil/liboil.h>
+#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
+