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

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

#include "grk_apps_config.h"

#ifndef GROK_HAVE_LIBJPEG
#error GROK_HAVE_LIBJPEG_NOT_DEFINED
#endif /* GROK_HAVE_LIBJPEG */

/*
 * 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 */

	/* 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 */
		uint32_t 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 bool 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.
 */

bool 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 = nullptr; /* 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 != nullptr; 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 TRUE;

	/* 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 == nullptr)
		return FALSE; /* oops, out of memory */

	/* and fill it in */
	for(marker = cinfo->marker_list; marker != nullptr; 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;
}
