File indexing completed on 2024-05-12 04:19:35

 /*
  * Little cms
  * Copyright (C) 1998-2004 Marti Maria <x@unknown.com>
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sublicense, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
  *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  * iccprofile.c
  *
  * This file provides code to read and write International Color Consortium
  * (ICC) device profiles embedded in JFIF JPEG image files.  The ICC has
  * defined a standard format for including such data in JPEG "APP2" markers.
  * The code given here does not know anything about the internal structure
  * of the ICC profile data; it just knows how to put the profile data into
  * a JPEG file being written, or get it back out when reading.
  *
  * This code depends on new features added to the IJG JPEG library as of
  * IJG release 6b; it will not compile or work with older IJG versions.
  *
  * NOTE: this code would need surgery to work on 16-bit-int machines
  * with ICC profiles exceeding 64K bytes in size.  If you need to do that,
  * change all the "unsigned int" variables to "INT32".  You'll also need
  * to find a malloc() replacement that can allocate more than 64K.
  */
 
 #include "iccjpeg.h"
 #include <stdlib.h>         /* define malloc() */
 
 
 /*
  * Since an ICC profile can be larger than the maximum size of a JPEG marker
  * (64K), we need provisions to split it into multiple markers.  The format
  * defined by the ICC specifies one or more APP2 markers containing the
  * following data:
  *  Identifying string  ASCII "ICC_PROFILE\0"  (12 bytes)
  *  Marker sequence number  1 for first APP2, 2 for next, etc (1 byte)
  *  Number of markers   Total number of APP2's used (1 byte)
  *      Profile data        (remainder of APP2 data)
  * Decoders should use the marker sequence numbers to reassemble the profile,
  * rather than assuming that the APP2 markers appear in the correct sequence.
  */
 
 #define ICC_MARKER  (JPEG_APP0 + 2) /* JPEG marker code for ICC */
 #define ICC_OVERHEAD_LEN  14        /* size of non-profile data in APP2 */
 #define MAX_BYTES_IN_MARKER  65533  /* maximum data len of a JPEG marker */
 #define MAX_DATA_BYTES_IN_MARKER  (MAX_BYTES_IN_MARKER - ICC_OVERHEAD_LEN)
 
 
 /*
  * This routine writes the given ICC profile data into a JPEG file.
  * It *must* be called AFTER calling jpeg_start_compress() and BEFORE
  * the first call to jpeg_write_scanlines().
  * (This ordering ensures that the APP2 marker(s) will appear after the
  * SOI and JFIF or Adobe markers, but before all else.)
  */
 
 void
 write_icc_profile (j_compress_ptr cinfo,
            const JOCTET *icc_data_ptr,
            unsigned int icc_data_len)
 {
   unsigned int num_markers; /* total number of markers we'll write */
   int cur_marker = 1;       /* per spec, counting starts at 1 */
   unsigned int length;      /* number of bytes to write in this marker */
 
   /* Calculate the number of markers we'll need, rounding up of course */
   num_markers = icc_data_len / MAX_DATA_BYTES_IN_MARKER;
   if (num_markers * MAX_DATA_BYTES_IN_MARKER != icc_data_len)
     num_markers++;
 
   while (icc_data_len > 0) {
     /* length of profile to put in this marker */
     length = icc_data_len;
     if (length > MAX_DATA_BYTES_IN_MARKER)
       length = MAX_DATA_BYTES_IN_MARKER;
     icc_data_len -= length;
 
     /* Write the JPEG marker header (APP2 code and marker length) */
     jpeg_write_m_header(cinfo, ICC_MARKER,
             (unsigned int) (length + ICC_OVERHEAD_LEN));
 
     /* Write the marker identifying string "ICC_PROFILE" (null-terminated).
      * We code it in this less-than-transparent way so that the code works
      * even if the local character set is not ASCII.
      */
     jpeg_write_m_byte(cinfo, 0x49);
     jpeg_write_m_byte(cinfo, 0x43);
     jpeg_write_m_byte(cinfo, 0x43);
     jpeg_write_m_byte(cinfo, 0x5F);
     jpeg_write_m_byte(cinfo, 0x50);
     jpeg_write_m_byte(cinfo, 0x52);
     jpeg_write_m_byte(cinfo, 0x4F);
     jpeg_write_m_byte(cinfo, 0x46);
     jpeg_write_m_byte(cinfo, 0x49);
     jpeg_write_m_byte(cinfo, 0x4C);
     jpeg_write_m_byte(cinfo, 0x45);
     jpeg_write_m_byte(cinfo, 0x0);
 
     /* Add the sequencing info */
     jpeg_write_m_byte(cinfo, cur_marker);
     jpeg_write_m_byte(cinfo, (int) num_markers);
 
     /* Add the profile data */
     while (length--) {
       jpeg_write_m_byte(cinfo, *icc_data_ptr);
       icc_data_ptr++;
     }
     cur_marker++;
   }
 }
 
 
 /*
  * Prepare for reading an ICC profile
  */
 
 void
 setup_read_icc_profile (j_decompress_ptr cinfo)
 {
   /* Tell the library to keep any APP2 data it may find */
   jpeg_save_markers(cinfo, ICC_MARKER, 0xFFFF);
 }
 
 
 /*
  * Handy subroutine to test whether a saved marker is an ICC profile marker.
  */
 
 static boolean
 marker_is_icc (jpeg_saved_marker_ptr marker)
 {
   return
     marker->marker == ICC_MARKER &&
     marker->data_length >= ICC_OVERHEAD_LEN &&
     /* verify the identifying string */
     GETJOCTET(marker->data[0]) == 0x49 &&
     GETJOCTET(marker->data[1]) == 0x43 &&
     GETJOCTET(marker->data[2]) == 0x43 &&
     GETJOCTET(marker->data[3]) == 0x5F &&
     GETJOCTET(marker->data[4]) == 0x50 &&
     GETJOCTET(marker->data[5]) == 0x52 &&
     GETJOCTET(marker->data[6]) == 0x4F &&
     GETJOCTET(marker->data[7]) == 0x46 &&
     GETJOCTET(marker->data[8]) == 0x49 &&
     GETJOCTET(marker->data[9]) == 0x4C &&
     GETJOCTET(marker->data[10]) == 0x45 &&
     GETJOCTET(marker->data[11]) == 0x0;
 }
 
 
 /*
  * See if there was an ICC profile in the JPEG file being read;
  * if so, reassemble and return the profile data.
  *
  * TRUE is returned if an ICC profile was found, FALSE if not.
  * If TRUE is returned, *icc_data_ptr is set to point to the
  * returned data, and *icc_data_len is set to its length.
  *
  * IMPORTANT: the data at **icc_data_ptr has been allocated with malloc()
  * and must be freed by the caller with free() when the caller no longer
  * needs it.  (Alternatively, we could write this routine to use the
  * IJG library's memory allocator, so that the data would be freed implicitly
  * at jpeg_finish_decompress() time.  But it seems likely that many apps
  * will prefer to have the data stick around after decompression finishes.)
  *
  * NOTE: if the file contains invalid ICC APP2 markers, we just silently
  * return FALSE.  You might want to issue an error message instead.
  */
 
 boolean
 read_icc_profile (j_decompress_ptr cinfo,
           JOCTET **icc_data_ptr,
           unsigned int *icc_data_len)
 {
   jpeg_saved_marker_ptr marker;
   int num_markers = 0;
   int seq_no;
   JOCTET *icc_data;
   unsigned int total_length;
 #define MAX_SEQ_NO  255     /* sufficient since marker numbers are bytes */
   char marker_present[MAX_SEQ_NO+1];      /* 1 if marker found */
   unsigned int data_length[MAX_SEQ_NO+1]; /* size of profile data in marker */
   unsigned int data_offset[MAX_SEQ_NO+1]; /* offset for data in marker */
 
   *icc_data_ptr = NULL;     /* avoid confusion if FALSE return */
   *icc_data_len = 0;
 
   /* This first pass over the saved markers discovers whether there are
    * any ICC markers and verifies the consistency of the marker numbering.
    */
 
   for (seq_no = 1; seq_no <= MAX_SEQ_NO; seq_no++)
     marker_present[seq_no] = 0;
 
   for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
     if (marker_is_icc(marker)) {
       if (num_markers == 0)
     num_markers = GETJOCTET(marker->data[13]);
       else if (num_markers != GETJOCTET(marker->data[13]))
     return FALSE;       /* inconsistent num_markers fields */
       seq_no = GETJOCTET(marker->data[12]);
       if (seq_no <= 0 || seq_no > num_markers)
     return FALSE;       /* bogus sequence number */
       if (marker_present[seq_no])
     return FALSE;       /* duplicate sequence numbers */
       marker_present[seq_no] = 1;
       data_length[seq_no] = marker->data_length - ICC_OVERHEAD_LEN;
     }
   }
 
   if (num_markers == 0)
     return FALSE;
 
   /* Check for missing markers, count total space needed,
    * compute offset of each marker's part of the data.
    */
 
   total_length = 0;
   for (seq_no = 1; seq_no <= num_markers; seq_no++) {
     if (marker_present[seq_no] == 0)
       return FALSE;     /* missing sequence number */
     data_offset[seq_no] = total_length;
     total_length += data_length[seq_no];
   }
 
   if (total_length <= 0)
     return FALSE;       /* found only empty markers? */
 
   /* Allocate space for assembled data */
   icc_data = (JOCTET *) malloc(total_length * sizeof(JOCTET));
   if (icc_data == NULL)
     return FALSE;       /* oops, out of memory */
 
   /* and fill it in */
   for (marker = cinfo->marker_list; marker != NULL; marker = marker->next) {
     if (marker_is_icc(marker)) {
       JOCTET FAR *src_ptr;
       JOCTET *dst_ptr;
       unsigned int length;
       seq_no = GETJOCTET(marker->data[12]);
       dst_ptr = icc_data + data_offset[seq_no];
       src_ptr = marker->data + ICC_OVERHEAD_LEN;
       length = data_length[seq_no];
       while (length--) {
     *dst_ptr++ = *src_ptr++;
       }
     }
   }
 
   *icc_data_ptr = icc_data;
   *icc_data_len = total_length;
 
   return TRUE;
 }