/* Copyright (C) 2001-2025 Artifex Software, Inc.

   All Rights Reserved.

   This software is provided AS-IS with no warranty, either express or

   implied.

   This software is distributed under license and may not be copied,

   modified or distributed except as expressly authorized under the terms

   of the license contained in the file LICENSE in this distribution.

   Refer to licensing information at http://www.artifex.com or contact

   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,

   CA 94129, USA, for further information.

*/

/*  A cache for icc colorspaces that  were created from PS CIE color

    spaces or from PDF cal color spaces.

*/

#include "std.h"

#include "stdpre.h"

#include "gstypes.h"

#include "gsmemory.h"

#include "gsstruct.h"

#include "scommon.h"

#include "gx.h"

#include "gzstate.h"

#include "gscms.h"

#include "gsicc_profilecache.h"

#include "gserrors.h"

#include "assert_.h"

#define ICC_CACHE_MAXPROFILE 50

/* Static prototypes */

static void rc_gsicc_profile_cache_free(gs_memory_t * mem, void *ptr_in,

                                        client_name_t cname);

static void gsicc_remove_cs_entry(gsicc_profile_cache_t *profile_cache);

gs_private_st_ptrs2(st_profile_entry, gsicc_profile_entry_t,

                    "gsicc_profile_entry", profile_entry_enum_ptrs,

                    profile_entry_reloc_ptrs, color_space, next);

gs_private_st_ptrs1(st_profile_cache, gsicc_profile_cache_t,

                    "gsicc_profile_cache", profile_list_enum_ptrs,

                    profile_list_reloc_ptrs, head);

/**

 * gsicc_cache_new: Allocate a new ICC cache manager

 * Return value: Pointer to allocated manager, or NULL on failure.

 **/

gsicc_profile_cache_t *

gsicc_profilecache_new(gs_memory_t *memory)

{

    gsicc_profile_cache_t *result;

    /* We want this to be maintained in stable_memory.  It should not be effected by the

       save and restores */

    memory = memory->stable_memory;

    result = gs_alloc_struct(memory, gsicc_profile_cache_t,

                             &st_profile_cache, "gsicc_profilecache_new");

    if ( result == NULL )

        return(NULL);

    rc_init_free(result, memory, 1, rc_gsicc_profile_cache_free);

    result->head = NULL;

    result->num_entries = 0;

    result->memory = memory;

    return(result);

}

static void

rc_gsicc_profile_cache_free(gs_memory_t * mem, void *ptr_in, client_name_t cname)

{

    gsicc_profile_cache_t *profile_cache = (gsicc_profile_cache_t * ) ptr_in;

    gsicc_profile_entry_t *curr = profile_cache->head, *next;

    assert(mem->stable_memory == profile_cache->memory);

    while (curr != NULL ){

        next = curr->next;

        rc_decrement(curr->color_space, "rc_gsicc_profile_cache_free");

        gs_free_object(profile_cache->memory, curr,

                       "rc_gsicc_profile_cache_free");

        profile_cache->num_entries--;

        curr = next;

    }

#ifdef DEBUG

    if (profile_cache->num_entries != 0)

        emprintf1(mem,"gsicc_profile_cache_free, num_entries is %d (should be 0).\n",

                  profile_cache->num_entries);

#endif

    gs_free_object(profile_cache->memory, profile_cache,

                   "rc_gsicc_profile_cache_free");

}

int

gsicc_add_cs(gs_gstate * pgs, gs_color_space * colorspace, uint64_t dictkey)

{

    gsicc_profile_entry_t *result;

    gsicc_profile_cache_t *profile_cache = pgs->icc_profile_cache;

    gs_memory_t *memory =  profile_cache->memory;

    if (dictkey == 0)

        return 0;

    /* The entry has to be added in stable memory. We want them

       to be maintained across the gsave and grestore process */

    result = gs_alloc_struct(memory, gsicc_profile_entry_t,

                             &st_profile_entry, "gsicc_add_cs");

    if (result == NULL)

        return_error(gs_error_VMerror);

    /* If needed, remove an entry (the last one) */

    if (profile_cache->num_entries >= ICC_CACHE_MAXPROFILE) {

        gsicc_remove_cs_entry(profile_cache);

    }

    /* Add to the top of the list. That way we find the MRU enty right away.

       Last entry stays the same. */

    result->next = profile_cache->head;

    profile_cache->head = result; /* MRU */

    result->color_space = colorspace;

    rc_increment(colorspace);

    result->key = dictkey;

    if_debug2m(gs_debug_flag_icc, memory,

               "[icc] Add cs to cache = "PRI_INTPTR", hash = %"PRIu64"\n",

               (intptr_t)result->color_space, (uint64_t)result->key);

    profile_cache->num_entries++;

    return 0;

}

gs_color_space*

gsicc_find_cs(uint64_t key_test, gs_gstate * pgs)

{

    gsicc_profile_cache_t *profile_cache = pgs->icc_profile_cache;

    gsicc_profile_entry_t *prev = NULL, *curr = profile_cache->head;

    if (key_test == 0)

        return NULL;

    /* Look through the cache for the key. If found, move to MRU */

    while (curr != NULL ){

        if (curr->key == key_test){

            if_debug2m(gs_debug_flag_icc, pgs->memory,

                       "[icc] Found cs = "PRI_INTPTR", hash = %"PRIu64"\n",

                       (intptr_t)curr->color_space, (uint64_t)curr->key);

            /* If not already at head of list, move this one there */

            if (curr != profile_cache->head) {

                /* We need to move found one to the top of the list. */

                prev->next = curr->next;

                curr->next = profile_cache->head;

                profile_cache->head = curr;

            }

            return(curr->color_space);

        }

        prev = curr;

        curr = curr->next;

    }

    return(NULL);

}

/* Remove the LRU entry, which ideally is at the bottom. Note that there

   is no need to have a ref_count in this structure since the color

   space objects that are the member variables are reference counted themselves */

static void

gsicc_remove_cs_entry(gsicc_profile_cache_t *profile_cache)

{

    gs_memory_t *memory = profile_cache->memory;

    gsicc_profile_entry_t *prev = NULL, *curr = profile_cache->head;

#ifdef DEBUG

    if (curr == NULL) {

        emprintf(memory, " attempt to remove from an empty profile cache.\n");

        return; /* gs_abort(); */

    }

#endif

    while (curr->next != NULL) {

        prev = curr;

        curr = curr->next;

    }

    profile_cache->num_entries--;

    if (prev == NULL) {

        /* No more entries */

        profile_cache->head = NULL;

#ifdef DEBUG

    if (profile_cache->num_entries != 0) {

        emprintf1(memory, "profile cache list empty, but list has num_entries=%d.\n",

                  profile_cache->num_entries);

    }

#endif

    } else {

        prev->next = NULL;  /* new tail */

    }

    /* Decremented, but someone could still be referencing this */

    /* If found again in the source document, it will be regenerated

       and added back into the cache. */

    if_debug2m(gs_debug_flag_icc, memory,

               "[icc] Remove cs from cache = "PRI_INTPTR", hash = %"PRIu64"\n",

               (intptr_t)curr->color_space, (uint64_t)curr->key);

    rc_decrement(curr->color_space, "gsicc_remove_cs_entry");

    gs_free_object(memory, curr, "gsicc_remove_cs_entry");

}