1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 #include <sys/stat.h>

    19 #include <fcntl.h>

    20 #include <unistd.h>

    21 #include <stdlib.h>

    22 #include <stdio.h>

    23 #include <string.h>

    24 #include <ctype.h>

    25 #include <limits.h>

    26 #include <liboil/liboil-stdint.h>

    27 #include <liboil/liboil.h>

    28 #include <liboil/liboildebug.h>

    29 #include <stdarg.h>

    30 

    31 #include "jpeg_internal.h"

    32 #include <liboil/globals.h>

    33 

    34 #define MAX(a,b) ((a)>(b) ? (a) : (b))

    35 

    36 

    37 extern uint8_t jpeg_standard_tables[];

    38 extern int jpeg_standard_tables_size;

    39 

    40 void jpeg_decoder_error(JpegDecoder *dec, char *fmt, ...);

    41 

    42 void jpeg_decoder_define_huffman_tables (JpegDecoder * dec);

    43 void jpeg_decoder_define_arithmetic_conditioning (JpegDecoder *dec);

    44 void jpeg_decoder_define_quantization_tables (JpegDecoder *dec);

    45 void jpeg_decoder_define_restart_interval (JpegDecoder *dec);

    46 void jpeg_decoder_start_of_frame (JpegDecoder * dec, int marker);

    47 void jpeg_decoder_start_of_scan (JpegDecoder * dec);

    48 

    49 

    50 /* misc helper function declarations */

    51 

    52 static void dumpbits (JpegBits * bits);

    53 static char *sprintbits (char *str, unsigned int bits, int n);

    54 

    55 static void huffman_table_load_std_jpeg (JpegDecoder * dec);

    56 

    57 static void jpeg_decoder_verify_header (JpegDecoder *dec);

    58 static void jpeg_decoder_init_decoder (JpegDecoder *dec);

    59 

    60 

    61 

    62 static void

    63 jpeg_decoder_verify_header (JpegDecoder *dec)

    64 {

    65   int max_quant_table = 0;

    66   int i;

    67 

    68   if (dec->sof_type != JPEG_MARKER_SOF_0) {

    69     OIL_ERROR("only handle baseline DCT");

    70     dec->error = TRUE;

    71   }

    72 

    73   if (dec->width < 1) {

    74     OIL_ERROR("height can't be 0");

    75     dec->error = TRUE;

    76   }

    77 

    78   switch (dec->sof_type) {

    79     case JPEG_MARKER_SOF_0:

    80       /* baseline DCT */

    81       max_quant_table = 3;

    82       if (dec->depth != 8) {

    83         OIL_ERROR("depth must be 8 (%d)", dec->depth);

    84         dec->error = TRUE;

    85       }

    86       break;

    87     case JPEG_MARKER_SOF_1:

    88       /* extended DCT */

    89       max_quant_table = 3;

    90       if (dec->depth != 8 && dec->depth != 12) {

    91         OIL_ERROR("depth must be 8 or 12 (%d)", dec->depth);

    92         dec->error = TRUE;

    93       }

    94       break;

    95     case JPEG_MARKER_SOF_2:

    96       /* progressive DCT */

    97       max_quant_table = 3;

    98       if (dec->depth != 8 && dec->depth != 12) {

    99         OIL_ERROR("depth must be 8 or 12 (%d)", dec->depth);

   100         dec->error = TRUE;

   101       }

   102       break;

   103     case JPEG_MARKER_SOF_3:

   104       /* lossless DCT */

   105       max_quant_table = 0;

   106       if (dec->depth < 2 || dec->depth > 16) {

   107         OIL_ERROR("depth must be between 2 and 16 (%d)", dec->depth);

   108         dec->error = TRUE;

   109       }

   110       break;

   111     default:

   112       break;

   113   }

   114 

   115   if (dec->n_components < 0 || dec->n_components > 255) {

   116     OIL_ERROR("n_components must be in the range 0-255 (%d)",

   117         dec->n_components);

   118     dec->error = TRUE;

   119   }

   120   if (dec->sof_type == JPEG_MARKER_SOF_2 && dec->n_components > 4) {

   121     OIL_ERROR("n_components must be <= 4 for progressive DCT (%d)",

   122         dec->n_components);

   123     dec->error = TRUE;

   124   }

   125 

   126   for (i = 0; i < dec->n_components; i++) {

   127     if (dec->components[i].id < 0 || dec->components[i].id > 255) {

   128       OIL_ERROR("component ID out of range");

   129       dec->error = TRUE;

   130       break;

   131     }

   132     if (dec->components[i].h_sample < 1 || dec->components[i].h_sample > 4 ||

   133         dec->components[i].v_sample < 1 || dec->components[i].v_sample > 4) {

   134       OIL_ERROR("sample factor(s) for component %d out of range %d %d",

   135           i, dec->components[i].h_sample, dec->components[i].v_sample);

   136       dec->error = TRUE;

   137       break;

   138     }

   139     if (dec->components[i].quant_table < 0 ||

   140         dec->components[i].quant_table > max_quant_table) {

   141       OIL_ERROR("quant table for component %d out of range (%d)",

   142           i, dec->components[i].quant_table);

   143       dec->error = TRUE;

   144       break;

   145     }

   146   }

   147 }

   148 

   149 static void

   150 jpeg_decoder_init_decoder (JpegDecoder *dec)

   151 {

   152   int max_h_sample = 0;

   153   int max_v_sample = 0;

   154   int i;

   155 

   156   /* decoder limitations */

   157   if (dec->n_components != 3) {

   158     jpeg_decoder_error(dec, "wrong number of components %d", dec->n_components);

   159     return;

   160   }

   161   if (dec->sof_type != JPEG_MARKER_SOF_0) {

   162     jpeg_decoder_error(dec, "only handle baseline DCT");

   163     return;

   164   }

   165 

   166 

   167 

   168 

   169   for (i=0; i < dec->n_components; i++) {

   170     max_h_sample = MAX (max_h_sample, dec->components[i].h_sample);

   171     max_v_sample = MAX (max_v_sample, dec->components[i].v_sample);

   172   }

   173 

   174   dec->width_blocks =

   175       (dec->width + 8 * max_h_sample - 1) / (8 * max_h_sample);

   176   dec->height_blocks =

   177       (dec->height + 8 * max_v_sample - 1) / (8 * max_v_sample);

   178   for (i = 0; i < dec->n_components; i++) {

   179     int rowstride;

   180     int image_size;

   181 

   182     dec->components[i].h_subsample = max_h_sample /

   183         dec->components[i].h_sample;

   184     dec->components[i].v_subsample = max_v_sample /

   185         dec->components[i].v_sample;

   186 

   187     rowstride = dec->width_blocks * 8 * max_h_sample /

   188         dec->components[i].h_subsample;

   189     image_size = rowstride *

   190         (dec->height_blocks * 8 * max_v_sample /

   191         dec->components[i].v_subsample);

   192     dec->components[i].rowstride = rowstride;

   193     dec->components[i].image = malloc (image_size);

   194   }

   195 }

   196 

   197 

   198 void

   199 generate_code_table (int *huffsize)

   200 {

   201   int code;

   202   int i;

   203   int j;

   204   int k;

   205   char str[33];

   206 

   207   //int l;

   208 

   209   code = 0;

   210   k = 0;

   211   for (i = 0; i < 16; i++) {

   212     for (j = 0; j < huffsize[i]; j++) {

   213       OIL_DEBUG ("huffcode[%d] = %s", k,

   214           sprintbits (str, code >> (15 - i), i + 1));

   215       code++;

   216       k++;

   217     }

   218     code <<= 1;

   219   }

   220 

   221 }

   222 

   223 int

   224 huffman_table_init_jpeg (HuffmanTable *table, JpegBits * bits)

   225 {

   226   int n_symbols;

   227   int huffsize[16];

   228   int i, j, k;

   229   unsigned int symbol;

   230   int n = 0;

   231 

   232   huffman_table_init (table);

   233 

   234   /* huffsize[i] is the number of symbols that have length

   235    * (i+1) bits.  Maximum bit length is 16 bits, so there are

   236    * 16 entries. */

   237   n_symbols = 0;

   238   for (i = 0; i < 16; i++) {

   239     huffsize[i] = jpeg_bits_get_u8 (bits);

   240     n++;

   241     n_symbols += huffsize[i];

   242   }

   243 

   244   /* Build up the symbol table.  The first symbol is all 0's, with

   245    * the number of bits determined by the first non-zero entry in

   246    * huffsize[].  Subsequent symbols with the same bit length are

   247    * incremented by 1.  Increasing the bit length shifts the

   248    * symbol 1 bit to the left. */

   249   symbol = 0;

   250   k = 0;

   251   for (i = 0; i < 16; i++) {

   252     for (j = 0; j < huffsize[i]; j++) {

   253       huffman_table_add (table, symbol, i + 1, jpeg_bits_get_u8 (bits));

   254       n++;

   255       symbol++;

   256       k++;

   257     }

   258     /* This checks that our symbol is actually less than the

   259      * number of bits we think it is.  This is only triggered

   260      * for bad huffsize[] arrays. */

   261     if (symbol >= (1 << (i + 1))) {

   262       /* FIXME jpeg_decoder_error() */

   263       OIL_DEBUG ("bad huffsize[] array");

   264       return -1;

   265     }

   266 

   267     symbol <<= 1;

   268   }

   269 

   270   huffman_table_dump (table);

   271 

   272   return n;

   273 }

   274 

   275 static void

   276 dumpbits (JpegBits * bits)

   277 {

   278   int i;

   279   int j;

   280   unsigned char *p;

   281   char s[40];

   282 

   283   p = bits->ptr;

   284   for (i = 0; i < 8; i++) {

   285     sprintf (s, "%02x %02x %02x %02x %02x %02x %02x %02x ........",

   286         p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);

   287     for (j = 0; j < 8; j++) {

   288       s[j + 24] = (isprint (p[j])) ? p[j] : '.';

   289     }

   290     OIL_DEBUG ("%s", s);

   291     p += 8;

   292   }

   293 

   294 }

   295 

   296 int

   297 jpeg_decoder_find_component_by_id (JpegDecoder * dec, int id)

   298 {

   299   int i;

   300 

   301   for (i = 0; i < dec->n_components; i++) {

   302     if (dec->components[i].id == id)

   303       return i;

   304   }

   305   OIL_DEBUG ("undefined component id %d", id);

   306   return 0;

   307 }

   308 

   309 int

   310 jpeg_decoder_application0 (JpegDecoder * dec, JpegBits * bits)

   311 {

   312   int length;

   313 

   314   OIL_DEBUG ("app0");

   315 

   316   length = get_be_u16 (bits);

   317   OIL_DEBUG ("length=%d", length);

   318 

   319   if (memcmp (bits->ptr, "JFIF", 4) == 0 && bits->ptr[4] == 0) {

   320     int version;

   321     int units;

   322     int x_density;

   323     int y_density;

   324     int x_thumbnail;

   325     int y_thumbnail;

   326 

   327     OIL_DEBUG ("JFIF");

   328     bits->ptr += 5;

   329 

   330     version = get_be_u16 (bits);

   331     units = get_u8 (bits);

   332     x_density = get_be_u16 (bits);

   333     y_density = get_be_u16 (bits);

   334     x_thumbnail = get_u8 (bits);

   335     y_thumbnail = get_u8 (bits);

   336 

   337     OIL_DEBUG ("version = %04x", version);

   338     OIL_DEBUG ("units = %d", units);

   339     OIL_DEBUG ("x_density = %d", x_density);

   340     OIL_DEBUG ("y_density = %d", y_density);

   341     OIL_DEBUG ("x_thumbnail = %d", x_thumbnail);

   342     OIL_DEBUG ("y_thumbnail = %d", y_thumbnail);

   343 

   344   }

   345 

   346   if (memcmp (bits->ptr, "JFXX", 4) == 0 && bits->ptr[4] == 0) {

   347     OIL_DEBUG ("JFIF extension (not handled)");

   348     bits->ptr += length - 2;

   349   }

   350 

   351   return length;

   352 }

   353 

   354 int

   355 jpeg_decoder_application_misc (JpegDecoder * dec, JpegBits * bits)

   356 {

   357   int length;

   358 

   359   OIL_DEBUG ("appX");

   360 

   361   length = get_be_u16 (bits);

   362   OIL_DEBUG ("length=%d", length);

   363 

   364   OIL_DEBUG ("JPEG application tag X ignored");

   365   dumpbits (bits);

   366 

   367   bits->ptr += length - 2;

   368 

   369   return length;

   370 }

   371 

   372 int

   373 jpeg_decoder_comment (JpegDecoder * dec, JpegBits * bits)

   374 {

   375   int length;

   376 

   377   OIL_DEBUG ("comment");

   378 

   379   length = get_be_u16 (bits);

   380   OIL_DEBUG ("length=%d", length);

   381 

   382   dumpbits (bits);

   383 

   384   bits->ptr += length - 2;

   385 

   386   return length;

   387 }

   388 

   389 int

   390 jpeg_decoder_restart_interval (JpegDecoder * dec, JpegBits * bits)

   391 {

   392   int length;

   393 

   394   OIL_DEBUG ("comment");

   395 

   396   length = get_be_u16 (bits);

   397   OIL_DEBUG ("length=%d", length);

   398 

   399   dec->restart_interval = get_be_u16 (bits);

   400   OIL_DEBUG ("restart_interval=%d", dec->restart_interval);

   401 

   402   return length;

   403 }

   404 

   405 int

   406 jpeg_decoder_restart (JpegDecoder * dec, JpegBits * bits)

   407 {

   408   OIL_DEBUG ("restart");

   409 

   410   return 0;

   411 }

   412 

   413 void

   414 jpeg_decoder_decode_entropy_segment (JpegDecoder * dec)

   415 {

   416   JpegBits * bits = &dec->bits;

   417   JpegBits b2, *bits2 = &b2;

   418   short block[64];

   419   short block2[64];

   420   unsigned char *newptr;

   421   int len;

   422   int j;

   423   int i;

   424   int go;

   425   int x, y;

   426   int n;

   427   int ret;

   428 

   429   len = 0;

   430   j = 0;

   431   while (1) {

   432     if (bits->ptr[len] == 0xff && bits->ptr[len + 1] != 0x00) {

   433       break;

   434     }

   435     len++;

   436   }

   437   OIL_DEBUG ("entropy length = %d", len);

   438 

   439   /* we allocate extra space, since the getbits() code can

   440    * potentially read past the end of the buffer */

   441   newptr = malloc (len + 2);

   442   for (i = 0; i < len; i++) {

   443     newptr[j] = bits->ptr[i];

   444     j++;

   445     if (bits->ptr[i] == 0xff)

   446       i++;

   447   }

   448   bits->ptr += len;

   449 

   450   bits2->ptr = newptr;

   451   bits2->idx = 0;

   452   bits2->end = newptr + j;

   453   newptr[j] = 0;

   454   newptr[j + 1] = 0;

   455 

   456   dec->dc[0] = dec->dc[1] = dec->dc[2] = dec->dc[3] = 128 * 8;

   457   go = 1;

   458   x = dec->x;

   459   y = dec->y;

   460   n = dec->restart_interval;

   461   if (n == 0) n = INT_MAX;

   462   while (n-- > 0) {

   463     for (i = 0; i < dec->scan_list_length; i++) {

   464       int dc_table_index;

   465       int ac_table_index;

   466       int quant_index;

   467       unsigned char *ptr;

   468       int component_index;

   469 

   470       OIL_DEBUG ("%d,%d: component=%d dc_table=%d ac_table=%d",

   471           x, y,

   472           dec->scan_list[i].component_index,

   473           dec->scan_list[i].dc_table, dec->scan_list[i].ac_table);

   474 

   475       component_index = dec->scan_list[i].component_index;

   476       dc_table_index = dec->scan_list[i].dc_table;

   477       ac_table_index = dec->scan_list[i].ac_table;

   478       quant_index = dec->scan_list[i].quant_table;

   479 

   480       ret = huffman_table_decode_macroblock (block,

   481           &dec->dc_huff_table[dc_table_index],

   482           &dec->ac_huff_table[ac_table_index], bits2);

   483       if (ret < 0) {

   484         OIL_DEBUG ("%d,%d: component=%d dc_table=%d ac_table=%d",

   485             x, y,

   486             dec->scan_list[i].component_index,

   487             dec->scan_list[i].dc_table, dec->scan_list[i].ac_table);

   488         n = 0;

   489         break;

   490       }

   491 

   492       OIL_DEBUG ("using quant table %d", quant_index);

   493       oil_mult8x8_s16 (block2, block, dec->quant_tables[quant_index].quantizer,

   494           sizeof (short) * 8, sizeof(short) * 8, sizeof (short) * 8);

   495       dec->dc[component_index] += block2[0];

   496       block2[0] = dec->dc[component_index];

   497       oil_unzigzag8x8_s16 (block, sizeof (short) * 8, block2,

   498           sizeof (short) * 8);

   499       oil_idct8x8_s16 (block2, sizeof (short) * 8, block, sizeof (short) * 8);

   500       oil_trans8x8_s16 (block, sizeof (short) * 8, block2, sizeof (short) * 8);

   501 

   502       ptr = dec->components[component_index].image +

   503           x * dec->components[component_index].h_sample +

   504           dec->scan_list[i].offset +

   505           dec->components[component_index].rowstride * y *

   506           dec->components[component_index].v_sample;

   507 

   508       oil_clipconv8x8_u8_s16 (ptr,

   509           dec->components[component_index].rowstride,

   510           block, sizeof (short) * 8);

   511     }

   512     x += 8;

   513     if (x * dec->scan_h_subsample >= dec->width) {

   514       x = 0;

   515       y += 8;

   516     }

   517     if (y * dec->scan_v_subsample >= dec->height) {

   518       go = 0;

   519     }

   520   }

   521   dec->x = x;

   522   dec->y = y;

   523   free (newptr);

   524 }

   525 

   526 

   527 

   528 JpegDecoder *

   529 jpeg_decoder_new (void)

   530 {

   531   JpegDecoder *dec;

   532 

   533   oil_init ();

   534 

   535   dec = malloc (sizeof(JpegDecoder));

   536   memset (dec, 0, sizeof(JpegDecoder));

   537 

   538   huffman_table_load_std_jpeg (dec);

   539 

   540   return dec;

   541 }

   542 

   543 void

   544 jpeg_decoder_free (JpegDecoder * dec)

   545 {

   546   int i;

   547 

   548   for (i = 0; i < JPEG_MAX_COMPONENTS; i++) {

   549     if (dec->components[i].image)

   550       free (dec->components[i].image);

   551   }

   552 

   553   if (dec->data)

   554     free (dec->data);

   555 

   556   free (dec);

   557 }

   558 

   559 void

   560 jpeg_decoder_error(JpegDecoder *dec, char *fmt, ...)

   561 {

   562   va_list varargs;

   563 

   564   if (dec->error) return;

   565 

   566   va_start (varargs, fmt);

   567 #if 0

   568   vasprintf(&dec->error_message, fmt, varargs);

   569 #else

   570   dec->error_message = malloc(100);

   571   vsnprintf(dec->error_message, 100, fmt, varargs);

   572 #endif

   573   va_end (varargs);

   574 

   575   OIL_ERROR("decoder error: %s", dec->error_message);

   576   abort();

   577   dec->error = TRUE;

   578 }

   579 

   580 int

   581 jpeg_decoder_get_marker (JpegDecoder *dec, int *marker)

   582 {

   583   int a,b;

   584   JpegBits *bits = &dec->bits;

   585 

   586   if (jpeg_bits_available(bits) < 2) {

   587     return FALSE;

   588   }

   589 

   590   a = jpeg_bits_get_u8(bits);

   591   if (a != 0xff) {

   592     jpeg_decoder_error(dec, "expected marker, not 0x%02x", a);

   593     return FALSE;

   594   }

   595 

   596   do {

   597     b = jpeg_bits_get_u8 (bits);

   598   } while (b == 0xff && jpeg_bits_error(bits));

   599 

   600   *marker = b;

   601   return TRUE;

   602 }

   603 

   604 void

   605 jpeg_decoder_skip (JpegDecoder *dec)

   606 {

   607   int length;

   608 

   609   length = jpeg_bits_get_u16_be (&dec->bits);

   610   jpeg_bits_skip (&dec->bits, length - 2);

   611 }

   612 

   613 int

   614 jpeg_decoder_decode (JpegDecoder *dec)

   615 {

   616   JpegBits *bits;

   617   int marker;

   618 

   619   dec->error = FALSE;

   620 

   621   bits = &dec->bits;

   622 

   623   /* Note: The spec is ambiguous as to whether fill bytes can preceed

   624    * the first marker.  We'll assume yes. */

   625   if (!jpeg_decoder_get_marker (dec, &marker)) {

   626     return FALSE;

   627   }

   628   if (marker != JPEG_MARKER_SOI) {

   629     jpeg_decoder_error(dec, "not a JPEG image");

   630     return FALSE;

   631   }

   632 

   633   /* Interpret markers up to the start of frame */

   634   while (!dec->error) {

   635     if (!jpeg_decoder_get_marker (dec, &marker)) {

   636       return FALSE;

   637     }

   638 

   639     if (marker == JPEG_MARKER_DEFINE_HUFFMAN_TABLES) {

   640       jpeg_decoder_define_huffman_tables (dec);

   641     } else if (marker == JPEG_MARKER_DEFINE_ARITHMETIC_CONDITIONING) {

   642       jpeg_decoder_define_arithmetic_conditioning (dec);

   643     } else if (marker == JPEG_MARKER_DEFINE_QUANTIZATION_TABLES) {

   644       jpeg_decoder_define_quantization_tables (dec);

   645     } else if (marker == JPEG_MARKER_DEFINE_RESTART_INTERVAL) {

   646       jpeg_decoder_define_restart_interval (dec);

   647     } else if (JPEG_MARKER_IS_APP(marker)) {

   648       /* FIXME decode app segment */

   649       jpeg_decoder_skip (dec);

   650     } else if (marker == JPEG_MARKER_COMMENT) {

   651       jpeg_decoder_skip (dec);

   652     } else if (JPEG_MARKER_IS_START_OF_FRAME(marker)) {

   653       break;

   654     } else {

   655       jpeg_decoder_error(dec, "unexpected marker 0x%02x", marker);

   656       return FALSE;

   657     }

   658   }

   659 

   660   jpeg_decoder_start_of_frame(dec, marker);

   661 

   662   jpeg_decoder_verify_header (dec);

   663   if (dec->error) {

   664     return FALSE;

   665   }

   666 

   667   jpeg_decoder_init_decoder (dec);

   668   if (dec->error) {

   669     return FALSE;

   670   }

   671 

   672   /* In this section, we loop over parse units until we reach the end

   673    * of the image. */

   674   while (!dec->error) {

   675     if (!jpeg_decoder_get_marker (dec, &marker)) {

   676       return FALSE;

   677     }

   678 

   679     if (marker == JPEG_MARKER_DEFINE_HUFFMAN_TABLES) {

   680       jpeg_decoder_define_huffman_tables (dec);

   681     } else if (marker == JPEG_MARKER_DEFINE_ARITHMETIC_CONDITIONING) {

   682       jpeg_decoder_define_arithmetic_conditioning (dec);

   683     } else if (marker == JPEG_MARKER_DEFINE_QUANTIZATION_TABLES) {

   684       jpeg_decoder_define_quantization_tables (dec);

   685     } else if (marker == JPEG_MARKER_DEFINE_RESTART_INTERVAL) {

   686       jpeg_decoder_define_restart_interval (dec);

   687     } else if (JPEG_MARKER_IS_APP(marker)) {

   688       jpeg_decoder_skip (dec);

   689     } else if (marker == JPEG_MARKER_COMMENT) {

   690       jpeg_decoder_skip (dec);

   691     } else if (marker == JPEG_MARKER_SOS) {

   692       jpeg_decoder_start_of_scan (dec);

   693       jpeg_decoder_decode_entropy_segment (dec);

   694     } else if (JPEG_MARKER_IS_RESET(marker)) {

   695       jpeg_decoder_decode_entropy_segment (dec);

   696     } else if (marker == JPEG_MARKER_EOI) {

   697       break;

   698     } else {

   699       jpeg_decoder_error(dec, "unexpected marker 0x%02x", marker);

   700       return FALSE;

   701     }

   702   }

   703 

   704   return TRUE;

   705 }

   706 

   707 /* handle markers */

   708 

   709 void

   710 jpeg_decoder_define_huffman_tables (JpegDecoder * dec)

   711 {

   712   JpegBits *bits = &dec->bits;

   713   int length;

   714   int tc;

   715   int th;

   716   int x;

   717   HuffmanTable *hufftab;

   718 

   719   OIL_DEBUG ("define huffman tables");

   720 

   721   length = jpeg_bits_get_u16_be (bits);

   722   if (length < 2) {

   723     jpeg_decoder_error(dec, "length too short");

   724     return;

   725   }

   726   length -= 2;

   727 

   728   while (length > 0) {

   729     x = jpeg_bits_get_u8 (bits);

   730     length--;

   731 

   732     tc = x >> 4;

   733     th = x & 0xf;

   734 

   735     OIL_DEBUG ("huff table type %d (%s) index %d", tc, tc ? "ac" : "dc", th);

   736     if (tc > 1 || th > 3) {

   737       jpeg_decoder_error(dec, "huffman table type or index out of range");

   738       return;

   739     }

   740 

   741     if (tc) {

   742       hufftab = &dec->ac_huff_table[th];

   743       length -= huffman_table_init_jpeg (hufftab, bits);

   744     } else {

   745       hufftab = &dec->dc_huff_table[th];

   746       length -= huffman_table_init_jpeg (hufftab, bits);

   747     }

   748   }

   749   if (length < 0) {

   750     jpeg_decoder_error(dec, "huffman table overran available bytes");

   751     return;

   752   }

   753 }

   754 

   755 void

   756 jpeg_decoder_define_quantization_tables (JpegDecoder *dec)

   757 {

   758   JpegBits *bits = &dec->bits;

   759   JpegQuantTable *table;

   760   int length;

   761   int pq;

   762   int tq;

   763   int i;

   764 

   765   OIL_INFO ("define quantization table");

   766 

   767   length = jpeg_bits_get_u16_be (bits);

   768   if (length < 2) {

   769     jpeg_decoder_error(dec, "length too short");

   770     return;

   771   }

   772   length -= 2;

   773 

   774   while (length > 0) {

   775     int x;

   776     

   777     x = jpeg_bits_get_u8 (bits);

   778     length--;

   779     pq = x >> 4;

   780     tq = x & 0xf;

   781 

   782     if (pq > 1) {

   783       jpeg_decoder_error (dec, "bad pq value");

   784       return;

   785     }

   786     if (tq > 3) {

   787       jpeg_decoder_error (dec, "bad tq value");

   788       return;

   789     }

   790 

   791     table = &dec->quant_tables[tq];

   792     if (pq) {

   793       for (i = 0; i < 64; i++) {

   794         table->quantizer[i] = jpeg_bits_get_u16_be (bits);

   795         length -= 2;

   796       }

   797     } else {

   798       for (i = 0; i < 64; i++) {

   799         table->quantizer[i] = jpeg_bits_get_u8 (bits);

   800         length -= 1;

   801       }

   802     }

   803   }

   804   if (length < 0) {

   805     jpeg_decoder_error(dec, "quantization table overran available bytes");

   806     return;

   807   }

   808 }

   809 

   810 void

   811 jpeg_decoder_define_restart_interval (JpegDecoder *dec)

   812 {

   813   JpegBits *bits = &dec->bits;

   814   int length;

   815 

   816   length = jpeg_bits_get_u16_be (bits);

   817   if (length != 4) {

   818     jpeg_decoder_error(dec, "length supposed to be 4 (%d)", length);

   819     return;

   820   }

   821 

   822   /* FIXME this needs to be checked somewhere */

   823   dec->restart_interval = jpeg_bits_get_u16_be (bits);

   824 }

   825 

   826 void

   827 jpeg_decoder_define_arithmetic_conditioning (JpegDecoder *dec)

   828 {

   829   /* we don't handle arithmetic coding, so skip it */

   830   jpeg_decoder_skip (dec);

   831 }

   832 

   833 void

   834 jpeg_decoder_start_of_frame (JpegDecoder * dec, int marker)

   835 {

   836   JpegBits *bits = &dec->bits;

   837   int i;

   838   int length;

   839 

   840   OIL_INFO ("start of frame");

   841 

   842   dec->sof_type = marker;

   843 

   844   length = jpeg_bits_get_u16_be (bits);

   845 

   846   if (jpeg_bits_available(bits) < length) {

   847     jpeg_decoder_error(dec, "not enough data for start_of_frame (%d < %d)",

   848         length, jpeg_bits_available(bits));

   849     return;

   850   }

   851 

   852   dec->depth = jpeg_bits_get_u8 (bits);

   853   dec->height = jpeg_bits_get_u16_be (bits);

   854   dec->width = jpeg_bits_get_u16_be (bits);

   855   dec->n_components = jpeg_bits_get_u8 (bits);

   856 

   857   OIL_DEBUG (

   858       "frame_length=%d depth=%d height=%d width=%d n_components=%d", length,

   859       dec->depth, dec->height, dec->width, dec->n_components);

   860 

   861   if (dec->n_components * 3 + 8 != length) {

   862     jpeg_decoder_error(dec, "inconsistent header");

   863     return;

   864   }

   865 

   866   for (i = 0; i < dec->n_components; i++) {

   867     dec->components[i].id = get_u8 (bits);

   868     dec->components[i].h_sample = getbits (bits, 4);

   869     dec->components[i].v_sample = getbits (bits, 4);

   870     dec->components[i].quant_table = get_u8 (bits);

   871 

   872     OIL_DEBUG (

   873         "[%d] id=%d h_sample=%d v_sample=%d quant_table=%d", i,

   874         dec->components[i].id, dec->components[i].h_sample,

   875         dec->components[i].v_sample, dec->components[i].quant_table);

   876   }

   877 }

   878 

   879 void

   880 jpeg_decoder_start_of_scan (JpegDecoder * dec)

   881 {

   882   JpegBits *bits = &dec->bits;

   883   int length;

   884   int i;

   885   int spectral_start;

   886   int spectral_end;

   887   int approx_high;

   888   int approx_low;

   889   int n;

   890   int tmp;

   891   int n_components;

   892 

   893   OIL_DEBUG ("start of scan");

   894 

   895   length = jpeg_bits_get_u16_be (bits);

   896   OIL_DEBUG ("length=%d", length);

   897 

   898   n_components = jpeg_bits_get_u8 (bits);

   899   n = 0;

   900   dec->scan_h_subsample = 0;

   901   dec->scan_v_subsample = 0;

   902   for (i = 0; i < n_components; i++) {

   903     int component_id;

   904     int dc_table;

   905     int ac_table;

   906     int x;

   907     int y;

   908     int index;

   909     int h_subsample;

   910     int v_subsample;

   911     int quant_index;

   912 

   913     component_id = jpeg_bits_get_u8 (bits);

   914     tmp = jpeg_bits_get_u8 (bits);

   915     dc_table = tmp >> 4;

   916     ac_table = tmp & 0xf;

   917     index = jpeg_decoder_find_component_by_id (dec, component_id);

   918 

   919     h_subsample = dec->components[index].h_sample;

   920     v_subsample = dec->components[index].v_sample;

   921     quant_index = dec->components[index].quant_table;

   922 

   923     for (y = 0; y < v_subsample; y++) {

   924       for (x = 0; x < h_subsample; x++) {

   925         dec->scan_list[n].component_index = index;

   926         dec->scan_list[n].dc_table = dc_table;

   927         dec->scan_list[n].ac_table = ac_table;

   928         dec->scan_list[n].quant_table = quant_index;

   929         dec->scan_list[n].x = x;

   930         dec->scan_list[n].y = y;

   931         dec->scan_list[n].offset =

   932             y * 8 * dec->components[index].rowstride + x * 8;

   933         n++;

   934       }

   935     }

   936 

   937     dec->scan_h_subsample = MAX (dec->scan_h_subsample, h_subsample);

   938     dec->scan_v_subsample = MAX (dec->scan_v_subsample, v_subsample);

   939 

   940     OIL_DEBUG ("component %d: index=%d dc_table=%d ac_table=%d n=%d",

   941         component_id, index, dc_table, ac_table, n);

   942   }

   943   dec->scan_list_length = n;

   944 

   945   spectral_start = jpeg_bits_get_u8 (bits);

   946   spectral_end = jpeg_bits_get_u8 (bits);

   947   OIL_DEBUG ("spectral range [%d,%d]", spectral_start, spectral_end);

   948   tmp = jpeg_bits_get_u8 (bits);

   949   approx_high = tmp >> 4;

   950   approx_low = tmp & 0xf;

   951   OIL_DEBUG ("approx range [%d,%d]", approx_low, approx_high);

   952 

   953   dec->x = 0;

   954   dec->y = 0;

   955   dec->dc[0] = dec->dc[1] = dec->dc[2] = dec->dc[3] = 128 * 8;

   956 }

   957 

   958 

   959 

   960 

   961 

   962 

   963 

   964 

   965 

   966 

   967 

   968 

   969 int

   970 jpeg_decoder_addbits (JpegDecoder * dec, unsigned char *data, unsigned int len)

   971 {

   972   unsigned int offset;

   973 

   974   offset = dec->bits.ptr - dec->data;

   975 

   976   dec->data = realloc (dec->data, dec->data_len + len);

   977   memcpy (dec->data + dec->data_len, data, len);

   978   dec->data_len += len;

   979 

   980   dec->bits.ptr = dec->data + offset;

   981   dec->bits.end = dec->data + dec->data_len;

   982 

   983   return 0;

   984 }

   985 

   986 int

   987 jpeg_decoder_get_image_size (JpegDecoder * dec, int *width, int *height)

   988 {

   989   if (width)

   990     *width = dec->width;

   991   if (height)

   992     *height = dec->height;

   993 

   994   return 0;

   995 }

   996 

   997 int

   998 jpeg_decoder_get_component_ptr (JpegDecoder * dec, int id,

   999     unsigned char **image, int *rowstride)

  1000 {

  1001   int i;

  1002 

  1003   i = jpeg_decoder_find_component_by_id (dec, id);

  1004   if (image)

  1005     *image = dec->components[i].image;

  1006   if (rowstride)

  1007     *rowstride = dec->components[i].rowstride;

  1008 

  1009   return 0;

  1010 }

  1011 

  1012 int

  1013 jpeg_decoder_get_component_size (JpegDecoder * dec, int id,

  1014     int *width, int *height)

  1015 {

  1016   int i;

  1017 

  1018   /* subsampling sizes are rounded up */

  1019 

  1020   i = jpeg_decoder_find_component_by_id (dec, id);

  1021   if (width)

  1022     *width = (dec->width - 1) / dec->components[i].h_subsample + 1;

  1023   if (height)

  1024     *height = (dec->height - 1) / dec->components[i].v_subsample + 1;

  1025 

  1026   return 0;

  1027 }

  1028 

  1029 int

  1030 jpeg_decoder_get_component_subsampling (JpegDecoder * dec, int id,

  1031     int *h_subsample, int *v_subsample)

  1032 {

  1033   int i;

  1034 

  1035   i = jpeg_decoder_find_component_by_id (dec, id);

  1036   if (h_subsample)

  1037     *h_subsample = dec->components[i].h_subsample;

  1038   if (v_subsample)

  1039     *v_subsample = dec->components[i].v_subsample;

  1040 

  1041   return 0;

  1042 }

  1043 

  1044 #if 0

  1045 int

  1046 jpeg_decoder_parse (JpegDecoder * dec)

  1047 {

  1048   JpegBits *bits = &dec->bits;

  1049   JpegBits b2;

  1050   unsigned int x;

  1051   unsigned int tag;

  1052   int i;

  1053 

  1054   while (bits->ptr < bits->end) {

  1055     x = get_u8 (bits);

  1056     if (x != 0xff) {

  1057       int n = 0;

  1058 

  1059       while (x != 0xff) {

  1060         x = get_u8 (bits);

  1061         n++;

  1062       }

  1063       OIL_DEBUG ("lost sync, skipped %d bytes", n);

  1064     }

  1065     while (x == 0xff) {

  1066       x = get_u8 (bits);

  1067     }

  1068     tag = x;

  1069     OIL_DEBUG ("tag %02x", tag);

  1070 

  1071     b2 = *bits;

  1072 

  1073     for (i = 0; i < n_jpeg_markers - 1; i++) {

  1074       if (tag == jpeg_markers[i].tag) {

  1075         break;

  1076       }

  1077     }

  1078     OIL_DEBUG ("tag: %s", jpeg_markers[i].name);

  1079     if (jpeg_markers[i].func) {

  1080       jpeg_markers[i].func (dec, &b2);

  1081     } else {

  1082       OIL_DEBUG ("unhandled or illegal JPEG marker (0x%02x)", tag);

  1083       dumpbits (&b2);

  1084     }

  1085     if (jpeg_markers[i].flags & JPEG_ENTROPY_SEGMENT) {

  1086       jpeg_decoder_decode_entropy_segment (dec, &b2);

  1087     }

  1088     syncbits (&b2);

  1089     bits->ptr = b2.ptr;

  1090   }

  1091 

  1092   return 0;

  1093 }

  1094 #endif

  1095 

  1096 

  1097 /* misc helper functins */

  1098 

  1099 static char *

  1100 sprintbits (char *str, unsigned int bits, int n)

  1101 {

  1102   int i;

  1103   int bit = 1 << (n - 1);

  1104 

  1105   for (i = 0; i < n; i++) {

  1106     str[i] = (bits & bit) ? '1' : '0';

  1107     bit >>= 1;

  1108   }

  1109   str[i] = 0;

  1110 

  1111   return str;

  1112 }

  1113 

  1114 static void

  1115 huffman_table_load_std_jpeg (JpegDecoder * dec)

  1116 {

  1117   JpegBits b, *bits = &b;

  1118 

  1119   bits->ptr = jpeg_standard_tables;

  1120   bits->idx = 0;

  1121   bits->end = jpeg_standard_tables + jpeg_standard_tables_size;

  1122 

  1123   huffman_table_init_jpeg (&dec->dc_huff_table[0], bits);

  1124   huffman_table_init_jpeg (&dec->ac_huff_table[0], bits);

  1125   huffman_table_init_jpeg (&dec->dc_huff_table[1], bits);

  1126   huffman_table_init_jpeg (&dec->ac_huff_table[1], bits);

  1127 }

  1128 

  1129 

  1130