/* Copyright (C) 2001-2026 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.

*/

/* jbig2decode filter implementation -- hooks in libjbig2dec */

#include "stdint_.h"

#include "memory_.h"

#include "stdio_.h" /* sprintf() for debug output */

#include "gserrors.h"

#include "gdebug.h"

#include "strimpl.h"

#include "sjbig2.h"

#include <limits.h>                     /* UINT_MAX */

/* stream implementation */

/* The /JBIG2Decode filter is a fairly memory intensive one to begin with,

   particularly in the initial jbig2dec library implementation. Furthermore,

   as a PDF 1.4 feature, we can assume a fairly large (host-level) machine.

   We therefore dispense with the normal Ghostscript memory discipline and

   let the library allocate all its resources on the heap. The pointers to

   these are not enumerated and so will not be garbage collected. We rely

   on our release() proc being called to deallocate state.

 */

private_st_jbig2decode_state(); /* creates a gc object for our state, defined in sjbig2.h */

/* error callback for jbig2 decoder */

static void

s_jbig2decode_error(void *callback_data, const char *msg, Jbig2Severity severity,

               uint32_t seg_idx)

{

    s_jbig2_callback_data_t *error_data = (s_jbig2_callback_data_t *)callback_data;

    const char *type;

    char segment[22];

    switch (severity) {

        case JBIG2_SEVERITY_DEBUG:

            type = "DEBUG"; break;;

        case JBIG2_SEVERITY_INFO:

            type = "info"; break;;

        case JBIG2_SEVERITY_WARNING:

            type = "WARNING"; break;;

        case JBIG2_SEVERITY_FATAL:

            type = "FATAL ERROR decoding image:";

            /* pass the fatal error upstream if possible */

            if (error_data != NULL) error_data->error = gs_error_ioerror;

            break;;

        default: type = "unknown message:"; break;;

    }

    if (seg_idx == JBIG2_UNKNOWN_SEGMENT_NUMBER) segment[0] = '\0';

    else gs_snprintf(segment, sizeof(segment), "(segment 0x%02x)", seg_idx);

    if (error_data)

    {

        char *message;

        int len;

        len = snprintf(NULL, 0, "jbig2dec %s %s %s", type, msg, segment);

        if (len < 0)

            return;

        message = (char *)gs_alloc_bytes(error_data->memory, len + 1, "sjbig2decode_error(message)");

        if (message == NULL)

            return;

        len = snprintf(message, len + 1, "jbig2dec %s %s %s", type, msg, segment);

        if (len < 0)

        {

            gs_free_object(error_data->memory, message, "s_jbig2decode_error(message)");

            return;

        }

        if (error_data->last_message != NULL && strcmp(message, error_data->last_message)) {

            if (error_data->repeats > 1)

            {

                if (error_data->severity == JBIG2_SEVERITY_FATAL || error_data->severity == JBIG2_SEVERITY_WARNING) {

                    dmlprintf1(error_data->memory, "jbig2dec last message repeated %ld times\n", error_data->repeats);

                } else {

                    if_debug1m('w', error_data->memory, "[w] jbig2dec last message repeated %ld times\n", error_data->repeats);

                }

            }

            gs_free_object(error_data->memory, error_data->last_message, "s_jbig2decode_error(last_message)");

            if (severity == JBIG2_SEVERITY_FATAL || severity == JBIG2_SEVERITY_WARNING) {

                dmlprintf1(error_data->memory, "%s\n", message);

            } else {

                if_debug1m('w', error_data->memory, "[w] %s\n", message);

            }

            error_data->last_message = message;

            error_data->severity = severity;

            error_data->type = type;

            error_data->repeats = 0;

        }

        else if (error_data->last_message != NULL) {

            error_data->repeats++;

            if (error_data->repeats % 1000000 == 0)

            {

                if (error_data->severity == JBIG2_SEVERITY_FATAL || error_data->severity == JBIG2_SEVERITY_WARNING) {

                    dmlprintf1(error_data->memory, "jbig2dec last message repeated %ld times so far\n", error_data->repeats);

                } else {

                    if_debug1m('w', error_data->memory, "[w] jbig2dec last message repeated %ld times so far\n", error_data->repeats);

                }

            }

            gs_free_object(error_data->memory, message, "s_jbig2decode_error(message)");

        }

        else if (error_data->last_message == NULL) {

            if (severity == JBIG2_SEVERITY_FATAL || severity == JBIG2_SEVERITY_WARNING) {

                dmlprintf1(error_data->memory, "%s\n", message);

            } else {

                if_debug1m('w', error_data->memory, "[w] %s\n", message);

            }

            error_data->last_message = message;

            error_data->severity = severity;

            error_data->type = type;

            error_data->repeats = 0;

        }

    }

    else

    {

/*

        FIXME s_jbig2_callback_data_t should be updated so that jbig2_ctx_new is not called

        with a NULL argument (see jbig2.h) and we never reach here with a NULL state

*/

        if (severity == JBIG2_SEVERITY_FATAL) {

            dlprintf3("jbig2dec %s %s %s\n", type, msg, segment);

        } else {

            if_debug3('w', "[w] jbig2dec %s %s %s\n", type, msg, segment);

        }

    }

}

static void

s_jbig2decode_flush_errors(void *callback_data)

{

    s_jbig2_callback_data_t *error_data = (s_jbig2_callback_data_t *)callback_data;

    if (error_data == NULL)

        return;

    if (error_data->last_message != NULL) {

        if (error_data->repeats > 1)

        {

            if (error_data->severity == JBIG2_SEVERITY_FATAL || error_data->severity == JBIG2_SEVERITY_WARNING) {

                dmlprintf1(error_data->memory, "jbig2dec last message repeated %ld times\n", error_data->repeats);

            } else {

                if_debug1m('w', error_data->memory, "[w] jbig2dec last message repeated %ld times\n", error_data->repeats);

            }

        }

        gs_free_object(error_data->memory, error_data->last_message, "s_jbig2decode_error(last_message)");

        error_data->last_message = NULL;

        error_data->repeats = 0;

    }

}

/* invert the bits in a buffer */

/* jbig2 and postscript have different senses of what pixel

   value is black, so we must invert the image */

static void

s_jbig2decode_invert_buffer(unsigned char *buf, size_t length)

{

    size_t i;

    for (i = 0; i < length; i++)

        *buf++ ^= 0xFF;

}

typedef struct {

        Jbig2Allocator allocator;

        gs_memory_t *mem;

} s_jbig2decode_allocator_t;

static void *s_jbig2decode_alloc(Jbig2Allocator *_allocator, size_t size)

{

        s_jbig2decode_allocator_t *allocator = (s_jbig2decode_allocator_t *) _allocator;

        if (size > UINT_MAX)

            return NULL;

        return gs_alloc_bytes(allocator->mem, size, "s_jbig2decode_alloc");

}

static void s_jbig2decode_free(Jbig2Allocator *_allocator, void *p)

{

        s_jbig2decode_allocator_t *allocator = (s_jbig2decode_allocator_t *) _allocator;

        gs_free_object(allocator->mem, p, "s_jbig2decode_free");

}

static void *s_jbig2decode_realloc(Jbig2Allocator *_allocator, void *p, size_t size)

{

        s_jbig2decode_allocator_t *allocator = (s_jbig2decode_allocator_t *) _allocator;

        if (size > UINT_MAX)

            return NULL;

        return gs_resize_object(allocator->mem, p, size, "s_jbig2decode_realloc");

}

/* parse a globals stream packed into a gs_bytestring for us by the postscript

   layer and stuff the resulting context into a pointer for use in later decoding */

int

s_jbig2decode_make_global_data(gs_memory_t *mem, byte *data, uint length, void **result)

{

    Jbig2Ctx *ctx = NULL;

    int code;

    s_jbig2decode_allocator_t *allocator;

    /* the cvision encoder likes to include empty global streams */

    if (length == 0) {

        if_debug0('w', "[w] ignoring zero-length jbig2 global stream.\n");

        *result = NULL;

        return 0;

    }

    allocator = (s_jbig2decode_allocator_t *) gs_alloc_bytes(mem,

            sizeof (s_jbig2decode_allocator_t), "s_jbig2_make_global_data");

    if (allocator == NULL) {

        *result = NULL;

        return_error(gs_error_VMerror);

    }

    allocator->allocator.alloc = s_jbig2decode_alloc;

    allocator->allocator.free = s_jbig2decode_free;

    allocator->allocator.realloc = s_jbig2decode_realloc;

    allocator->mem = mem;

    /* allocate a context with which to parse our global segments */

    ctx = jbig2_ctx_new((Jbig2Allocator *) allocator, JBIG2_OPTIONS_EMBEDDED,

                            NULL, s_jbig2decode_error, NULL);

    if (ctx == NULL) {

        gs_free_object(mem, allocator, "s_jbig2_make_global_data");

        return_error(gs_error_VMerror);

    }

    /* parse the global bitstream */

    code = jbig2_data_in(ctx, data, length);

    if (code) {

        /* error parsing the global stream */

        allocator = (s_jbig2decode_allocator_t *) jbig2_ctx_free(ctx);

        gs_free_object(allocator->mem, allocator, "s_jbig2_make_global_data");

        *result = NULL;

        return_error(gs_error_ioerror);

    }

    /* canonize and store our global state */

    *result = jbig2_make_global_ctx(ctx);

    return 0; /* todo: check for allocation failure */

}

/* release a global ctx pointer */

void

s_jbig2decode_free_global_data(void *data)

{

    Jbig2GlobalCtx *global_ctx = (Jbig2GlobalCtx*)data;

    s_jbig2decode_allocator_t *allocator;

    allocator = (s_jbig2decode_allocator_t *) jbig2_global_ctx_free(global_ctx);

    gs_free_object(allocator->mem, allocator, "s_jbig2decode_free_global_data");

}

/* store a global ctx pointer in our state structure.

 * If "gd" is NULL, then this library must free the global context.

 * If not-NULL, then it will be memory managed by caller, for example,

 * garbage collected in the case of the PS interpreter.

 * Currently gpdf will use NULL, and the PDF implemented in the gs interpreter would use

 * the garbage collection.

 */

int

s_jbig2decode_set_global_data(stream_state *ss, s_jbig2_global_data_t *gd, void *global_ctx)

{

    stream_jbig2decode_state *state = (stream_jbig2decode_state*)ss;

    state->global_struct = gd;

    state->global_ctx = global_ctx;

    return 0;

}

/* initialize the steam.

   this involves allocating the context structures, and

   initializing the global context from the /JBIG2Globals object reference

 */

static int

s_jbig2decode_init(stream_state * ss)

{

    stream_jbig2decode_state *const state = (stream_jbig2decode_state *) ss;

    Jbig2GlobalCtx *global_ctx = state->global_ctx; /* may be NULL */

    int code = 0;

    s_jbig2decode_allocator_t *allocator = NULL;

    state->callback_data = (s_jbig2_callback_data_t *)gs_alloc_bytes(

                                                ss->memory->non_gc_memory,

                                                sizeof(s_jbig2_callback_data_t),

            "s_jbig2decode_init(callback_data)");

    if (state->callback_data) {

        state->callback_data->memory = ss->memory->non_gc_memory;

        state->callback_data->error = 0;

        state->callback_data->last_message = NULL;

        state->callback_data->repeats = 0;

        allocator = (s_jbig2decode_allocator_t *) gs_alloc_bytes(ss->memory->non_gc_memory, sizeof (s_jbig2decode_allocator_t), "s_jbig2decode_init(allocator)");

        if (allocator == NULL) {

                s_jbig2decode_error(state->callback_data, "failed to allocate custom jbig2dec allocator", JBIG2_SEVERITY_FATAL, -1);

        }

        else {

                Jbig2Options options;

                allocator->allocator.alloc = s_jbig2decode_alloc;

                allocator->allocator.free = s_jbig2decode_free;

                allocator->allocator.realloc = s_jbig2decode_realloc;

                allocator->mem = ss->memory->non_gc_memory;

                /* initialize the decoder with the parsed global context if any */

#ifdef JBIG2_SUPPORTS_FORGIVING

                options = JBIG2_OPTIONS_EMBEDDED_FORGIVING;

#else

                options = JBIG2_OPTIONS_EMBEDDED; /* Old version of JBIG2. Do the best we can. */

#endif

                state->decode_ctx = jbig2_ctx_new((Jbig2Allocator *) allocator, options,

                             global_ctx, s_jbig2decode_error, state->callback_data);

                if (state->decode_ctx == NULL) {

                        gs_free_object(allocator->mem, allocator, "s_jbig2decode_release");

                }

        }

        code = state->callback_data->error;

    }

    else {

        code = gs_error_VMerror;

    }

    state->image = 0;

    return_error (code);

}

/* process a section of the input and return any decoded data.

   see strimpl.h for return codes.

 */

static int

s_jbig2decode_process(stream_state * ss, stream_cursor_read * pr,

                  stream_cursor_write * pw, bool last)

{

    stream_jbig2decode_state *const state = (stream_jbig2decode_state *) ss;

    Jbig2Image *image = state->image;

    size_t in_size = pr->limit - pr->ptr;

    size_t out_size = pw->limit - pw->ptr;

    int status = 0;

    /* there will only be a single page image,

       so pass all data in before looking for any output.

       note that the gs stream library expects offset-by-one

       indexing of the buffers, while jbig2dec uses normal 0 indexes */

    if (in_size > 0) {

        /* pass all available input to the decoder */

        jbig2_data_in(state->decode_ctx, pr->ptr + 1, in_size);

        pr->ptr += in_size;

        /* simulate end-of-page segment */

        if (last == 1) {

            jbig2_complete_page(state->decode_ctx);

        }

        /* handle fatal decoding errors reported through our callback */

        if (state->callback_data->error) return state->callback_data->error;

    } else {

        /* Ran out of input, try and terminate cleanly */

        if (last == 1) {

            jbig2_complete_page(state->decode_ctx);

        }

    }

    if (out_size > 0) {

        if (image == NULL) {

            /* see if a page image in available */

            image = jbig2_page_out(state->decode_ctx);

            if (image != NULL) {

                state->image = image;

                state->offset = 0;

            }

        }

        if (image != NULL) {

            /* copy data out of the decoded image, if any */

            size_t image_size = (size_t)image->height*image->stride;

            size_t usable = min(image_size - state->offset, out_size);

            memcpy(pw->ptr + 1, image->data + state->offset, usable);

            s_jbig2decode_invert_buffer(pw->ptr + 1, usable);

            state->offset += usable;

            pw->ptr += usable;

            status = (state->offset < image_size) ? 1 : 0;

        }

    }

    return status;

}

/* stream release.

   free all our decoder state.

 */

static void

s_jbig2decode_release(stream_state *ss)

{

    stream_jbig2decode_state *const state = (stream_jbig2decode_state *) ss;

    if (state->decode_ctx) {

        s_jbig2decode_allocator_t *allocator = NULL;

        if (state->image) jbig2_release_page(state->decode_ctx, state->image);

  state->image = NULL;

        s_jbig2decode_flush_errors(state->callback_data);

        allocator = (s_jbig2decode_allocator_t *) jbig2_ctx_free(state->decode_ctx);

  state->decode_ctx = NULL;

        gs_free_object(allocator->mem, allocator, "s_jbig2decode_release");

    }

    if (state->callback_data) {

        gs_memory_t *mem = state->callback_data->memory;

        gs_free_object(state->callback_data->memory, state->callback_data->last_message, "s_jbig2decode_release(message)");

        gs_free_object(mem, state->callback_data, "s_jbig2decode_release(callback_data)");

  state->callback_data = NULL;

    }

    if (state->global_struct != NULL) {

        /* the interpreter calls jbig2decode_free_global_data() separately */

    } else {

        /* We are responsible for freeing global context */

        if (state->global_ctx) {

            s_jbig2decode_free_global_data(state->global_ctx);

            state->global_ctx = NULL;

        }

    }

}

void

s_jbig2decode_finalize(const gs_memory_t *cmem, void *vptr)

{

    (void)cmem;

    s_jbig2decode_release((stream_state *)vptr);

}

/* set stream defaults.

   this hook exists to avoid confusing the gc with bogus

   pointers. we use it similarly just to NULL all the pointers.

   (could just be done in _init?)

 */

static void

s_jbig2decode_set_defaults(stream_state *ss)

{

    stream_jbig2decode_state *const state = (stream_jbig2decode_state *) ss;

    /* state->global_ctx is not owned by us */

    state->global_struct = NULL;

    state->global_ctx = NULL;

    state->decode_ctx = NULL;

    state->image = NULL;

    state->offset = 0;

    state->callback_data = NULL;

}

/* stream template */

const stream_template s_jbig2decode_template = {

    &st_jbig2decode_state,

    s_jbig2decode_init,

    s_jbig2decode_process,

    1, 1, /* min in and out buffer sizes we can handle --should be ~32k,64k for efficiency? */

    s_jbig2decode_release,

    s_jbig2decode_set_defaults

};