v4l2_libs/libv4lconvert/tinyjpeg.c

/*
 * Small jpeg decoder library
 *
 * Copyright (c) 2006, Luc Saillard <luc@saillard.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:
 *
 * - Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *
 * - 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.
 *
 * - Neither the name of the author nor the names of its contributors may be
 *  used to endorse or promote products derived from this software without
 *  specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <errno.h>

#include "tinyjpeg.h"
#include "tinyjpeg-internal.h"
#include "libv4lconvert-priv.h"

enum std_markers {
	DQT  = 0xDB, /* Define Quantization Table */
	SOF  = 0xC0, /* Start of Frame (size information) */
	DHT  = 0xC4, /* Huffman Table */
	SOI  = 0xD8, /* Start of Image */
	SOS  = 0xDA, /* Start of Scan */
	RST  = 0xD0, /* Reset Marker d0 -> .. */
	RST7 = 0xD7, /* Reset Marker .. -> d7 */
	EOI  = 0xD9, /* End of Image */
	DRI  = 0xDD, /* Define Restart Interval */
	APP0 = 0xE0,
};

#define cY	0
#define cCb	1
#define cCr	2

#define BLACK_Y 0
#define BLACK_U 127
#define BLACK_V 127

#if DEBUG
#if LOG2FILE

#define trace(fmt, args...) do { \
	FILE *f = fopen("/tmp/jpeg.log", "a"); \
	fprintf(f, fmt, ## args); \
	fflush(f); \
	fclose(f); \
} while (0)

#else

#define trace(fmt, args...) do { \
	fprintf(stderr, fmt, ## args); \
	fflush(stderr); \
} while (0)
#endif

#else
#define trace(fmt, args...) do { } while (0)
#endif

#define error(fmt, args...) do { \
	snprintf(priv->error_string, sizeof(priv->error_string), fmt, ## args); \
	return -1; \
} while (0)


#if 0
static char *print_bits(unsigned int value, char *bitstr)
{
	int i, j;

	i = 31;
	while (i > 0) {
		if (value & (1UL << i))
			break;
		i--;
	}
	j = 0;
	while (i >= 0) {
		bitstr[j++] = (value & (1UL << i)) ? '1' : '0';
		i--;
	}
	bitstr[j] = 0;
	return bitstr;
}

static void print_next_16bytes(int offset, const unsigned char *stream)
{
	trace("%4.4x: %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x %2.2x\n",
			offset,
			stream[0], stream[1], stream[2], stream[3],
			stream[4], stream[5], stream[6], stream[7],
			stream[8], stream[9], stream[10], stream[11],
			stream[12], stream[13], stream[14], stream[15]);
}

#endif


static const unsigned char zigzag[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
};

/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
/* IMPORTANT: these are only valid for 8-bit data precision! */
static const unsigned char bits_dc_luminance[17] = {
	0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
};
static const unsigned char val_dc_luminance[] = {
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
};

static const unsigned char bits_dc_chrominance[17] = {
	0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
};
static const unsigned char val_dc_chrominance[] = {
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
};

static const unsigned char bits_ac_luminance[17] = {
	0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
};
static const unsigned char val_ac_luminance[] = {
	0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
	0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
	0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
	0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
	0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
	0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
	0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
	0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
	0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
	0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
	0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
	0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
	0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
	0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
	0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
	0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
	0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
	0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
	0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
	0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
	0xf9, 0xfa
};

static const unsigned char bits_ac_chrominance[17] = {
	0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77
};

static const unsigned char val_ac_chrominance[] = {
	0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
	0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
	0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
	0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
	0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
	0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
	0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
	0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
	0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
	0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
	0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
	0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
	0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
	0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
	0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
	0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
	0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
	0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
	0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
	0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
	0xf9, 0xfa
};

#if 0 /* unused */
/* Standard JPEG quantization tables from Annex K of the JPEG standard.
   Note unlike in Annex K the entries here are in zigzag order! */
const unsigned char standard_quantization[][64] = { {
		0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e,
		0x0d, 0x0e, 0x12, 0x11, 0x10, 0x13, 0x18, 0x28,
		0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23, 0x25,
		0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33,
		0x38, 0x37, 0x40, 0x48, 0x5c, 0x4e, 0x40, 0x44,
		0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0x51, 0x57,
		0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71,
		0x79, 0x70, 0x64, 0x78, 0x5c, 0x65, 0x67, 0x63,
	},
	{
		0x11, 0x12, 0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a,
		0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63,
		0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
		0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
		0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
		0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
		0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
		0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
	},
};
#endif

/*
 * 4 functions to manage the stream
 *
 *  fill_nbits: put at least nbits in the reservoir of bits.
 *              But convert any 0xff,0x00 into 0xff
 *  get_nbits: read nbits from the stream, and put it in result,
 *             bits is removed from the stream and the reservoir is filled
 *             automaticaly. The result is signed according to the number of
 *             bits.
 *  look_nbits: read nbits from the stream without marking as read.
 *  skip_nbits: read nbits from the stream but do not return the result.
 *
 * stream: current pointer in the jpeg data (read bytes per bytes)
 * nbits_in_reservoir: number of bits filled into the reservoir
 * reservoir: register that contains bits information. Only nbits_in_reservoir
 *            is valid.
 *                          nbits_in_reservoir
 *                        <--    17 bits    -->
 *            Ex: 0000 0000 1010 0000 1111 0000   <== reservoir
 *                        ^
 *                        bit 1
 *            To get two bits from this example
 *                 result = (reservoir >> 15) & 3
 *
 */
#define fill_nbits(reservoir, nbits_in_reservoir, stream, nbits_wanted) do { \
	while (nbits_in_reservoir < nbits_wanted) { \
		unsigned char c; \
		if (stream >= priv->stream_end) { \
			snprintf(priv->error_string, sizeof(priv->error_string), \
					"fill_nbits error: need %u more bits\n", \
					nbits_wanted - nbits_in_reservoir); \
			longjmp(priv->jump_state, -EIO); \
		} \
		c = *stream++; \
		reservoir <<= 8; \
		if (c == 0xff && *stream == 0x00) \
			stream++; \
		reservoir |= c; \
		nbits_in_reservoir += 8; \
	} \
}  while (0);

/* Signed version !!!! */
#define get_nbits(reservoir, nbits_in_reservoir, stream, nbits_wanted, result) do { \
	fill_nbits(reservoir, nbits_in_reservoir, stream, (nbits_wanted)); \
	result = ((reservoir) >> (nbits_in_reservoir - (nbits_wanted))); \
	nbits_in_reservoir -= (nbits_wanted);  \
	reservoir &= ((1U << nbits_in_reservoir) - 1); \
	if ((unsigned int)result < (1UL << ((nbits_wanted) - 1))) \
		result += (0xFFFFFFFFUL << (nbits_wanted)) + 1; \
}  while (0);

#define look_nbits(reservoir, nbits_in_reservoir, stream, nbits_wanted, result) do { \
	fill_nbits(reservoir, nbits_in_reservoir, stream, (nbits_wanted)); \
	result = ((reservoir) >> (nbits_in_reservoir - (nbits_wanted))); \
}  while (0);

/* To speed up the decoding, we assume that the reservoir have enough bit
 * slow version:
 * #define skip_nbits(reservoir, nbits_in_reservoir, stream, nbits_wanted) do { \
 *   fill_nbits(reservoir, nbits_in_reservoir, stream, (nbits_wanted)); \
 *   nbits_in_reservoir -= (nbits_wanted); \
 *   reservoir &= ((1U << nbits_in_reservoir) - 1); \
 * }  while(0);
 */
#define skip_nbits(reservoir, nbits_in_reservoir, stream, nbits_wanted) do { \
	nbits_in_reservoir -= (nbits_wanted); \
	reservoir &= ((1U << nbits_in_reservoir) - 1); \
}  while (0);

#define be16_to_cpu(x) (((x)[0] << 8) | (x)[1])

static void resync(struct jdec_private *priv);

/**
 * Get the next (valid) huffman code in the stream.
 *
 * To speedup the procedure, we look HUFFMAN_HASH_NBITS bits and the code is
 * lower than HUFFMAN_HASH_NBITS we have automaticaly the length of the code
 * and the value by using two lookup table.
 * Else if the value is not found, just search (linear) into an array for each
 * bits is the code is present.
 *
 * If the code is not present for any reason, -1 is return.
 */
static int get_next_huffman_code(struct jdec_private *priv, struct huffman_table *huffman_table)
{
	int value, hcode;
	unsigned int extra_nbits, nbits;
	uint16_t *slowtable;

	look_nbits(priv->reservoir, priv->nbits_in_reservoir, priv->stream, HUFFMAN_HASH_NBITS, hcode);
	value = huffman_table->lookup[hcode];
	if (value >= 0) {
		unsigned int code_size = huffman_table->code_size[value];

		skip_nbits(priv->reservoir, priv->nbits_in_reservoir, priv->stream, code_size);
		return value;
	}

	/* Decode more bits each time ... */
	for (extra_nbits = 0; extra_nbits < 16 - HUFFMAN_HASH_NBITS; extra_nbits++) {
		nbits = HUFFMAN_HASH_NBITS + 1 + extra_nbits;

		look_nbits(priv->reservoir, priv->nbits_in_reservoir, priv->stream, nbits, hcode);
		slowtable = huffman_table->slowtable[extra_nbits];
		/* Search if the code is in this array */
		while (slowtable[0]) {
			if (slowtable[0] == hcode) {
				skip_nbits(priv->reservoir, priv->nbits_in_reservoir, priv->stream, nbits);
				return slowtable[1];
			}
			slowtable += 2;
		}
	}
	snprintf(priv->error_string, sizeof(priv->error_string),
			"unknown huffman code: %08x\n", (unsigned int)hcode);
	longjmp(priv->jump_state, -EIO);
	return 0;
}

/**
 *
 * Decode a single block that contains the DCT coefficients.
 * The table coefficients is already dezigzaged at the end of the operation.
 *
 */
static void process_Huffman_data_unit(struct jdec_private *priv, int component)
{
	unsigned char j;
	unsigned int huff_code;
	unsigned char size_val, count_0;

	struct component *c = &priv->component_infos[component];
	short int DCT[64];

	/* Initialize the DCT coef table */
	memset(DCT, 0, sizeof(DCT));

	/* DC coefficient decoding */
	huff_code = get_next_huffman_code(priv, c->DC_table);
	if (huff_code) {
		get_nbits(priv->reservoir, priv->nbits_in_reservoir, priv->stream, huff_code, DCT[0]);
		DCT[0] += c->previous_DC;
		c->previous_DC = DCT[0];
	} else {
		DCT[0] = c->previous_DC;
	}


	/* AC coefficient decoding */
	j = 1;
	while (j < 64) {
		huff_code = get_next_huffman_code(priv, c->AC_table);

		size_val = huff_code & 0xF;
		count_0 = huff_code >> 4;

		if (size_val == 0) { /* RLE */
			if (count_0 == 0)
				break;	/* EOB found, go out */
			else if (count_0 == 0xF)
				j += 16;	/* skip 16 zeros */
		} else {
			j += count_0;	/* skip count_0 zeroes */
			if (j < 64) {
				get_nbits(priv->reservoir, priv->nbits_in_reservoir, priv->stream, size_val, DCT[j]);
				j++;
			}
		}
	}

	if (j > 64) {
		snprintf(priv->error_string, sizeof(priv->error_string),
				"error: more then 63 AC components (%d) in huffman unit\n", (int)j);
		longjmp(priv->jump_state, -EIO);
	}

	for (j = 0; j < 64; j++)
		c->DCT[j] = DCT[zigzag[j]];
}

/*
 * Takes two array of bits, and build the huffman table for size, and code
 *
 * lookup will return the symbol if the code is less or equal than HUFFMAN_HASH_NBITS.
 * code_size will be used to known how many bits this symbol is encoded.
 * slowtable will be used when the first lookup didn't give the result.
 */
static int build_huffman_table(struct jdec_private *priv, const unsigned char *bits, const unsigned char *vals, struct huffman_table *table)
{
	unsigned int i, j, code, code_size, val, nbits;
	unsigned char huffsize[257], *hz;
	unsigned int huffcode[257], *hc;
	int slowtable_used[16 - HUFFMAN_HASH_NBITS];

	/*
	 * Build a temp array
	 *   huffsize[X] => numbers of bits to write vals[X]
	 */
	hz = huffsize;
	for (i = 1; i <= 16; i++) {
		for (j = 1; j <= bits[i]; j++)
			*hz++ = i;
	}
	*hz = 0;

	memset(table->lookup, 0xff, sizeof(table->lookup));
	for (i = 0; i < (16 - HUFFMAN_HASH_NBITS); i++)
		slowtable_used[i] = 0;

	/* Build a temp array
	 *   huffcode[X] => code used to write vals[X]
	 */
	code = 0;
	hc = huffcode;
	hz = huffsize;
	nbits = *hz;
	while (*hz) {
		while (*hz == nbits) {
			*hc++ = code++;
			hz++;
		}
		code <<= 1;
		nbits++;
	}

	/*
	 * Build the lookup table, and the slowtable if needed.
	 */
	for (i = 0; huffsize[i]; i++) {
		val = vals[i];
		code = huffcode[i];
		code_size = huffsize[i];

		trace("val=%2.2x code=%8.8x codesize=%2.2d\n", i, code, code_size);

		table->code_size[val] = code_size;
		if (code_size <= HUFFMAN_HASH_NBITS) {
			/*
			 * Good: val can be put in the lookup table, so fill all value of this
			 * column with value val
			 */
			int repeat = 1UL << (HUFFMAN_HASH_NBITS - code_size);

			code <<= HUFFMAN_HASH_NBITS - code_size;
			while (repeat--)
				table->lookup[code++] = val;

		} else {
			/* Perhaps sorting the array will be an optimization */
			int slowtable_index = code_size - HUFFMAN_HASH_NBITS - 1;

			if (slowtable_used[slowtable_index] == 254)
				error("slow Huffman table overflow\n");

			table->slowtable[slowtable_index][slowtable_used[slowtable_index]]
				= code;
			table->slowtable[slowtable_index][slowtable_used[slowtable_index] + 1]
				= val;
			slowtable_used[slowtable_index] += 2;
		}
	}

	for (i = 0; i < (16 - HUFFMAN_HASH_NBITS); i++)
		table->slowtable[i][slowtable_used[i]] = 0;

	return 0;
}

static int build_default_huffman_tables(struct jdec_private *priv)
{
	if ((priv->flags & TINYJPEG_FLAGS_MJPEG_TABLE)
			&& priv->default_huffman_table_initialized)
		return 0;

	if (build_huffman_table(priv, bits_dc_luminance, val_dc_luminance, &priv->HTDC[0]))
		return -1;
	if (build_huffman_table(priv, bits_ac_luminance, val_ac_luminance, &priv->HTAC[0]))
		return -1;

	if (build_huffman_table(priv, bits_dc_chrominance, val_dc_chrominance, &priv->HTDC[1]))
		return -1;
	if (build_huffman_table(priv, bits_ac_chrominance, val_ac_chrominance, &priv->HTAC[1]))
		return -1;

	priv->default_huffman_table_initialized = 1;
	return 0;
}



/*******************************************************************************
 *
 * Colorspace conversion routine
 *
 *
 * Note:
 * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
 * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
 * The conversion equations to be implemented are therefore
 *      R = Y                + 1.40200 * Cr
 *      G = Y - 0.34414 * Cb - 0.71414 * Cr
 *      B = Y + 1.77200 * Cb
 *
 ******************************************************************************/

static unsigned char clamp(int i)
{
	if (i < 0)
		return 0;
	if (i > 255)
		return 255;
	return i;
}


/**
 *  YCrCb -> YUV420P (1x1)
 *  .---.
 *  | 1 |
 *  `---'
 */
static void YCrCB_to_YUV420P_1x1(struct jdec_private *priv)
{
	const unsigned char *s, *y;
	unsigned char *p;
	int i, j;

	p = priv->plane[0];
	y = priv->Y;
	for (i = 0; i < 8; i++) {
		memcpy(p, y, 8);
		p += priv->width;
		y += 8;
	}

	p = priv->plane[1];
	s = priv->Cb;
	for (i = 0; i < 8; i += 2) {
		for (j = 0; j < 8; j += 2, s += 2)
			*p++ = *s;
		s += 8; /* Skip one line */
		p += priv->width / 2 - 4;
	}

	p = priv->plane[2];
	s = priv->Cr;
	for (i = 0; i < 8; i += 2) {
		for (j = 0; j < 8; j += 2, s += 2)
			*p++ = *s;
		s += 8; /* Skip one line */
		p += priv->width / 2 - 4;
	}
}

/**
 *  YCrCb -> YUV420P (2x1)
 *  .-------.
 *  | 1 | 2 |
 *  `-------'
 */
static void YCrCB_to_YUV420P_2x1(struct jdec_private *priv)
{
	unsigned char *p;
	const unsigned char *s, *y1;
	unsigned int i;

	p = priv->plane[0];
	y1 = priv->Y;
	for (i = 0; i < 8; i++) {
		memcpy(p, y1, 16);
		p += priv->width;
		y1 += 16;
	}

	p = priv->plane[1];
	s = priv->Cb;
	for (i = 0; i < 8; i += 2) {
		memcpy(p, s, 8);
		s += 16; /* Skip one line */
		p += priv->width / 2;
	}

	p = priv->plane[2];
	s = priv->Cr;
	for (i = 0; i < 8; i += 2) {
		memcpy(p, s, 8);
		s += 16; /* Skip one line */
		p += priv->width/2;
	}
}


/**
 *  YCrCb -> YUV420P (1x2)
 *  .---.
 *  | 1 |
 *  |---|
 *  | 2 |
 *  `---'
 */
static void YCrCB_to_YUV420P_1x2(struct jdec_private *priv)
{
	const unsigned char *s, *y;
	unsigned char *p;
	int i, j;

	p = priv->plane[0];
	y = priv->Y;
	for (i = 0; i < 16; i++) {
		memcpy(p, y, 8);
		p += priv->width;
		y += 8;
	}

	p = priv->plane[1];
	s = priv->Cb;
	for (i = 0; i < 8; i++) {
		for (j = 0; j < 8; j += 2, s += 2)
			*p++ = *s;
		p += priv->width / 2 - 4;
	}

	p = priv->plane[2];
	s = priv->Cr;
	for (i = 0; i < 8; i++) {
		for (j = 0; j < 8; j += 2, s += 2)
			*p++ = *s;
		p += priv->width / 2 - 4;
	}
}

/**
 *  YCrCb -> YUV420P (2x2)
 *  .-------.
 *  | 1 | 2 |
 *  |---+---|
 *  | 3 | 4 |
 *  `-------'
 */
static void YCrCB_to_YUV420P_2x2(struct jdec_private *priv)
{
	unsigned char *p;
	const unsigned char *s, *y1;
	unsigned int i;

	p = priv->plane[0];
	y1 = priv->Y;
	for (i = 0; i < 16; i++) {
		memcpy(p, y1, 16);
		p += priv->width;
		y1 += 16;
	}

	p = priv->plane[1];
	s = priv->Cb;
	for (i = 0; i < 8; i++) {
		memcpy(p, s, 8);
		s += 8;
		p += priv->width / 2;
	}

	p = priv->plane[2];
	s = priv->Cr;
	for (i = 0; i < 8; i++) {
		memcpy(p, s, 8);
		s += 8;
		p += priv->width / 2;
	}
}

/**
 *  YCrCb -> RGB24 (1x1)
 *  .---.
 *  | 1 |
 *  `---'
 */
static void YCrCB_to_RGB24_1x1(struct jdec_private *priv)
{
	const unsigned char *Y, *Cb, *Cr;
	unsigned char *p;
	int i, j;
	int offset_to_next_row;

#define SCALEBITS       10
#define ONE_HALF        (1UL << (SCALEBITS - 1))
#define FIX(x)          ((int)((x) * (1UL << SCALEBITS) + 0.5))

	p = priv->plane[0];
	Y = priv->Y;
	Cb = priv->Cb;
	Cr = priv->Cr;
	offset_to_next_row = priv->width * 3 - 8 * 3;

	for (i = 0; i < 8; i++) {
		for (j = 0; j < 8; j++) {
			int y, cb, cr;
			int add_r, add_g, add_b;
			int r, g , b;

			y  = (*Y++) << SCALEBITS;
			cb = *Cb++ - 128;
			cr = *Cr++ - 128;
			add_r = FIX(1.40200) * cr + ONE_HALF;
			add_g = -FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
			add_b = FIX(1.77200) * cb + ONE_HALF;

			r = (y + add_r) >> SCALEBITS;
			*p++ = clamp(r);
			g = (y + add_g) >> SCALEBITS;
			*p++ = clamp(g);
			b = (y + add_b) >> SCALEBITS;
			*p++ = clamp(b);

		}

		p += offset_to_next_row;
	}

#undef SCALEBITS
#undef ONE_HALF
#undef FIX
}

/**
 *  YCrCb -> BGR24 (1x1)
 *  .---.
 *  | 1 |
 *  `---'
 */
static void YCrCB_to_BGR24_1x1(struct jdec_private *priv)
{
	const unsigned char *Y, *Cb, *Cr;
	unsigned char *p;
	int i, j;
	int offset_to_next_row;

#define SCALEBITS       10
#define ONE_HALF        (1UL << (SCALEBITS - 1))
#define FIX(x)          ((int)((x) * (1UL << SCALEBITS) + 0.5))

	p = priv->plane[0];
	Y = priv->Y;
	Cb = priv->Cb;
	Cr = priv->Cr;
	offset_to_next_row = priv->width * 3 - 8 * 3;

	for (i = 0; i < 8; i++) {
		for (j = 0; j < 8; j++) {
			int y, cb, cr;
			int add_r, add_g, add_b;
			int r, g , b;

			y  = (*Y++) << SCALEBITS;
			cb = *Cb++ - 128;
			cr = *Cr++ - 128;
			add_r = FIX(1.40200) * cr + ONE_HALF;
			add_g = -FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
			add_b = FIX(1.77200) * cb + ONE_HALF;

			b = (y + add_b) >> SCALEBITS;
			*p++ = clamp(b);
			g = (y + add_g) >> SCALEBITS;
			*p++ = clamp(g);
			r = (y + add_r) >> SCALEBITS;
			*p++ = clamp(r);

		}
		p += offset_to_next_row;
	}

#undef SCALEBITS
#undef ONE_HALF
#undef FIX
}


/**
 *  YCrCb -> RGB24 (2x1)
 *  .-------.
 *  | 1 | 2 |
 *  `-------'
 */
static void YCrCB_to_RGB24_2x1(struct jdec_private *priv)
{
	const unsigned char *Y, *Cb, *Cr;
	unsigned char *p;
	int i, j;
	int offset_to_next_row;

#define SCALEBITS       10
#define ONE_HALF        (1UL << (SCALEBITS - 1))
#define FIX(x)          ((int)((x) * (1UL << SCALEBITS) + 0.5))

	p = priv->plane[0];
	Y = priv->Y;
	Cb = priv->Cb;
	Cr = priv->Cr;
	offset_to_next_row = priv->width * 3 - 16 * 3;

	for (i = 0; i < 8; i++) {
		for (j = 0; j < 8; j++) {
			int y, cb, cr;
			int add_r, add_g, add_b;
			int r, g , b;

			y  = (*Y++) << SCALEBITS;
			cb = *Cb++ - 128;
			cr = *Cr++ - 128;
			add_r = FIX(1.40200) * cr + ONE_HALF;
			add_g = -FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
			add_b = FIX(1.77200) * cb + ONE_HALF;

			r = (y + add_r) >> SCALEBITS;
			*p++ = clamp(r);
			g = (y + add_g) >> SCALEBITS;
			*p++ = clamp(g);
			b = (y + add_b) >> SCALEBITS;
			*p++ = clamp(b);

			y  = (*Y++) << SCALEBITS;
			r = (y + add_r) >> SCALEBITS;
			*p++ = clamp(r);
			g = (y + add_g) >> SCALEBITS;
			*p++ = clamp(g);
			b = (y + add_b) >> SCALEBITS;
			*p++ = clamp(b);
		}

		p += offset_to_next_row;
	}

#undef SCALEBITS
#undef ONE_HALF
#undef FIX
}

/*
 *  YCrCb -> BGR24 (2x1)
 *  .-------.
 *  | 1 | 2 |
 *  `-------'
 */
static void YCrCB_to_BGR24_2x1(struct jdec_private *priv)
{
	const unsigned char *Y, *Cb, *Cr;
	unsigned char *p;
	int i, j;
	int offset_to_next_row;

#define SCALEBITS       10
#define ONE_HALF        (1UL << (SCALEBITS - 1))
#define FIX(x)          ((int)((x) * (1UL << SCALEBITS) + 0.5))

	p = priv->plane[0];
	Y = priv->Y;
	Cb = priv->Cb;
	Cr = priv->Cr;
	offset_to_next_row = priv->width * 3 - 16 * 3;

	for (i = 0; i < 8; i++) {
		for (j = 0; j < 8; j++) {
			int y, cb, cr;
			int add_r, add_g, add_b;
			int r, g , b;

			cb = *Cb++ - 128;
			cr = *Cr++ - 128;
			add_r = FIX(1.40200) * cr + ONE_HALF;
			add_g = -FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
			add_b = FIX(1.77200) * cb + ONE_HALF;

			y  = (*Y++) << SCALEBITS;
			b = (y + add_b) >> SCALEBITS;
			*p++ = clamp(b);
			g = (y + add_g) >> SCALEBITS;
			*p++ = clamp(g);
			r = (y + add_r) >> SCALEBITS;
			*p++ = clamp(r);

			y  = (*Y++) << SCALEBITS;
			b = (y + add_b) >> SCALEBITS;
			*p++ = clamp(b);
			g = (y + add_g) >> SCALEBITS;
			*p++ = clamp(g);
			r = (y + add_r) >> SCALEBITS;
			*p++ = clamp(r);
		}

		p += offset_to_next_row;
	}

#undef SCALEBITS
#undef ONE_HALF
#undef FIX
}

/**
 *  YCrCb -> RGB24 (1x2)
 *  .---.
 *  | 1 |
 *  |---|
 *  | 2 |
 *  `---'
 */
static void YCrCB_to_RGB24_1x2(struct jdec_private *priv)
{
	const unsigned char *Y, *Cb, *Cr;
	unsigned char *p, *p2;
	int i, j;
	int offset_to_next_row;

#define SCALEBITS       10
#define ONE_HALF        (1UL << (SCALEBITS - 1))
#define FIX(x)          ((int)((x) * (1UL << SCALEBITS) + 0.5))

	p = priv->plane[0];
	p2 = priv->plane[0] + priv->width * 3;
	Y = priv->Y;
	Cb = priv->Cb;
	Cr = priv->Cr;
	offset_to_next_row = 2 * priv->width * 3 - 8 * 3;

	for (i = 0; i < 8; i++) {
		for (j = 0; j < 8; j++) {
			int y, cb, cr;
			int add_r, add_g, add_b;
			int r, g , b;

			cb = *Cb++ - 128;
			cr = *Cr++ - 128;
			add_r = FIX(1.40200) * cr + ONE_HALF;
			add_g = -FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
			add_b = FIX(1.77200) * cb + ONE_HALF;

			y  = (*Y++) << SCALEBITS;
			r = (y + add_r) >> SCALEBITS;
			*p++ = clamp(r);
			g = (y + add_g) >> SCALEBITS;
			*p++ = clamp(g);
			b = (y + add_b) >> SCALEBITS;
			*p++ = clamp(b);

			y  = (Y[8-1]) << SCALEBITS;
			r = (y + add_r) >> SCALEBITS;
			*p2++ = clamp(r);
			g = (y + add_g) >> SCALEBITS;
			*p2++ = clamp(g);
			b = (y + add_b) >> SCALEBITS;
			*p2++ = clamp(b);

		}
		Y += 8;
		p += offset_to_next_row;
		p2 += offset_to_next_row;
	}

#undef SCALEBITS
#undef ONE_HALF
#undef FIX
}

/*
 *  YCrCb -> BGR24 (1x2)
 *  .---.
 *  | 1 |
 *  |---|
 *  | 2 |
 *  `---'
 */
static void YCrCB_to_BGR24_1x2(struct jdec_private *priv)
{
	const unsigned char *Y, *Cb, *Cr;
	unsigned char *p, *p2;
	int i, j;
	int offset_to_next_row;

#define SCALEBITS       10
#define ONE_HALF        (1UL << (SCALEBITS - 1))
#define FIX(x)          ((int)((x) * (1UL << SCALEBITS) + 0.5))

	p = priv->plane[0];
	p2 = priv->plane[0] + priv->width * 3;
	Y = priv->Y;
	Cb = priv->Cb;
	Cr = priv->Cr;
	offset_to_next_row = 2 * priv->width * 3 - 8 * 3;

	for (i = 0; i < 8; i++) {
		for (j = 0; j < 8; j++) {
			int y, cb, cr;
			int add_r, add_g, add_b;
			int r, g , b;

			cb = *Cb++ - 128;
			cr = *Cr++ - 128;
			add_r = FIX(1.40200) * cr + ONE_HALF;
			add_g = -FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
			add_b = FIX(1.77200) * cb + ONE_HALF;

			y  = (*Y++) << SCALEBITS;
			b = (y + add_b) >> SCALEBITS;
			*p++ = clamp(b);
			g = (y + add_g) >> SCALEBITS;
			*p++ = clamp(g);
			r = (y + add_r) >> SCALEBITS;
			*p++ = clamp(r);

			y  = (Y[8-1]) << SCALEBITS;
			b = (y + add_b) >> SCALEBITS;
			*p2++ = clamp(b);
			g = (y + add_g) >> SCALEBITS;
			*p2++ = clamp(g);
			r = (y + add_r) >> SCALEBITS;
			*p2++ = clamp(r);

		}
		Y += 8;
		p += offset_to_next_row;
		p2 += offset_to_next_row;
	}

#undef SCALEBITS
#undef ONE_HALF
#undef FIX
}


/**
 *  YCrCb -> RGB24 (2x2)
 *  .-------.
 *  | 1 | 2 |
 *  |---+---|
 *  | 3 | 4 |
 *  `-------'
 */
static void YCrCB_to_RGB24_2x2(struct jdec_private *priv)
{
	const unsigned char *Y, *Cb, *Cr;
	unsigned char *p, *p2;
	int i, j;
	int offset_to_next_row;

#define SCALEBITS       10
#define ONE_HALF        (1UL << (SCALEBITS - 1))
#define FIX(x)          ((int)((x) * (1UL << SCALEBITS) + 0.5))

	p = priv->plane[0];
	p2 = priv->plane[0] + priv->width * 3;
	Y = priv->Y;
	Cb = priv->Cb;
	Cr = priv->Cr;
	offset_to_next_row = (priv->width * 3 * 2) - 16 * 3;

	for (i = 0; i < 8; i++) {
		for (j = 0; j < 8; j++) {
			int y, cb, cr;
			int add_r, add_g, add_b;
			int r, g , b;

			cb = *Cb++ - 128;
			cr = *Cr++ - 128;
			add_r = FIX(1.40200) * cr + ONE_HALF;
			add_g = -FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
			add_b = FIX(1.77200) * cb + ONE_HALF;

			y  = (*Y++) << SCALEBITS;
			r = (y + add_r) >> SCALEBITS;
			*p++ = clamp(r);
			g = (y + add_g) >> SCALEBITS;
			*p++ = clamp(g);
			b = (y + add_b) >> SCALEBITS;
			*p++ = clamp(b);

			y  = (*Y++) << SCALEBITS;
			r = (y + add_r) >> SCALEBITS;
			*p++ = clamp(r);
			g = (y + add_g) >> SCALEBITS;
			*p++ = clamp(g);
			b = (y + add_b) >> SCALEBITS;
			*p++ = clamp(b);

			y  = (Y[16-2]) << SCALEBITS;
			r = (y + add_r) >> SCALEBITS;
			*p2++ = clamp(r);
			g = (y + add_g) >> SCALEBITS;
			*p2++ = clamp(g);
			b = (y + add_b) >> SCALEBITS;
			*p2++ = clamp(b);

			y  = (Y[16-1]) << SCALEBITS;
			r = (y + add_r) >> SCALEBITS;
			*p2++ = clamp(r);
			g = (y + add_g) >> SCALEBITS;
			*p2++ = clamp(g);
			b = (y + add_b) >> SCALEBITS;
			*p2++ = clamp(b);
		}
		Y  += 16;
		p  += offset_to_next_row;
		p2 += offset_to_next_row;
	}

#undef SCALEBITS
#undef ONE_HALF
#undef FIX
}


/*
 *  YCrCb -> BGR24 (2x2)
 *  .-------.
 *  | 1 | 2 |
 *  |---+---|
 *  | 3 | 4 |
 *  `-------'
 */
static void YCrCB_to_BGR24_2x2(struct jdec_private *priv)
{
	const unsigned char *Y, *Cb, *Cr;
	unsigned char *p, *p2;
	int i, j;
	int offset_to_next_row;

#define SCALEBITS       10
#define ONE_HALF        (1UL << (SCALEBITS - 1))
#define FIX(x)          ((int)((x) * (1UL << SCALEBITS) + 0.5))

	p = priv->plane[0];
	p2 = priv->plane[0] + priv->width * 3;
	Y = priv->Y;
	Cb = priv->Cb;
	Cr = priv->Cr;
	offset_to_next_row = (priv->width * 3 * 2) - 16 * 3;

	for (i = 0; i < 8; i++) {
		for (j = 0; j < 8; j++) {
			int y, cb, cr;
			int add_r, add_g, add_b;
			int r, g , b;

			cb = *Cb++ - 128;
			cr = *Cr++ - 128;
			add_r = FIX(1.40200) * cr + ONE_HALF;
			add_g = -FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
			add_b = FIX(1.77200) * cb + ONE_HALF;

			y  = (*Y++) << SCALEBITS;
			b = (y + add_b) >> SCALEBITS;
			*p++ = clamp(b);
			g = (y + add_g) >> SCALEBITS;
			*p++ = clamp(g);
			r = (y + add_r) >> SCALEBITS;
			*p++ = clamp(r);

			y  = (*Y++) << SCALEBITS;
			b = (y + add_b) >> SCALEBITS;
			*p++ = clamp(b);
			g = (y + add_g) >> SCALEBITS;
			*p++ = clamp(g);
			r = (y + add_r) >> SCALEBITS;
			*p++ = clamp(r);

			y  = (Y[16-2]) << SCALEBITS;
			b = (y + add_b) >> SCALEBITS;
			*p2++ = clamp(b);
			g = (y + add_g) >> SCALEBITS;
			*p2++ = clamp(g);
			r = (y + add_r) >> SCALEBITS;
			*p2++ = clamp(r);

			y  = (Y[16-1]) << SCALEBITS;
			b = (y + add_b) >> SCALEBITS;
			*p2++ = clamp(b);
			g = (y + add_g) >> SCALEBITS;
			*p2++ = clamp(g);
			r = (y + add_r) >> SCALEBITS;
			*p2++ = clamp(r);
		}
		Y  += 16;
		p  += offset_to_next_row;
		p2 += offset_to_next_row;
	}

#undef SCALEBITS
#undef ONE_HALF
#undef FIX
}



/**
 *  YCrCb -> Grey (1x1)
 *  .---.
 *  | 1 |
 *  `---'
 */
static void YCrCB_to_Grey_1x1(struct jdec_private *priv)
{
	const unsigned char *y;
	unsigned char *p;
	unsigned int i;
	int offset_to_next_row;

	p = priv->plane[0];
	y = priv->Y;
	offset_to_next_row = priv->width;

	for (i = 0; i < 8; i++) {
		memcpy(p, y, 8);
		y += 8;
		p += offset_to_next_row;
	}
}

/**
 *  YCrCb -> Grey (2x1)
 *  .-------.
 *  | 1 | 2 |
 *  `-------'
 */
static void YCrCB_to_Grey_2x1(struct jdec_private *priv)
{
	const unsigned char *y;
	unsigned char *p;
	unsigned int i;

	p = priv->plane[0];
	y = priv->Y;

	for (i = 0; i < 8; i++) {
		memcpy(p, y, 16);
		y += 16;
		p += priv->width;
	}
}


/**
 *  YCrCb -> Grey (1x2)
 *  .---.
 *  | 1 |
 *  |---|
 *  | 2 |
 *  `---'
 */
static void YCrCB_to_Grey_1x2(struct jdec_private *priv)
{
	const unsigned char *y;
	unsigned char *p;
	unsigned int i;

	p = priv->plane[0];
	y = priv->Y;

	for (i = 0; i < 16; i++) {
		memcpy(p, y, 8);
		y += 8;
		p += priv->width;
	}
}

/**
 *  YCrCb -> Grey (2x2)
 *  .-------.
 *  | 1 | 2 |
 *  |---+---|
 *  | 3 | 4 |
 *  `-------'
 */
static void YCrCB_to_Grey_2x2(struct jdec_private *priv)
{
	const unsigned char *y;
	unsigned char *p;
	unsigned int i;

	p = priv->plane[0];
	y = priv->Y;

	for (i = 0; i < 16; i++) {
		memcpy(p, y, 16);
		y += 16;
		p += priv->width;
	}
}


/*
 * Decode all the 3 components for 1x1
 */
static void decode_MCU_1x1_3planes(struct jdec_private *priv)
{
	// Y
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y, 8);

	// Cb
	process_Huffman_data_unit(priv, cCb);
	IDCT(&priv->component_infos[cCb], priv->Cb, 8);

	// Cr
	process_Huffman_data_unit(priv, cCr);
	IDCT(&priv->component_infos[cCr], priv->Cr, 8);
}

/*
 * Decode a 1x1 directly in 1 color
 */
static void decode_MCU_1x1_1plane(struct jdec_private *priv)
{
	// Y
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y, 8);

	// Cb
	process_Huffman_data_unit(priv, cCb);
	IDCT(&priv->component_infos[cCb], priv->Cb, 8);

	// Cr
	process_Huffman_data_unit(priv, cCr);
	IDCT(&priv->component_infos[cCr], priv->Cr, 8);
}


/*
 * Decode a 2x1
 *  .-------.
 *  | 1 | 2 |
 *  `-------'
 */
static void decode_MCU_2x1_3planes(struct jdec_private *priv)
{
	// Y
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y, 16);
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y + 8, 16);

	// Cb
	process_Huffman_data_unit(priv, cCb);
	IDCT(&priv->component_infos[cCb], priv->Cb, 8);

	// Cr
	process_Huffman_data_unit(priv, cCr);
	IDCT(&priv->component_infos[cCr], priv->Cr, 8);
}

static void build_quantization_table(float *qtable, const unsigned char *ref_table);

static void pixart_decode_MCU_2x1_3planes(struct jdec_private *priv)
{
	unsigned char marker;

	look_nbits(priv->reservoir, priv->nbits_in_reservoir, priv->stream,
		   8, marker);

	/* Sometimes the pac7302 switches chrominance setting halfway though a
	   frame, with a quite ugly looking result, so we drop such frames. */
	if (priv->first_marker == 0)
		priv->first_marker = marker;
	else if ((marker & 0x80) != (priv->first_marker & 0x80)) {
		snprintf(priv->error_string, sizeof(priv->error_string),
			"Pixart JPEG error: chrominance changed halfway\n");
		longjmp(priv->jump_state, -EIO);
	}

	/* Pixart JPEG MCU-s are preceded by a marker indicating the quality
	   setting with which the MCU is compressed, IOW the MCU-s may have a
	   different quantization table per MCU. So if the marker changes we
	   need to rebuild the quantization tables. */
	if (marker != priv->marker) {
		int i, j, comp, lumi;
		unsigned char qt[64];
		/* These values have been found by trial and error and seem to
		   work reasonably. Markers with index 0 - 7 are never
		   generated by the hardware, so they are likely wrong. */
		const int qfactor[32] = {
			 25,   30,  35,  40,  45,  50,  55,  60,
			 65,   70,  75,  80,  85,  90,  95, 100,
			100,  100, 120, 140, 160, 180, 210, 240,
			270,  300, 330, 360, 390, 420, 450, 480
		};
		/* These tables were found in SPC230NC.SYS */
		const unsigned char pixart_q[][64] = { {
			0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
			0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
			0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
			0x08, 0x08, 0x08, 0x08, 0x10, 0x10, 0x10, 0x10,
			0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
			0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
			0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x20, 0x20,
			0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
		}, {
			0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x10, 0x10,
			0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
			0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
			0x10, 0x10, 0x10, 0x10, 0x20, 0x20, 0x20, 0x20,
			0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
			0x20, 0x20, 0x20, 0x40, 0x40, 0x40, 0x40, 0x40,
			0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
			0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
		}, {
			0x08, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x10, 0x10,
			0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
			0x10, 0x10, 0x10, 0x10, 0x10, 0x20, 0x20, 0x20,
			0x20, 0x20, 0x20, 0x20, 0x40, 0x40, 0x40, 0x40,
			0x40, 0x40, 0x40, 0x40, 0x63, 0x63, 0x63, 0x63,
			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
		}, {
			0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x20, 0x20,
			0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63,
			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
		} };

		i = (marker & 0x7c) >> 2; /* Bits 0 and 1 are always 0 */
		comp = qfactor[i];
		lumi = (marker & 0x40) ? 1 : 0;
		/* printf("marker %02x comp %d lumi %d\n", marker, comp, lumi); */

		/* Note the DC quantization factor is fixed! */
		qt[0] = pixart_q[lumi][0]; 
		for (i = 1; i < 64; i++) {
			j = (pixart_q[lumi][i] * comp + 50) / 100;
			qt[i] = (j < 255) ? j : 255;
		}
		build_quantization_table(priv->Q_tables[0], qt);

		/* If bit 7 of the marker is set chrominance uses the
		   luminance quantization table */
		if (!(marker & 0x80)) {
			qt[0] = pixart_q[3][0];
			for (i = 1; i < 64; i++) {
				j = (pixart_q[3][i] * comp + 50) / 100;
				qt[i] = (j < 255) ? j : 255;
			}
		}
		build_quantization_table(priv->Q_tables[1], qt);

		priv->marker = marker;
	}
	skip_nbits(priv->reservoir, priv->nbits_in_reservoir, priv->stream, 8);

	// Y
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y, 16);
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y + 8, 16);

	// Cb
	process_Huffman_data_unit(priv, cCb);
	IDCT(&priv->component_infos[cCb], priv->Cb, 8);

	// Cr
	process_Huffman_data_unit(priv, cCr);
	IDCT(&priv->component_infos[cCr], priv->Cr, 8);
}

/*
 * Decode a 2x1
 *  .-------.
 *  | 1 | 2 |
 *  `-------'
 */
static void decode_MCU_2x1_1plane(struct jdec_private *priv)
{
	// Y
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y, 16);
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y + 8, 16);

	// Cb
	process_Huffman_data_unit(priv, cCb);

	// Cr
	process_Huffman_data_unit(priv, cCr);
}


/*
 * Decode a 2x2
 *  .-------.
 *  | 1 | 2 |
 *  |---+---|
 *  | 3 | 4 |
 *  `-------'
 */
static void decode_MCU_2x2_3planes(struct jdec_private *priv)
{
	// Y
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y, 16);
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y + 8, 16);
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y + 64 * 2, 16);
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y + 64 * 2 + 8, 16);

	// Cb
	process_Huffman_data_unit(priv, cCb);
	IDCT(&priv->component_infos[cCb], priv->Cb, 8);

	// Cr
	process_Huffman_data_unit(priv, cCr);
	IDCT(&priv->component_infos[cCr], priv->Cr, 8);
}

/*
 * Decode a 2x2 directly in GREY format (8bits)
 *  .-------.
 *  | 1 | 2 |
 *  |---+---|
 *  | 3 | 4 |
 *  `-------'
 */
static void decode_MCU_2x2_1plane(struct jdec_private *priv)
{
	// Y
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y, 16);
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y + 8, 16);
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y + 64 * 2, 16);
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y + 64 * 2 + 8, 16);

	// Cb
	process_Huffman_data_unit(priv, cCb);

	// Cr
	process_Huffman_data_unit(priv, cCr);
}

/*
 * Decode a 1x2 mcu
 *  .---.
 *  | 1 |
 *  |---|
 *  | 2 |
 *  `---'
 */
static void decode_MCU_1x2_3planes(struct jdec_private *priv)
{
	// Y
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y, 8);
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y + 64, 8);

	// Cb
	process_Huffman_data_unit(priv, cCb);
	IDCT(&priv->component_infos[cCb], priv->Cb, 8);

	// Cr
	process_Huffman_data_unit(priv, cCr);
	IDCT(&priv->component_infos[cCr], priv->Cr, 8);
}

/*
 * Decode a 1x2 mcu
 *  .---.
 *  | 1 |
 *  |---|
 *  | 2 |
 *  `---'
 */
static void decode_MCU_1x2_1plane(struct jdec_private *priv)
{
	// Y
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y, 8);
	process_Huffman_data_unit(priv, cY);
	IDCT(&priv->component_infos[cY], priv->Y + 64, 8);

	// Cb
	process_Huffman_data_unit(priv, cCb);

	// Cr
	process_Huffman_data_unit(priv, cCr);
}

static void print_SOF(const unsigned char *stream)
{
#if DEBUG
	int width, height, nr_components, precision;
	const char *nr_components_to_string[] = {
		"????",
		"Grayscale",
		"????",
		"YCbCr",
		"CYMK"
	};

	precision = stream[2];
	height = be16_to_cpu(stream + 3);
	width  = be16_to_cpu(stream + 5);
	nr_components = stream[7];

	trace("> SOF marker\n");
	trace("Size:%dx%d nr_components:%d (%s)  precision:%d\n",
			width, height,
			nr_components, nr_components_to_string[nr_components],
			precision);
#endif
}

/*******************************************************************************
 *
 * JPEG/JFIF Parsing functions
 *
 * Note: only a small subset of the jpeg file format is supported. No markers,
 * nor progressive stream is supported.
 *
 ******************************************************************************/

static void build_quantization_table(float *qtable, const unsigned char *ref_table)
{
	/* Taken from libjpeg. Copyright Independent JPEG Group's LLM idct.
	 * For float AA&N IDCT method, divisors are equal to quantization
	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
	 *   scalefactor[0] = 1
	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
	 * We apply a further scale factor of 8.
	 * What's actually stored is 1/divisor so that the inner loop can
	 * use a multiplication rather than a division.
	 */
	int i, j;
	static const double aanscalefactor[8] = {
		1.0, 1.387039845, 1.306562965, 1.175875602,
		1.0, 0.785694958, 0.541196100, 0.275899379
	};
	const unsigned char *zz = zigzag;

	for (i = 0; i < 8; i++)
		for (j = 0; j < 8; j++)
			*qtable++ = ref_table[*zz++] * aanscalefactor[i] * aanscalefactor[j];

}

static int parse_DQT(struct jdec_private *priv, const unsigned char *stream)
{
	int qi;
	float *table;
	const unsigned char *dqt_block_end;

	trace("> DQT marker\n");
	dqt_block_end = stream + be16_to_cpu(stream);
	stream += 2;	/* Skip length */

	while (stream < dqt_block_end) {
		qi = *stream++;
#if SANITY_CHECK
		if (qi >> 4)
			error("16 bits quantization table is not supported\n");
		if (qi >= COMPONENTS)
			error("No more than %d quantization tables supported (got %d)\n",
					COMPONENTS, qi + 1);
#endif
		table = priv->Q_tables[qi];
		build_quantization_table(table, stream);
		stream += 64;
	}
	trace("< DQT marker\n");
	return 0;
}

static int parse_SOF(struct jdec_private *priv, const unsigned char *stream)
{
	int i, width, height, nr_components, cid, sampling_factor;
	int Q_table;
	struct component *c;

	trace("> SOF marker\n");
	print_SOF(stream);

	height = be16_to_cpu(stream+3);
	width  = be16_to_cpu(stream+5);
	nr_components = stream[7];
#if SANITY_CHECK
	if (stream[2] != 8)
		error("Precision other than 8 is not supported\n");
	if (width > JPEG_MAX_WIDTH || height > JPEG_MAX_HEIGHT)
		error("Width and Height (%dx%d) seems suspicious\n", width, height);
	if (nr_components != 3)
		error("We only support YUV images\n");
	if (height % 8)
		error("Height need to be a multiple of 8 (current height is %d)\n", height);
	if (width % 16)
		error("Width need to be a multiple of 16 (current Width is %d)\n", width);
#endif
	stream += 8;
	for (i = 0; i < nr_components; i++) {
		cid = *stream++;
		sampling_factor = *stream++;
		Q_table = *stream++;
		c = &priv->component_infos[i];
#if SANITY_CHECK
		c->cid = cid;
#endif
		c->Vfactor = sampling_factor & 0xf;
		c->Hfactor = sampling_factor >> 4;
		c->Q_table = priv->Q_tables[Q_table];
		trace("Component:%d  factor:%dx%d  Quantization table:%d\n",
				cid, c->Hfactor, c->Hfactor, Q_table);

	}
	priv->width = width;
	priv->height = height;

	trace("< SOF marker\n");

	return 0;
}

static int parse_SOS(struct jdec_private *priv, const unsigned char *stream)
{
	unsigned int i, cid, table;
	unsigned int nr_components = stream[2];

	trace("> SOS marker\n");

#if SANITY_CHECK
	if (nr_components != 3 && nr_components != 1)
		error("We only support YCbCr image\n");
#endif

	if (nr_components == 1)
		priv->flags |= TINYJPEG_FLAGS_PLANAR_JPEG;
#if SANITY_CHECK
	else if (priv->flags & TINYJPEG_FLAGS_PLANAR_JPEG)
		error("SOS with more then 1 component while decoding planar JPEG\n");
#endif

	stream += 3;
	for (i = 0; i < nr_components; i++) {
		cid = *stream++;
		table = *stream++;
		if (nr_components == 1) {
#if SANITY_CHECK
			/* Find matching cid so we store the tables in the right component */
			for (i = 0; i < COMPONENTS; i++)
				if (priv->component_infos[i].cid == cid)
					break;

			if (i == COMPONENTS)
				error("Unknown cid in SOS: %u\n", cid);

			priv->current_cid = cid;
#else
			i = cid - 1;
#endif
			trace("SOS cid: %u, using component_info: %u\n", cid, i);
		}
#if SANITY_CHECK
		if ((table & 0xf) >= HUFFMAN_TABLES)
			error("We do not support more than %d AC Huffman table\n",
					HUFFMAN_TABLES);
		if ((table >> 4) >= HUFFMAN_TABLES)
			error("We do not support more than %d DC Huffman table\n",
					HUFFMAN_TABLES);
		if (cid != priv->component_infos[i].cid)
			error("SOS cid order (%u:%u) isn't compatible with the SOF marker (%u:%u)\n",
					i, cid, i, priv->component_infos[i].cid);
		trace("ComponentId:%u  tableAC:%d tableDC:%d\n", cid, table & 0xf, table >> 4);
#endif
		priv->component_infos[i].AC_table = &priv->HTAC[table & 0xf];
		priv->component_infos[i].DC_table = &priv->HTDC[table >> 4];
	}
	priv->stream = stream + 3;

	/* ITU-T T.81 (9/92) chapter E.1.3 clearly states that RSTm is to be set to 0 at the beginning of each scan */
	priv->last_rst_marker_seen = 0;

	trace("< SOS marker\n");

	return 0;
}

static int parse_DHT(struct jdec_private *priv, const unsigned char *stream)
{
	unsigned int count, i;
	unsigned char huff_bits[17];
	int length, index;

	length = be16_to_cpu(stream) - 2;
	stream += 2;	/* Skip length */

	trace("> DHT marker (length=%d)\n", length);

	while (length > 0) {
		index = *stream++;

		/* We need to calculate the number of bytes 'vals' will takes */
		huff_bits[0] = 0;
		count = 0;
		for (i = 1; i < 17; i++) {
			huff_bits[i] = *stream++;
			count += huff_bits[i];
		}
#if SANITY_CHECK
		if (count > 1024)
			error("No more than 1024 bytes is allowed to describe a huffman table\n");
		if ((index & 0xf) >= HUFFMAN_TABLES)
			error("No mode than %d Huffman tables is supported\n", HUFFMAN_TABLES);
		trace("Huffman table %s n%d\n", (index & 0xf0) ? "AC" : "DC", index & 0xf);
		trace("Length of the table: %d\n", count);
#endif

		if (index & 0xf0) {
			if (build_huffman_table(priv, huff_bits, stream, &priv->HTAC[index & 0xf]))
				return -1;
		} else {
			if (build_huffman_table(priv, huff_bits, stream, &priv->HTDC[index & 0xf]))
				return -1;
		}

		length -= 1;
		length -= 16;
		length -= count;
		stream += count;
	}
	trace("< DHT marker\n");
	return 0;
}

static int parse_DRI(struct jdec_private *priv, const unsigned char *stream)
{
	unsigned int length;

	trace("> DRI marker\n");

	length = be16_to_cpu(stream);

#if SANITY_CHECK
	if (length != 4)
		error("Length of DRI marker need to be 4\n");
#endif

	priv->restart_interval = be16_to_cpu(stream + 2);

#if DEBUG
	trace("Restart interval = %d\n", priv->restart_interval);
#endif

	trace("< DRI marker\n");

	return 0;
}



static void resync(struct jdec_private *priv)
{
	int i;

	/* Init DC coefficients */
	for (i = 0; i < COMPONENTS; i++)
		priv->component_infos[i].previous_DC = 0;

	priv->reservoir = 0;
	priv->nbits_in_reservoir = 0;
	if (priv->restart_interval > 0)
		priv->restarts_to_go = priv->restart_interval;
	else
		priv->restarts_to_go = -1;
}

static int find_next_rst_marker(struct jdec_private *priv)
{
	int rst_marker_found = 0;
	int marker;
	const unsigned char *stream = priv->stream;

	/* Parse marker */
	while (!rst_marker_found) {
		while (*stream++ != 0xff) {
			if (stream >= priv->stream_end)
				error("EOF while search for a RST marker.\n");
		}
		/* Skip any padding ff byte (this is normal) */
		while (*stream == 0xff) {
			stream++;
			if (stream >= priv->stream_end)
				error("EOF while search for a RST marker.\n");
		}

		marker = *stream++;
		if ((RST + priv->last_rst_marker_seen) == marker)
			rst_marker_found = 1;
		else if (marker >= RST && marker <= RST7)
			error("Wrong Reset marker found, abording\n");
		else if (marker == EOI)
			return 0;
	}

	priv->stream = stream;
	priv->last_rst_marker_seen++;
	priv->last_rst_marker_seen &= 7;

	return 0;
}

static int find_next_sos_marker(struct jdec_private *priv)
{
	const unsigned char *stream = priv->stream;

	/* Parse marker */
	while (1) {
		while (*stream++ != 0xff) {
			if (stream >= priv->stream_end)
				error("EOF while search for a SOS marker.\n");
		}
		/* Skip any padding ff byte (this is normal) */
		while (*stream == 0xff) {
			stream++;
			if (stream >= priv->stream_end)
				error("EOF while search for a SOS marker.\n");
		}

		if (*stream++ == SOS)
			break; /* Found it ! */
	}

	priv->stream = stream;

	return 0;
}

static int parse_JFIF(struct jdec_private *priv, const unsigned char *stream)
{
	int chuck_len;
	int marker;
	int sof_marker_found = 0;
	int dqt_marker_found = 0;
	int sos_marker_found = 0;
	int dht_marker_found = 0;
	const unsigned char *next_chunck;

	/* Parse marker */
	while (!sos_marker_found) {
		if (*stream++ != 0xff)
			goto bogus_jpeg_format;
		/* Skip any padding ff byte (this is normal) */
		while (*stream == 0xff)
			stream++;

		marker = *stream++;
		chuck_len = be16_to_cpu(stream);
		next_chunck = stream + chuck_len;
		switch (marker) {
		case SOF:
			if (parse_SOF(priv, stream) < 0)
				return -1;
			sof_marker_found = 1;
			break;
		case DQT:
			if (parse_DQT(priv, stream) < 0)
				return -1;
			dqt_marker_found = 1;
			break;
		case SOS:
			if (parse_SOS(priv, stream) < 0)
				return -1;
			sos_marker_found = 1;
			break;
		case DHT:
			if (parse_DHT(priv, stream) < 0)
				return -1;
			dht_marker_found = 1;
			break;
		case DRI:
			if (parse_DRI(priv, stream) < 0)
				return -1;
			break;
		default:
			trace("> Unknown marker %2.2x\n", marker);
			break;
		}

		stream = next_chunck;
	}

	if (!sof_marker_found ||
			(!dqt_marker_found && !(priv->flags & TINYJPEG_FLAGS_PIXART_JPEG)))
		goto bogus_jpeg_format;

	if (!dht_marker_found) {
		trace("No Huffman table loaded, using the default one\n");
		if (build_default_huffman_tables(priv))
			return -1;
	}

#ifdef SANITY_CHECK
	if ((priv->component_infos[cY].Hfactor < priv->component_infos[cCb].Hfactor)
			|| (priv->component_infos[cY].Hfactor < priv->component_infos[cCr].Hfactor))
		error("Horizontal sampling factor for Y should be greater than horitontal sampling factor for Cb or Cr\n");
	if ((priv->component_infos[cY].Vfactor < priv->component_infos[cCb].Vfactor)
			|| (priv->component_infos[cY].Vfactor < priv->component_infos[cCr].Vfactor))
		error("Vertical sampling factor for Y should be greater than vertical sampling factor for Cb or Cr\n");
	if ((priv->component_infos[cCb].Hfactor != 1)
			|| (priv->component_infos[cCr].Hfactor != 1)
			|| (priv->component_infos[cCb].Vfactor != 1)
			|| (priv->component_infos[cCr].Vfactor != 1))
		error("Sampling other than 1x1 for Cr and Cb is not supported\n");
	if ((priv->flags & TINYJPEG_FLAGS_PLANAR_JPEG) &&
			((priv->component_infos[cY].Hfactor != 2)
			    || (priv->component_infos[cY].Hfactor != 2)))
		error("Sampling other than 2x2 for Y is not supported with planar JPEG\n");
#endif

	return 0;
bogus_jpeg_format:
	error("Bogus jpeg format\n");
	return -1;
}

/*******************************************************************************
 *
 * Functions exported of the library.
 *
 * Note: Some applications can access directly to internal pointer of the
 * structure. It's is not recommended, but if you have many images to
 * uncompress with the same parameters, some functions can be called to speedup
 * the decoding.
 *
 ******************************************************************************/

/**
 * Allocate a new tinyjpeg decoder object.
 *
 * Before calling any other functions, an object need to be called.
 */
struct jdec_private *tinyjpeg_init(void)
{
	struct jdec_private *priv;

	priv = (struct jdec_private *)calloc(1, sizeof(struct jdec_private));
	if (priv == NULL)
		return NULL;
	return priv;
}

/**
 * Free a tinyjpeg object.
 *
 * No others function can be called after this one.
 */
void tinyjpeg_free(struct jdec_private *priv)
{
	int i;

	for (i = 0; i < COMPONENTS; i++) {
		free(priv->components[i]);
		free(priv->tmp_buf[i]);
		priv->components[i] = NULL;
		priv->tmp_buf[i] = NULL;
	}
	priv->tmp_buf_y_size = 0;
	free(priv->stream_filtered);
	free(priv);
}

/**
 * Initialize the tinyjpeg object and prepare the decoding of the stream.
 *
 * Check if the jpeg can be decoded with this jpeg decoder.
 * Fill some table used for preprocessing.
 */
int tinyjpeg_parse_header(struct jdec_private *priv, const unsigned char *buf, unsigned int size)
{
	/* Identify the file */
	if ((buf[0] != 0xFF) || (buf[1] != SOI))
		error("Not a JPG file ?\n");

	priv->stream_end = buf + size;

	return parse_JFIF(priv, buf + 2);
}

static const decode_MCU_fct decode_mcu_3comp_table[4] = {
	decode_MCU_1x1_3planes,
	decode_MCU_1x2_3planes,
	decode_MCU_2x1_3planes,
	decode_MCU_2x2_3planes,
};

static const decode_MCU_fct pixart_decode_mcu_3comp_table[4] = {
	NULL,
	NULL,
	pixart_decode_MCU_2x1_3planes,
	NULL,
};

static const decode_MCU_fct decode_mcu_1comp_table[4] = {
	decode_MCU_1x1_1plane,
	decode_MCU_1x2_1plane,
	decode_MCU_2x1_1plane,
	decode_MCU_2x2_1plane,
};

static const convert_colorspace_fct convert_colorspace_yuv420p[4] = {
	YCrCB_to_YUV420P_1x1,
	YCrCB_to_YUV420P_1x2,
	YCrCB_to_YUV420P_2x1,
	YCrCB_to_YUV420P_2x2,
};

static const convert_colorspace_fct convert_colorspace_rgb24[4] = {
	YCrCB_to_RGB24_1x1,
	YCrCB_to_RGB24_1x2,
	YCrCB_to_RGB24_2x1,
	YCrCB_to_RGB24_2x2,
};

static const convert_colorspace_fct convert_colorspace_bgr24[4] = {
	YCrCB_to_BGR24_1x1,
	YCrCB_to_BGR24_1x2,
	YCrCB_to_BGR24_2x1,
	YCrCB_to_BGR24_2x2,
};

static const convert_colorspace_fct convert_colorspace_grey[4] = {
	YCrCB_to_Grey_1x1,
	YCrCB_to_Grey_1x2,
	YCrCB_to_Grey_2x1,
	YCrCB_to_Grey_2x2,
};

int tinyjpeg_decode_planar(struct jdec_private *priv, int pixfmt);

/* This function parses and removes the special Pixart JPEG chunk headers */
static int pixart_filter(struct jdec_private *priv, unsigned char *dest,
		const unsigned char *src, int n)
{
	int chunksize, copied = 0;

	/* The first data bytes encodes the image size:
	   0x60: 160x120
	   0x61: 320x240
	   0x62: 640x480
	   160x120 images are not chunked due to their small size!
	*/
	if (src[0] == 0x60) {
			memcpy(dest, src + 1, n - 1);
			return n - 1;
	}

	src++;
	n--;

	/* The first chunk is always 1024 bytes, 5 bytes are dropped in the
kernel: 0xff 0xff 0x00 0xff 0x96, and we skip one unknown byte */
	chunksize = 1024 - 6;

	while (1) {
		if (n < chunksize)
			break; /* Short frame */

		memcpy(dest, src, chunksize);
		dest += chunksize;
		src += chunksize;
		copied += chunksize;
		n -= chunksize;

		if (n < 4)
			break; /* Short frame */

		if (src[0] != 0xff || src[1] != 0xff || src[2] != 0xff)
			error("Missing Pixart ff ff ff xx header, "
			      "got: %02x %02x %02x %02x, copied sofar: %d\n",
			      src[0], src[1], src[2], src[3], copied);
		if (src[3] > 6)
			error("Unexpected Pixart chunk size: %d\n", src[3]);

		chunksize = src[3];
		src += 4;
		n -= 4;

		if (chunksize == 0) {
			/* 0 indicates we are done, copy whatever remains */
			memcpy(dest, src, n);
			return copied + n;
		}

		chunksize = 2048 >> chunksize;
	}
	error("Short Pixart JPEG frame\n");
}

/**
 * Decode and convert the jpeg image into @pixfmt@ image
 *
 * Note: components will be automaticaly allocated if no memory is attached.
 */
int tinyjpeg_decode(struct jdec_private *priv, int pixfmt)
{
	unsigned int x, y, xstride_by_mcu, ystride_by_mcu;
	unsigned int bytes_per_blocklines[3], bytes_per_mcu[3];
	decode_MCU_fct decode_MCU;
	const decode_MCU_fct *decode_mcu_table;
	const convert_colorspace_fct *colorspace_array_conv;
	convert_colorspace_fct convert_to_pixfmt;

	if (setjmp(priv->jump_state))
		return -1;

	if (priv->flags & TINYJPEG_FLAGS_PLANAR_JPEG)
		return tinyjpeg_decode_planar(priv, pixfmt);

	/* To keep gcc happy initialize some array */
	bytes_per_mcu[1] = 0;
	bytes_per_mcu[2] = 0;
	bytes_per_blocklines[1] = 0;
	bytes_per_blocklines[2] = 0;

	decode_mcu_table = decode_mcu_3comp_table;
	if (priv->flags & TINYJPEG_FLAGS_PIXART_JPEG) {
		int length;

		priv->stream_filtered =
			v4lconvert_alloc_buffer(priv->stream_end - priv->stream,
					&priv->stream_filtered,
					&priv->stream_filtered_bufsize);
		if (!priv->stream_filtered)
			error("Out of memory!\n");

		length =  pixart_filter(priv, priv->stream_filtered,
				priv->stream, priv->stream_end - priv->stream);
		if (length < 0)
			return length;
		priv->stream = priv->stream_filtered;
		priv->stream_end = priv->stream + length;
		priv->first_marker = 0;

		decode_mcu_table = pixart_decode_mcu_3comp_table;
	}

	switch (pixfmt) {
	case TINYJPEG_FMT_YUV420P:
		colorspace_array_conv = convert_colorspace_yuv420p;
		if (priv->components[0] == NULL)
			priv->components[0] = (uint8_t *)malloc(priv->width * priv->height);
		if (priv->components[1] == NULL)
			priv->components[1] = (uint8_t *)malloc(priv->width * priv->height/4);
		if (priv->components[2] == NULL)
			priv->components[2] = (uint8_t *)malloc(priv->width * priv->height/4);
		bytes_per_blocklines[0] = priv->width;
		bytes_per_blocklines[1] = priv->width/4;
		bytes_per_blocklines[2] = priv->width/4;
		bytes_per_mcu[0] = 8;
		bytes_per_mcu[1] = 4;
		bytes_per_mcu[2] = 4;
		break;

	case TINYJPEG_FMT_RGB24:
		colorspace_array_conv = convert_colorspace_rgb24;
		if (priv->components[0] == NULL)
			priv->components[0] = (uint8_t *)malloc(priv->width * priv->height * 3);
		bytes_per_blocklines[0] = priv->width * 3;
		bytes_per_mcu[0] = 3*8;
		break;

	case TINYJPEG_FMT_BGR24:
		colorspace_array_conv = convert_colorspace_bgr24;
		if (priv->components[0] == NULL)
			priv->components[0] = (uint8_t *)malloc(priv->width * priv->height * 3);
		bytes_per_blocklines[0] = priv->width * 3;
		bytes_per_mcu[0] = 3*8;
		break;

	case TINYJPEG_FMT_GREY:
		decode_mcu_table = decode_mcu_1comp_table;
		if (priv->flags & TINYJPEG_FLAGS_PIXART_JPEG)
			error("Greyscale output not support for PIXART JPEG's\n");
		colorspace_array_conv = convert_colorspace_grey;
		if (priv->components[0] == NULL)
			priv->components[0] = (uint8_t *)malloc(priv->width * priv->height);
		bytes_per_blocklines[0] = priv->width;
		bytes_per_mcu[0] = 8;
		break;

	default:
		error("Bad pixel format\n");
	}

	xstride_by_mcu = ystride_by_mcu = 8;
	if ((priv->component_infos[cY].Hfactor | priv->component_infos[cY].Vfactor) == 1) {
		decode_MCU = decode_mcu_table[0];
		convert_to_pixfmt = colorspace_array_conv[0];
		trace("Use decode 1x1 sampling\n");
	} else if (priv->component_infos[cY].Hfactor == 1) {
		decode_MCU = decode_mcu_table[1];
		convert_to_pixfmt = colorspace_array_conv[1];
		ystride_by_mcu = 16;
		trace("Use decode 1x2 sampling (not supported)\n");
	} else if (priv->component_infos[cY].Vfactor == 2) {
		decode_MCU = decode_mcu_table[3];
		convert_to_pixfmt = colorspace_array_conv[3];
		xstride_by_mcu = 16;
		ystride_by_mcu = 16;
		trace("Use decode 2x2 sampling\n");
	} else {
		decode_MCU = decode_mcu_table[2];
		convert_to_pixfmt = colorspace_array_conv[2];
		xstride_by_mcu = 16;
		trace("Use decode 2x1 sampling\n");
	}

	if (decode_MCU == NULL)
		error("no decode MCU function for this JPEG format (PIXART?)\n");

	resync(priv);

	/* Don't forget to that block can be either 8 or 16 lines */
	bytes_per_blocklines[0] *= ystride_by_mcu;
	bytes_per_blocklines[1] *= ystride_by_mcu;
	bytes_per_blocklines[2] *= ystride_by_mcu;

	bytes_per_mcu[0] *= xstride_by_mcu / 8;
	bytes_per_mcu[1] *= xstride_by_mcu / 8;
	bytes_per_mcu[2] *= xstride_by_mcu / 8;

	/* Just the decode the image by macroblock (size is 8x8, 8x16, or 16x16) */
	for (y = 0; y < priv->height / ystride_by_mcu; y++) {
		//trace("Decoding row %d\n", y);
		priv->plane[0] = priv->components[0] + (y * bytes_per_blocklines[0]);
		priv->plane[1] = priv->components[1] + (y * bytes_per_blocklines[1]);
		priv->plane[2] = priv->components[2] + (y * bytes_per_blocklines[2]);
		for (x = 0; x < priv->width; x += xstride_by_mcu) {
			decode_MCU(priv);
			convert_to_pixfmt(priv);
			priv->plane[0] += bytes_per_mcu[0];
			priv->plane[1] += bytes_per_mcu[1];
			priv->plane[2] += bytes_per_mcu[2];
			if (priv->restarts_to_go > 0) {
				priv->restarts_to_go--;
				if (priv->restarts_to_go == 0) {
					priv->stream -= (priv->nbits_in_reservoir / 8);
					resync(priv);
					if (find_next_rst_marker(priv) < 0)
						return -1;
				}
			}
		}
	}

	if (priv->flags & TINYJPEG_FLAGS_PIXART_JPEG) {
		/* Additional sanity check for funky Pixart format */
		if ((priv->stream_end - priv->stream) > 5)
			error("Pixart JPEG error, stream does not end with EOF marker\n");
	}

	return 0;
}

int tinyjpeg_decode_planar(struct jdec_private *priv, int pixfmt)
{
	unsigned int i, x, y;
	uint8_t *y_buf, *u_buf, *v_buf, *p, *p2;

	switch (pixfmt) {
	case TINYJPEG_FMT_GREY:
		error("Greyscale output not supported with planar JPEG input\n");
		break;

	case TINYJPEG_FMT_RGB24:
	case TINYJPEG_FMT_BGR24:
		if (priv->tmp_buf_y_size < (priv->width * priv->height)) {
			for (i = 0; i < COMPONENTS; i++) {
				free(priv->tmp_buf[i]);
				priv->tmp_buf[i] = malloc(priv->width * priv->height / (i ? 4 : 1));
				if (!priv->tmp_buf[i])
					error("Could not allocate memory for temporary buffers\n");
			}
			priv->tmp_buf_y_size = priv->width * priv->height;
		}
		y_buf = priv->tmp_buf[cY];
		u_buf = priv->tmp_buf[cCb];
		v_buf = priv->tmp_buf[cCr];
		break;

	case TINYJPEG_FMT_YUV420P:
		y_buf = priv->components[cY];
		u_buf = priv->components[cCb];
		v_buf = priv->components[cCr];
		break;

	default:
		error("Bad pixel format\n");
	}

#if SANITY_CHECK
	if (priv->current_cid != priv->component_infos[cY].cid)
		error("Planar jpeg first SOS cid does not match Y cid (%u:%u)\n",
				priv->current_cid, priv->component_infos[cY].cid);
#endif

	resync(priv);

	for (y = 0; y < priv->height / 8; y++) {
		for (x = 0; x < priv->width / 8; x++) {
			process_Huffman_data_unit(priv, cY);
			IDCT(&priv->component_infos[cY], y_buf, priv->width);
			y_buf += 8;
		}
		y_buf += 7 * priv->width;
	}

	priv->stream -= (priv->nbits_in_reservoir/8);
	resync(priv);
	if (find_next_sos_marker(priv) < 0)
		return -1;
	if (parse_SOS(priv, priv->stream) < 0)
		return -1;

#if SANITY_CHECK
	if (priv->current_cid != priv->component_infos[cCb].cid)
		error("Planar jpeg second SOS cid does not match Cn cid (%u:%u)\n",
				priv->current_cid, priv->component_infos[cCb].cid);
#endif

	for (y = 0; y < priv->height / 16; y++) {
		for (x = 0; x < priv->width / 16; x++) {
			process_Huffman_data_unit(priv, cCb);
			IDCT(&priv->component_infos[cCb], u_buf, priv->width / 2);
			u_buf += 8;
		}
		u_buf += 7 * (priv->width / 2);
	}

	priv->stream -= (priv->nbits_in_reservoir / 8);
	resync(priv);
	if (find_next_sos_marker(priv) < 0)
		return -1;
	if (parse_SOS(priv, priv->stream) < 0)
		return -1;

#if SANITY_CHECK
	if (priv->current_cid != priv->component_infos[cCr].cid)
		error("Planar jpeg third SOS cid does not match Cr cid (%u:%u)\n",
				priv->current_cid, priv->component_infos[cCr].cid);
#endif

	for (y = 0; y < priv->height / 16; y++) {
		for (x = 0; x < priv->width / 16; x++) {
			process_Huffman_data_unit(priv, cCr);
			IDCT(&priv->component_infos[cCr], v_buf, priv->width / 2);
			v_buf += 8;
		}
		v_buf += 7 * (priv->width / 2);
	}

#define SCALEBITS       10
#define ONE_HALF        (1UL << (SCALEBITS - 1))
#define FIX(x)          ((int)((x) * (1UL << SCALEBITS) + 0.5))

	switch (pixfmt) {
	case TINYJPEG_FMT_RGB24:
		y_buf = priv->tmp_buf[cY];
		u_buf = priv->tmp_buf[cCb];
		v_buf = priv->tmp_buf[cCr];
		p = priv->components[0];
		p2 = priv->components[0] + priv->width * 3;

		for (y = 0; y < priv->height / 2; y++) {
			for (x = 0; x < priv->width / 2; x++) {
				int l, cb, cr;
				int add_r, add_g, add_b;
				int r, g , b;

				cb = *u_buf++ - 128;
				cr = *v_buf++ - 128;
				add_r = FIX(1.40200) * cr + ONE_HALF;
				add_g = -FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
				add_b = FIX(1.77200) * cb + ONE_HALF;

				l  = (*y_buf) << SCALEBITS;
				r = (l + add_r) >> SCALEBITS;
				*p++ = clamp(r);
				g = (l + add_g) >> SCALEBITS;
				*p++ = clamp(g);
				b = (l + add_b) >> SCALEBITS;
				*p++ = clamp(b);

				l  = (y_buf[priv->width]) << SCALEBITS;
				r = (l + add_r) >> SCALEBITS;
				*p2++ = clamp(r);
				g = (l + add_g) >> SCALEBITS;
				*p2++ = clamp(g);
				b = (l + add_b) >> SCALEBITS;
				*p2++ = clamp(b);

				y_buf++;

				l  = (*y_buf) << SCALEBITS;
				r = (l + add_r) >> SCALEBITS;
				*p++ = clamp(r);
				g = (l + add_g) >> SCALEBITS;
				*p++ = clamp(g);
				b = (l + add_b) >> SCALEBITS;
				*p++ = clamp(b);

				l  = (y_buf[priv->width]) << SCALEBITS;
				r = (l + add_r) >> SCALEBITS;
				*p2++ = clamp(r);
				g = (l + add_g) >> SCALEBITS;
				*p2++ = clamp(g);
				b = (l + add_b) >> SCALEBITS;
				*p2++ = clamp(b);

				y_buf++;
			}
			y_buf += priv->width;
			p  += priv->width * 3;
			p2 += priv->width * 3;
		}
		break;

	case TINYJPEG_FMT_BGR24:
		y_buf = priv->tmp_buf[cY];
		u_buf = priv->tmp_buf[cCb];
		v_buf = priv->tmp_buf[cCr];
		p = priv->components[0];
		p2 = priv->components[0] + priv->width * 3;

		for (y = 0; y < priv->height / 2; y++) {
			for (x = 0; x < priv->width / 2; x++) {
				int l, cb, cr;
				int add_r, add_g, add_b;
				int r, g , b;

				cb = *u_buf++ - 128;
				cr = *v_buf++ - 128;
				add_r = FIX(1.40200) * cr + ONE_HALF;
				add_g = -FIX(0.34414) * cb - FIX(0.71414) * cr + ONE_HALF;
				add_b = FIX(1.77200) * cb + ONE_HALF;

				l  = (*y_buf) << SCALEBITS;
				b = (l + add_b) >> SCALEBITS;
				*p++ = clamp(b);
				g = (l + add_g) >> SCALEBITS;
				*p++ = clamp(g);
				r = (l + add_r) >> SCALEBITS;
				*p++ = clamp(r);

				l  = (y_buf[priv->width]) << SCALEBITS;
				b = (l + add_b) >> SCALEBITS;
				*p2++ = clamp(b);
				g = (l + add_g) >> SCALEBITS;
				*p2++ = clamp(g);
				r = (l + add_r) >> SCALEBITS;
				*p2++ = clamp(r);

				y_buf++;

				l  = (*y_buf) << SCALEBITS;
				b = (l + add_b) >> SCALEBITS;
				*p++ = clamp(b);
				g = (l + add_g) >> SCALEBITS;
				*p++ = clamp(g);
				r = (l + add_r) >> SCALEBITS;
				*p++ = clamp(r);

				l  = (y_buf[priv->width]) << SCALEBITS;
				b = (l + add_b) >> SCALEBITS;
				*p2++ = clamp(b);
				g = (l + add_g) >> SCALEBITS;
				*p2++ = clamp(g);
				r = (l + add_r) >> SCALEBITS;
				*p2++ = clamp(r);

				y_buf++;
			}
			y_buf += priv->width;
			p  += priv->width * 3;
			p2 += priv->width * 3;
		}
		break;
	}

#undef SCALEBITS
#undef ONE_HALF
#undef FIX

	return 0;
}

const char *tinyjpeg_get_errorstring(struct jdec_private *priv)
{
	return priv->error_string;
}

void tinyjpeg_get_size(struct jdec_private *priv, unsigned int *width, unsigned int *height)
{
	*width = priv->width;
	*height = priv->height;
}

int tinyjpeg_get_components(struct jdec_private *priv, unsigned char **components)
{
	int i;

	for (i = 0; i < COMPONENTS && priv->components[i]; i++)
		components[i] = priv->components[i];
	return 0;
}

int tinyjpeg_set_components(struct jdec_private *priv, unsigned char **components, unsigned int ncomponents)
{
	unsigned int i;

	if (ncomponents > COMPONENTS)
		ncomponents = COMPONENTS;
	for (i = 0; i < ncomponents; i++)
		priv->components[i] = components[i];
	return 0;
}

int tinyjpeg_set_flags(struct jdec_private *priv, int flags)
{
	int oldflags = priv->flags;

	priv->flags = flags;
	return oldflags;
}