/*

 * 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