/* * Small jpeg decoder library * * Copyright (c) 2006, Luc Saillard * 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 #include #include #include #include #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; }