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


/* Mask clipping support */
#include "gx.h"
#include "gserrors.h"
#include "gxdevice.h"
#include "gxdevmem.h"
#include "gxmclip.h"

/* Structure descriptor */
public_st_device_mask_clip();

/* GC procedures */
static ENUM_PTRS_WITH(device_mask_clip_enum_ptrs, gx_device_mask_clip *mcdev)
{
    if (index < st_gx_strip_bitmap_max_ptrs) {
        return ENUM_USING(st_gx_strip_bitmap, &mcdev->tiles,
                          sizeof(mcdev->tiles), index);
    }
    index -= st_gx_strip_bitmap_max_ptrs;
    if (index < st_device_memory_max_ptrs) {
        return ENUM_USING(st_device_memory, &mcdev->mdev,
                          sizeof(mcdev->mdev), index);
    }
    ENUM_PREFIX(st_device_forward, st_device_memory_max_ptrs);
}
ENUM_PTRS_END
static RELOC_PTRS_WITH(device_mask_clip_reloc_ptrs, gx_device_mask_clip *mcdev)
{
    RELOC_PREFIX(st_device_forward);
    RELOC_USING(st_gx_strip_bitmap, &mcdev->tiles, sizeof(mcdev->tiles));
    RELOC_USING(st_device_memory, &mcdev->mdev, sizeof(mcdev->mdev));
    if (mcdev->mdev.base != 0) {
        /*
         * Update the line pointers specially, since they point into the
         * buffer that is part of the mask clipping device itself.
         */
        long diff = (char *)RELOC_OBJ(mcdev) - (char *)mcdev;
        int i;

        for (i = 0; i < mcdev->mdev.height; ++i)
            mcdev->mdev.line_ptrs[i] += diff;
        mcdev->mdev.base = mcdev->mdev.line_ptrs[0];
        mcdev->mdev.line_ptrs =
            (void *)((char *)(mcdev->mdev.line_ptrs) + diff);
    }
}
RELOC_PTRS_END

/* Initialize a mask clipping device. */
int
gx_mask_clip_initialize(gx_device_mask_clip * cdev,
                        const gx_device_mask_clip * proto,
                        const gx_bitmap * bits, gx_device * tdev,
                        int tx, int ty, gs_memory_t *mem)
{
    int buffer_width = bits->size.x;
    int buffer_height =
        tile_clip_buffer_size / (bits->raster + sizeof(byte *));

    if (mem == NULL)
        gx_device_init_on_stack((gx_device *)cdev,
                                (const gx_device *)proto,
                                tdev->memory);
    else
        (void)gx_device_init((gx_device *)cdev,
                             (const gx_device *)proto,
                             mem, true);
    cdev->width = tdev->width;
    cdev->height = tdev->height;
    cdev->color_info = tdev->color_info;
    gx_device_set_target((gx_device_forward *)cdev, tdev);
    cdev->phase.x = -tx;
    cdev->phase.y = -ty;
    if (buffer_height > bits->size.y)
        buffer_height = bits->size.y;
    gs_make_mem_mono_device(&cdev->mdev, 0, 0);
    for (;;) {
        ulong bitmap_size = max_ulong;

        /* Bug 702124: Allow for the case when size.y == 0 - then
         * buffer_height will be zero, and it's not a VMerror. */
        if (bits->size.y > 0 && buffer_height <= 0) {
            /*
             * The tile is too wide to buffer even one scan line.
             * We could do copy_mono in chunks, but for now, we punt.
             */
            cdev->mdev.base = 0;
            return_error(gs_error_VMerror);
        }
        cdev->mdev.width = buffer_width;
        cdev->mdev.height = buffer_height;
        gdev_mem_bitmap_size(&cdev->mdev, &bitmap_size);
        if (bitmap_size <= tile_clip_buffer_size)
            break;
        buffer_height--;
    }
    cdev->mdev.base = cdev->buffer.bytes;
    return (*dev_proc(&cdev->mdev, open_device))((gx_device *)&cdev->mdev);
}