home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / include / jlib / jdmarker.cpp < prev    next >
C/C++ Source or Header  |  2000-05-16  |  44KB  |  1,577 lines
  1. //-------------------------------------------------------------------------//
  2. //          Windows Graphics Programming: Win32 GDI and DirectDraw         //
  3. //                        ISBN  0-13-086985-6                              //
  4. //                                                                         //
  5. //  Modified by: Yuan, Feng                             www.fengyuan.com   //
  6. //  Changes    : C++, exception, in-memory source, BGR byte order          //
  7. //  Version    : 1.00.000, May 31, 2000                                    //
  8. //-------------------------------------------------------------------------//
  9.  
  10. /*
  11.  * jdmarker.c
  12.  *
  13.  * Copyright (C) 1991-1998, Thomas G. Lane.
  14.  * This file is part of the Independent JPEG Group's software.
  15.  * For conditions of distribution and use, see the accompanying README file.
  16.  *
  17.  * This file contains routines to decode JPEG datastream markers.
  18.  * Most of the complexity arises from our desire to support input
  19.  * suspension: if not all of the data for a marker is available,
  20.  * we must exit back to the application.  On resumption, we reprocess
  21.  * the marker.
  22.  */
  23.  
  24. #define JPEG_INTERNALS
  25. #include "jinclude.h"
  26. #include "jpeglib.h"
  27.  
  28.  
  29. typedef enum {            /* JPEG marker codes */
  30.   M_SOF0  = 0xc0,
  31.   M_SOF1  = 0xc1,
  32.   M_SOF2  = 0xc2,
  33.   M_SOF3  = 0xc3,
  34.   
  35.   M_SOF5  = 0xc5,
  36.   M_SOF6  = 0xc6,
  37.   M_SOF7  = 0xc7,
  38.   
  39.   M_JPG   = 0xc8,
  40.   M_SOF9  = 0xc9,
  41.   M_SOF10 = 0xca,
  42.   M_SOF11 = 0xcb,
  43.   
  44.   M_SOF13 = 0xcd,
  45.   M_SOF14 = 0xce,
  46.   M_SOF15 = 0xcf,
  47.   
  48.   M_DHT   = 0xc4,
  49.   
  50.   M_DAC   = 0xcc,
  51.   
  52.   M_RST0  = 0xd0,
  53.   M_RST1  = 0xd1,
  54.   M_RST2  = 0xd2,
  55.   M_RST3  = 0xd3,
  56.   M_RST4  = 0xd4,
  57.   M_RST5  = 0xd5,
  58.   M_RST6  = 0xd6,
  59.   M_RST7  = 0xd7,
  60.   
  61.   M_SOI   = 0xd8,
  62.   M_EOI   = 0xd9,
  63.   M_SOS   = 0xda,
  64.   M_DQT   = 0xdb,
  65.   M_DNL   = 0xdc,
  66.   M_DRI   = 0xdd,
  67.   M_DHP   = 0xde,
  68.   M_EXP   = 0xdf,
  69.   
  70.   M_APP0  = 0xe0,
  71.   M_APP1  = 0xe1,
  72.   M_APP2  = 0xe2,
  73.   M_APP3  = 0xe3,
  74.   M_APP4  = 0xe4,
  75.   M_APP5  = 0xe5,
  76.   M_APP6  = 0xe6,
  77.   M_APP7  = 0xe7,
  78.   M_APP8  = 0xe8,
  79.   M_APP9  = 0xe9,
  80.   M_APP10 = 0xea,
  81.   M_APP11 = 0xeb,
  82.   M_APP12 = 0xec,
  83.   M_APP13 = 0xed,
  84.   M_APP14 = 0xee,
  85.   M_APP15 = 0xef,
  86.   
  87.   M_JPG0  = 0xf0,
  88.   M_JPG13 = 0xfd,
  89.   M_COM   = 0xfe,
  90.   
  91.   M_TEM   = 0x01,
  92.   
  93.   M_ERROR = 0x100
  94. } JPEG_MARKER;
  95.  
  96.  
  97. /* Private state */
  98.  
  99. typedef struct {
  100.   struct jpeg_marker_reader pub; /* public fields */
  101.  
  102.   /* Application-overridable marker processing methods */
  103.   jpeg_marker_parser_method process_COM;
  104.   jpeg_marker_parser_method process_APPn[16];
  105.  
  106.   /* Limit on marker data length to save for each marker type */
  107.   unsigned int length_limit_COM;
  108.   unsigned int length_limit_APPn[16];
  109.  
  110.   /* Status of COM/APPn marker saving */
  111.   jpeg_saved_marker_ptr cur_marker;    /* NULL if not processing a marker */
  112.   unsigned int bytes_read;        /* data bytes read so far in marker */
  113.   /* Note: cur_marker is not linked into marker_list until it's all read. */
  114. } my_marker_reader;
  115.  
  116. typedef my_marker_reader * my_marker_ptr;
  117.  
  118.  
  119. /*
  120.  * Macros for fetching data from the data source module.
  121.  *
  122.  * At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect
  123.  * the current restart point; we update them only when we have reached a
  124.  * suitable place to restart if a suspension occurs.
  125.  */
  126.  
  127. /* Declare and initialize local copies of input pointer/count */
  128. class KInput
  129. {
  130.     jpeg_source_mgr * datasrc;
  131.  
  132. public:
  133.  
  134.     const JOCTET    * next_input_byte;
  135.     size_t              bytes_in_buffer;
  136.  
  137.     KInput(j_decompress_ptr cinfo)
  138.     {
  139.         datasrc            = cinfo->src;
  140.         next_input_byte = datasrc->next_input_byte;
  141.         bytes_in_buffer = datasrc->bytes_in_buffer;
  142.     }
  143.  
  144.     /* Unload the local copies --- do this only at a restart boundary */
  145.     void INPUT_SYNC(j_decompress_ptr cinfo)
  146.     { 
  147.         datasrc->next_input_byte = next_input_byte;
  148.         datasrc->bytes_in_buffer = bytes_in_buffer;
  149.     }
  150.  
  151.     /* Reload the local copies --- used only in MAKE_BYTE_AVAIL */
  152.     void INPUT_RELOAD(j_decompress_ptr cinfo)
  153.     { 
  154.         next_input_byte = datasrc->next_input_byte;
  155.         bytes_in_buffer = datasrc->bytes_in_buffer;
  156.     }
  157.  
  158.     /* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available.
  159.     * Note we do *not* do INPUT_SYNC before calling fill_input_buffer,
  160.     * but we must reload the local copies after a successful fill.
  161.     */
  162.     boolean MAKE_BYTE_AVAIL(j_decompress_ptr cinfo)
  163.     {
  164.         if ( bytes_in_buffer == 0 )
  165.         {
  166.             if ( ! datasrc->fill_input_buffer(cinfo) )
  167.                 return FALSE;
  168.         
  169.             INPUT_RELOAD(cinfo);
  170.         }
  171.  
  172.         return TRUE;
  173.     }
  174.  
  175.     /* Read a byte into variable V.
  176.     * If must suspend, take the specified action (typically "return FALSE").
  177.     */
  178.     boolean INPUT_BYTE(j_decompress_ptr cinfo, int & V)
  179.     {
  180.         if ( ! MAKE_BYTE_AVAIL(cinfo) )
  181.             return FALSE;
  182.  
  183.         bytes_in_buffer--;
  184.         V = (unsigned char) GETJOCTET(*next_input_byte++);
  185.     
  186.         return TRUE;
  187.     }
  188.  
  189.     boolean INPUT_BYTE(j_decompress_ptr cinfo, unsigned char & V)
  190.     {
  191.         if ( ! MAKE_BYTE_AVAIL(cinfo) )
  192.             return FALSE;
  193.  
  194.         bytes_in_buffer--;
  195.         V = GETJOCTET(*next_input_byte++);
  196.     
  197.         return TRUE;
  198.     }
  199.  
  200.     /* As above, but read two bytes interpreted as an unsigned 16-bit integer.
  201.     * V should be declared unsigned int or perhaps long.
  202.     */
  203.     boolean INPUT_2BYTES(j_decompress_ptr cinfo, long & V)
  204.     {
  205.         if ( ! MAKE_BYTE_AVAIL(cinfo) )
  206.             return FALSE;
  207.  
  208.         bytes_in_buffer--;
  209.         V = ((unsigned char) GETJOCTET(*next_input_byte++)) << 8;
  210.  
  211.         if ( ! MAKE_BYTE_AVAIL(cinfo) )
  212.             return FALSE;
  213.  
  214.         bytes_in_buffer--;
  215.         V |= (unsigned char) GETJOCTET(*next_input_byte++);
  216.  
  217.         return TRUE;
  218.     }
  219.  
  220.     boolean INPUT_2BYTES(j_decompress_ptr cinfo, unsigned int & V)
  221.     {
  222.         if ( ! MAKE_BYTE_AVAIL(cinfo) )
  223.             return FALSE;
  224.  
  225.         bytes_in_buffer--;
  226.         V = ((unsigned char) GETJOCTET(*next_input_byte++)) << 8;
  227.  
  228.         if ( ! MAKE_BYTE_AVAIL(cinfo) )
  229.             return FALSE;
  230.  
  231.         bytes_in_buffer--;
  232.         V |= (unsigned char) GETJOCTET(*next_input_byte++);
  233.  
  234.         return TRUE;
  235.     }
  236.  
  237.     boolean INPUT_2BYTES(j_decompress_ptr cinfo, int & V)
  238.     {
  239.         if ( ! MAKE_BYTE_AVAIL(cinfo) )
  240.             return FALSE;
  241.  
  242.         bytes_in_buffer--;
  243.         V = ((unsigned char) GETJOCTET(*next_input_byte++)) << 8;
  244.  
  245.         if ( ! MAKE_BYTE_AVAIL(cinfo) )
  246.             return FALSE;
  247.  
  248.         bytes_in_buffer--;
  249.         V |= (unsigned char) GETJOCTET(*next_input_byte++);
  250.  
  251.         return TRUE;
  252.     }
  253.  
  254. };
  255.  
  256. /*
  257.  * Routines to process JPEG markers.
  258.  *
  259.  * Entry condition: JPEG marker itself has been read and its code saved
  260.  *   in cinfo->unread_marker; input restart point is just after the marker.
  261.  *
  262.  * Exit: if return TRUE, have read and processed any parameters, and have
  263.  *   updated the restart point to point after the parameters.
  264.  *   If return FALSE, was forced to suspend before reaching end of
  265.  *   marker parameters; restart point has not been moved.  Same routine
  266.  *   will be called again after application supplies more input data.
  267.  *
  268.  * This approach to suspension assumes that all of a marker's parameters
  269.  * can fit into a single input bufferload.  This should hold for "normal"
  270.  * markers.  Some COM/APPn markers might have large parameter segments
  271.  * that might not fit.  If we are simply dropping such a marker, we use
  272.  * skip_input_data to get past it, and thereby put the problem on the
  273.  * source manager's shoulders.  If we are saving the marker's contents
  274.  * into memory, we use a slightly different convention: when forced to
  275.  * suspend, the marker processor updates the restart point to the end of
  276.  * what it's consumed (ie, the end of the buffer) before returning FALSE.
  277.  * On resumption, cinfo->unread_marker still contains the marker code,
  278.  * but the data source will point to the next chunk of marker data.
  279.  * The marker processor must retain internal state to deal with this.
  280.  *
  281.  * Note that we don't bother to avoid duplicate trace messages if a
  282.  * suspension occurs within marker parameters.  Other side effects
  283.  * require more care.
  284.  */
  285.  
  286.  
  287. LOCAL(boolean)
  288. get_soi (j_decompress_ptr cinfo)
  289. /* Process an SOI marker */
  290. {
  291.   int i;
  292.   
  293.   TRACEMS(cinfo, 1, JTRC_SOI);
  294.  
  295.   if (cinfo->marker->saw_SOI)
  296.     cinfo->ERREXIT(JERR_SOI_DUPLICATE);
  297.  
  298.   /* Reset all parameters that are defined to be reset by SOI */
  299.  
  300.   for (i = 0; i < NUM_ARITH_TBLS; i++) {
  301.     cinfo->arith_dc_L[i] = 0;
  302.     cinfo->arith_dc_U[i] = 1;
  303.     cinfo->arith_ac_K[i] = 5;
  304.   }
  305.   cinfo->restart_interval = 0;
  306.  
  307.   /* Set initial assumptions for colorspace etc */
  308.  
  309.   cinfo->jpeg_color_space = JCS_UNKNOWN;
  310.   cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling??? */
  311.  
  312.   cinfo->saw_JFIF_marker = FALSE;
  313.   cinfo->JFIF_major_version = 1; /* set default JFIF APP0 values */
  314.   cinfo->JFIF_minor_version = 1;
  315.   cinfo->density_unit = 0;
  316.   cinfo->X_density = 1;
  317.   cinfo->Y_density = 1;
  318.   cinfo->saw_Adobe_marker = FALSE;
  319.   cinfo->Adobe_transform = 0;
  320.  
  321.   cinfo->marker->saw_SOI = TRUE;
  322.  
  323.   return TRUE;
  324. }
  325.  
  326.  
  327. LOCAL(boolean)
  328. get_sof (j_decompress_ptr cinfo, boolean is_prog, boolean is_arith)
  329. /* Process a SOFn marker */
  330. {
  331.     long length;
  332.     int c, ci;
  333.     jpeg_component_info * compptr;
  334.     
  335.     KInput input(cinfo);
  336.  
  337.     cinfo->progressive_mode = is_prog;
  338.     cinfo->arith_code = is_arith;
  339.  
  340.     if ( ! input.INPUT_2BYTES(cinfo, length) )
  341.         return FALSE;
  342.  
  343.     if ( ! input.INPUT_BYTE(cinfo, cinfo->data_precision) )
  344.         return FALSE;
  345.   
  346.     if ( ! input.INPUT_2BYTES(cinfo, cinfo->image_height) )
  347.         return FALSE;
  348.   
  349.     if ( ! input.INPUT_2BYTES(cinfo, cinfo->image_width) )
  350.         return FALSE;
  351.   
  352.     if ( ! input.INPUT_BYTE(cinfo, cinfo->num_components) )
  353.         return FALSE;
  354.  
  355.     length -= 8;
  356.  
  357.     TRACEMS4(cinfo, 1, JTRC_SOF, cinfo->unread_marker,
  358.        (int) cinfo->image_width, (int) cinfo->image_height,
  359.        cinfo->num_components);
  360.  
  361.     if (cinfo->marker->saw_SOF)
  362.         cinfo->ERREXIT(JERR_SOF_DUPLICATE);
  363.  
  364.     /* We don't support files in which the image height is initially specified */
  365.     /* as 0 and is later redefined by DNL.  As long as we have to check that,  */
  366.     /* might as well have a general sanity check. */
  367.     if (cinfo->image_height <= 0 || cinfo->image_width <= 0 || cinfo->num_components <= 0)
  368.         cinfo->ERREXIT(JERR_EMPTY_IMAGE);
  369.  
  370.     if (length != (cinfo->num_components * 3))
  371.         cinfo->ERREXIT(JERR_BAD_LENGTH);
  372.  
  373.     if (cinfo->comp_info == NULL)    /* do only once, even if suspend */
  374.         cinfo->comp_info = (jpeg_component_info *) cinfo->mem->alloc_small
  375.             (JPOOL_IMAGE,
  376.              cinfo->num_components * sizeof(jpeg_component_info));
  377.   
  378.     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) 
  379.     {
  380.         compptr->component_index = ci;
  381.         
  382.         if ( ! input.INPUT_BYTE(cinfo, compptr->component_id) )
  383.             return FALSE;
  384.         
  385.         if ( ! input.INPUT_BYTE(cinfo, c) )
  386.             return FALSE;
  387.         
  388.         compptr->h_samp_factor = (c >> 4) & 15;
  389.         compptr->v_samp_factor = (c     ) & 15;
  390.         
  391.         if ( ! input.INPUT_BYTE(cinfo, compptr->quant_tbl_no) )
  392.             return FALSE;
  393.  
  394.         TRACEMS4(cinfo, 1, JTRC_SOF_COMPONENT,
  395.             compptr->component_id, compptr->h_samp_factor,
  396.             compptr->v_samp_factor, compptr->quant_tbl_no);
  397.     }
  398.  
  399.     cinfo->marker->saw_SOF = TRUE;
  400.  
  401.     input.INPUT_SYNC(cinfo);
  402.     
  403.     return TRUE;
  404. }
  405.  
  406.  
  407. LOCAL(boolean) get_sos (j_decompress_ptr cinfo)
  408. /* Process a SOS marker */
  409. {
  410.     long length;
  411.     int i, ci, n, c, cc;
  412.     jpeg_component_info * compptr;
  413.     
  414.     KInput input(cinfo);
  415.  
  416.     if (! cinfo->marker->saw_SOF)
  417.         cinfo->ERREXIT(JERR_SOS_NO_SOF);
  418.  
  419.     if ( ! input.INPUT_2BYTES(cinfo, length) )
  420.         return FALSE;
  421.  
  422.     if ( ! input.INPUT_BYTE(cinfo, n) )
  423.         return FALSE; /* Number of components */
  424.  
  425.     TRACEMS1(cinfo, 1, JTRC_SOS, n);
  426.  
  427.     if (length != (n * 2 + 6) || n < 1 || n > MAX_COMPS_IN_SCAN)
  428.         cinfo->ERREXIT(JERR_BAD_LENGTH);
  429.  
  430.     cinfo->comps_in_scan = n;
  431.  
  432.     /* Collect the component-spec parameters */
  433.  
  434.     for (i = 0; i < n; i++) 
  435.     {
  436.         if ( ! input.INPUT_BYTE(cinfo, cc) )
  437.             return FALSE;
  438.         
  439.         if ( ! input.INPUT_BYTE(cinfo, c) )
  440.             return FALSE;
  441.     
  442.         for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; ci++, compptr++) 
  443.         {
  444.             if (cc == compptr->component_id)
  445.                 goto id_found;
  446.         }
  447.  
  448.         cinfo->ERREXIT1(JERR_BAD_COMPONENT_ID, cc);
  449.  
  450.   id_found:
  451.  
  452.         cinfo->cur_comp_info[i] = compptr;
  453.         compptr->dc_tbl_no = (c >> 4) & 15;
  454.         compptr->ac_tbl_no = (c     ) & 15;
  455.     
  456.         TRACEMS3(cinfo, 1, JTRC_SOS_COMPONENT, cc,
  457.             compptr->dc_tbl_no, compptr->ac_tbl_no);
  458.     }
  459.  
  460.     /* Collect the additional scan parameters Ss, Se, Ah/Al. */
  461.     if ( ! input.INPUT_BYTE(cinfo, c) )
  462.         return FALSE;
  463.     cinfo->Ss = c;
  464.     
  465.     if ( ! input.INPUT_BYTE(cinfo, c) )
  466.         return FALSE;
  467.     cinfo->Se = c;
  468.     
  469.     if ( ! input.INPUT_BYTE(cinfo, c) )
  470.         return FALSE;
  471.     cinfo->Ah = (c >> 4) & 15;
  472.     cinfo->Al = (c     ) & 15;
  473.  
  474.     TRACEMS4(cinfo, 1, JTRC_SOS_PARAMS, cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
  475.  
  476.     /* Prepare to scan data & restart markers */
  477.     cinfo->marker->next_restart_num = 0;
  478.  
  479.     /* Count another SOS marker */
  480.     cinfo->input_scan_number++;
  481.  
  482.     input.INPUT_SYNC(cinfo);
  483.   
  484.     return TRUE;
  485. }
  486.  
  487.  
  488. #ifdef D_ARITH_CODING_SUPPORTED
  489.  
  490. LOCAL(boolean)
  491. get_dac (j_decompress_ptr cinfo)
  492. /* Process a DAC marker */
  493. {
  494.   long length;
  495.   int index, val;
  496.   INPUT_VARS(cinfo);
  497.  
  498.   INPUT_2BYTES(cinfo, length, return FALSE);
  499.   length -= 2;
  500.   
  501.   while (length > 0) {
  502.     INPUT_BYTE(cinfo, index, return FALSE);
  503.     INPUT_BYTE(cinfo, val, return FALSE);
  504.  
  505.     length -= 2;
  506.  
  507.     TRACEMS2(cinfo, 1, JTRC_DAC, index, val);
  508.  
  509.     if (index < 0 || index >= (2*NUM_ARITH_TBLS))
  510.       cinfo->ERREXIT1(JERR_DAC_INDEX, index);
  511.  
  512.     if (index >= NUM_ARITH_TBLS) { /* define AC table */
  513.       cinfo->arith_ac_K[index-NUM_ARITH_TBLS] = (UINT8) val;
  514.     } else {            /* define DC table */
  515.       cinfo->arith_dc_L[index] = (UINT8) (val & 0x0F);
  516.       cinfo->arith_dc_U[index] = (UINT8) (val >> 4);
  517.       if (cinfo->arith_dc_L[index] > cinfo->arith_dc_U[index])
  518.     cinfo->ERREXIT1(JERR_DAC_VALUE, val);
  519.     }
  520.   }
  521.  
  522.   if (length != 0)
  523.     cinfo->ERREXIT(JERR_BAD_LENGTH);
  524.  
  525.   INPUT_SYNC(cinfo);
  526.   return TRUE;
  527. }
  528.  
  529. #else /* ! D_ARITH_CODING_SUPPORTED */
  530.  
  531. #define get_dac(cinfo)  skip_variable(cinfo)
  532.  
  533. #endif /* D_ARITH_CODING_SUPPORTED */
  534.  
  535.  
  536. LOCAL(boolean) get_dht (j_decompress_ptr cinfo)
  537. /* Process a DHT marker */
  538. {
  539.     long length;
  540.     UINT8 bits[17];
  541.     UINT8 huffval[256];
  542.     int i, index, count;
  543.     JHUFF_TBL **htblptr;
  544.   
  545.     KInput input(cinfo);
  546.  
  547.     if ( ! input.INPUT_2BYTES(cinfo, length) )
  548.         return FALSE;
  549.   
  550.     length -= 2;
  551.   
  552.     while (length > 16) 
  553.     {
  554.         if ( ! input.INPUT_BYTE(cinfo, index) )
  555.             return FALSE;
  556.  
  557.         TRACEMS1(cinfo, 1, JTRC_DHT, index);
  558.       
  559.         bits[0] = 0;
  560.         count = 0;
  561.         for (i = 1; i <= 16; i++) 
  562.         {
  563.             if ( ! input.INPUT_BYTE(cinfo, bits[i]) )
  564.                 return FALSE;
  565.       
  566.             count += bits[i];
  567.         }
  568.  
  569.         length -= 1 + 16;
  570.  
  571.         TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
  572.             bits[1], bits[2], bits[3], bits[4],
  573.             bits[5], bits[6], bits[7], bits[8]);
  574.         TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
  575.             bits[9], bits[10], bits[11], bits[12],
  576.             bits[13], bits[14], bits[15], bits[16]);
  577.  
  578.         /* Here we just do minimal validation of the counts to avoid walking
  579.         * off the end of our table space.  jdhuff.c will check more carefully.
  580.         */
  581.         if (count > 256 || ((long) count) > length)
  582.             cinfo->ERREXIT(JERR_BAD_HUFF_TABLE);
  583.  
  584.         for (i = 0; i < count; i++)
  585.             if ( ! input.INPUT_BYTE(cinfo, huffval[i]) )
  586.                 return FALSE;
  587.  
  588.         length -= count;
  589.  
  590.         if (index & 0x10)         /* AC table definition */
  591.         {
  592.             index -= 0x10;
  593.             htblptr = &cinfo->ac_huff_tbl_ptrs[index];
  594.         } 
  595.         else             /* DC table definition */
  596.         {
  597.             htblptr = &cinfo->dc_huff_tbl_ptrs[index];
  598.         }
  599.  
  600.         if (index < 0 || index >= NUM_HUFF_TBLS)
  601.             cinfo->ERREXIT1(JERR_DHT_INDEX, index);
  602.  
  603.         if (*htblptr == NULL)
  604.             *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
  605.   
  606.         memcpy((*htblptr)->bits, bits, sizeof((*htblptr)->bits));
  607.         memcpy((*htblptr)->huffval, huffval, sizeof((*htblptr)->huffval));
  608.     }
  609.  
  610.     if (length != 0)
  611.         cinfo->ERREXIT(JERR_BAD_LENGTH);
  612.  
  613.     input.INPUT_SYNC(cinfo);
  614.     
  615.     return TRUE;
  616. }
  617.  
  618.  
  619. LOCAL(boolean) get_dqt (j_decompress_ptr cinfo)
  620. /* Process a DQT marker */
  621. {
  622.     long length;
  623.     int n, i, prec;
  624.     int tmp;
  625.     JQUANT_TBL *quant_ptr;
  626.     
  627.     KInput input(cinfo);
  628.  
  629.     if ( ! input.INPUT_2BYTES(cinfo, length) )
  630.         return FALSE;
  631.     length -= 2;
  632.  
  633.     while (length > 0) 
  634.     {
  635.         if ( ! input.INPUT_BYTE(cinfo, n) )
  636.             return FALSE;
  637.     
  638.         prec = n >> 4;
  639.         n &= 0x0F;
  640.  
  641.         TRACEMS2(cinfo, 1, JTRC_DQT, n, prec);
  642.  
  643.         if (n >= NUM_QUANT_TBLS)
  644.             cinfo->ERREXIT1(JERR_DQT_INDEX, n);
  645.       
  646.         if (cinfo->quant_tbl_ptrs[n] == NULL)
  647.             cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) cinfo);
  648.             quant_ptr = cinfo->quant_tbl_ptrs[n];
  649.  
  650.         for (i = 0; i < DCTSIZE2; i++) 
  651.         {
  652.             if (prec)
  653.             {
  654.                 if ( ! input.INPUT_2BYTES(cinfo, tmp) )
  655.                     return FALSE;
  656.             }
  657.             else
  658.             {
  659.                 if ( ! input.INPUT_BYTE(cinfo, tmp) )
  660.                     return FALSE;
  661.             }
  662.       
  663.             /* We convert the zigzag-order table to natural array order. */
  664.             quant_ptr->quantval[jpeg_natural_order[i]] = (UINT16) tmp;
  665.         }
  666.  
  667.         if (cinfo->err->trace_level >= 2) 
  668.         {
  669.             for (i = 0; i < DCTSIZE2; i += 8) 
  670.             {
  671.                 TRACEMS8(cinfo, 2, JTRC_QUANTVALS,
  672.                     quant_ptr->quantval[i],   quant_ptr->quantval[i+1],
  673.                     quant_ptr->quantval[i+2], quant_ptr->quantval[i+3],
  674.                     quant_ptr->quantval[i+4], quant_ptr->quantval[i+5],
  675.                     quant_ptr->quantval[i+6], quant_ptr->quantval[i+7]);
  676.             }
  677.         }
  678.  
  679.         length -= DCTSIZE2+1;
  680.         if (prec) length -= DCTSIZE2;
  681.     }
  682.  
  683.     if (length != 0)
  684.         cinfo->ERREXIT(JERR_BAD_LENGTH);
  685.  
  686.     input.INPUT_SYNC(cinfo);
  687.     
  688.     return TRUE;
  689. }
  690.  
  691.  
  692. LOCAL(boolean) get_dri (j_decompress_ptr cinfo)
  693. /* Process a DRI marker */
  694. {
  695.     long length;
  696.     unsigned int tmp;
  697.     
  698.     KInput input(cinfo);
  699.  
  700.     if ( ! input.INPUT_2BYTES(cinfo, length) )
  701.         return FALSE;
  702.   
  703.     if (length != 4)
  704.         cinfo->ERREXIT(JERR_BAD_LENGTH);
  705.  
  706.     if ( ! input.INPUT_2BYTES(cinfo, tmp) )
  707.         return FALSE;
  708.  
  709.     TRACEMS1(cinfo, 1, JTRC_DRI, tmp);
  710.  
  711.     cinfo->restart_interval = tmp;
  712.  
  713.     input.INPUT_SYNC(cinfo);
  714.     
  715.     return TRUE;
  716. }
  717.  
  718.  
  719. /*
  720.  * Routines for processing APPn and COM markers.
  721.  * These are either saved in memory or discarded, per application request.
  722.  * APP0 and APP14 are specially checked to see if they are
  723.  * JFIF and Adobe markers, respectively.
  724.  */
  725.  
  726. #define APP0_DATA_LEN    14    /* Length of interesting data in APP0 */
  727. #define APP14_DATA_LEN    12    /* Length of interesting data in APP14 */
  728. #define APPN_DATA_LEN    14    /* Must be the largest of the above!! */
  729.  
  730.  
  731. LOCAL(void)
  732. examine_app0 (j_decompress_ptr cinfo, JOCTET * data, unsigned int datalen, long remaining)
  733. /* Examine first few bytes from an APP0.
  734.  * Take appropriate action if it is a JFIF marker.
  735.  * datalen is # of bytes at data[], remaining is length of rest of marker data.
  736.  */
  737. {
  738.     long totallen = (long) datalen + remaining;
  739.  
  740.     if (datalen >= APP0_DATA_LEN &&
  741.         GETJOCTET(data[0]) == 0x4A &&
  742.         GETJOCTET(data[1]) == 0x46 &&
  743.         GETJOCTET(data[2]) == 0x49 &&
  744.         GETJOCTET(data[3]) == 0x46 &&
  745.         GETJOCTET(data[4]) == 0) 
  746.     {
  747.         /* Found JFIF APP0 marker: save info */
  748.         cinfo->saw_JFIF_marker = TRUE;
  749.         cinfo->JFIF_major_version = GETJOCTET(data[5]);
  750.         cinfo->JFIF_minor_version = GETJOCTET(data[6]);
  751.         cinfo->density_unit = GETJOCTET(data[7]);
  752.         cinfo->X_density = (GETJOCTET(data[8]) << 8) + GETJOCTET(data[9]);
  753.         cinfo->Y_density = (GETJOCTET(data[10]) << 8) + GETJOCTET(data[11]);
  754.     
  755.         /* Check version.
  756.         * Major version must be 1, anything else signals an incompatible change.
  757.         * (We used to treat this as an error, but now it's a nonfatal warning,
  758.         * because some bozo at Hijaak couldn't read the spec.)
  759.         * Minor version should be 0..2, but process anyway if newer.
  760.         */
  761.         if (cinfo->JFIF_major_version != 1)
  762.             cinfo->WARNMS2(JWRN_JFIF_MAJOR, cinfo->JFIF_major_version, cinfo->JFIF_minor_version);
  763.         
  764.         /* Generate trace messages */
  765.         TRACEMS5(cinfo, 1, JTRC_JFIF,
  766.             cinfo->JFIF_major_version, cinfo->JFIF_minor_version,
  767.             cinfo->X_density, cinfo->Y_density, cinfo->density_unit);
  768.     
  769.         /* Validate thumbnail dimensions and issue appropriate messages */
  770.         if ( GETJOCTET(data[12]) | GETJOCTET(data[13]) )
  771.             TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL, GETJOCTET(data[12]), GETJOCTET(data[13]));
  772.     
  773.         totallen -= APP0_DATA_LEN;
  774.         if ( totallen != ((long)GETJOCTET(data[12]) * (long)GETJOCTET(data[13]) * (long) 3) )
  775.             TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int) totallen);
  776.     } 
  777.     else if (datalen >= 6 &&
  778.             GETJOCTET(data[0]) == 0x4A &&
  779.             GETJOCTET(data[1]) == 0x46 &&
  780.             GETJOCTET(data[2]) == 0x58 &&
  781.             GETJOCTET(data[3]) == 0x58 &&
  782.             GETJOCTET(data[4]) == 0) 
  783.     {
  784.         /* Found JFIF "JFXX" extension APP0 marker */
  785.         /* The library doesn't actually do anything with these,
  786.         * but we try to produce a helpful trace message.
  787.         */
  788.         switch (GETJOCTET(data[5])) 
  789.         {
  790.             case 0x10:
  791.                 TRACEMS1(cinfo, 1, JTRC_THUMB_JPEG, (int) totallen);
  792.                 break;
  793.                 
  794.             case 0x11:
  795.                 TRACEMS1(cinfo, 1, JTRC_THUMB_PALETTE, (int) totallen);
  796.                 break;
  797.     
  798.             case 0x13:
  799.                 TRACEMS1(cinfo, 1, JTRC_THUMB_RGB, (int) totallen);
  800.                 break;
  801.     
  802.             default:
  803.                 TRACEMS2(cinfo, 1, JTRC_JFIF_EXTENSION, GETJOCTET(data[5]), (int) totallen);
  804.                 break;
  805.         }
  806.     } 
  807.     else 
  808.     {
  809.         /* Start of APP0 does not match "JFIF" or "JFXX", or too short */
  810.         TRACEMS1(cinfo, 1, JTRC_APP0, (int) totallen);
  811.     }
  812. }
  813.  
  814.  
  815. LOCAL(void) examine_app14 (j_decompress_ptr cinfo, JOCTET * data,
  816.            unsigned int datalen, long remaining)
  817. /* Examine first few bytes from an APP14.
  818.  * Take appropriate action if it is an Adobe marker.
  819.  * datalen is # of bytes at data[], remaining is length of rest of marker data.
  820.  */
  821. {
  822.     unsigned int version, flags0, flags1, transform;
  823.  
  824.     if (datalen >= APP14_DATA_LEN &&
  825.         GETJOCTET(data[0]) == 0x41 &&
  826.         GETJOCTET(data[1]) == 0x64 &&
  827.         GETJOCTET(data[2]) == 0x6F &&
  828.         GETJOCTET(data[3]) == 0x62 &&
  829.         GETJOCTET(data[4]) == 0x65) 
  830.     {
  831.         /* Found Adobe APP14 marker */
  832.         version = (GETJOCTET(data[5]) << 8) + GETJOCTET(data[6]);
  833.         flags0 = (GETJOCTET(data[7]) << 8) + GETJOCTET(data[8]);
  834.         flags1 = (GETJOCTET(data[9]) << 8) + GETJOCTET(data[10]);
  835.         transform = GETJOCTET(data[11]);
  836.         TRACEMS4(cinfo, 1, JTRC_ADOBE, version, flags0, flags1, transform);
  837.         cinfo->saw_Adobe_marker = TRUE;
  838.         cinfo->Adobe_transform = (UINT8) transform;
  839.     } 
  840.     else 
  841.     {
  842.         /* Start of APP14 does not match "Adobe", or too short */
  843.         TRACEMS1(cinfo, 1, JTRC_APP14, (int) (datalen + remaining));
  844.     }
  845. }
  846.  
  847.  
  848. boolean get_interesting_appn (j_decompress_ptr cinfo)
  849. /* Process an APP0 or APP14 marker without saving it */
  850. {
  851.     long length;
  852.     JOCTET b[APPN_DATA_LEN];
  853.     unsigned int i, numtoread;
  854.     
  855.     KInput input(cinfo);
  856.  
  857.     if ( ! input.INPUT_2BYTES(cinfo, length) )
  858.         return FALSE;
  859.     length -= 2;
  860.  
  861.     /* get the interesting part of the marker data */
  862.     if (length >= APPN_DATA_LEN)
  863.         numtoread = APPN_DATA_LEN;
  864.     else if (length > 0)
  865.         numtoread = (unsigned int) length;
  866.     else
  867.         numtoread = 0;
  868.   
  869.     for (i = 0; i < numtoread; i++)
  870.         if ( ! input.INPUT_BYTE(cinfo, b[i]) )
  871.             return FALSE;
  872.     
  873.     length -= numtoread;
  874.  
  875.     /* process it */
  876.     switch (cinfo->unread_marker) 
  877.     {
  878.         case M_APP0:
  879.             examine_app0(cinfo, (JOCTET *) b, numtoread, length);
  880.             break;
  881.   
  882.         case M_APP14:
  883.             examine_app14(cinfo, (JOCTET *) b, numtoread, length);
  884.             break;
  885.   
  886.         default:
  887.             /* can't get here unless jpeg_save_markers chooses wrong processor */
  888.             cinfo->ERREXIT1(JERR_UNKNOWN_MARKER, cinfo->unread_marker);
  889.             break;
  890.     }
  891.  
  892.     /* skip any remaining data -- could be lots */
  893.       input.INPUT_SYNC(cinfo);
  894.     
  895.     if (length > 0)
  896.         cinfo->src->skip_input_data(cinfo, (long) length);
  897.  
  898.     return TRUE;
  899. }
  900.  
  901.  
  902. #ifdef SAVE_MARKERS_SUPPORTED
  903.  
  904. boolean save_marker (j_decompress_ptr cinfo)
  905. /* Save an APPn or COM marker into the marker list */
  906. {
  907.     my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
  908.     jpeg_saved_marker_ptr cur_marker = marker->cur_marker;
  909.     unsigned int bytes_read, data_length;
  910.     JOCTET * data;
  911.     long length = 0;
  912.     
  913.     KInput input(cinfo);
  914.     
  915.     if (cur_marker == NULL) 
  916.     {
  917.         /* begin reading a marker */
  918.         if ( ! input.INPUT_2BYTES(cinfo, length) )
  919.             return FALSE;
  920.     
  921.         length -= 2;
  922.         if (length >= 0)         /* watch out for bogus length word */
  923.         {
  924.             /* figure out how much we want to save */
  925.             unsigned int limit;
  926.             
  927.             if (cinfo->unread_marker == (int) M_COM)
  928.                 limit = marker->length_limit_COM;
  929.             else
  930.                 limit = marker->length_limit_APPn[cinfo->unread_marker - (int) M_APP0];
  931.       
  932.             if ((unsigned int) length < limit)
  933.                 limit = (unsigned int) length;
  934.       
  935.             /* allocate and initialize the marker item */
  936.             cur_marker = (jpeg_saved_marker_ptr) cinfo->mem->alloc_large(JPOOL_IMAGE, sizeof(struct jpeg_marker_struct) + limit);
  937.       
  938.             cur_marker->next = NULL;
  939.             cur_marker->marker = (UINT8) cinfo->unread_marker;
  940.             cur_marker->original_length = (unsigned int) length;
  941.             cur_marker->data_length = limit;
  942.       
  943.             /* data area is just beyond the jpeg_marker_struct */
  944.             data = cur_marker->data = (JOCTET *) (cur_marker + 1);
  945.             marker->cur_marker = cur_marker;
  946.             marker->bytes_read = 0;
  947.             bytes_read = 0;
  948.             data_length = limit;
  949.         } 
  950.         else 
  951.         {
  952.             /* deal with bogus length word */
  953.             bytes_read = data_length = 0;
  954.             data = NULL;
  955.         }
  956.     } 
  957.     else 
  958.     {
  959.         /* resume reading a marker */
  960.         bytes_read = marker->bytes_read;
  961.         data_length = cur_marker->data_length;
  962.         data = cur_marker->data + bytes_read;
  963.     }
  964.  
  965.     while (bytes_read < data_length) 
  966.     {
  967.         input.INPUT_SYNC(cinfo);        /* move the restart point to here */
  968.     
  969.         marker->bytes_read = bytes_read;
  970.         /* If there's not at least one byte in buffer, suspend */
  971.         
  972.         if ( ! input.MAKE_BYTE_AVAIL(cinfo) )
  973.             return FALSE;
  974.         
  975.         /* Copy bytes with reasonable rapidity */
  976.         while (bytes_read < data_length && input.bytes_in_buffer > 0) 
  977.         {
  978.             *data++ = * input.next_input_byte++;
  979.             input.bytes_in_buffer--;
  980.             bytes_read++;
  981.         }
  982.     }
  983.  
  984.     /* Done reading what we want to read */
  985.     if (cur_marker != NULL)     /* will be NULL if bogus length word */
  986.     {
  987.         /* Add new marker to end of list */
  988.         if (cinfo->marker_list == NULL) 
  989.         {
  990.             cinfo->marker_list = cur_marker;
  991.         } 
  992.         else 
  993.         {
  994.             jpeg_saved_marker_ptr prev = cinfo->marker_list;
  995.       
  996.             while (prev->next != NULL)
  997.                 prev = prev->next;
  998.             prev->next = cur_marker;
  999.         }
  1000.     
  1001.         /* Reset pointer & calc remaining data length */
  1002.         data = cur_marker->data;
  1003.         length = cur_marker->original_length - data_length;
  1004.     }
  1005.   
  1006.     /* Reset to initial state for next marker */
  1007.     marker->cur_marker = NULL;
  1008.  
  1009.     /* Process the marker if interesting; else just make a generic trace msg */
  1010.     switch (cinfo->unread_marker) 
  1011.     {
  1012.         case M_APP0:
  1013.             examine_app0(cinfo, data, data_length, length);
  1014.             break;
  1015.   
  1016.         case M_APP14:
  1017.             examine_app14(cinfo, data, data_length, length);
  1018.             break;
  1019.   
  1020.         default:
  1021.             TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) (data_length + length));
  1022.             break;
  1023.     }
  1024.  
  1025.     /* skip any remaining data -- could be lots */
  1026.     input.INPUT_SYNC(cinfo);        /* do before skip_input_data */
  1027.   
  1028.     if (length > 0)
  1029.         cinfo->src->skip_input_data(cinfo, (long) length);
  1030.  
  1031.     return TRUE;
  1032. }
  1033.  
  1034. #endif /* SAVE_MARKERS_SUPPORTED */
  1035.  
  1036.  
  1037. boolean skip_variable (j_decompress_ptr cinfo)
  1038. /* Skip over an unknown or uninteresting variable-length marker */
  1039. {
  1040.     long length;
  1041.     KInput input(cinfo);
  1042.  
  1043.     if ( ! input.INPUT_2BYTES(cinfo, length) )
  1044.         return FALSE;
  1045.   
  1046.     length -= 2;
  1047.   
  1048.     TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) length);
  1049.  
  1050.     input.INPUT_SYNC(cinfo);        /* do before skip_input_data */
  1051.   
  1052.     if (length > 0)
  1053.         cinfo->src->skip_input_data(cinfo, (long) length);
  1054.  
  1055.     return TRUE;
  1056. }
  1057.  
  1058.  
  1059. /*
  1060.  * Find the next JPEG marker, save it in cinfo->unread_marker.
  1061.  * Returns FALSE if had to suspend before reaching a marker;
  1062.  * in that case cinfo->unread_marker is unchanged.
  1063.  *
  1064.  * Note that the result might not be a valid marker code,
  1065.  * but it will never be 0 or FF.
  1066.  */
  1067.  
  1068. LOCAL(boolean) next_marker (j_decompress_ptr cinfo)
  1069. {
  1070.     int c;
  1071.     KInput input(cinfo);
  1072.  
  1073.     for (;;) 
  1074.     {
  1075.         if ( ! input.INPUT_BYTE(cinfo, c) )
  1076.             return FALSE;
  1077.         
  1078.         /* Skip any non-FF bytes.
  1079.         * This may look a bit inefficient, but it will not occur in a valid file.
  1080.         * We sync after each discarded byte so that a suspending data source
  1081.         * can discard the byte from its buffer.
  1082.         */
  1083.         while (c != 0xFF) 
  1084.         {
  1085.             cinfo->marker->discarded_bytes++;
  1086.             input.INPUT_SYNC(cinfo);
  1087.             
  1088.             if (! input.INPUT_BYTE(cinfo, c) )
  1089.                 return FALSE;
  1090.         }
  1091.         
  1092.         /* This loop swallows any duplicate FF bytes.  Extra FFs are legal as
  1093.         * pad bytes, so don't count them in discarded_bytes.  We assume there
  1094.         * will not be so many consecutive FF bytes as to overflow a suspending
  1095.         * data source's input buffer.
  1096.         */
  1097.         do 
  1098.         {
  1099.             if ( ! input.INPUT_BYTE(cinfo, c) )
  1100.                 return FALSE;
  1101.         } 
  1102.         while (c == 0xFF);
  1103.     
  1104.         if (c != 0)
  1105.             break;            /* found a valid marker, exit loop */
  1106.         /* Reach here if we found a stuffed-zero data sequence (FF/00).
  1107.         * Discard it and loop back to try again.
  1108.         */
  1109.         cinfo->marker->discarded_bytes += 2;
  1110.         
  1111.         input.INPUT_SYNC(cinfo);
  1112.     }
  1113.  
  1114.     if (cinfo->marker->discarded_bytes != 0) 
  1115.     {
  1116.         cinfo->WARNMS2(JWRN_EXTRANEOUS_DATA, cinfo->marker->discarded_bytes, c);
  1117.         cinfo->marker->discarded_bytes = 0;
  1118.     }
  1119.  
  1120.     cinfo->unread_marker = c;
  1121.  
  1122.     input.INPUT_SYNC(cinfo);
  1123.     
  1124.     return TRUE;
  1125. }
  1126.  
  1127.  
  1128. LOCAL(boolean) first_marker (j_decompress_ptr cinfo)
  1129. /* Like next_marker, but used to obtain the initial SOI marker. */
  1130. /* For this marker, we do not allow preceding garbage or fill; otherwise,
  1131.  * we might well scan an entire input file before realizing it ain't JPEG.
  1132.  * If an application wants to process non-JFIF files, it must seek to the
  1133.  * SOI before calling the JPEG library.
  1134.  */
  1135. {
  1136.     int c, c2;
  1137.     KInput input(cinfo);
  1138.  
  1139.     if ( ! input.INPUT_BYTE(cinfo, c) )
  1140.         return FALSE;
  1141.     
  1142.     if ( ! input.INPUT_BYTE(cinfo, c2) )
  1143.         return FALSE;
  1144.     
  1145.     if (c != 0xFF || c2 != (int) M_SOI)
  1146.         cinfo->ERREXIT2(JERR_NO_SOI, c, c2);
  1147.  
  1148.     cinfo->unread_marker = c2;
  1149.  
  1150.     input.INPUT_SYNC(cinfo);
  1151.     
  1152.     return TRUE;
  1153. }
  1154.  
  1155.  
  1156. /*
  1157.  * Read markers until SOS or EOI.
  1158.  *
  1159.  * Returns same codes as are defined for jpeg_consume_input:
  1160.  * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
  1161.  */
  1162.  
  1163. int read_markers (j_decompress_ptr cinfo)
  1164. {
  1165.     /* Outer loop repeats once for each marker. */
  1166.     for (;;) 
  1167.     {
  1168.         /* Collect the marker proper, unless we already did. */
  1169.         /* NB: first_marker() enforces the requirement that SOI appear first. */
  1170.         if (cinfo->unread_marker == 0) 
  1171.         {
  1172.             if (! cinfo->marker->saw_SOI) 
  1173.             {
  1174.                 if (! first_marker(cinfo))
  1175.                     return JPEG_SUSPENDED;
  1176.             } 
  1177.             else 
  1178.             {
  1179.                 if (! next_marker(cinfo))
  1180.                     return JPEG_SUSPENDED;
  1181.             }
  1182.         }
  1183.     
  1184.         /* At this point cinfo->unread_marker contains the marker code and the
  1185.         * input point is just past the marker proper, but before any parameters.
  1186.         * A suspension will cause us to return with this state still true.
  1187.         */
  1188.         switch (cinfo->unread_marker) 
  1189.         {
  1190.             case M_SOI:
  1191.                 if (! get_soi(cinfo))
  1192.                     return JPEG_SUSPENDED;
  1193.                 break;
  1194.  
  1195.             case M_SOF0:        /* Baseline */
  1196.             case M_SOF1:        /* Extended sequential, Huffman */
  1197.                 if (! get_sof(cinfo, FALSE, FALSE))
  1198.                     return JPEG_SUSPENDED;
  1199.                 break;
  1200.  
  1201.             case M_SOF2:        /* Progressive, Huffman */
  1202.                 if (! get_sof(cinfo, TRUE, FALSE))
  1203.                     return JPEG_SUSPENDED;
  1204.                 break;
  1205.  
  1206.             case M_SOF9:        /* Extended sequential, arithmetic */
  1207.                 if (! get_sof(cinfo, FALSE, TRUE))
  1208.                     return JPEG_SUSPENDED;
  1209.                 break;
  1210.  
  1211.             case M_SOF10:        /* Progressive, arithmetic */
  1212.                 if (! get_sof(cinfo, TRUE, TRUE))
  1213.                     return JPEG_SUSPENDED;
  1214.                 break;
  1215.  
  1216.             /* Currently unsupported SOFn types */
  1217.             case M_SOF3:        /* Lossless, Huffman */
  1218.             case M_SOF5:        /* Differential sequential, Huffman */
  1219.             case M_SOF6:        /* Differential progressive, Huffman */
  1220.             case M_SOF7:        /* Differential lossless, Huffman */
  1221.             case M_JPG:            /* Reserved for JPEG extensions */
  1222.             case M_SOF11:        /* Lossless, arithmetic */
  1223.             case M_SOF13:        /* Differential sequential, arithmetic */
  1224.             case M_SOF14:        /* Differential progressive, arithmetic */
  1225.             case M_SOF15:        /* Differential lossless, arithmetic */
  1226.                 cinfo->ERREXIT1(JERR_SOF_UNSUPPORTED, cinfo->unread_marker);
  1227.                 break;
  1228.  
  1229.             case M_SOS:
  1230.                 if (! get_sos(cinfo))
  1231.                     return JPEG_SUSPENDED;
  1232.                 cinfo->unread_marker = 0;    /* processed the marker */
  1233.                 return JPEG_REACHED_SOS;
  1234.     
  1235.             case M_EOI:
  1236.                 TRACEMS(cinfo, 1, JTRC_EOI);
  1237.                 cinfo->unread_marker = 0;    /* processed the marker */
  1238.                 return JPEG_REACHED_EOI;
  1239.       
  1240.             case M_DAC:
  1241.                 if (! get_dac(cinfo))
  1242.                     return JPEG_SUSPENDED;
  1243.                 break;
  1244.       
  1245.             case M_DHT:
  1246.                 if (! get_dht(cinfo))
  1247.                     return JPEG_SUSPENDED;
  1248.                 break;
  1249.       
  1250.             case M_DQT:
  1251.                 if (! get_dqt(cinfo))
  1252.                     return JPEG_SUSPENDED;
  1253.                 break;
  1254.       
  1255.             case M_DRI:
  1256.                 if (! get_dri(cinfo))
  1257.                     return JPEG_SUSPENDED;
  1258.                 break;
  1259.       
  1260.             case M_APP0:
  1261.             case M_APP1:
  1262.             case M_APP2:
  1263.             case M_APP3:
  1264.             case M_APP4:
  1265.             case M_APP5:
  1266.             case M_APP6:
  1267.             case M_APP7:
  1268.             case M_APP8:
  1269.             case M_APP9:
  1270.             case M_APP10:
  1271.             case M_APP11:
  1272.             case M_APP12:
  1273.             case M_APP13:
  1274.             case M_APP14:
  1275.             case M_APP15:
  1276.                 if (! (*((my_marker_ptr) cinfo->marker)->process_APPn[cinfo->unread_marker - (int) M_APP0]) (cinfo))
  1277.                     return JPEG_SUSPENDED;
  1278.                 break;
  1279.       
  1280.             case M_COM:
  1281.                 if (! (*((my_marker_ptr) cinfo->marker)->process_COM) (cinfo))
  1282.                     return JPEG_SUSPENDED;
  1283.                 break;
  1284.  
  1285.             case M_RST0:        /* these are all parameterless */
  1286.             case M_RST1:
  1287.             case M_RST2:
  1288.             case M_RST3:
  1289.             case M_RST4:
  1290.             case M_RST5:
  1291.             case M_RST6:
  1292.             case M_RST7:
  1293.             case M_TEM:
  1294.                 TRACEMS1(cinfo, 1, JTRC_PARMLESS_MARKER, cinfo->unread_marker);
  1295.                 break;
  1296.  
  1297.             case M_DNL:            /* Ignore DNL ... perhaps the wrong thing */
  1298.                 if (! skip_variable(cinfo))
  1299.                     return JPEG_SUSPENDED;
  1300.                 break;
  1301.  
  1302.             default:            /* must be DHP, EXP, JPGn, or RESn */
  1303.                 /* For now, we treat the reserved markers as fatal errors since they are
  1304.                 * likely to be used to signal incompatible JPEG Part 3 extensions.
  1305.                 * Once the JPEG 3 version-number marker is well defined, this code
  1306.                 * ought to change!
  1307.                 */
  1308.                 cinfo->ERREXIT1(JERR_UNKNOWN_MARKER, cinfo->unread_marker);
  1309.                 break;
  1310.         }
  1311.         /* Successfully processed marker, so reset state variable */
  1312.         cinfo->unread_marker = 0;
  1313.     } /* end loop */
  1314. }
  1315.  
  1316.  
  1317. /*
  1318.  * Read a restart marker, which is expected to appear next in the datastream;
  1319.  * if the marker is not there, take appropriate recovery action.
  1320.  * Returns FALSE if suspension is required.
  1321.  *
  1322.  * This is called by the entropy decoder after it has read an appropriate
  1323.  * number of MCUs.  cinfo->unread_marker may be nonzero if the entropy decoder
  1324.  * has already read a marker from the data source.  Under normal conditions
  1325.  * cinfo->unread_marker will be reset to 0 before returning; if not reset,
  1326.  * it holds a marker which the decoder will be unable to read past.
  1327.  */
  1328.  
  1329. boolean
  1330. read_restart_marker (j_decompress_ptr cinfo)
  1331. {
  1332.   /* Obtain a marker unless we already did. */
  1333.   /* Note that next_marker will complain if it skips any data. */
  1334.   if (cinfo->unread_marker == 0) {
  1335.     if (! next_marker(cinfo))
  1336.       return FALSE;
  1337.   }
  1338.  
  1339.   if (cinfo->unread_marker ==
  1340.       ((int) M_RST0 + cinfo->marker->next_restart_num)) {
  1341.     /* Normal case --- swallow the marker and let entropy decoder continue */
  1342.     TRACEMS1(cinfo, 3, JTRC_RST, cinfo->marker->next_restart_num);
  1343.     cinfo->unread_marker = 0;
  1344.   } else {
  1345.     /* Uh-oh, the restart markers have been messed up. */
  1346.     /* Let the data source manager determine how to resync. */
  1347.     if (! cinfo->src->resync_to_restart(cinfo,
  1348.                         cinfo->marker->next_restart_num))
  1349.       return FALSE;
  1350.   }
  1351.  
  1352.   /* Update next-restart state */
  1353.   cinfo->marker->next_restart_num = (cinfo->marker->next_restart_num + 1) & 7;
  1354.  
  1355.   return TRUE;
  1356. }
  1357.  
  1358.  
  1359. /*
  1360.  * This is the default resync_to_restart method for data source managers
  1361.  * to use if they don't have any better approach.  Some data source managers
  1362.  * may be able to back up, or may have additional knowledge about the data
  1363.  * which permits a more intelligent recovery strategy; such managers would
  1364.  * presumably supply their own resync method.
  1365.  *
  1366.  * read_restart_marker calls resync_to_restart if it finds a marker other than
  1367.  * the restart marker it was expecting.  (This code is *not* used unless
  1368.  * a nonzero restart interval has been declared.)  cinfo->unread_marker is
  1369.  * the marker code actually found (might be anything, except 0 or FF).
  1370.  * The desired restart marker number (0..7) is passed as a parameter.
  1371.  * This routine is supposed to apply whatever error recovery strategy seems
  1372.  * appropriate in order to position the input stream to the next data segment.
  1373.  * Note that cinfo->unread_marker is treated as a marker appearing before
  1374.  * the current data-source input point; usually it should be reset to zero
  1375.  * before returning.
  1376.  * Returns FALSE if suspension is required.
  1377.  *
  1378.  * This implementation is substantially constrained by wanting to treat the
  1379.  * input as a data stream; this means we can't back up.  Therefore, we have
  1380.  * only the following actions to work with:
  1381.  *   1. Simply discard the marker and let the entropy decoder resume at next
  1382.  *      byte of file.
  1383.  *   2. Read forward until we find another marker, discarding intervening
  1384.  *      data.  (In theory we could look ahead within the current bufferload,
  1385.  *      without having to discard data if we don't find the desired marker.
  1386.  *      This idea is not implemented here, in part because it makes behavior
  1387.  *      dependent on buffer size and chance buffer-boundary positions.)
  1388.  *   3. Leave the marker unread (by failing to zero cinfo->unread_marker).
  1389.  *      This will cause the entropy decoder to process an empty data segment,
  1390.  *      inserting dummy zeroes, and then we will reprocess the marker.
  1391.  *
  1392.  * #2 is appropriate if we think the desired marker lies ahead, while #3 is
  1393.  * appropriate if the found marker is a future restart marker (indicating
  1394.  * that we have missed the desired restart marker, probably because it got
  1395.  * corrupted).
  1396.  * We apply #2 or #3 if the found marker is a restart marker no more than
  1397.  * two counts behind or ahead of the expected one.  We also apply #2 if the
  1398.  * found marker is not a legal JPEG marker code (it's certainly bogus data).
  1399.  * If the found marker is a restart marker more than 2 counts away, we do #1
  1400.  * (too much risk that the marker is erroneous; with luck we will be able to
  1401.  * resync at some future point).
  1402.  * For any valid non-restart JPEG marker, we apply #3.  This keeps us from
  1403.  * overrunning the end of a scan.  An implementation limited to single-scan
  1404.  * files might find it better to apply #2 for markers other than EOI, since
  1405.  * any other marker would have to be bogus data in that case.
  1406.  */
  1407.  
  1408. boolean jpeg_source_mgr::resync_to_restart (j_decompress_ptr cinfo, int desired)
  1409. {
  1410.   int marker = cinfo->unread_marker;
  1411.   int action = 1;
  1412.   
  1413.   /* Always put up a warning. */
  1414.   cinfo->WARNMS2(JWRN_MUST_RESYNC, marker, desired);
  1415.   
  1416.   /* Outer loop handles repeated decision after scanning forward. */
  1417.   for (;;) {
  1418.     if (marker < (int) M_SOF0)
  1419.       action = 2;        /* invalid marker */
  1420.     else if (marker < (int) M_RST0 || marker > (int) M_RST7)
  1421.       action = 3;        /* valid non-restart marker */
  1422.     else {
  1423.       if (marker == ((int) M_RST0 + ((desired+1) & 7)) ||
  1424.       marker == ((int) M_RST0 + ((desired+2) & 7)))
  1425.     action = 3;        /* one of the next two expected restarts */
  1426.       else if (marker == ((int) M_RST0 + ((desired-1) & 7)) ||
  1427.            marker == ((int) M_RST0 + ((desired-2) & 7)))
  1428.     action = 2;        /* a prior restart, so advance */
  1429.       else
  1430.     action = 1;        /* desired restart or too far away */
  1431.     }
  1432.     TRACEMS2(cinfo, 4, JTRC_RECOVERY_ACTION, marker, action);
  1433.     switch (action) {
  1434.     case 1:
  1435.       /* Discard marker and let entropy decoder resume processing. */
  1436.       cinfo->unread_marker = 0;
  1437.       return TRUE;
  1438.     case 2:
  1439.       /* Scan to the next marker, and repeat the decision loop. */
  1440.       if (! next_marker(cinfo))
  1441.     return FALSE;
  1442.       marker = cinfo->unread_marker;
  1443.       break;
  1444.     case 3:
  1445.       /* Return without advancing past this marker. */
  1446.       /* Entropy decoder will be forced to process an empty segment. */
  1447.       return TRUE;
  1448.     }
  1449.   } /* end loop */
  1450. }
  1451.  
  1452.  
  1453. /*
  1454.  * Reset marker processing state to begin a fresh datastream.
  1455.  */
  1456.  
  1457. void
  1458. reset_marker_reader (j_decompress_ptr cinfo)
  1459. {
  1460.   my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
  1461.  
  1462.   cinfo->comp_info = NULL;        /* until allocated by get_sof */
  1463.   cinfo->input_scan_number = 0;        /* no SOS seen yet */
  1464.   cinfo->unread_marker = 0;        /* no pending marker */
  1465.   marker->pub.saw_SOI = FALSE;        /* set internal state too */
  1466.   marker->pub.saw_SOF = FALSE;
  1467.   marker->pub.discarded_bytes = 0;
  1468.   marker->cur_marker = NULL;
  1469. }
  1470.  
  1471.  
  1472. /*
  1473.  * Initialize the marker reader module.
  1474.  * This is called only once, when the decompression object is created.
  1475.  */
  1476.  
  1477. GLOBAL(void)
  1478. jinit_marker_reader (j_decompress_ptr cinfo)
  1479. {
  1480.   my_marker_ptr marker;
  1481.   int i;
  1482.  
  1483.   /* Create subobject in permanent pool */
  1484.   marker = (my_marker_ptr)
  1485.     cinfo->mem->alloc_small(JPOOL_PERMANENT,
  1486.                 sizeof(my_marker_reader));
  1487.   cinfo->marker = (struct jpeg_marker_reader *) marker;
  1488.   /* Initialize public method pointers */
  1489.   marker->pub.reset_marker_reader = reset_marker_reader;
  1490.   marker->pub.read_markers = read_markers;
  1491.   marker->pub.read_restart_marker = read_restart_marker;
  1492.   /* Initialize COM/APPn processing.
  1493.    * By default, we examine and then discard APP0 and APP14,
  1494.    * but simply discard COM and all other APPn.
  1495.    */
  1496.   marker->process_COM = skip_variable;
  1497.   marker->length_limit_COM = 0;
  1498.   for (i = 0; i < 16; i++) {
  1499.     marker->process_APPn[i] = skip_variable;
  1500.     marker->length_limit_APPn[i] = 0;
  1501.   }
  1502.   marker->process_APPn[0] = get_interesting_appn;
  1503.   marker->process_APPn[14] = get_interesting_appn;
  1504.   /* Reset marker processing state */
  1505.   reset_marker_reader(cinfo);
  1506. }
  1507.  
  1508.  
  1509. /*
  1510.  * Control saving of COM and APPn markers into marker_list.
  1511.  */
  1512.  
  1513. #ifdef SAVE_MARKERS_SUPPORTED
  1514.  
  1515. GLOBAL(void)
  1516. jpeg_save_markers (j_decompress_ptr cinfo, int marker_code,
  1517.            unsigned int length_limit)
  1518. {
  1519.   my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
  1520.   long maxlength;
  1521.   jpeg_marker_parser_method processor;
  1522.  
  1523.   /* Length limit mustn't be larger than what we can allocate
  1524.    * (should only be a concern in a 16-bit environment).
  1525.    */
  1526.   maxlength = cinfo->mem->max_alloc_chunk - sizeof(struct jpeg_marker_struct);
  1527.   if (((long) length_limit) > maxlength)
  1528.     length_limit = (unsigned int) maxlength;
  1529.  
  1530.   /* Choose processor routine to use.
  1531.    * APP0/APP14 have special requirements.
  1532.    */
  1533.   if (length_limit) {
  1534.     processor = save_marker;
  1535.     /* If saving APP0/APP14, save at least enough for our internal use. */
  1536.     if (marker_code == (int) M_APP0 && length_limit < APP0_DATA_LEN)
  1537.       length_limit = APP0_DATA_LEN;
  1538.     else if (marker_code == (int) M_APP14 && length_limit < APP14_DATA_LEN)
  1539.       length_limit = APP14_DATA_LEN;
  1540.   } else {
  1541.     processor = skip_variable;
  1542.     /* If discarding APP0/APP14, use our regular on-the-fly processor. */
  1543.     if (marker_code == (int) M_APP0 || marker_code == (int) M_APP14)
  1544.       processor = get_interesting_appn;
  1545.   }
  1546.  
  1547.   if (marker_code == (int) M_COM) {
  1548.     marker->process_COM = processor;
  1549.     marker->length_limit_COM = length_limit;
  1550.   } else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15) {
  1551.     marker->process_APPn[marker_code - (int) M_APP0] = processor;
  1552.     marker->length_limit_APPn[marker_code - (int) M_APP0] = length_limit;
  1553.   } else
  1554.     cinfo->ERREXIT1(JERR_UNKNOWN_MARKER, marker_code);
  1555. }
  1556.  
  1557. #endif /* SAVE_MARKERS_SUPPORTED */
  1558.  
  1559.  
  1560. /*
  1561.  * Install a special processing method for COM or APPn markers.
  1562.  */
  1563.  
  1564. GLOBAL(void)
  1565. jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code,
  1566.                jpeg_marker_parser_method routine)
  1567. {
  1568.   my_marker_ptr marker = (my_marker_ptr) cinfo->marker;
  1569.  
  1570.   if (marker_code == (int) M_COM)
  1571.     marker->process_COM = routine;
  1572.   else if (marker_code >= (int) M_APP0 && marker_code <= (int) M_APP15)
  1573.     marker->process_APPn[marker_code - (int) M_APP0] = routine;
  1574.   else
  1575.     cinfo->ERREXIT1(JERR_UNKNOWN_MARKER, marker_code);
  1576. }
  1577.