/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 1998-01-25
 * Description : helper methods to handle ICC color profile with JPEG file.
 *
 * SPDX-FileCopyrightText: 1998-2004 by Marti Maria <info at littlecms dot com>
 * SPDX-FileCopyrightText: 2005-2026 by Gilles Caulier <caulier dot gilles at gmail dot com>
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 *
 * ============================================================ */

#include "iccjpeg.h"

/* C includes */

#include <stdlib.h>    /* define malloc() */

/**
 * @note 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.
 */

/**
 * JPEG marker code for ICC
 */
#define ICC_MARKER                              (JPEG_APP0 + 2)

/**
 * Size of non-profile data in APP2
 */
#define ICC_OVERHEAD_LEN                        14                 // krazy:exclude=defines

/**
 * Maximum data len of a JPEG marker
 */
#define MAX_BYTES_IN_MARKER                     65533              // krazy:exclude=defines

#define MAX_DATA_BYTES_IN_MARKER                (MAX_BYTES_IN_MARKER - ICC_OVERHEAD_LEN)

/**
 * Sufficient since marker numbers are bytes
 */
#define MAX_SEQ_NO                              255                // krazy:exclude=defines

/**
 * @brief 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 = 0;   /* total number of markers we'll write     */
    int cur_marker           = 1;   /* per spec, counting starts at 1          */
    unsigned int length      = 0;   /* 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++;
    }
}

/**
 * @brief 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);
}

/**
 * @brief 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));
}

/**
 * @brief See if there was an ICC profile in the JPEG file being read;
 * if so, reassemble and return the profile data.
 *
 * @return TRUE 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                = 0;
    JOCTET* icc_data          = NULL;
    unsigned int total_length = 0;


    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))
        {
            seq_no              = GETJOCTET(marker->data[12]);
            JOCTET* dst_ptr     = icc_data + data_offset[seq_no];
            JOCTET FAR* src_ptr = marker->data + ICC_OVERHEAD_LEN;
            unsigned int length = data_length[seq_no];

            while (length--)
            {
                *dst_ptr++ = *src_ptr++;
            }
        }
    }

    *icc_data_ptr = icc_data;
    *icc_data_len = total_length;

    return TRUE;
}
