swfdec/jpeg/jpeg.c

   1
   2 #ifdef HAVE_CONFIG_H
   3 #include "config.h"
   4 #endif
   5
   6 #include <liboil/liboil.h>
   7 #include <liboil/liboil-stdint.h>
   8 #include <cogcompat.h>
   9
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include <string.h>
  13
  14 #include "jpeg.h"
  15
  16
  17 extern uint8_t jpeg_standard_tables[];
  18 extern int jpeg_standard_tables_size;
  19
  20 void jpeg_decoder_define_huffman_tables (JpegDecoder * dec);
  21 void jpeg_decoder_define_arithmetic_conditioning (JpegDecoder *dec);
  22 void jpeg_decoder_define_quantization_tables (JpegDecoder *dec);
  23 void jpeg_decoder_define_restart_interval (JpegDecoder *dec);
  24 void jpeg_decoder_start_of_frame (JpegDecoder * dec, int marker);
  25 void jpeg_decoder_start_of_scan (JpegDecoder * dec);
  26
  27
  28 /* misc helper function declarations */
  29
  30 static void jpeg_load_standard_huffman_tables (JpegDecoder * dec);
  31
  32 static void jpeg_decoder_verify_header (JpegDecoder *dec);
  33 static void jpeg_decoder_init_decoder (JpegDecoder *dec);
  34
  35
  36 void
  37 jpeg_decoder_error(JpegDecoder *dec, const char *fmt, ...)
  38 {
  39   va_list varargs;
  40
  41   if (dec->error) return;
  42
  43   va_start (varargs, fmt);
  44 #ifdef HAVE_VASPRINTF
  45   vasprintf(&dec->error_message, fmt, varargs);
  46 #else
  47   dec->error_message = malloc(250);
  48   vsnprintf(dec->error_message, 250 - 1, fmt, varargs);
  49   dec->error_message[250 - 1] = 0;
  50 #endif
  51   va_end (varargs);
  52
  53   dec->error = TRUE;
  54 }
  55
  56 #define jpeg_decoder_error(dec, ...) { \
  57   COG_ERROR("decoder error: "__VA_ARGS__); \
  58   jpeg_decoder_error (dec, __VA_ARGS__); \
  59 }
  60
  61 static void
  62 jpeg_decoder_verify_header (JpegDecoder *dec)
  63 {
  64   int max_quant_table = 0;
  65   int i;
  66
  67   if (dec->sof_type != JPEG_MARKER_SOF_0) {
  68     COG_ERROR("only handle baseline DCT");
  69     dec->error = TRUE;
  70   }
  71
  72   if (dec->width < 1) {
  73     COG_ERROR("width can't be 0");
  74     dec->error = TRUE;
  75   }
  76
  77   if (dec->height < 1) {
  78     COG_ERROR("height can't be 0");
  79     dec->error = TRUE;
  80   }
  81
  82   switch (dec->sof_type) {
  83     case JPEG_MARKER_SOF_0:
  84       /* baseline DCT */
  85       max_quant_table = 3;
  86       if (dec->depth != 8) {
  87         COG_ERROR("depth must be 8 (%d)", dec->depth);
  88         dec->error = TRUE;
  89       }
  90       break;
  91     case JPEG_MARKER_SOF_1:
  92       /* extended DCT */
  93       max_quant_table = 3;
  94       if (dec->depth != 8 && dec->depth != 12) {
  95         COG_ERROR("depth must be 8 or 12 (%d)", dec->depth);
  96         dec->error = TRUE;
  97       }
  98       break;
  99     case JPEG_MARKER_SOF_2:
 100       /* progressive DCT */
 101       max_quant_table = 3;
 102       if (dec->depth != 8 && dec->depth != 12) {
 103         COG_ERROR("depth must be 8 or 12 (%d)", dec->depth);
 104         dec->error = TRUE;
 105       }
 106       break;
 107     case JPEG_MARKER_SOF_3:
 108       /* lossless DCT */
 109       max_quant_table = 0;
 110       if (dec->depth < 2 || dec->depth > 16) {
 111         COG_ERROR("depth must be between 2 and 16 (%d)", dec->depth);
 112         dec->error = TRUE;
 113       }
 114       break;
 115     default:
 116       break;
 117   }
 118
 119   if (dec->n_components < 0 || dec->n_components > 255) {
 120     COG_ERROR("n_components must be in the range 0-255 (%d)",
 121         dec->n_components);
 122     dec->error = TRUE;
 123   }
 124   if (dec->sof_type == JPEG_MARKER_SOF_2 && dec->n_components > 4) {
 125     COG_ERROR("n_components must be <= 4 for progressive DCT (%d)",
 126         dec->n_components);
 127     dec->error = TRUE;
 128   }
 129
 130   for (i = 0; i < dec->n_components; i++) {
 131     if (dec->components[i].id < 0 || dec->components[i].id > 255) {
 132       COG_ERROR("component ID out of range");
 133       dec->error = TRUE;
 134       break;
 135     }
 136     if (dec->components[i].h_sample < 1 || dec->components[i].h_sample > 4 ||
 137         dec->components[i].v_sample < 1 || dec->components[i].v_sample > 4) {
 138       COG_ERROR("sample factor(s) for component %d out of range %d %d",
 139           i, dec->components[i].h_sample, dec->components[i].v_sample);
 140       dec->error = TRUE;
 141       break;
 142     }
 143     if (dec->components[i].quant_table < 0 ||
 144         dec->components[i].quant_table > max_quant_table) {
 145       COG_ERROR("quant table for component %d out of range (%d)",
 146           i, dec->components[i].quant_table);
 147       dec->error = TRUE;
 148       break;
 149     }
 150   }
 151
 152  if ((1 << 30) / dec->width / dec->height < dec->n_components) {
 153    COG_ERROR ("image is too big (width %d, height %d, %d components)",
 154        dec->width, dec->height, dec->n_components);
 155    dec->error = TRUE;
 156  }
 157 }
 158
 159 static void
 160 jpeg_decoder_init_decoder (JpegDecoder *dec)
 161 {
 162   int max_h_sample = 0;
 163   int max_v_sample = 0;
 164   int i;
 165
 166   /* decoder limitations */
 167   if (dec->n_components != 3) {
 168     jpeg_decoder_error(dec, "wrong number of components %d", dec->n_components);
 169     return;
 170   }
 171   if (dec->sof_type != JPEG_MARKER_SOF_0) {
 172     jpeg_decoder_error(dec, "only handle baseline DCT");
 173     return;
 174   }
 175
 176   for (i=0; i < dec->n_components; i++) {
 177     max_h_sample = MAX (max_h_sample, dec->components[i].h_sample);
 178     max_v_sample = MAX (max_v_sample, dec->components[i].v_sample);
 179   }
 180
 181   dec->width_blocks =
 182       (dec->width + 8 * max_h_sample - 1) / (8 * max_h_sample);
 183   dec->height_blocks =
 184       (dec->height + 8 * max_v_sample - 1) / (8 * max_v_sample);
 185   for (i = 0; i < dec->n_components; i++) {
 186     int rowstride;
 187     int image_size;
 188
 189     dec->components[i].h_subsample = max_h_sample /
 190         dec->components[i].h_sample;
 191     dec->components[i].v_subsample = max_v_sample /
 192         dec->components[i].v_sample;
 193
 194     rowstride = dec->width_blocks * 8 * max_h_sample /
 195         dec->components[i].h_subsample;
 196     image_size = rowstride *
 197         (dec->height_blocks * 8 * max_v_sample /
 198         dec->components[i].v_subsample);
 199     dec->components[i].rowstride = rowstride;
 200     dec->components[i].image = malloc (image_size);
 201   }
 202 }
 203
 204 #if 0
 205 static char *
 206 sprintbits (char *str, unsigned int bits, int n)
 207 {
 208   int i;
 209   int bit = 1 << (n - 1);
 210
 211   for (i = 0; i < n; i++) {
 212     str[i] = (bits & bit) ? '1' : '0';
 213     bit >>= 1;
 214   }
 215   str[i] = 0;
 216
 217   return str;
 218 }
 219
 220 static void
 221 generate_code_table (int *huffsize)
 222 {
 223   int code;
 224   int i;
 225   int j;
 226   int k;
 227   char str[33];
 228
 229   //int l;
 230
 231   code = 0;
 232   k = 0;
 233   for (i = 0; i < 16; i++) {
 234     for (j = 0; j < huffsize[i]; j++) {
 235       COG_DEBUG ("huffcode[%d] = %s", k,
 236           sprintbits (str, code >> (15 - i), i + 1));
 237       code++;
 238       k++;
 239     }
 240     code <<= 1;
 241   }
 242
 243 }
 244 #endif
 245
 246 static int
 247 huffman_table_init_jpeg (JpegDecoder *decoder, HuffmanTable *table, JpegBits * bits)
 248 {
 249   int n_symbols;
 250   int huffsize[16];
 251   int i, j, k;
 252   unsigned int symbol;
 253   int n = 0;
 254
 255   huffman_table_init (table);
 256
 257   /* huffsize[i] is the number of symbols that have length
 258    * (i+1) bits.  Maximum bit length is 16 bits, so there are
 259    * 16 entries. */
 260   n_symbols = 0;
 261   for (i = 0; i < 16; i++) {
 262     huffsize[i] = jpeg_bits_get_u8 (bits);
 263     n++;
 264     n_symbols += huffsize[i];
 265   }
 266
 267   /* Build up the symbol table.  The first symbol is all 0's, with
 268    * the number of bits determined by the first non-zero entry in
 269    * huffsize[].  Subsequent symbols with the same bit length are
 270    * incremented by 1.  Increasing the bit length shifts the
 271    * symbol 1 bit to the left. */
 272   symbol = 0;
 273   k = 0;
 274   for (i = 0; i < 16; i++) {
 275     for (j = 0; j < huffsize[i]; j++) {
 276       huffman_table_add (table, symbol, i + 1, jpeg_bits_get_u8 (bits));
 277       n++;
 278       symbol++;
 279       k++;
 280     }
 281     /* This checks that our symbol is actually less than the
 282      * number of bits we think it is.  This is only triggered
 283      * for bad huffsize[] arrays. */
 284     if (symbol >= (1U << (i + 1))) {
 285       jpeg_decoder_error (decoder, "bad huffsize[] array");
 286       return -1;
 287     }
 288
 289     symbol <<= 1;
 290   }
 291
 292   huffman_table_dump (table);
 293
 294   return n;
 295 }
 296
 297 static int
 298 jpeg_decoder_find_component_by_id (JpegDecoder * dec, int id)
 299 {
 300   int i;
 301
 302   for (i = 0; i < dec->n_components; i++) {
 303     if (dec->components[i].id == id)
 304       return i;
 305   }
 306   COG_DEBUG ("undefined component id %d", id);
 307   return 0;
 308 }
 309
 310 int
 311 jpeg_decoder_application0 (JpegDecoder * dec, JpegBits * bits)
 312 {
 313   int length;
 314
 315   COG_DEBUG ("app0");
 316
 317   length = get_be_u16 (bits);
 318   COG_DEBUG ("length=%d", length);
 319
 320   if (memcmp (bits->ptr, "JFIF", 4) == 0 && bits->ptr[4] == 0) {
 321     int version;
 322     int units;
 323     int x_density;
 324     int y_density;
 325     int x_thumbnail;
 326     int y_thumbnail;
 327
 328     COG_DEBUG ("JFIF");
 329     bits->ptr += 5;
 330
 331     version = get_be_u16 (bits);
 332     units = get_u8 (bits);
 333     x_density = get_be_u16 (bits);
 334     y_density = get_be_u16 (bits);
 335     x_thumbnail = get_u8 (bits);
 336     y_thumbnail = get_u8 (bits);
 337
 338     COG_DEBUG ("version = %04x", version);
 339     COG_DEBUG ("units = %d", units);
 340     COG_DEBUG ("x_density = %d", x_density);
 341     COG_DEBUG ("y_density = %d", y_density);
 342     COG_DEBUG ("x_thumbnail = %d", x_thumbnail);
 343     COG_DEBUG ("y_thumbnail = %d", y_thumbnail);
 344
 345   }
 346
 347   if (memcmp (bits->ptr, "JFXX", 4) == 0 && bits->ptr[4] == 0) {
 348     COG_DEBUG ("JFIF extension (not handled)");
 349     bits->ptr += length - 2;
 350   }
 351
 352   return length;
 353 }
 354
 355 int
 356 jpeg_decoder_application_misc (JpegDecoder * dec, JpegBits * bits)
 357 {
 358   int length;
 359
 360   COG_DEBUG ("appX");
 361
 362   length = get_be_u16 (bits);
 363   COG_DEBUG ("length=%d", length);
 364
 365   COG_DEBUG ("JPEG application tag X ignored");
 366   //dumpbits (bits);
 367
 368   bits->ptr += length - 2;
 369
 370   return length;
 371 }
 372
 373 int
 374 jpeg_decoder_comment (JpegDecoder * dec, JpegBits * bits)
 375 {
 376   int length;
 377
 378   COG_DEBUG ("comment");
 379
 380   length = get_be_u16 (bits);
 381   COG_DEBUG ("length=%d", length);
 382
 383   //dumpbits (bits);
 384
 385   bits->ptr += length - 2;
 386
 387   return length;
 388 }
 389
 390 int
 391 jpeg_decoder_restart_interval (JpegDecoder * dec, JpegBits * bits)
 392 {
 393   int length;
 394
 395   COG_DEBUG ("comment");
 396
 397   length = get_be_u16 (bits);
 398   COG_DEBUG ("length=%d", length);
 399
 400   dec->restart_interval = get_be_u16 (bits);
 401   COG_DEBUG ("restart_interval=%d", dec->restart_interval);
 402
 403   return length;
 404 }
 405
 406 int
 407 jpeg_decoder_restart (JpegDecoder * dec, JpegBits * bits)
 408 {
 409   COG_DEBUG ("restart");
 410
 411   return 0;
 412 }
 413
 414 void
 415 jpeg_decoder_decode_entropy_segment (JpegDecoder * dec)
 416 {
 417   JpegBits * bits = &dec->bits;
 418   JpegBits b2, *bits2 = &b2;
 419   short block[64];
 420   short block2[64];
 421   unsigned char *newptr;
 422   int len;
 423   int maxlen;
 424   int j;
 425   int i;
 426   int go;
 427   int x, y;
 428   int n;
 429   int ret;
 430
 431   len = 0;
 432   maxlen = jpeg_bits_available (bits) - 1;
 433   j = 0;
 434   while (len < maxlen) {
 435     if (bits->ptr[len] == 0xff && bits->ptr[len + 1] != 0x00) {
 436       break;
 437     }
 438     len++;
 439   }
 440   COG_DEBUG ("entropy length = %d", len);
 441
 442   /* we allocate extra space, since the getbits() code can
 443    * potentially read past the end of the buffer */
 444   newptr = malloc (len + 2);
 445   for (i = 0; i < len; i++) {
 446     newptr[j] = bits->ptr[i];
 447     j++;
 448     if (bits->ptr[i] == 0xff)
 449       i++;
 450   }
 451   bits->ptr += len;
 452
 453   bits2->ptr = newptr;
 454   bits2->idx = 0;
 455   bits2->end = newptr + j;
 456   newptr[j] = 0;
 457   newptr[j + 1] = 0;
 458
 459   dec->dc[0] = dec->dc[1] = dec->dc[2] = dec->dc[3] = 128 * 8;
 460   go = 1;
 461   x = dec->x;
 462   y = dec->y;
 463   n = dec->restart_interval;
 464   if (n == 0) n = (1<<26); /* max number of blocks */
 465   while (go && n-- > 0) {
 466     for (i = 0; i < dec->scan_list_length; i++) {
 467       int dc_table_index;
 468       int ac_table_index;
 469       int quant_index;
 470       unsigned char *ptr;
 471       int component_index;
 472
 473       COG_DEBUG ("%d,%d: component=%d dc_table=%d ac_table=%d",
 474           x, y,
 475           dec->scan_list[i].component_index,
 476           dec->scan_list[i].dc_table, dec->scan_list[i].ac_table);
 477
 478       component_index = dec->scan_list[i].component_index;
 479       dc_table_index = dec->scan_list[i].dc_table;
 480       ac_table_index = dec->scan_list[i].ac_table;
 481       quant_index = dec->scan_list[i].quant_table;
 482
 483       ret = huffman_table_decode_macroblock (dec, block,
 484           &dec->dc_huff_table[dc_table_index],
 485           &dec->ac_huff_table[ac_table_index], bits2);
 486       if (ret < 0) {
 487         COG_DEBUG ("%d,%d: component=%d dc_table=%d ac_table=%d",
 488             x, y,
 489             dec->scan_list[i].component_index,
 490             dec->scan_list[i].dc_table, dec->scan_list[i].ac_table);
 491         n = 0;
 492         break;
 493       }
 494
 495       COG_DEBUG ("using quant table %d", quant_index);
 496       oil_mult8x8_s16 (block2, block, dec->quant_tables[quant_index].quantizer,
 497           sizeof (short) * 8, sizeof(short) * 8, sizeof (short) * 8);
 498       dec->dc[component_index] += block2[0];
 499       block2[0] = dec->dc[component_index];
 500       oil_unzigzag8x8_s16 (block, sizeof (short) * 8, block2,
 501           sizeof (short) * 8);
 502       oil_idct8x8_s16 (block2, sizeof (short) * 8, block, sizeof (short) * 8);
 503       oil_trans8x8_s16 (block, sizeof (short) * 8, block2, sizeof (short) * 8);
 504
 505       ptr = dec->components[component_index].image +
 506           x * dec->components[component_index].h_sample +
 507           dec->scan_list[i].offset +
 508           dec->components[component_index].rowstride * y *
 509           dec->components[component_index].v_sample;
 510
 511       oil_clipconv8x8_u8_s16 (ptr,
 512           dec->components[component_index].rowstride,
 513           block, sizeof (short) * 8);
 514     }
 515     x += 8;
 516     if (x * dec->scan_h_subsample >= dec->width) {
 517       x = 0;
 518       y += 8;
 519     }
 520     if (y * dec->scan_v_subsample >= dec->height) {
 521       go = 0;
 522     }
 523   }
 524   dec->x = x;
 525   dec->y = y;
 526   free (newptr);
 527 }
 528
 529
 530
 531 JpegDecoder *
 532 jpeg_decoder_new (void)
 533 {
 534   JpegDecoder *dec;
 535
 536   oil_init ();
 537
 538   dec = malloc (sizeof(JpegDecoder));
 539   memset (dec, 0, sizeof(JpegDecoder));
 540
 541   jpeg_load_standard_huffman_tables (dec);
 542
 543   return dec;
 544 }
 545
 546 void
 547 jpeg_decoder_free (JpegDecoder * dec)
 548 {
 549   int i;
 550
 551   for (i = 0; i < JPEG_LIMIT_COMPONENTS; i++) {
 552     if (dec->components[i].image)
 553       free (dec->components[i].image);
 554   }
 555
 556   if (dec->data)
 557     free (dec->data);
 558
 559   free (dec);
 560 }
 561
 562 static int
 563 jpeg_decoder_get_marker (JpegDecoder *dec, int *marker)
 564 {
 565   int a,b;
 566   JpegBits *bits = &dec->bits;
 567
 568   if (jpeg_bits_available(bits) < 2) {
 569     return FALSE;
 570   }
 571
 572   a = jpeg_bits_get_u8(bits);
 573   if (a != 0xff) {
 574     jpeg_decoder_error(dec, "expected marker, not 0x%02x", a);
 575     return FALSE;
 576   }
 577
 578   do {
 579     b = jpeg_bits_get_u8 (bits);
 580   } while (b == 0xff && jpeg_bits_error(bits));
 581
 582   *marker = b;
 583   return TRUE;
 584 }
 585
 586 static void
 587 jpeg_decoder_skip (JpegDecoder *dec)
 588 {
 589   int length;
 590
 591   length = jpeg_bits_get_u16_be (&dec->bits);
 592   jpeg_bits_skip (&dec->bits, length - 2);
 593 }
 594
 595 int
 596 jpeg_decoder_decode (JpegDecoder *dec)
 597 {
 598   JpegBits *bits;
 599   int marker;
 600
 601   dec->error = FALSE;
 602
 603   bits = &dec->bits;
 604
 605   /* Note: The spec is ambiguous as to whether fill bytes can come
 606    * before the first marker.  We'll assume yes. */
 607   if (!jpeg_decoder_get_marker (dec, &marker)) {
 608     return FALSE;
 609   }
 610   if (dec->strict && marker != JPEG_MARKER_SOI) {
 611     jpeg_decoder_error(dec, "not a JPEG image");
 612     return FALSE;
 613   }
 614
 615   /* Interpret markers up to the start of frame */
 616   while (!dec->error) {
 617     if (!jpeg_decoder_get_marker (dec, &marker)) {
 618       return FALSE;
 619     }
 620
 621     if (marker == JPEG_MARKER_DEFINE_HUFFMAN_TABLES) {
 622       jpeg_decoder_define_huffman_tables (dec);
 623     } else if (marker == JPEG_MARKER_DEFINE_ARITHMETIC_CONDITIONING) {
 624       jpeg_decoder_define_arithmetic_conditioning (dec);
 625     } else if (marker == JPEG_MARKER_DEFINE_QUANTIZATION_TABLES) {
 626       jpeg_decoder_define_quantization_tables (dec);
 627     } else if (marker == JPEG_MARKER_DEFINE_RESTART_INTERVAL) {
 628       jpeg_decoder_define_restart_interval (dec);
 629     } else if (JPEG_MARKER_IS_APP(marker)) {
 630       /* FIXME decode app segment */
 631       jpeg_decoder_skip (dec);
 632     } else if (marker == JPEG_MARKER_COMMENT) {
 633       jpeg_decoder_skip (dec);
 634     } else if (JPEG_MARKER_IS_START_OF_FRAME(marker)) {
 635       break;
 636     } else if (marker == JPEG_MARKER_SOI) {
 637       if (dec->strict) {
 638         jpeg_decoder_error (dec, "unexpected SOI");
 639         return FALSE;
 640       }
 641     } else if (marker == JPEG_MARKER_EOI) {
 642       if (dec->strict) {
 643         jpeg_decoder_error (dec, "unexpected EOI");
 644         return FALSE;
 645       }
 646     } else {
 647       jpeg_decoder_error(dec, "unexpected marker 0x%02x", marker);
 648       return FALSE;
 649     }
 650   }
 651   if (dec->error) {
 652     return FALSE;
 653   }
 654
 655   jpeg_decoder_start_of_frame(dec, marker);
 656
 657   jpeg_decoder_verify_header (dec);
 658   if (dec->error) {
 659     return FALSE;
 660   }
 661
 662   jpeg_decoder_init_decoder (dec);
 663   if (dec->error) {
 664     return FALSE;
 665   }
 666
 667   /* In this section, we loop over parse units until we reach the end
 668    * of the image. */
 669   while (!dec->error) {
 670     if (!jpeg_decoder_get_marker (dec, &marker)) {
 671       return FALSE;
 672     }
 673
 674     if (marker == JPEG_MARKER_DEFINE_HUFFMAN_TABLES) {
 675       jpeg_decoder_define_huffman_tables (dec);
 676     } else if (marker == JPEG_MARKER_DEFINE_ARITHMETIC_CONDITIONING) {
 677       jpeg_decoder_define_arithmetic_conditioning (dec);
 678     } else if (marker == JPEG_MARKER_DEFINE_QUANTIZATION_TABLES) {
 679       jpeg_decoder_define_quantization_tables (dec);
 680     } else if (marker == JPEG_MARKER_DEFINE_RESTART_INTERVAL) {
 681       jpeg_decoder_define_restart_interval (dec);
 682     } else if (JPEG_MARKER_IS_APP(marker)) {
 683       jpeg_decoder_skip (dec);
 684     } else if (marker == JPEG_MARKER_COMMENT) {
 685       jpeg_decoder_skip (dec);
 686     } else if (marker == JPEG_MARKER_SOS) {
 687       jpeg_decoder_start_of_scan (dec);
 688       if (dec->error) {
 689         return FALSE;
 690       }
 691       jpeg_decoder_decode_entropy_segment (dec);
 692     } else if (JPEG_MARKER_IS_RESET(marker)) {
 693       jpeg_decoder_decode_entropy_segment (dec);
 694     } else if (marker == JPEG_MARKER_SOI) {
 695       if (dec->strict) {
 696         jpeg_decoder_error (dec, "unexpected SOI");
 697         return FALSE;
 698       }
 699     } else if (marker == JPEG_MARKER_EOI) {
 700       if (dec->strict) {
 701         jpeg_decoder_error (dec, "unexpected EOI");
 702         return FALSE;
 703       } else {
 704         break;
 705       }
 706     } else {
 707       jpeg_decoder_error(dec, "unexpected marker 0x%02x", marker);
 708       return FALSE;
 709     }
 710   }
 711   if (dec->error) {
 712     return FALSE;
 713   }
 714
 715   return TRUE;
 716 }
 717
 718 /* handle markers */
 719
 720 void
 721 jpeg_decoder_define_huffman_tables (JpegDecoder * dec)
 722 {
 723   JpegBits *bits = &dec->bits;
 724   int length;
 725   int tc;
 726   int th;
 727   int x;
 728   HuffmanTable *hufftab;
 729
 730   COG_DEBUG ("define huffman tables");
 731
 732   length = jpeg_bits_get_u16_be (bits);
 733   if (length < 2) {
 734     jpeg_decoder_error(dec, "length too short");
 735     return;
 736   }
 737   length -= 2;
 738
 739   while (length > 0) {
 740     x = jpeg_bits_get_u8 (bits);
 741     length--;
 742
 743     tc = x >> 4;
 744     th = x & 0xf;
 745
 746     COG_DEBUG ("huff table type %d (%s) idx %d", tc, tc ? "ac" : "dc", th);
 747     if (tc > 1 || th > 3) {
 748       jpeg_decoder_error(dec, "huffman table type or idx out of range");
 749       return;
 750     }
 751
 752     if (tc) {
 753       hufftab = &dec->ac_huff_table[th];
 754       length -= huffman_table_init_jpeg (dec, hufftab, bits);
 755     } else {
 756       hufftab = &dec->dc_huff_table[th];
 757       length -= huffman_table_init_jpeg (dec, hufftab, bits);
 758     }
 759     if (dec->error) {
 760       return;
 761     }
 762   }
 763   if (length < 0) {
 764     jpeg_decoder_error(dec, "huffman table overran available bytes");
 765     return;
 766   }
 767 }
 768
 769 void
 770 jpeg_decoder_define_quantization_tables (JpegDecoder *dec)
 771 {
 772   JpegBits *bits = &dec->bits;
 773   JpegQuantTable *table;
 774   int length;
 775   int pq;
 776   int tq;
 777   int i;
 778
 779   COG_INFO ("define quantization table");
 780
 781   length = jpeg_bits_get_u16_be (bits);
 782   if (length < 2) {
 783     jpeg_decoder_error(dec, "length too short");
 784     return;
 785   }
 786   length -= 2;
 787
 788   while (length > 0) {
 789     int x;
 790
 791     x = jpeg_bits_get_u8 (bits);
 792     length--;
 793     pq = x >> 4;
 794     tq = x & 0xf;
 795
 796     if (pq > 1) {
 797       jpeg_decoder_error (dec, "bad pq value");
 798       return;
 799     }
 800     if (tq > 3) {
 801       jpeg_decoder_error (dec, "bad tq value");
 802       return;
 803     }
 804
 805     table = &dec->quant_tables[tq];
 806     if (pq) {
 807       for (i = 0; i < 64; i++) {
 808         table->quantizer[i] = jpeg_bits_get_u16_be (bits);
 809         length -= 2;
 810       }
 811     } else {
 812       for (i = 0; i < 64; i++) {
 813         table->quantizer[i] = jpeg_bits_get_u8 (bits);
 814         length -= 1;
 815       }
 816     }
 817   }
 818   if (length < 0) {
 819     jpeg_decoder_error(dec, "quantization table overran available bytes");
 820     return;
 821   }
 822 }
 823
 824 void
 825 jpeg_decoder_define_restart_interval (JpegDecoder *dec)
 826 {
 827   JpegBits *bits = &dec->bits;
 828   int length;
 829
 830   length = jpeg_bits_get_u16_be (bits);
 831   if (length != 4) {
 832     jpeg_decoder_error(dec, "length supposed to be 4 (%d)", length);
 833     return;
 834   }
 835
 836   /* FIXME this needs to be checked somewhere */
 837   dec->restart_interval = jpeg_bits_get_u16_be (bits);
 838 }
 839
 840 void
 841 jpeg_decoder_define_arithmetic_conditioning (JpegDecoder *dec)
 842 {
 843   /* we don't handle arithmetic coding, so skip it */
 844   jpeg_decoder_skip (dec);
 845 }
 846
 847 void
 848 jpeg_decoder_start_of_frame (JpegDecoder * dec, int marker)
 849 {
 850   JpegBits *bits = &dec->bits;
 851   int i;
 852   int length;
 853
 854   COG_INFO ("start of frame");
 855
 856   dec->sof_type = marker;
 857
 858   length = jpeg_bits_get_u16_be (bits);
 859
 860   if (jpeg_bits_available(bits) < length) {
 861     jpeg_decoder_error(dec, "not enough data for start_of_frame (%d < %d)",
 862         length, jpeg_bits_available(bits));
 863     return;
 864   }
 865
 866   dec->depth = jpeg_bits_get_u8 (bits);
 867   dec->height = jpeg_bits_get_u16_be (bits);
 868   dec->width = jpeg_bits_get_u16_be (bits);
 869   dec->n_components = jpeg_bits_get_u8 (bits);
 870
 871   COG_DEBUG (
 872       "frame_length=%d depth=%d height=%d width=%d n_components=%d", length,
 873       dec->depth, dec->height, dec->width, dec->n_components);
 874
 875   if (dec->n_components * 3 + 8 != length) {
 876     jpeg_decoder_error(dec, "inconsistent header");
 877     return;
 878   }
 879
 880   for (i = 0; i < dec->n_components; i++) {
 881     dec->components[i].id = get_u8 (bits);
 882     dec->components[i].h_sample = getbits (bits, 4);
 883     dec->components[i].v_sample = getbits (bits, 4);
 884     dec->components[i].quant_table = get_u8 (bits);
 885
 886     COG_DEBUG (
 887         "[%d] id=%d h_sample=%d v_sample=%d quant_table=%d", i,
 888         dec->components[i].id, dec->components[i].h_sample,
 889         dec->components[i].v_sample, dec->components[i].quant_table);
 890   }
 891 }
 892
 893 void
 894 jpeg_decoder_start_of_scan (JpegDecoder * dec)
 895 {
 896   JpegBits *bits = &dec->bits;
 897   int length;
 898   int i;
 899   int spectral_start;
 900   int spectral_end;
 901   int approx_high;
 902   int approx_low;
 903   int n;
 904   int tmp;
 905   int n_components;
 906
 907   COG_DEBUG ("start of scan");
 908
 909   length = jpeg_bits_get_u16_be (bits);
 910   COG_DEBUG ("length=%d", length);
 911
 912   n_components = jpeg_bits_get_u8 (bits);
 913   n = 0;
 914   dec->scan_h_subsample = 0;
 915   dec->scan_v_subsample = 0;
 916   for (i = 0; i < n_components; i++) {
 917     int component_id;
 918     int dc_table;
 919     int ac_table;
 920     int x;
 921     int y;
 922     int idx;
 923     int h_subsample;
 924     int v_subsample;
 925     int quant_index;
 926
 927     component_id = jpeg_bits_get_u8 (bits);
 928     tmp = jpeg_bits_get_u8 (bits);
 929     dc_table = tmp >> 4;
 930     ac_table = tmp & 0xf;
 931     idx = jpeg_decoder_find_component_by_id (dec, component_id);
 932
 933     h_subsample = dec->components[idx].h_sample;
 934     v_subsample = dec->components[idx].v_sample;
 935     quant_index = dec->components[idx].quant_table;
 936
 937     for (y = 0; y < v_subsample; y++) {
 938       for (x = 0; x < h_subsample; x++) {
 939         dec->scan_list[n].component_index = idx;
 940         dec->scan_list[n].dc_table = dc_table;
 941         dec->scan_list[n].ac_table = ac_table;
 942         dec->scan_list[n].quant_table = quant_index;
 943         dec->scan_list[n].x = x;
 944         dec->scan_list[n].y = y;
 945         dec->scan_list[n].offset =
 946             y * 8 * dec->components[idx].rowstride + x * 8;
 947         n++;
 948         if (n > JPEG_LIMIT_SCAN_LIST_LENGTH) {
 949           jpeg_decoder_error(dec, "scan list too long");
 950           return;
 951         }
 952       }
 953     }
 954
 955     dec->scan_h_subsample = MAX (dec->scan_h_subsample, h_subsample);
 956     dec->scan_v_subsample = MAX (dec->scan_v_subsample, v_subsample);
 957
 958     COG_DEBUG ("component %d: idx=%d dc_table=%d ac_table=%d n=%d",
 959         component_id, idx, dc_table, ac_table, n);
 960   }
 961   dec->scan_list_length = n;
 962
 963
 964   spectral_start = jpeg_bits_get_u8 (bits);
 965   spectral_end = jpeg_bits_get_u8 (bits);
 966   COG_DEBUG ("spectral range [%d,%d]", spectral_start, spectral_end);
 967   tmp = jpeg_bits_get_u8 (bits);
 968   approx_high = tmp >> 4;
 969   approx_low = tmp & 0xf;
 970   COG_DEBUG ("approx range [%d,%d]", approx_low, approx_high);
 971
 972   dec->x = 0;
 973   dec->y = 0;
 974   dec->dc[0] = dec->dc[1] = dec->dc[2] = dec->dc[3] = 128 * 8;
 975 }
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988 int
 989 jpeg_decoder_addbits (JpegDecoder * dec, unsigned char *data, unsigned int len)
 990 {
 991   unsigned int offset;
 992
 993   offset = dec->bits.ptr - dec->data;
 994
 995   dec->data = realloc (dec->data, dec->data_len + len);
 996   memcpy (dec->data + dec->data_len, data, len);
 997   dec->data_len += len;
 998
 999   dec->bits.ptr = dec->data + offset;
1000   dec->bits.end = dec->data + dec->data_len;
1001
1002   return 0;
1003 }
1004
1005 int
1006 jpeg_decoder_get_image_size (JpegDecoder * dec, unsigned int *width, unsigned int *height)
1007 {
1008   if (width)
1009     *width = (unsigned) dec->width;
1010   if (height)
1011     *height = (unsigned) dec->height;
1012
1013   return 0;
1014 }
1015
1016 int
1017 jpeg_decoder_get_component_ptr (JpegDecoder * dec, int id,
1018     unsigned char **image, int *rowstride)
1019 {
1020   int i;
1021
1022   i = jpeg_decoder_find_component_by_id (dec, id);
1023   if (image)
1024     *image = dec->components[i].image;
1025   if (rowstride)
1026     *rowstride = dec->components[i].rowstride;
1027
1028   return 0;
1029 }
1030
1031 int
1032 jpeg_decoder_get_component_size (JpegDecoder * dec, int id,
1033     int *width, int *height)
1034 {
1035   int i;
1036
1037   /* subsampling sizes are rounded up */
1038
1039   i = jpeg_decoder_find_component_by_id (dec, id);
1040   if (width)
1041     *width = (dec->width - 1) / dec->components[i].h_subsample + 1;
1042   if (height)
1043     *height = (dec->height - 1) / dec->components[i].v_subsample + 1;
1044
1045   return 0;
1046 }
1047
1048 int
1049 jpeg_decoder_get_component_subsampling (JpegDecoder * dec, int id,
1050     int *h_subsample, int *v_subsample)
1051 {
1052   int i;
1053
1054   i = jpeg_decoder_find_component_by_id (dec, id);
1055   if (h_subsample)
1056     *h_subsample = dec->components[i].h_subsample;
1057   if (v_subsample)
1058     *v_subsample = dec->components[i].v_subsample;
1059
1060   return 0;
1061 }
1062
1063 #if 0
1064 int
1065 jpeg_decoder_parse (JpegDecoder * dec)
1066 {
1067   JpegBits *bits = &dec->bits;
1068   JpegBits b2;
1069   unsigned int x;
1070   unsigned int tag;
1071   int i;
1072
1073   while (bits->ptr < bits->end) {
1074     x = get_u8 (bits);
1075     if (x != 0xff) {
1076       int n = 0;
1077
1078       while (x != 0xff) {
1079         x = get_u8 (bits);
1080         n++;
1081       }
1082       OIL_DEBUG ("lost sync, skipped %d bytes", n);
1083     }
1084     while (x == 0xff) {
1085       x = get_u8 (bits);
1086     }
1087     tag = x;
1088     OIL_DEBUG ("tag %02x", tag);
1089
1090     b2 = *bits;
1091
1092     for (i = 0; i < n_jpeg_markers - 1; i++) {
1093       if (tag == jpeg_markers[i].tag) {
1094         break;
1095       }
1096     }
1097     OIL_DEBUG ("tag: %s", jpeg_markers[i].name);
1098     if (jpeg_markers[i].func) {
1099       jpeg_markers[i].func (dec, &b2);
1100     } else {
1101       OIL_DEBUG ("unhandled or illegal JPEG marker (0x%02x)", tag);
1102       dumpbits (&b2);
1103     }
1104     if (jpeg_markers[i].flags & JPEG_ENTROPY_SEGMENT) {
1105       jpeg_decoder_decode_entropy_segment (dec, &b2);
1106     }
1107     syncbits (&b2);
1108     bits->ptr = b2.ptr;
1109   }
1110
1111   return 0;
1112 }
1113 #endif
1114
1115
1116 /* misc helper functins */
1117
1118 static void
1119 jpeg_load_standard_huffman_tables (JpegDecoder * dec)
1120 {
1121   JpegBits b, *bits = &b;
1122
1123   bits->ptr = jpeg_standard_tables;
1124   bits->idx = 0;
1125   bits->end = jpeg_standard_tables + jpeg_standard_tables_size;
1126
1127   huffman_table_init_jpeg (dec, &dec->dc_huff_table[0], bits);
1128   huffman_table_init_jpeg (dec, &dec->ac_huff_table[0], bits);
1129   huffman_table_init_jpeg (dec, &dec->dc_huff_table[1], bits);
1130   huffman_table_init_jpeg (dec, &dec->ac_huff_table[1], bits);
1131 }
1132
1133
1134