Cppcheck report - GATE C/C++ Framework: gate/graphics/pixmapimages.c

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger                                  |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/

#include "gate/graphics/pixmapimages.h"
#include "gate/strings.h"
#include "gate/results.h"
#include "gate/maps.h"
#include "gate/comparers.h"
#include "gate/debugging.h"
#include "gate/arrays.h"

gate_result_t gate_pixmapimage_parse(char const* const* lines, gate_rasterimage_t* image,
    gate_int32_t* hotspot_x, gate_int32_t* hotspot_y)
{
    gate_int64_t width, height, colors, depth, hx, hy, x, y;
    gate_result_t ret;
    char const* lineptr;
<--- The scope of the variable 'lineptr' can be reduced. [+]
The scope of the variable 'lineptr' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_size_t linelen;
    gate_size_t result;
    gate_size_t ndx;
    gate_size_t col_count;
    gate_map_t colormap = GATE_INIT_EMPTY;
    gate_string_t line;
    gate_size_t colmarkerlen;
    gate_size_t coldescroffset;
    gate_string_t colmarker;
    gate_string_t coldescriptor;
    gate_color_t color;
    gate_color_t* colorptr;
    gate_color_t const* currentcolor;
    static gate_color_t const transparent_color = { { 1, 1, 1, 0 } };

    GATE_UNUSED_ARG(hotspot_x);
    GATE_UNUSED_ARG(hotspot_y);

    do
    {
        if (lines == NULL)
        {
            ret = GATE_RESULT_NULLPOINTER;
            break;
        }
        lineptr = lines[0];
        linelen = gate_str_length(lineptr);

        if (0 == (result = gate_str_parse_int64(lineptr, linelen, &width))) { ret = GATE_RESULT_INVALIDHEADER; break; };
        lineptr += result; linelen -= result;

        if (0 == (result = gate_str_parse_int64(lineptr, linelen, &height))) { ret = GATE_RESULT_INVALIDHEADER; break; };
        lineptr += result; linelen -= result;

        if (0 == (result = gate_str_parse_int64(lineptr, linelen, &colors))) { ret = GATE_RESULT_INVALIDHEADER; break; };
        lineptr += result; linelen -= result;
        col_count = (gate_size_t)colors;

        if (0 == (result = gate_str_parse_int64(lineptr, linelen, &depth))) { ret = GATE_RESULT_INVALIDHEADER; break; };
        lineptr += result; linelen -= result;

        if (0 == (result = gate_str_parse_int64(lineptr, linelen, &hx))) { hx = 0; };
        lineptr += result; linelen -= result;

        if (0 == (result = gate_str_parse_int64(lineptr, linelen, &hy))) { hy = 0; };
        lineptr += result; linelen -= result;

        if (NULL == gate_map_create(&colormap, &gate_compare_string,
            sizeof(gate_string_t), &gate_string_copy_constructor, &gate_string_destructor,
            sizeof(gate_color_t), NULL, NULL))
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        ret = GATE_RESULT_OK;
        ++lines;

        colmarkerlen = (gate_size_t)depth;
        coldescroffset = colmarkerlen + 1;

        /* build the color map that connects all text-tokens to a parsed color value */
        for (ndx = 0; ndx != col_count; ++ndx, ++lines)
        {
            if (NULL == gate_string_create_static(&line, *lines))
            {
                ret = GATE_RESULT_OUTOFMEMORY;
                break;
            }
            if (gate_string_length(&line) <= coldescroffset)
            {
                ret = GATE_RESULT_INVALIDDATA;
                break;
            }

            switch (line.str[coldescroffset])
            {
            case 'c':
            case 'g':
            {
                if (NULL == gate_string_substr(&colmarker, &line, 0, colmarkerlen))
                {
                    continue;
                }
                if (NULL == gate_string_substr(&coldescriptor, &line, coldescroffset + 2, GATE_STR_NPOS))
                {
                    gate_string_release(&colmarker);
                    continue;
                }

                if (gate_str_starts_with_ic(coldescriptor.str, coldescriptor.length, "none", 4))
                {
                    gate_map_add(&colormap, &colmarker, &transparent_color);
                }
                else
                {
                    if (gate_color_parse_hex(coldescriptor.str, coldescriptor.length, &color))
                    {
                        gate_map_add(&colormap, &colmarker, &color);
                    }
                }

                gate_string_release(&coldescriptor);
                gate_string_release(&colmarker);
                break;
            }
            }
            gate_string_release(&line);
        }

        if (GATE_FAILED(ret))
        {
            break;
        }

        if (NULL == gate_rasterimage_create(image, GATE_IMAGE_PIXELFORMAT_DEFAULT,
            (gate_uint32_t)width, (gate_uint32_t)height, NULL))
        {

            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        /* set pixels of image by finding the text token in the colormap */

        colorptr = (gate_color_t*)gate_rasterimage_get_line_ptr(image, 0);
        for (y = 0; y != height; ++y, ++lines)
        {
            if (NULL == gate_string_create_static(&line, *lines))
            {
                ret = GATE_RESULT_OUTOFMEMORY;
                break;
            }

            GATE_DEBUG_ASSERT(line.length == (gate_size_t)(width * depth));

            for (x = 0, ndx = 0; x != width; ++x, ++colorptr)
            {

                if (NULL != gate_string_substr(&colmarker, &line, ndx, (gate_size_t)depth))
                {
                    currentcolor = (gate_color_t const*)gate_map_get_value(&colormap, &colmarker);
                    if (currentcolor != NULL)
                    {
                        *colorptr = *currentcolor;
                    }
                    gate_string_release(&colmarker);
                }
                ndx += (gate_size_t)depth;
            }

            gate_string_release(&line);
        }

    } while (0);

    gate_map_destroy(&colormap);

    return ret;
}

typedef enum pixmap_loader_state_enum
{
    pls_header,
    pls_info,
    pls_palette,
    pls_content,
    pls_end,
    pls_error,
} pixmap_loader_state_t;

typedef struct pixmap_info_class
{
    unsigned width;
    unsigned height;
    unsigned colors;
    unsigned bytes_per_pixel;
} pixmap_info_t;

static gate_string_t* decode_pixmap_line(gate_string_t* target, gate_string_t const* src)
{
    gate_size_t pos;
    if (!gate_string_starts_with_char(src, '\"'))
    {
        return NULL;
    }
    pos = gate_string_char_pos_last(src, '\"');
    if ((GATE_STR_NPOS == pos) || (0 == pos))
    {
        return NULL;
    }
    gate_string_substr(target, src, 1, pos - 1);
    return target;
}

static pixmap_info_t* parse_info(pixmap_info_t* info, gate_string_t const* content)
{
    static gate_string_t const sep = GATE_STRING_INIT_STATIC(" ");
    gate_string_t data = GATE_STRING_INIT_EMPTY;
    gate_string_t item = GATE_STRING_INIT_EMPTY;
    unsigned numbers[32] = { 0 };
    unsigned ndx = 0;
    gate_bool_t continue_parse = true;
    gate_size_t len_parsed;
    gate_uint64_t num;

    gate_string_duplicate(&data, content);
    while (continue_parse && (ndx < sizeof(numbers) / sizeof(numbers[0])))
    {
        len_parsed = gate_string_parse(&data, &sep, 0, &item, &data, false);
        if (len_parsed > 0)
        {
            if (0 != gate_string_parse_uint(&item, &num))
            {
                numbers[ndx] = (unsigned)num;
                ++ndx;
            }
        }
        else
        {
            if (0 != gate_string_parse_uint(&data, &num))
            {
                numbers[ndx] = (unsigned)num;
                ++ndx;
            }
            continue_parse = false;
        }
    }
    gate_string_release(&data);
    if (ndx >= 4)
    {
        info->width = numbers[0];
        info->height = numbers[1];
        info->colors = numbers[2];
        info->bytes_per_pixel = numbers[3];
        if ((info->width > 0) && (info->width <= 4096)
            && (info->height > 0) && (info->height <= 4096)
            && (info->colors > 0) && (info->colors <= 4096)
            && (info->bytes_per_pixel > 0) && (info->bytes_per_pixel <= 4)
            )
        {
            return info;
        }
    }
    return NULL;
}

typedef struct pixmap_color_class
{
    char			token[4];
    gate_color_t	col;
} pixmap_color_t;

static void parse_color_token(gate_color_t* col, char const* str, gate_size_t len)
{
    gate_mem_clear(col, sizeof(gate_color_t));
    if (str[0] == '#')
    {
        gate_str_parse_hex_byte(&str[1], &col->r);
        gate_str_parse_hex_byte(&str[3], &col->g);
        gate_str_parse_hex_byte(&str[5], &col->b);
        col->a = 255;
    }
}

static pixmap_color_t* parse_color(pixmap_color_t* col, pixmap_info_t const* info, gate_string_t const* data)
{
    char type_chr;
    gate_mem_clear(col, sizeof(pixmap_color_t));
    gate_mem_copy(&col->token[0], data->str, info->bytes_per_pixel);
    type_chr = data->str[info->bytes_per_pixel + 1];
    if ((type_chr == 'c') || (type_chr == 'g'))
    {
        parse_color_token(&col->col, &data->str[info->bytes_per_pixel + 3], data->length - info->bytes_per_pixel - 3);
    }
    return col;
}

static void parse_image_line(gate_color_t* ptr_pixels, pixmap_info_t const* info, gate_arraylist_t colors, gate_string_t const* data)
{
    gate_size_t len = gate_string_length(data) / info->bytes_per_pixel;
    gate_size_t ndx;
    pixmap_color_t const* ptr_colentries = (pixmap_color_t const*)gate_arraylist_get(colors, 0);
    pixmap_color_t const* ptr_curentry;
    gate_size_t colcount = gate_arraylist_length(colors);
    char const* ptr_curdata;
    unsigned x;
    if (len > info->width)
    {
        len = info->width;
    }
    ptr_curdata = data->str;
    for (x = 0; x != len; ++x, ++ptr_pixels)
    {
        ptr_curentry = ptr_colentries;
        for (ndx = 0; ndx != colcount; ++ndx, ++ptr_curentry)
        {
            if (0 == gate_mem_compare(ptr_curdata, ptr_curentry->token, info->bytes_per_pixel))
            {
                *ptr_pixels = ptr_curentry->col;
                break;
            }
        }
        ptr_curdata += info->bytes_per_pixel;
    }
}

gate_result_t gate_pixmapimage_load(gate_stream_t* srcstream, gate_rasterimage_t* image, gate_enumint_t flags)
{
    gate_result_t result = GATE_RESULT_FAILED;
    char linebuffer[4096];
    gate_size_t linelen;
    pixmap_loader_state_t state = pls_header;
    gate_string_t line = GATE_STRING_INIT_EMPTY;
    gate_string_t content = GATE_STRING_INIT_EMPTY;
    pixmap_info_t info = GATE_INIT_EMPTY;
    gate_arraylist_t colors = NULL;
    pixmap_color_t colmapping;
    gate_color_t* ptr_pixel;
    unsigned y = 0;
    GATE_UNUSED_ARG(flags);

    do
    {
        if (!srcstream || !image)
        {
            result = GATE_RESULT_INVALIDARG;
            break;
        }

        colors = gate_arraylist_create(sizeof(pixmap_color_t), NULL, 0, NULL, NULL);

        gate_mem_clear(image, sizeof(gate_rasterimage_t));

        while ((state != pls_end) && (state != pls_error))
        {
            result = gate_stream_read_line(srcstream, linebuffer, sizeof(linebuffer), &linelen);
            GATE_BREAK_IF_FAILED(result);
            if (linelen == 0)
            {
                break;
            }

            gate_string_create_static_len(&line, linebuffer, linelen);
            gate_string_trim(&line, &line);
            if (0 == gate_string_length(&line))
            {
                continue;
            }
            if (gate_string_starts_with_str(&line, "/*") || gate_string_ends_with_str(&line, "*/"))
            {
                continue;
            }

            switch (state)
            {
            case pls_header:
            {
                if (gate_string_ends_with_char(&line, '{'))
                {
                    /* header is skipped -> read info line */
                    state = pls_info;
                }
                break;
            }
            case pls_info:
            {
                if (NULL == decode_pixmap_line(&content, &line))
                {
                    result = GATE_RESULT_INVALIDINPUT;
                    state = pls_error;
                    break;
                }
                if (NULL == parse_info(&info, &content))
                {
                    result = GATE_RESULT_INVALIDINPUT;
                    state = pls_error;
                    break;
                }
                if (NULL == gate_rasterimage_create(image, GATE_IMAGE_PIXELFORMAT_RGBA, info.width, info.height, NULL))
                {
                    result = GATE_RESULT_OUTOFMEMORY;
                    state = pls_error;
                    break;
                }
                state = pls_palette;
                break;
            }
            case pls_palette:
            {
                if (NULL == decode_pixmap_line(&content, &line))
                {
                    result = GATE_RESULT_INVALIDINPUT;
                    state = pls_error;
                    break;
                }
                if (NULL == parse_color(&colmapping, &info, &content))
                {
                    result = GATE_RESULT_INVALIDINPUT;
                    state = pls_error;
                    break;
                }
                if (NULL == gate_arraylist_add(colors, &colmapping))
                {
                    result = GATE_RESULT_OUTOFMEMORY;
                    state = pls_error;
                    break;
                }
                if (gate_arraylist_length(colors) >= info.colors)
                {
                    state = pls_content;
                }
                break;
            }
            case pls_content:
            {
                if (NULL == decode_pixmap_line(&content, &line))
                {
                    result = GATE_RESULT_INVALIDINPUT;
                    state = pls_error;
                    break;
                }
                ptr_pixel = (gate_color_t*)gate_rasterimage_get_line_ptr(image, y);
                if (ptr_pixel)
                {
                    parse_image_line(ptr_pixel, &info, colors, &content);
                }
                ++y;
                if (y >= info.height)
                {
                    state = pls_end;
                }
                break;
            }
            case pls_end:
            case pls_error:
            {
                break;
            }
            }
            gate_string_release(&content);
        }

        GATE_BREAK_IF_FAILED(result);
        if (state != pls_end)
        {
            gate_rasterimage_release(image);
            result = GATE_RESULT_INVALIDSTATE;
        }
    } while (0);

    gate_arraylist_release(colors);

    return result;
}

static void copy_rgba(gate_uint8_t* dst, gate_uint8_t const* src, gate_size_t len)
{
    gate_mem_copy(dst, src, len * 4);
}

static gate_string_t const pix_chars = GATE_STRING_INIT_STATIC(" _.,:;~#=+-*/|^!$%&()[]{}<>@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");

static void print_color(gate_stream_t* strm, gate_uint32_t col, gate_uint16_t n)
{
    char const* ptr = gate_string_ptr(&pix_chars, 0);
    const gate_size_t ccount = gate_string_length(&pix_chars);
    gate_uint16_t ndx1 = (gate_uint16_t)((gate_size_t)n / (gate_size_t)ccount);
    gate_uint16_t ndx2 = (gate_uint16_t)((gate_size_t)n % (gate_size_t)ccount);
    gate_color_t c;
    c.rgba = col;

    if (ndx1 >= ccount)
    {
        ndx1 = 0;
    }

    gate_stream_print(strm,
        GATE_PRINT_CSTR, "\"",
        GATE_PRINT_CHAR, ptr[ndx1],
        GATE_PRINT_CHAR, ptr[ndx2],
        GATE_PRINT_CSTR, " g ",
        GATE_PRINT_END);

    if (c.a < 128)
    {
        gate_stream_print(strm,
            GATE_PRINT_CSTR, "None",
            GATE_PRINT_END);
    }
    else
    {
        gate_stream_print(strm,
            GATE_PRINT_CSTR, "#",
            GATE_PRINT_H8, c.r,
            GATE_PRINT_H8, c.g,
            GATE_PRINT_H8, c.b,
            GATE_PRINT_END);
    }

    gate_stream_print(strm,
        GATE_PRINT_CSTR, "\",\n",
        GATE_PRINT_END);
}

gate_result_t gate_pixmapimage_save(gate_rasterimage_t const* image, gate_stream_t* deststream, gate_enumint_t flags)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_map_t col_map = GATE_INIT_EMPTY;
    char const* ptr = gate_string_ptr(&pix_chars, 0);
    const gate_size_t ccount = gate_string_length(&pix_chars);
    gate_uint16_t ncol = 0;
    unsigned y, x;
    gate_uint8_t const* ptr_image_line;
    gate_color_converter_t line_writer = NULL;
    gate_uint8_t buffer[4096];
    gate_uint8_t* ptr_buffer = &buffer[0];
    gate_color_t const* ptr_pixel;
    gate_uint16_t col_count;
    gate_color_t c;
    gate_map_iterator_t col_iter;

    do
    {
        switch (image->pixel_format)
        {
        case GATE_IMAGE_PIXELFORMAT_RGBA:
        case GATE_IMAGE_PIXELFORMAT_RGB32:	line_writer = &copy_rgba; break;
        case GATE_IMAGE_PIXELFORMAT_BGRA:
        case GATE_IMAGE_PIXELFORMAT_BGR32:	line_writer = &gate_color_convert_rgba_from_bgra_32; break;

        case GATE_IMAGE_PIXELFORMAT_RGB24:	line_writer = &gate_color_convert_rgba_from_rgb_24; break;
        case GATE_IMAGE_PIXELFORMAT_BGR24:	line_writer = &gate_color_convert_rgba_from_bgr_24; break;

        case GATE_IMAGE_PIXELFORMAT_RGB555:	line_writer = &gate_color_convert_rgba_from_rgb_15; break;
        case GATE_IMAGE_PIXELFORMAT_RGB565:	line_writer = &gate_color_convert_rgba_from_rgb_16; break;
        case GATE_IMAGE_PIXELFORMAT_ARGB4:	line_writer = &gate_color_convert_rgba_from_argb_16; break;
        case GATE_IMAGE_PIXELFORMAT_YUV2:	line_writer = &gate_color_convert_rgba_from_yuv2_16; break;

        case GATE_IMAGE_PIXELFORMAT_PAL8:	line_writer = &gate_color_convert_rgba_from_pal_8; break;
        case GATE_IMAGE_PIXELFORMAT_GRAY8:	line_writer = &gate_color_convert_rgba_from_gray_8; break;
        default:
            break;
        }

        if (line_writer == NULL)
        {
            ret = GATE_RESULT_NOTSUPPORTED;
            break;
        }

        c.rgba = 0;
        gate_map_create(&col_map, gate_compare_uint32, sizeof(gate_uint32_t), NULL, NULL, sizeof(gate_uint16_t), NULL, NULL);
        gate_map_add(&col_map, &c.rgba, &ncol);
        ++ncol;

        for (y = 0; y != image->height; ++y)
        {
            ptr_image_line = (gate_uint8_t const*)gate_rasterimage_get_line_ptr(image, y);
            line_writer(ptr_buffer, ptr_image_line, image->width);
            ptr_pixel = (gate_color_t const*)ptr_buffer;
            for (x = 0; x != image->width; ++x)
            {
                if (NULL == gate_map_get(&col_map, &ptr_pixel[x].rgba))
                {
                    gate_map_add(&col_map, &ptr_pixel[x].rgba, &ncol);
                    ++ncol;
                }
            }
        }

        col_count = (gate_uint16_t)gate_map_count(&col_map);

        gate_stream_print(deststream,
            GATE_PRINT_CSTR, "/* XPM */\nstatic char const * gate_icon_brick_xpm[] = {\n\"",
            GATE_PRINT_UI16, (gate_uint16_t)image->width,
            GATE_PRINT_CSTR, " ",
            GATE_PRINT_UI16, (gate_uint16_t)image->height,
            GATE_PRINT_CSTR, " ",
            GATE_PRINT_UI16, (gate_uint16_t)col_count,
            GATE_PRINT_CSTR, " ",
            GATE_PRINT_UI16, (gate_uint16_t)2,
            GATE_PRINT_CSTR, "\",\n",
            GATE_PRINT_END
        );

        col_iter = gate_map_first(&col_map);
        while (col_iter)
        {
            print_color(deststream,
                *(gate_uint32_t const*)gate_map_iterator_key(col_iter),
                *(gate_uint16_t const*)gate_map_iterator_value(col_iter));
            col_iter = gate_map_iterator_next(col_iter);
        }

        for (y = 0; y != image->height; ++y)
        {
            ptr_image_line = (gate_uint8_t const*)gate_rasterimage_get_line_ptr(image, y);
            line_writer(ptr_buffer, ptr_image_line, image->width);
            ptr_pixel = (gate_color_t const*)ptr_buffer;
            gate_stream_print(deststream, GATE_PRINT_CSTR, "\"", GATE_PRINT_END);
            for (x = 0; x != image->width; ++x)
            {
                gate_uint16_t const* ptr_n = gate_map_get_value(&col_map, &ptr_pixel[x].rgba);
                if (ptr_n == NULL)
                {
                    gate_stream_print(deststream, GATE_PRINT_CSTR, "  ", GATE_PRINT_END);
                }
                else
                {
                    gate_uint16_t ndx1 = (gate_uint16_t)((gate_size_t)*ptr_n / (gate_size_t)ccount);
                    gate_uint16_t ndx2 = (gate_uint16_t)((gate_size_t)*ptr_n % (gate_size_t)ccount);
                    if (ndx1 >= ccount)
                    {
                        ndx1 = 0;
                    }
                    gate_stream_print(deststream,
                        GATE_PRINT_CHAR, ptr[ndx1],
                        GATE_PRINT_CHAR, ptr[ndx2],
                        GATE_PRINT_END);
                }
            }
            gate_stream_print(deststream, GATE_PRINT_CSTR, "\",\n", GATE_PRINT_END);
        }
        gate_stream_print(deststream,
            GATE_PRINT_CSTR, "};\n",
            GATE_PRINT_END
        );

        ret = GATE_RESULT_OK;

    } while (0);

    gate_map_destroy(&col_map);
    return ret;
}