Mercurial > cgi-bin > hgwebdir.cgi > PR > Applications > VSs > VSs__jpeg_decoder__Proj

annotate VSs_tinyjpeg/tinyjpeg-parse.c @ 4:62350c40504f

find changesets by author, revision, files, or words in the commit message
running in sequential mode
author Nina Engelhardt <nengel@mailbox.tu-berlin.de>
date Mon, 20 Aug 2012 16:56:27 +0200
parents
children
rev   line source
nengel@0 1 #include <stdio.h>
nengel@0 2 #include <stdlib.h>
nengel@0 3 #include <string.h>
nengel@0 4 #include <stdint.h>
nengel@0 5 #include <errno.h>
nengel@0 6
nengel@0 7 #include "tinyjpeg.h"
nengel@0 8 #include "tinyjpeg-internal.h"
nengel@0 9
nengel@0 10 extern char error_string[256];
nengel@0 11
nengel@0 12 static const unsigned char zigzag[64] =
nengel@0 13 {
nengel@0 14 0, 1, 5, 6, 14, 15, 27, 28,
nengel@0 15 2, 4, 7, 13, 16, 26, 29, 42,
nengel@0 16 3, 8, 12, 17, 25, 30, 41, 43,
nengel@0 17 9, 11, 18, 24, 31, 40, 44, 53,
nengel@0 18 10, 19, 23, 32, 39, 45, 52, 54,
nengel@0 19 20, 22, 33, 38, 46, 51, 55, 60,
nengel@0 20 21, 34, 37, 47, 50, 56, 59, 61,
nengel@0 21 35, 36, 48, 49, 57, 58, 62, 63
nengel@0 22 };
nengel@0 23
nengel@0 24 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
nengel@0 25 /* IMPORTANT: these are only valid for 8-bit data precision! */
nengel@0 26 static const unsigned char bits_dc_luminance[17] =
nengel@0 27 {
nengel@0 28 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
nengel@0 29 };
nengel@0 30 static const unsigned char val_dc_luminance[] =
nengel@0 31 {
nengel@0 32 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
nengel@0 33 };
nengel@0 34
nengel@0 35 static const unsigned char bits_dc_chrominance[17] =
nengel@0 36 {
nengel@0 37 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
nengel@0 38 };
nengel@0 39 static const unsigned char val_dc_chrominance[] =
nengel@0 40 {
nengel@0 41 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
nengel@0 42 };
nengel@0 43
nengel@0 44 static const unsigned char bits_ac_luminance[17] =
nengel@0 45 {
nengel@0 46 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
nengel@0 47 };
nengel@0 48 static const unsigned char val_ac_luminance[] =
nengel@0 49 {
nengel@0 50 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
nengel@0 51 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
nengel@0 52 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
nengel@0 53 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
nengel@0 54 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
nengel@0 55 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
nengel@0 56 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
nengel@0 57 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
nengel@0 58 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
nengel@0 59 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
nengel@0 60 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
nengel@0 61 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
nengel@0 62 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
nengel@0 63 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
nengel@0 64 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
nengel@0 65 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
nengel@0 66 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
nengel@0 67 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
nengel@0 68 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
nengel@0 69 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
nengel@0 70 0xf9, 0xfa
nengel@0 71 };
nengel@0 72
nengel@0 73 static const unsigned char bits_ac_chrominance[17] =
nengel@0 74 {
nengel@0 75 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77
nengel@0 76 };
nengel@0 77
nengel@0 78 static const unsigned char val_ac_chrominance[] =
nengel@0 79 {
nengel@0 80 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
nengel@0 81 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
nengel@0 82 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
nengel@0 83 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
nengel@0 84 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
nengel@0 85 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
nengel@0 86 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
nengel@0 87 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
nengel@0 88 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
nengel@0 89 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
nengel@0 90 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
nengel@0 91 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
nengel@0 92 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
nengel@0 93 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
nengel@0 94 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
nengel@0 95 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
nengel@0 96 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
nengel@0 97 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
nengel@0 98 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
nengel@0 99 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
nengel@0 100 0xf9, 0xfa
nengel@0 101 };
nengel@0 102
nengel@0 103 static void print_SOF(const unsigned char *stream)
nengel@0 104 {
nengel@0 105 int width, height, nr_components, precision;
nengel@0 106
nengel@0 107 precision = stream[2];
nengel@0 108 height = be16_to_cpu(stream+3);
nengel@0 109 width = be16_to_cpu(stream+5);
nengel@0 110 nr_components = stream[7];
nengel@0 111
nengel@0 112 trace("> SOF marker\n");
nengel@0 113 trace("Size:%dx%d nr_components:%d precision:%d\n",
nengel@0 114 width, height,
nengel@0 115 nr_components,
nengel@0 116 precision);
nengel@0 117 }
nengel@0 118
nengel@0 119
nengel@0 120 /*
nengel@0 121 * Takes two array of bits, and build the huffman table for size, and code
nengel@0 122 *
nengel@0 123 * lookup will return the symbol if the code is less or equal than HUFFMAN_HASH_NBITS.
nengel@0 124 * code_size will be used to known how many bits this symbol is encoded.
nengel@0 125 * slowtable will be used when the first lookup didn't give the result.
nengel@0 126 */
nengel@0 127 static void build_huffman_table(const unsigned char *bits, const unsigned char *vals, struct huffman_table *table)
nengel@0 128 {
nengel@0 129 unsigned int i, j, code, code_size, val, nbits;
nengel@0 130 unsigned char huffsize[HUFFMAN_BITS_SIZE+1], *hz;
nengel@0 131 unsigned int huffcode[HUFFMAN_BITS_SIZE+1], *hc;
nengel@0 132 int next_free_entry;
nengel@0 133
nengel@0 134 /*
nengel@0 135 * Build a temp array
nengel@0 136 * huffsize[X] => numbers of bits to write vals[X]
nengel@0 137 */
nengel@0 138 hz = huffsize;
nengel@0 139 for (i=1; i<=16; i++)
nengel@0 140 {
nengel@0 141 for (j=1; j<=bits[i]; j++)
nengel@0 142 *hz++ = i;
nengel@0 143 }
nengel@0 144 *hz = 0;
nengel@0 145
nengel@0 146 memset(table->lookup, 0xff, sizeof(table->lookup));
nengel@0 147 for (i=0; i<(16-HUFFMAN_HASH_NBITS); i++)
nengel@0 148 table->slowtable[i][0] = 0;
nengel@0 149
nengel@0 150 /* Build a temp array
nengel@0 151 * huffcode[X] => code used to write vals[X]
nengel@0 152 */
nengel@0 153 code = 0;
nengel@0 154 hc = huffcode;
nengel@0 155 hz = huffsize;
nengel@0 156 nbits = *hz;
nengel@0 157 while (*hz)
nengel@0 158 {
nengel@0 159 while (*hz == nbits)
nengel@0 160 {
nengel@0 161 *hc++ = code++;
nengel@0 162 hz++;
nengel@0 163 }
nengel@0 164 code <<= 1;
nengel@0 165 nbits++;
nengel@0 166 }
nengel@0 167
nengel@0 168 /*
nengel@0 169 * Build the lookup table, and the slowtable if needed.
nengel@0 170 */
nengel@0 171 next_free_entry = -1;
nengel@0 172 for (i=0; huffsize[i]; i++)
nengel@0 173 {
nengel@0 174 val = vals[i];
nengel@0 175 code = huffcode[i];
nengel@0 176 code_size = huffsize[i];
nengel@0 177
nengel@0 178 trace("val=%2.2x code=%8.8x codesize=%2.2d\n", val, code, code_size);
nengel@0 179
nengel@0 180 table->code_size[val] = code_size;
nengel@0 181 if (code_size <= HUFFMAN_HASH_NBITS)
nengel@0 182 {
nengel@0 183 /*
nengel@0 184 * Good: val can be put in the lookup table, so fill all value of this
nengel@0 185 * column with value val
nengel@0 186 */
nengel@0 187 int repeat = 1UL<<(HUFFMAN_HASH_NBITS - code_size);
nengel@0 188 code <<= HUFFMAN_HASH_NBITS - code_size;
nengel@0 189 while ( repeat-- )
nengel@0 190 table->lookup[code++] = val;
nengel@0 191
nengel@0 192 }
nengel@0 193 else
nengel@0 194 {
nengel@0 195 /* Perhaps sorting the array will be an optimization */
nengel@0 196 uint16_t *slowtable = table->slowtable[code_size-HUFFMAN_HASH_NBITS-1];
nengel@0 197 while(slowtable[0])
nengel@0 198 slowtable+=2;
nengel@0 199 slowtable[0] = code;
nengel@0 200 slowtable[1] = val;
nengel@0 201 slowtable[2] = 0;
nengel@0 202 }
nengel@0 203
nengel@0 204 }
nengel@0 205 }
nengel@0 206
nengel@0 207 static void build_default_huffman_tables(struct jdec_private *priv)
nengel@0 208 {
nengel@0 209 if ( (priv->flags & TINYJPEG_FLAGS_MJPEG_TABLE)
nengel@0 210 && priv->default_huffman_table_initialized)
nengel@0 211 return;
nengel@0 212
nengel@0 213 build_huffman_table(bits_dc_luminance, val_dc_luminance, &priv->HTDC[0]);
nengel@0 214 build_huffman_table(bits_ac_luminance, val_ac_luminance, &priv->HTAC[0]);
nengel@0 215
nengel@0 216 build_huffman_table(bits_dc_chrominance, val_dc_chrominance, &priv->HTDC[1]);
nengel@0 217 build_huffman_table(bits_ac_chrominance, val_ac_chrominance, &priv->HTAC[1]);
nengel@0 218
nengel@0 219 priv->default_huffman_table_initialized = 1;
nengel@0 220 }
nengel@0 221
nengel@0 222 /*******************************************************************************
nengel@0 223 *
nengel@0 224 * JPEG/JFIF Parsing functions
nengel@0 225 *
nengel@0 226 * Note: only a small subset of the jpeg file format is supported. No markers,
nengel@0 227 * nor progressive stream is supported.
nengel@0 228 *
nengel@0 229 ******************************************************************************/
nengel@0 230
nengel@0 231 static void build_quantization_table(float *qtable, const unsigned char *ref_table)
nengel@0 232 {
nengel@0 233 /* Taken from libjpeg. Copyright Independent JPEG Group's LLM idct.
nengel@0 234 * For float AA&N IDCT method, divisors are equal to quantization
nengel@0 235 * coefficients scaled by scalefactor[row]*scalefactor[col], where
nengel@0 236 * scalefactor[0] = 1
nengel@0 237 * scalefactor[k] = cos(k*PI/16) * sqrt(2) for k=1..7
nengel@0 238 * We apply a further scale factor of 8.
nengel@0 239 * What's actually stored is 1/divisor so that the inner loop can
nengel@0 240 * use a multiplication rather than a division.
nengel@0 241 */
nengel@0 242 int i, j;
nengel@0 243 static const double aanscalefactor[8] = {
nengel@0 244 1.0, 1.387039845, 1.306562965, 1.175875602,
nengel@0 245 1.0, 0.785694958, 0.541196100, 0.275899379
nengel@0 246 };
nengel@0 247 const unsigned char *zz = zigzag;
nengel@0 248
nengel@0 249 for (i=0; i<8; i++) {
nengel@0 250 for (j=0; j<8; j++) {
nengel@0 251 *qtable++ = ref_table[*zz++] * aanscalefactor[i] * aanscalefactor[j];
nengel@0 252 }
nengel@0 253 }
nengel@0 254
nengel@0 255 }
nengel@0 256
nengel@0 257 static int parse_DQT(struct jdec_private *priv, const unsigned char *stream)
nengel@0 258 {
nengel@0 259 int qi;
nengel@0 260 float *table;
nengel@0 261 const unsigned char *dqt_block_end;
nengel@0 262
nengel@0 263 trace("> DQT marker\n");
nengel@0 264 dqt_block_end = stream + be16_to_cpu(stream);
nengel@0 265 stream += 2; /* Skip length */
nengel@0 266
nengel@0 267 while (stream < dqt_block_end)
nengel@0 268 {
nengel@0 269 qi = *stream++;
nengel@0 270 #if SANITY_CHECK
nengel@0 271 if (qi>>4)
nengel@0 272 error("16 bits quantization table is not supported\n");
nengel@0 273 if (qi>4)
nengel@0 274 error("No more 4 quantization table is supported (got %d)\n", qi);
nengel@0 275 #endif
nengel@0 276 table = priv->Q_tables[qi];
nengel@0 277 build_quantization_table(table, stream);
nengel@0 278 stream += 64;
nengel@0 279 }
nengel@0 280 trace("< DQT marker\n");
nengel@0 281 return 0;
nengel@0 282 }
nengel@0 283
nengel@0 284 static int parse_SOF(struct jdec_private *priv, const unsigned char *stream)
nengel@0 285 {
nengel@0 286 int i, width, height, nr_components, cid, sampling_factor;
nengel@0 287 int Q_table;
nengel@0 288 struct component *c;
nengel@0 289
nengel@0 290 trace("> SOF marker\n");
nengel@0 291 print_SOF(stream);
nengel@0 292
nengel@0 293 height = be16_to_cpu(stream+3);
nengel@0 294 width = be16_to_cpu(stream+5);
nengel@0 295 nr_components = stream[7];
nengel@0 296 #if SANITY_CHECK
nengel@0 297 if (stream[2] != 8)
nengel@0 298 error("Precision other than 8 is not supported\n");
nengel@0 299 if (nr_components != 3)
nengel@0 300 error("We only support YUV images\n");
nengel@0 301 if (height%16)
nengel@0 302 error("Height need to be a multiple of 16 (current height is %d)\n", height);
nengel@0 303 if (width%16)
nengel@0 304 error("Width need to be a multiple of 16 (current Width is %d)\n", width);
nengel@0 305 #endif
nengel@0 306 stream += 8;
nengel@0 307 for (i=0; i<nr_components; i++) {
nengel@0 308 cid = *stream++;
nengel@0 309 sampling_factor = *stream++;
nengel@0 310 Q_table = *stream++;
nengel@0 311 c = &priv->component_infos[i];
nengel@0 312 #if SANITY_CHECK
nengel@0 313 c->cid = cid;
nengel@0 314 if (Q_table >= COMPONENTS)
nengel@0 315 error("Bad Quantization table index (got %d, max allowed %d)\n", Q_table, COMPONENTS-1);
nengel@0 316 #endif
nengel@0 317 c->Vfactor = sampling_factor&0xf;
nengel@0 318 c->Hfactor = sampling_factor>>4;
nengel@0 319 c->Q_table = priv->Q_tables[Q_table];
nengel@0 320 trace("Component:%d factor:%dx%d Quantization table:%d\n", cid, c->Hfactor, c->Hfactor, Q_table );
nengel@0 321
nengel@0 322 }
nengel@0 323 priv->width = width;
nengel@0 324 priv->height = height;
nengel@0 325 priv->mcus_in_width = width/16;
nengel@0 326 priv->mcus_in_height = height/16;
nengel@0 327 priv->restart_interval = priv->mcus_in_width * priv->mcus_in_height;
nengel@0 328
nengel@0 329 trace("< SOF marker\n");
nengel@0 330
nengel@0 331 return 0;
nengel@0 332 }
nengel@0 333
nengel@0 334 static int parse_SOS(struct jdec_private *priv, const unsigned char *stream)
nengel@0 335 {
nengel@0 336 unsigned int i, cid, table;
nengel@0 337 unsigned int nr_components = stream[2];
nengel@0 338
nengel@0 339 trace("> SOS marker\n");
nengel@0 340
nengel@0 341 #if SANITY_CHECK
nengel@0 342 if (nr_components != 3)
nengel@0 343 error("We only support YCbCr image\n");
nengel@0 344 #endif
nengel@0 345
nengel@0 346 stream += 3;
nengel@0 347 for (i=0;i<nr_components;i++) {
nengel@0 348 cid = *stream++;
nengel@0 349 table = *stream++;
nengel@0 350 #if SANITY_CHECK
nengel@0 351 if ((table&0xf)>=4)
nengel@0 352 error("We do not support more than 2 AC Huffman table\n");
nengel@0 353 if ((table>>4)>=4)
nengel@0 354 error("We do not support more than 2 DC Huffman table\n");
nengel@0 355 if (cid != priv->component_infos[i].cid)
nengel@0 356 error("SOS cid order (%d:%d) isn't compatible with the SOF marker (%d:%d)\n",
nengel@0 357 i, cid, i, priv->component_infos[i].cid);
nengel@0 358 trace("ComponentId:%d tableAC:%d tableDC:%d\n", cid, table&0xf, table>>4);
nengel@0 359 #endif
nengel@0 360 priv->component_infos[i].AC_table = &priv->HTAC[table&0xf];
nengel@0 361 priv->component_infos[i].DC_table = &priv->HTDC[table>>4];
nengel@0 362 }
nengel@0 363 priv->stream = stream+3;
nengel@0 364 trace("< SOS marker\n");
nengel@0 365 return 0;
nengel@0 366 }
nengel@0 367
nengel@0 368 static int parse_DHT(struct jdec_private *priv, const unsigned char *stream)
nengel@0 369 {
nengel@0 370 unsigned int count, i;
nengel@0 371 unsigned char huff_bits[17];
nengel@0 372 int length, index;
nengel@0 373
nengel@0 374 length = be16_to_cpu(stream) - 2;
nengel@0 375 stream += 2; /* Skip length */
nengel@0 376
nengel@0 377 trace("> DHT marker (length=%d)\n", length);
nengel@0 378
nengel@0 379 while (length>0) {
nengel@0 380 index = *stream++;
nengel@0 381
nengel@0 382 /* We need to calculate the number of bytes 'vals' will takes */
nengel@0 383 huff_bits[0] = 0;
nengel@0 384 count = 0;
nengel@0 385 for (i=1; i<17; i++) {
nengel@0 386 huff_bits[i] = *stream++;
nengel@0 387 count += huff_bits[i];
nengel@0 388 }
nengel@0 389 #if SANITY_CHECK
nengel@0 390 if (count >= HUFFMAN_BITS_SIZE)
nengel@0 391 error("No more than %d bytes is allowed to describe a huffman table", HUFFMAN_BITS_SIZE);
nengel@0 392 if ( (index &0xf) >= HUFFMAN_TABLES)
nengel@0 393 error("No more than %d Huffman tables is supported (got %d)\n", HUFFMAN_TABLES, index&0xf);
nengel@0 394 trace("Huffman table %s[%d] length=%d\n", (index&0xf0)?"AC":"DC", index&0xf, count);
nengel@0 395 #endif
nengel@0 396
nengel@0 397 if (index & 0xf0 )
nengel@0 398 build_huffman_table(huff_bits, stream, &priv->HTAC[index&0xf]);
nengel@0 399 else
nengel@0 400 build_huffman_table(huff_bits, stream, &priv->HTDC[index&0xf]);
nengel@0 401
nengel@0 402 length -= 1;
nengel@0 403 length -= 16;
nengel@0 404 length -= count;
nengel@0 405 stream += count;
nengel@0 406 }
nengel@0 407 trace("< DHT marker\n");
nengel@0 408 return 0;
nengel@0 409 }
nengel@0 410
nengel@0 411 static int parse_DRI(struct jdec_private *priv, const unsigned char *stream)
nengel@0 412 {
nengel@0 413 unsigned int length;
nengel@0 414
nengel@0 415 trace("> DRI marker\n");
nengel@0 416
nengel@0 417 length = be16_to_cpu(stream);
nengel@0 418
nengel@0 419 #if SANITY_CHECK
nengel@0 420 if (length != 4)
nengel@0 421 error("Length of DRI marker need to be 4\n");
nengel@0 422 #endif
nengel@0 423
nengel@0 424 priv->restart_interval = be16_to_cpu(stream+2);
nengel@0 425 if (priv->restart_interval == 0)
nengel@0 426 priv->restart_interval = priv->mcus_in_width * priv->mcus_in_height;
nengel@0 427
nengel@0 428 #if DEBUG
nengel@0 429 trace("Restart interval = %d\n", priv->restart_interval);
nengel@0 430 #endif
nengel@0 431
nengel@0 432 trace("< DRI marker\n");
nengel@0 433
nengel@0 434 return 0;
nengel@0 435 }
nengel@0 436
nengel@0 437 int parse_JFIF(struct jdec_private *priv, const unsigned char *stream)
nengel@0 438 {
nengel@0 439 int chuck_len;
nengel@0 440 int marker;
nengel@0 441 int sos_marker_found = 0;
nengel@0 442 int dht_marker_found = 0;
nengel@0 443 const unsigned char *next_chunck;
nengel@0 444
nengel@0 445 /* Parse marker */
nengel@0 446 while (!sos_marker_found)
nengel@0 447 {
nengel@0 448 if (*stream++ != 0xff) {
nengel@0 449 trace("Bogus jpeg format\n");
nengel@0 450 return -1;
nengel@0 451 }
nengel@0 452 /* Skip any padding ff byte (this is normal) */
nengel@0 453 while (*stream == 0xff)
nengel@0 454 stream++;
nengel@0 455
nengel@0 456 marker = *stream++;
nengel@0 457 chuck_len = be16_to_cpu(stream);
nengel@0 458 next_chunck = stream + chuck_len;
nengel@0 459 switch (marker)
nengel@0 460 {
nengel@0 461 case SOF:
nengel@0 462 if (parse_SOF(priv, stream) < 0)
nengel@0 463 return -1;
nengel@0 464 break;
nengel@0 465 case DQT:
nengel@0 466 if (parse_DQT(priv, stream) < 0)
nengel@0 467 return -1;
nengel@0 468 break;
nengel@0 469 case SOS:
nengel@0 470 if (parse_SOS(priv, stream) < 0)
nengel@0 471 return -1;
nengel@0 472 sos_marker_found = 1;
nengel@0 473 break;
nengel@0 474 case DHT:
nengel@0 475 if (parse_DHT(priv, stream) < 0)
nengel@0 476 return -1;
nengel@0 477 dht_marker_found = 1;
nengel@0 478 break;
nengel@0 479 case DRI:
nengel@0 480 if (parse_DRI(priv, stream) < 0)
nengel@0 481 return -1;
nengel@0 482 break;
nengel@0 483 default:
nengel@0 484 trace("> Unknown marker %2.2x\n", marker);
nengel@0 485 break;
nengel@0 486 }
nengel@0 487
nengel@0 488 stream = next_chunck;
nengel@0 489 }
nengel@0 490
nengel@0 491 if (!dht_marker_found) {
nengel@0 492 trace("No Huffman table loaded, using the default one\n");
nengel@0 493 build_default_huffman_tables(priv);
nengel@0 494 }
nengel@0 495
nengel@0 496 #ifdef SANITY_CHECK
nengel@0 497 if ( (priv->component_infos[cY].Hfactor < priv->component_infos[cCb].Hfactor)
nengel@0 498 || (priv->component_infos[cY].Hfactor < priv->component_infos[cCr].Hfactor))
nengel@0 499 error("Horizontal sampling factor for Y should be greater than horitontal sampling factor for Cb or Cr\n");
nengel@0 500 if ( (priv->component_infos[cY].Vfactor < priv->component_infos[cCb].Vfactor)
nengel@0 501 || (priv->component_infos[cY].Vfactor < priv->component_infos[cCr].Vfactor))
nengel@0 502 error("Vertical sampling factor for Y should be greater than vertical sampling factor for Cb or Cr\n");
nengel@0 503 if ( (priv->component_infos[cCb].Hfactor!=1)
nengel@0 504 || (priv->component_infos[cCr].Hfactor!=1)
nengel@0 505 || (priv->component_infos[cCb].Vfactor!=1)
nengel@0 506 || (priv->component_infos[cCr].Vfactor!=1))
nengel@0 507 error("Sampling other than 1x1 for Cr and Cb is not supported");
nengel@0 508 #endif
nengel@0 509
nengel@0 510 return 0;
nengel@0 511 }