19918707358

Committed 04 Dec 2025 05:12AM UTC coverage: 38.402% (-4.0%) from 42.395%

Build # 19918707358

Build Type

push

github

Committed by

saitoha

Commit Message

tests: fix meson msys dll lookup

Run Details

9738 of 38220 branches covered (25.48%)

12841 of 33438 relevant lines covered (38.4%)

782420.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.25

/src/fromsixel.c

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright (c) 2025 libsixel developers. See `AUTHORS`.
 * Copyright (c) 2014-2016 Hayaki Saito
 * Copyright (c) 2014 kmiya@culti
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * This file is derived from "sixel" original version (2014-3-2)
 * http://nanno.dip.jp/softlib/man/rlogin/sixel.tar.gz
 *
 */

/*
 * Initial developer of this file is kmiya@culti.
 *
 * He distributes it under very permissive license which permits
 * useing, copying, modification, redistribution, and all other
 * public activities without any restrictions.
 *
 * He declares this is compatible with MIT/BSD/GPL.
 *
 * Hayaki Saito <saitoha@me.com> modified this and re-licensed
 * it to the MIT license.
 */
#include "config.h"

/* STDC_HEADERS */
#include <stdlib.h>
#include <stdio.h>

#if HAVE_CTYPE_H
# include <ctype.h>   /* isdigit */
#endif  /* HAVE_CTYPE_H */
#if HAVE_STRING_H
# include <string.h>  /* memcpy */
#endif  /* HAVE_STRING_H */
#if HAVE_LIMITS_H
# include <limits.h>
#endif  /* HAVE_LIMITS_H */
#if HAVE_INTTYPES_H
# include <inttypes.h>
#endif  /* HAVE_INTTYPES_H */
#if HAVE_ASSERT_H
# include <assert.h>
#endif  /* HAVE_ASSERT_H */

#include <sixel.h>
#include "output.h"
#include "decoder-image.h"
#include "decoder-parallel.h"
#include "logger.h"

#define SIXEL_RGB(r, g, b) (((r) << 16) + ((g) << 8) +  (b))

#define PALVAL(n,a,m) (((n) * (a) + ((m) / 2)) / (m))

#define SIXEL_XRGB(r,g,b) SIXEL_RGB(PALVAL(r, 255, 100), PALVAL(g, 255, 100), PALVAL(b, 255, 100))

#define DECSIXEL_PARAMS_MAX 16
#define SIXEL_PALETTE_MAX_DECODER 65536
typedef unsigned char sixel_decoder_index_t;

static int const sixel_default_color_table[] = {
    SIXEL_XRGB(0,  0,  0),   /*  0 Black    */
    SIXEL_XRGB(20, 20, 80),  /*  1 Blue     */
    SIXEL_XRGB(80, 13, 13),  /*  2 Red      */
    SIXEL_XRGB(20, 80, 20),  /*  3 Green    */
    SIXEL_XRGB(80, 20, 80),  /*  4 Magenta  */
    SIXEL_XRGB(20, 80, 80),  /*  5 Cyan     */
    SIXEL_XRGB(80, 80, 20),  /*  6 Yellow   */
    SIXEL_XRGB(53, 53, 53),  /*  7 Gray 50% */
    SIXEL_XRGB(26, 26, 26),  /*  8 Gray 25% */
    SIXEL_XRGB(33, 33, 60),  /*  9 Blue*    */
    SIXEL_XRGB(60, 26, 26),  /* 10 Red*     */
    SIXEL_XRGB(33, 60, 33),  /* 11 Green*   */
    SIXEL_XRGB(60, 33, 60),  /* 12 Magenta* */
    SIXEL_XRGB(33, 60, 60),  /* 13 Cyan*    */
    SIXEL_XRGB(60, 60, 33),  /* 14 Yellow*  */
    SIXEL_XRGB(80, 80, 80),  /* 15 Gray 75% */
};


/*
 * Store a single pixel in the image buffer. When the decoder is in direct
 * color mode the palette index is translated into an RGBA quadruplet with an
 * opaque alpha channel. Indexed mode keeps the original palette entry so the
 * caller can compose a palette later.
 */
static void
image_buffer_store_pixel(image_buffer_t *image, size_t pos, int color_index)
{
    unsigned char *bytes;
    int color;
    int depth;

    depth = image->depth;
    if (color_index < 0 || color_index >= SIXEL_PALETTE_MAX_DECODER) {
        return;
    }

    if (depth == 1U) {
        image->pixels.in_bytes[pos] = (unsigned char)color_index;
    } else if (depth == 2U) {
        image->pixels.in_shorts[pos] = (unsigned short)color_index;
    } else {  /* rgba */
        color = image->palette[color_index];
        bytes = image->pixels.in_bytes + pos * 4U;
        bytes[0] = (unsigned char)((color >> 16) & 0xff);
        bytes[1] = (unsigned char)((color >> 8) & 0xff);
        bytes[2] = (unsigned char)(color & 0xff);
        bytes[3] = 255u;
    }
}

/*
 * Fill a horizontal run starting at (x, y) with the requested palette index.
 * Direct color output expands the span into RGBA bytes to keep the alpha
 * channel and the color components consistent with single pixel writes.
 */
static void
image_buffer_fill_span(image_buffer_t *image,
                       int y,
                       int x,
                       int repeat,
                       int color_index)
{
    size_t pos;
    int n;

    pos = (size_t)image->width * (size_t)y + (size_t)x;

    if (image->depth == 1U) {
        memset(image->pixels.in_bytes + pos, color_index, (size_t)repeat);
    } else {
        for (n = 0; n < repeat; ++n) {
            image_buffer_store_pixel(image, pos + (size_t)n, color_index);
        }
    }
}

typedef enum parse_state {
    PS_GROUND     = 0,
    PS_ESC        = 1,  /* ESC */
    PS_DCS        = 2,  /* DCS Device Control String Introducer \033P P...P I...I F */
    PS_DECSIXEL   = 3,  /* DECSIXEL body part ", $, -, ? ... ~ */
    PS_DECGRA     = 4,  /* DECGRA Set Raster Attributes " Pan; Pad; Ph; Pv */
    PS_DECGRI     = 5,  /* DECGRI Graphics Repeat Introducer ! Pn Ch */
    PS_DECGCI     = 6   /* DECGCI Graphics Color Introducer # Pc; Pu; Px; Py; Pz */
} parse_state_t;

typedef struct parser_context {
    parse_state_t state;
    int pos_x;
    int pos_y;
    int max_x;
    int max_y;
    int attributed_pan;
    int attributed_pad;
    int attributed_ph;
    int attributed_pv;
    int repeat_count;
    int color_index;
    int bgindex;
    int param;
    int nparams;
    int params[DECSIXEL_PARAMS_MAX];
} parser_context_t;


/*
 * Primary color hues:
 *  blue:    0 degrees
 *  red:   120 degrees
 *  green: 240 degrees
 */
static int
hls_to_rgb(int hue, int lum, int sat)
{
    double min, max;
    int r, g, b;

    if (sat == 0) {
        r = g = b = lum;
    }

    /* https://wikimedia.org/api/rest_v1/media/math/render/svg/17e876f7e3260ea7fed73f69e19c71eb715dd09d */
    max = lum + sat * (1.0 - (lum > 50 ? (2 * (lum / 100.0) - 1.0): - (2 * (lum / 100.0) - 1.0))) / 2.0;

    /* https://wikimedia.org/api/rest_v1/media/math/render/svg/f6721b57985ad83db3d5b800dc38c9980eedde1d */
    min = lum - sat * (1.0 - (lum > 50 ? (2 * (lum / 100.0) - 1.0): - (2 * (lum / 100.0) - 1.0))) / 2.0;

    /* sixel hue color ring is roteted -120 degree from nowdays general one. */
    hue = (hue + 240) % 360;

    /* https://wikimedia.org/api/rest_v1/media/math/render/svg/937e8abdab308a22ff99de24d645ec9e70f1e384 */
    switch (hue / 60) {
    case 0:  /* 0 <= hue < 60 */
        r = max;
        g = (min + (max - min) * (hue / 60.0));
        b = min;
        break;
    case 1:  /* 60 <= hue < 120 */
        r = min + (max - min) * ((120 - hue) / 60.0);
        g = max;
        b = min;
        break;
    case 2:  /* 120 <= hue < 180 */
        r = min;
        g = max;
        b = (min + (max - min) * ((hue - 120) / 60.0));
        break;
    case 3:  /* 180 <= hue < 240 */
        r = min;
        g = (min + (max - min) * ((240 - hue) / 60.0));
        b = max;
        break;
    case 4:  /* 240 <= hue < 300 */
        r = (min + (max - min) * ((hue - 240) / 60.0));
        g = min;
        b = max;
        break;
    case 5:  /* 300 <= hue < 360 */
        r = max;
        g = min;
        b = (min + (max - min) * ((360 - hue) / 60.0));
        break;
    default:
#if HAVE___BUILTIN_UNREACHABLE
        __builtin_unreachable();
#endif
        break;
    }

    return SIXEL_XRGB(r, g, b);
}


SIXELSTATUS
image_buffer_init(
    image_buffer_t        *image,
    int                    width,
    int                    height,
    int                    bgindex,
    int                    depth,
    sixel_allocator_t     *allocator)
{
    SIXELSTATUS status = SIXEL_FALSE;
    size_t size;
    size_t stride;
    int i;
    int n;
    int r;
    int g;
    int b;

    /* check parameters */
    if (width <= 0) {
        sixel_helper_set_additional_message(
            "image_buffer_init: an invalid width parameter detected.");
        status = SIXEL_BAD_INPUT;
        goto end;
    }
    if (height <= 0) {
        sixel_helper_set_additional_message(
            "image_buffer_init: an invalid width parameter detected.");
        status = SIXEL_BAD_INPUT;
        goto end;
    }
    if (width > SIXEL_WIDTH_LIMIT) {
        sixel_helper_set_additional_message(
            "image_buffer_init: given width parameter is too huge.");
        status = SIXEL_BAD_INPUT;
        goto end;
    }
    if (height > SIXEL_HEIGHT_LIMIT) {
        sixel_helper_set_additional_message(
            "image_buffer_init: given height parameter is too huge.");
        status = SIXEL_BAD_INPUT;
        goto end;
    }

    image->depth = depth;
    stride = (size_t)width * depth;
    size = stride * (size_t)height;
    image->width = width;
    image->height = height;
    image->pixels.p = (unsigned char *)sixel_allocator_malloc(allocator, size);
    if (depth == 4U) {
        image->ncolors = (-1);
    } else {
        image->ncolors = 2;
    }

    if (image->pixels.p == NULL) {
        sixel_helper_set_additional_message(
            "sixel_deocde_raw: sixel_allocator_malloc() failed.");
        status = SIXEL_BAD_ALLOCATION;
        goto end;
    }
    if (depth == 4U) {
        memset(image->pixels.p, 0U, size);
    } else {
        if (depth == 1U) {
            memset(image->pixels.p, bgindex, size);
        } else {  /* 2U */
            for (n = 0; n <= width * height; ++n) {
                image_buffer_store_pixel(image, n, bgindex);
            }
        }

        /* palette initialization */
        for (n = 0; n < 16; n++) {
            image->palette[n] = sixel_default_color_table[n];
        }

        /* colors 16-231 are a 6x6x6 color cube */
        for (r = 0; r < 6; r++) {
            for (g = 0; g < 6; g++) {
                for (b = 0; b < 6; b++) {
                    image->palette[n++] = SIXEL_RGB(r * 51, g * 51, b * 51);
                }
            }
        }

        /* colors 232-255 are a grayscale ramp, intentionally leaving out */
        for (i = 0; i < 24; i++) {
            image->palette[n++] = SIXEL_RGB(i * 11, i * 11, i * 11);
        }

#if HAVE_ASSERT
        assert(n == 256);
#endif  /* HAVE_ASSERT */

    for (n = 256; n < SIXEL_PALETTE_MAX_DECODER; n++) {
        image->palette[n] = SIXEL_RGB(255, 255, 255);
    }
    }
    status = SIXEL_OK;

end:
    return status;
}


SIXELSTATUS
image_buffer_resize(
    image_buffer_t        *image,
    int                    width,
    int                    height,
    int                    bgindex,
    sixel_allocator_t     *allocator)
{
    SIXELSTATUS status = SIXEL_FALSE;
    size_t size;
    unsigned char *alt_buffer;
    int n;
    int min_height;
    size_t stride;
    size_t old_stride;
    size_t copy_stride;
    size_t depth = image->depth;

    /* check parameters */
    if (width <= 0) {
        sixel_helper_set_additional_message(
            "image_buffer_init: an invalid width parameter detected.");
        status = SIXEL_BAD_INPUT;
        goto end;
    }
    if (height <= 0) {
        sixel_helper_set_additional_message(
            "image_buffer_init: an invalid width parameter detected.");
        status = SIXEL_BAD_INPUT;
        goto end;
    }
    if (height > SIXEL_HEIGHT_LIMIT) {
        sixel_helper_set_additional_message(
            "image_buffer_init: given height parameter is too huge.");
        status = SIXEL_BAD_INPUT;
        goto end;
    }
    if (width > SIXEL_WIDTH_LIMIT) {
        sixel_helper_set_additional_message(
            "image_buffer_init: given width parameter is too huge.");
        status = SIXEL_BAD_INPUT;
        goto end;
    }
    if (height > SIXEL_HEIGHT_LIMIT) {
        sixel_helper_set_additional_message(
            "image_buffer_init: given height parameter is too huge.");
        status = SIXEL_BAD_INPUT;
        goto end;
    }

    stride = (size_t)width * depth;
    size = stride * (size_t)height;
    alt_buffer = (sixel_decoder_index_t *)sixel_allocator_malloc(allocator, size);
    if (alt_buffer == NULL || size == 0) {
        /* free source image */
        sixel_allocator_free(allocator, image->pixels.p);
        image->pixels.p = NULL;
        sixel_helper_set_additional_message(
            "image_buffer_resize: sixel_allocator_malloc() failed.");
        status = SIXEL_BAD_ALLOCATION;
        goto end;
    }

    min_height = height > image->height ? image->height: height;
    old_stride = (size_t)image->width * depth;
    if (width > image->width) {
        copy_stride = old_stride;
        for (n = 0; n < min_height; ++n) {
            memcpy(alt_buffer + stride * (size_t)n,
                   image->pixels.in_bytes + old_stride * (size_t)n,
                   copy_stride);
            if (stride > copy_stride) {
                if (depth == 4U) {  /* rgba */
                    memset(alt_buffer + stride * (size_t)n + copy_stride,
                           0,
                           stride - copy_stride);
                } else {
                    memset(alt_buffer + stride * (size_t)n + copy_stride,
                           bgindex,
                           stride - copy_stride);
                }
            }
        }
    } else {
        copy_stride = stride;
        for (n = 0; n < min_height; ++n) {
            memcpy(alt_buffer + stride * (size_t)n,
                   image->pixels.in_bytes + old_stride * (size_t)n,
                   copy_stride);
        }
    }

    if (height > image->height) {
        if (depth == 4u) {  /* rgba */
            memset(alt_buffer + stride * (size_t)image->height,
                   0,
                   stride * (size_t)(height - image->height));
        } else {
            memset(alt_buffer + stride * (size_t)image->height,
                   bgindex,
                   stride * (size_t)(height - image->height));
        }
    }

    /* free source image */
    sixel_allocator_free(allocator, image->pixels.p);

    image->pixels.in_bytes = alt_buffer;
    image->width = width;
    image->height = height;

    status = SIXEL_OK;

end:
    return status;
}


static SIXELSTATUS
parser_context_init(parser_context_t *context)
{
    SIXELSTATUS status = SIXEL_FALSE;

    context->state = PS_GROUND;
    context->pos_x = 0;
    context->pos_y = 0;
    context->max_x = 0;
    context->max_y = 0;
    context->attributed_pan = 2;
    context->attributed_pad = 1;
    context->attributed_ph = 0;
    context->attributed_pv = 0;
    context->repeat_count = 1;
    context->color_index = 15;
    context->bgindex = (-1);
    context->nparams = 0;
    context->param = 0;

    status = SIXEL_OK;

    return status;
}


static SIXELSTATUS
safe_addition_for_params(parser_context_t *context, unsigned char *p)
{
    SIXELSTATUS status = SIXEL_FALSE;
    int x;

    x = *p - '0'; /* 0 <= x <= 9 */
    if ((context->param > INT_MAX / 10) || (x > INT_MAX - context->param * 10)) {
        status = SIXEL_BAD_INTEGER_OVERFLOW;
        sixel_helper_set_additional_message(
            "safe_addition_for_params: ingeger overflow detected.");
        goto end;
    }
    context->param = context->param * 10 + x;
    status = SIXEL_OK;

end:
    return status;
}


/* convert sixel data into indexed pixel bytes and palette data */
SIXELAPI SIXELSTATUS
sixel_decode_raw_impl(
    unsigned char     *p,         /* sixel bytes */
    int                len,       /* size of sixel bytes */
    image_buffer_t    *image,
    parser_context_t  *context,
    sixel_allocator_t *allocator, /* allocator object */
    sixel_logger_t    *logger,
    int logger_prepared)
{
    SIXELSTATUS status = SIXEL_FALSE;
    int n;
    int i;
    int y;
    int bits;
    int sixel_vertical_mask;
    int sx;
    int sy;
    int c;
    size_t pos;
    unsigned char *p0 = p;
#if SIXEL_ENABLE_THREADS
    int parallel_started = 0;
    int raster_ready = 0;
    int palette_ready = 0;
    unsigned char *parallel_anchor = p;
#else
    (void) logger;
    (void) logger_prepared;
#endif  /* SIXEL_ENABLE_THREADS */

    while (p < p0 + len) {
        switch (context->state) {
        case PS_GROUND:
            switch (*p) {
            case 0x1b:
                context->state = PS_ESC;
                p++;
                break;
            case 0x90:
                context->state = PS_DCS;
                p++;
                break;
            case 0x9c:
                p++;
                goto finalize;
            default:
                p++;
                break;
            }
            break;

        case PS_ESC:
            switch (*p) {
            case '\\':
            case 0x9c:
                p++;
                goto finalize;
            case 'P':
                context->param = -1;
                context->state = PS_DCS;
                p++;
                break;
            default:
                p++;
                break;
            }
            break;

        case PS_DCS:
            switch (*p) {
            case 0x1b:
                context->state = PS_ESC;
                p++;
                break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                if (context->param < 0) {
                    context->param = 0;
                }
                status = safe_addition_for_params(context, p);
                if (SIXEL_FAILED(status)) {
                    goto end;
                }
                p++;
                break;
            case ';':
                if (context->param < 0) {
                    context->param = 0;
                }
                if (context->nparams < DECSIXEL_PARAMS_MAX) {
                    context->params[context->nparams++] = context->param;
                }
                context->param = 0;
                p++;
                break;
            case 'q':
                if (context->param >= 0 && context->nparams < DECSIXEL_PARAMS_MAX) {
                    context->params[context->nparams++] = context->param;
                }
                if (context->nparams > 0) {
                    /* Pn1 */
                    switch (context->params[0]) {
                    case 0:
                    case 1:
                        context->attributed_pad = 2;
                        break;
                    case 2:
                        context->attributed_pad = 5;
                        break;
                    case 3:
                    case 4:
                        context->attributed_pad = 4;
                        break;
                    case 5:
                    case 6:
                        context->attributed_pad = 3;
                        break;
                    case 7:
                    case 8:
                        context->attributed_pad = 2;
                        break;
                    case 9:
                        context->attributed_pad = 1;
                        break;
                    default:
                        context->attributed_pad = 2;
                        break;
                    }
                }

                if (context->nparams > 2) {
                    /* Pn3 */
                    if (context->params[2] == 0) {
                        context->params[2] = 10;
                    }
                    context->attributed_pan = context->attributed_pan * context->params[2] / 10;
                    context->attributed_pad = context->attributed_pad * context->params[2] / 10;
                    if (context->attributed_pan <= 0) {
                        context->attributed_pan = 1;
                    }
                    if (context->attributed_pad <= 0) {
                        context->attributed_pad = 1;
                    }
                }
                context->nparams = 0;
                context->state = PS_DECSIXEL;
                p++;
                break;
            default:
                p++;
                break;
            }
            break;

        case PS_DECSIXEL:
            switch (*p) {
            case '\x1b':
                context->state = PS_ESC;
                p++;
                break;
            case '"':
                context->param = 0;
                context->nparams = 0;
                context->state = PS_DECGRA;
                p++;
                break;
            case '!':
                context->param = 0;
                context->nparams = 0;
                context->state = PS_DECGRI;
                p++;
                break;
            case '#':
                context->param = 0;
                context->nparams = 0;
#if SIXEL_ENABLE_THREADS
                if (!palette_ready) {
                    palette_ready = 1;
                }
#endif  /* SIXEL_ENABLE_THREADS */
                context->state = PS_DECGCI;
                p++;
                break;
            case '$':
                /* DECGCR Graphics Carriage Return */
                context->pos_x = 0;
#if SIXEL_ENABLE_THREADS
                if (!palette_ready) {
                    palette_ready = 1;
                }
                if (!parallel_started && raster_ready && palette_ready) {
                    status = sixel_decoder_parallel_request_start(
                        image->depth == 4U ? 1: 0,
                        p0,
                        len,
                        parallel_anchor,
                        image,
                        image->palette,
                        logger_prepared ? logger : NULL);
                    parallel_started = 1;
                    if (status == SIXEL_FALSE) {
                        /* Parallel decode aborted; continue serially. */
                    } else {
                        goto end;
                    }
                }
#endif  /* SIXEL_ENABLE_THREADS */
                p++;
                break;
            case '-':
                /* DECGNL Graphics Next Line */
                context->pos_x = 0;
                context->pos_y += 6;
#if SIXEL_ENABLE_THREADS
                if (!palette_ready) {
                    palette_ready = 1;
                }
                if (!parallel_started && raster_ready && palette_ready) {
                    status = sixel_decoder_parallel_request_start(
                        image->depth == 4U ? 1: 0,
                        p0,
                        len,
                        parallel_anchor,
                        image,
                        image->palette,
                        logger_prepared ? logger : NULL);
                    parallel_started = 1;
                    if (status == SIXEL_FALSE) {
                        /* Parallel decode aborted; continue serially. */
                    } else {
                        goto end;
                    }
                }
#endif  /* SIXEL_ENABLE_THREADS */
                p++;
                break;
            default:
                if (*p >= '?' && *p <= '~') {  /* sixel characters */
#if SIXEL_ENABLE_THREADS
                    if (!palette_ready) {
                        palette_ready = 1;
                    }
                    if (!parallel_started && raster_ready && palette_ready) {
                        status = sixel_decoder_parallel_request_start(
                            image->depth == 4U ? 1: 0,
                            p0,
                            len,
                            parallel_anchor,
                            image,
                            image->palette,
                            logger_prepared ? logger : NULL);
                        parallel_started = 1;
                        if (status == SIXEL_FALSE) {
                            /* Parallel decode aborted; continue serially. */
                        } else {
                            goto end;
                        }
                    }
#endif  /* SIXEL_ENABLE_THREADS */

                    sx = image->width;
                    while (sx < context->pos_x + context->repeat_count) {
                        sx *= 2;
                    }

                    sy = image->height;
                    while (sy < context->pos_y + 6) {
                        sy *= 2;
                    }

                    if (sx > image->width || sy > image->height) {
                        status = image_buffer_resize(image, sx, sy, context->bgindex, allocator);
                        if (SIXEL_FAILED(status)) {
                            goto end;
                        }
                    }

                    if (image->depth != 4U &&
                            context->color_index > image->ncolors) {
                        image->ncolors = context->color_index;
                    }

                    if (context->pos_x < 0 || context->pos_y < 0) {
                        status = SIXEL_BAD_INPUT;
                        goto end;
                    }
                    bits = *p - '?';

                    if (bits == 0) {
                        context->pos_x += context->repeat_count;
                    } else {
                        sixel_vertical_mask = 0x01;
                        if (context->repeat_count <= 1) {
                            for (i = 0; i < 6; i++) {
                                if ((bits & sixel_vertical_mask) != 0) {
                                    pos =
                                        (size_t)image->width *
                                        (size_t)(context->pos_y + i) +
                                        (size_t)context->pos_x;
                                    image_buffer_store_pixel(
                                        image,
                                        pos,
                                        context->color_index);
                                    if (context->max_x < context->pos_x) {
                                        context->max_x = context->pos_x;
                                    }
                                    if (context->max_y < (context->pos_y + i)) {
                                        context->max_y = context->pos_y + i;
                                    }
                                }
                                sixel_vertical_mask <<= 1;
                            }
                            context->pos_x += 1;
                        } else {
                            /* context->repeat_count > 1 */
                            for (i = 0; i < 6; i++) {
                                if ((bits & sixel_vertical_mask) != 0) {
                                    c = sixel_vertical_mask << 1;
                                    for (n = 1; (i + n) < 6; n++) {
                                        if ((bits & c) == 0) {
                                            break;
                                        }
                                        c <<= 1;
                                    }
                                    for (y = context->pos_y + i; y < context->pos_y + i + n; ++y) {
                                        image_buffer_fill_span(
                                            image,
                                            y,
                                            context->pos_x,
                                            context->repeat_count,
                                            context->color_index);
                                    }
                                    if (context->max_x < (context->pos_x + context->repeat_count - 1)) {
                                        context->max_x = context->pos_x + context->repeat_count - 1;
                                    }
                                    if (context->max_y < (context->pos_y + i + n - 1)) {
                                        context->max_y = context->pos_y + i + n - 1;
                                    }
                                    i += (n - 1);
                                    sixel_vertical_mask <<= (n - 1);
                                }
                                sixel_vertical_mask <<= 1;
                            }
                            context->pos_x += context->repeat_count;
                        }
                    }
                    context->repeat_count = 1;
                }
                p++;
                break;
            }
            break;

        case PS_DECGRA:
            /* DECGRA Set Raster Attributes " Pan; Pad; Ph; Pv */
            switch (*p) {
            case '\x1b':
                context->state = PS_ESC;
                p++;
                break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                status = safe_addition_for_params(context, p);
                if (SIXEL_FAILED(status)) {
                    goto end;
                }
                p++;
                break;
            case ';':
                if (context->nparams < DECSIXEL_PARAMS_MAX) {
                    context->params[context->nparams++] = context->param;
                }
                context->param = 0;
                p++;
                break;
            default:
                if (context->nparams < DECSIXEL_PARAMS_MAX) {
                    context->params[context->nparams++] = context->param;
                }
                if (context->nparams > 0) {
                    context->attributed_pad = context->params[0];
                }
                if (context->nparams > 1) {
                    context->attributed_pan = context->params[1];
                }
                if (context->nparams > 2 && context->params[2] > 0) {
                    context->attributed_ph = context->params[2];
                }
                if (context->nparams > 3 && context->params[3] > 0) {
                    context->attributed_pv = context->params[3];
                }

                if (context->attributed_pan <= 0) {
                    context->attributed_pan = 1;
                }
                if (context->attributed_pad <= 0) {
                    context->attributed_pad = 1;
                }

                if (image->width < context->attributed_ph ||
                        image->height < context->attributed_pv) {
                    sx = context->attributed_ph;
                    if (image->width > context->attributed_ph) {
                        sx = image->width;
                    }

                    sy = context->attributed_pv;
                    if (image->height > context->attributed_pv) {
                        sy = image->height;
                    }

                    status = image_buffer_resize(image, sx, sy, context->bgindex, allocator);
                    if (SIXEL_FAILED(status)) {
                        goto end;
                    }
                }
#if SIXEL_ENABLE_THREADS
                if (!raster_ready && context->attributed_ph > 0 &&
                        context->attributed_pv > 0) {
                    raster_ready = 1;
                }
                parallel_anchor = p;
#endif  /* SIXEL_ENABLE_THREADS */
                context->state = PS_DECSIXEL;
                context->param = 0;
                context->nparams = 0;
            }
            break;

        case PS_DECGRI:
            /* DECGRI Graphics Repeat Introducer ! Pn Ch */
            switch (*p) {
            case '\x1b':
                context->state = PS_ESC;
                p++;
                break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                status = safe_addition_for_params(context, p);
                if (SIXEL_FAILED(status)) {
                    goto end;
                }
                p++;
                break;
            default:
                context->repeat_count = context->param;
                if (context->repeat_count == 0) {
                    context->repeat_count = 1;
                }
                if (context->repeat_count > 0xffff) {  /* check too huge number */
                    status = SIXEL_BAD_INPUT;
                    sixel_helper_set_additional_message(
                        "sixel_decode_raw_impl: detected too huge repeat parameter.");
                    goto end;
                }
                context->state = PS_DECSIXEL;
                context->param = 0;
                context->nparams = 0;
                break;
            }
            break;

        case PS_DECGCI:
            /* DECGCI Graphics Color Introducer # Pc; Pu; Px; Py; Pz */
            switch (*p) {
            case '\x1b':
                context->state = PS_ESC;
                p++;
                break;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                status = safe_addition_for_params(context, p);
                if (SIXEL_FAILED(status)) {
                    goto end;
                }
                p++;
                break;
            case ';':
                if (context->nparams < DECSIXEL_PARAMS_MAX) {
                    context->params[context->nparams++] = context->param;
                }
                context->param = 0;
                p++;
                break;
            default:
                context->state = PS_DECSIXEL;
                if (context->nparams < DECSIXEL_PARAMS_MAX) {
                    context->params[context->nparams++] = context->param;
                }
                context->param = 0;

                if (context->nparams > 0) {
                    context->color_index = context->params[0];
                    if (context->color_index < 0) {
                        context->color_index = 0;
                    } else if (context->color_index >= SIXEL_PALETTE_MAX_DECODER) {
                        context->color_index = SIXEL_PALETTE_MAX_DECODER - 1;
                    }
                }

                if (context->color_index + 1 > image->ncolors) {
                    image->ncolors = context->color_index + 1;
                    if (image->ncolors > SIXEL_PALETTE_MAX_DECODER) {
                        image->ncolors = SIXEL_PALETTE_MAX_DECODER;
                    }
                }

                if (context->nparams > 4) {
                    if (context->params[1] == 1) {
                        /* HLS */
                        if (context->params[2] > 360) {
                            context->params[2] = 360;
                        }
                        if (context->params[3] > 100) {
                            context->params[3] = 100;
                        }
                        if (context->params[4] > 100) {
                            context->params[4] = 100;
                        }
                        image->palette[context->color_index]
                            = hls_to_rgb(context->params[2], context->params[3], context->params[4]);
                    } else if (context->params[1] == 2) {
                        /* RGB */
                        if (context->params[2] > 100) {
                            context->params[2] = 100;
                        }
                        if (context->params[3] > 100) {
                            context->params[3] = 100;
                        }
                        if (context->params[4] > 100) {
                            context->params[4] = 100;
                        }
                        image->palette[context->color_index]
                            = SIXEL_XRGB(context->params[2], context->params[3], context->params[4]);
                    }
#if SIXEL_ENABLE_THREADS
                    parallel_anchor = p;
#endif  /* SIXEL_ENABLE_THREADS */
                }
                break;
            }
            break;
        default:
            break;
        }
    }

finalize:
    if (++context->max_x < context->attributed_ph) {
        context->max_x = context->attributed_ph;
    }

    if (++context->max_y < context->attributed_pv) {
        context->max_y = context->attributed_pv;
    }

    if (image->width > context->max_x || image->height > context->max_y) {
        status = image_buffer_resize(image, context->max_x, context->max_y, context->bgindex, allocator);
        if (SIXEL_FAILED(status)) {
            goto end;
        }
    }

    status = SIXEL_OK;

end:
    return status;
}


static SIXELSTATUS
sixel_decode_image(
    unsigned char     *p,
    int                len,
    int                initial_width,
    int                initial_height,
    int                depth,
    image_buffer_t    *image,
    parser_context_t  *context,
    sixel_allocator_t *allocator)
{
    SIXELSTATUS status = SIXEL_FALSE;
    sixel_logger_t logger;
    int logger_prepared;

    image->pixels.p = NULL;

    sixel_logger_init(&logger);
    logger_prepared = 0;
    (void)sixel_logger_prepare_env(&logger);
    logger_prepared = logger.active;
    if (logger_prepared) {
        /*
         * File I/O window for timeline visualization. The buffer is already
         * populated, but logging the bounds keeps decode timing aligned with
         * encoder logs.
         */
        sixel_logger_logf(&logger,
                          "decoder",
                          "io",
                          "start",
                          0,
                          0,
                          0,
                          len,
                          0,
                          len,
                          "reading sixel payload");
    }

    status = parser_context_init(context);
    if (SIXEL_FAILED(status)) {
        goto end;
    }

    /*
     * The serial parser always runs first. When palette and raster
     * attributes become available, the parser may request a parallel worker
     * via sixel_decoder_parallel_request_start(). This guarantees bounds
     * checks and logging are consistent before any background decode starts.
     */

    if (logger_prepared) {
        /* Mark when the serial parser begins scanning tokens. */
        sixel_logger_logf(&logger,
                          "decoder",
                          "controller",
                          "start",
                          0,
                          0,
                          0,
                          len,
                          0,
                          len,
                          "serial parser begin depth=%u",
                          depth);
    }

    status = image_buffer_init(image,
                               initial_width,
                               initial_height,
                               context->bgindex,
                               depth,
                               allocator);
    if (SIXEL_FAILED(status)) {
        goto end;
    }

    status = sixel_decode_raw_impl(p,
                                   len,
                                   image,
                                   context,
                                   allocator,
                                   &logger,
                                   logger_prepared);
    if (SIXEL_FAILED(status)) {
        sixel_allocator_free(allocator, image->pixels.p);
        image->pixels.p = NULL;
        goto end;
    }

    status = SIXEL_OK;

end:
    if (logger_prepared) {
        sixel_logger_logf(&logger,
                          "decoder",
                          "parser",
                          "finish",
                          0,
                          0,
                          0,
                          len,
                          0,
                          len,
                          "parser status=%d",
                          status);
        sixel_logger_logf(&logger,
                          "decoder",
                          "io",
                          "finish",
                          0,
                          0,
                          0,
                          len,
                          0,
                          len,
                          "input processed status=%d",
                          status);
        sixel_logger_close(&logger);
    }
    return status;
}


/* convert sixel data into indexed pixel bytes and palette data */
SIXELAPI SIXELSTATUS
sixel_decode_raw(
    unsigned char       /* in */  *p,           /* sixel bytes */
    int                 /* in */  len,          /* size of sixel bytes */
    unsigned char       /* out */ **pixels,     /* decoded pixels */
    int                 /* out */ *pwidth,      /* image width */
    int                 /* out */ *pheight,     /* image height */
    unsigned char       /* out */ **palette,    /* RGB palette */
    int                 /* out */ *ncolors,     /* palette size (<= 256) */
    sixel_allocator_t   /* in */  *allocator)   /* allocator object or null */
{
    SIXELSTATUS status = SIXEL_FALSE;
    parser_context_t context;
    image_buffer_t image;
    int n;
    int alloc_size;

    image.pixels.p = NULL;

    if (allocator) {
        sixel_allocator_ref(allocator);
    } else {
        status = sixel_allocator_new(&allocator, NULL, NULL, NULL, NULL);
        if (SIXEL_FAILED(status)) {
            allocator = NULL;
            goto error;
        }
    }

    status = sixel_decode_image(p,
                                len,
                                1,  /* initial_width */
                                1,  /* initial_height */
                                1,  /* depth */
                                &image,
                                &context,
                                allocator);
    if (SIXEL_FAILED(status)) {
        goto error;
    }

    *ncolors = alloc_size = image.ncolors;
    if (alloc_size < SIXEL_PALETTE_MAX_DECODER) {
        /* memory access range should be 0 <= 255 */
        alloc_size = SIXEL_PALETTE_MAX_DECODER;
    }
    *palette = (unsigned char *)sixel_allocator_malloc(allocator, (size_t)(alloc_size * 3));
    if (palette == NULL) {
        sixel_allocator_free(allocator, image.pixels.p);
        sixel_helper_set_additional_message(
            "sixel_deocde_raw: sixel_allocator_malloc() failed.");
        status = SIXEL_BAD_ALLOCATION;
        goto error;
    }
    for (n = 0; n < *ncolors; ++n) {
        (*palette)[n * 3 + 0] = image.palette[n] >> 16 & 0xff;
        (*palette)[n * 3 + 1] = image.palette[n] >> 8 & 0xff;
        (*palette)[n * 3 + 2] = image.palette[n] & 0xff;
    }

    *pwidth = image.width;
    *pheight = image.height;
    *pixels = image.pixels.p;

    status = SIXEL_OK;
    goto end;

error:
    if (image.pixels.p != NULL) {
        if (allocator != NULL) {
            sixel_allocator_free(allocator, image.pixels.p);
        } else {
            free(image.pixels.p);
        }
        image.pixels.p = NULL;
    }

end:
    sixel_allocator_unref(allocator);
    return status;
}


/* convert sixel data into wide-indexed(16bit) pixels and palette data */
SIXELAPI SIXELSTATUS
sixel_decode_wide(
    unsigned char       /* in */  *p,           /* sixel bytes */
    int                 /* in */  len,          /* size of sixel bytes */
    unsigned short      /* out */ **pixels,     /* decoded wide indexes */
    int                 /* out */ *pwidth,      /* image width */
    int                 /* out */ *pheight,     /* image height */
    unsigned char       /* out */ **palette,    /* RGB palette */
    int                 /* out */ *ncolors,     /* palette size (<= 256) */
    sixel_allocator_t   /* in */  *allocator)   /* allocator object or null */
{
    SIXELSTATUS status = SIXEL_FALSE;
    parser_context_t context;
    image_buffer_t image;
    int n;
    int alloc_size;

    image.pixels.p = NULL;

    if (allocator) {
        sixel_allocator_ref(allocator);
    } else {
        status = sixel_allocator_new(&allocator, NULL, NULL, NULL, NULL);
        if (SIXEL_FAILED(status)) {
            allocator = NULL;
            goto error;
        }
    }

    status = sixel_decode_image(p,
                                len,
                                1,  /* initial width */
                                1,  /* initial height */
                                2,  /* depth */
                                &image,
                                &context,
                                allocator);
    if (SIXEL_FAILED(status)) {
        goto error;
    }

    *ncolors = alloc_size = image.ncolors;
    if (alloc_size < SIXEL_PALETTE_MAX_DECODER) {
        /* memory access range should be 0 <= 255 */
        alloc_size = SIXEL_PALETTE_MAX_DECODER;
    }
    *palette = (unsigned char *)sixel_allocator_malloc(allocator, (size_t)(alloc_size * 3));
    if (palette == NULL) {
        sixel_allocator_free(allocator, image.pixels.p);
        sixel_helper_set_additional_message(
            "sixel_deocde_raw: sixel_allocator_malloc() failed.");
        status = SIXEL_BAD_ALLOCATION;
        goto error;
    }
    for (n = 0; n < *ncolors; ++n) {
        (*palette)[n * 3 + 0] = image.palette[n] >> 16 & 0xff;
        (*palette)[n * 3 + 1] = image.palette[n] >> 8 & 0xff;
        (*palette)[n * 3 + 2] = image.palette[n] & 0xff;
    }

    *pwidth = image.width;
    *pheight = image.height;
    *pixels = image.pixels.in_shorts;

    status = SIXEL_OK;
    goto end;

error:
    if (image.pixels.p != NULL) {
        if (allocator != NULL) {
            sixel_allocator_free(allocator, image.pixels.p);
        } else {
            free(image.pixels.p);
        }
        image.pixels.p = NULL;
    }

end:
    sixel_allocator_unref(allocator);
    return status;
}


SIXELAPI SIXELSTATUS
sixel_decode_direct(
    unsigned char       *p,
    int                  len,
    unsigned char      **pixels,
    int                 *pwidth,
    int                 *pheight,
    sixel_allocator_t   *allocator)
{
    SIXELSTATUS status = SIXEL_FALSE;
    parser_context_t context;
    image_buffer_t image;

    image.pixels.p = NULL;

    if (allocator) {
        sixel_allocator_ref(allocator);
    } else {
        status = sixel_allocator_new(&allocator, NULL, NULL, NULL, NULL);
        if (SIXEL_FAILED(status)) {
            allocator = NULL;
            goto error;
        }
    }

    status = sixel_decode_image(p,
                                len,
                                1,
                                1,
                                4U,
                                &image,
                                &context,
                                allocator);
    if (SIXEL_FAILED(status)) {
        goto error;
    }

    *pwidth = image.width;
    *pheight = image.height;
    *pixels = image.pixels.in_bytes;

    status = SIXEL_OK;
    goto end;

error:
    if (image.pixels.p != NULL) {
        if (allocator != NULL) {
            sixel_allocator_free(allocator, image.pixels.p);
        } else {
            free(image.pixels.p);
        }
        image.pixels.p = NULL;
    }

end:
    sixel_allocator_unref(allocator);
    return status;
}


/* deprecated */
SIXELAPI SIXELSTATUS
sixel_decode(unsigned char              /* in */   *p,        /* sixel bytes */
             int                        /* in */    len,      /* size of sixel bytes */
             unsigned char              /* out */ **pixels,   /* decoded pixels */
             int                        /* out */  *pwidth,   /* image width */
             int                        /* out */  *pheight,  /* image height */
             unsigned char              /* out */ **palette,  /* ARGB palette */
             int                        /* out */  *ncolors,  /* palette size (<= 256) */
    sixel_allocator_function   /* in */  fn_malloc)  /* malloc function */
{
    SIXELSTATUS status = SIXEL_FALSE;
    sixel_allocator_t *allocator = NULL;
    parser_context_t context;
    image_buffer_t image;
    int n;

    status = sixel_allocator_new(&allocator, fn_malloc, NULL, NULL, NULL);
    if (SIXEL_FAILED(status)) {
        allocator = NULL;
        goto end;
    }

    status = sixel_decode_image(p,
                                len,
                                2048,
                                2048,
                                0,
                                &image,
                                &context,
                                allocator);
    if (SIXEL_FAILED(status)) {
        goto end;
    }

    *ncolors = image.ncolors;
    *palette = (unsigned char *)sixel_allocator_malloc(allocator, (size_t)(*ncolors * 3));
    if (palette == NULL) {
        sixel_allocator_free(allocator, image.pixels.p);
        sixel_helper_set_additional_message(
            "sixel_deocde_raw: sixel_allocator_malloc() failed.");
        status = SIXEL_BAD_ALLOCATION;
        goto end;
    }
    for (n = 0; n < *ncolors; ++n) {
        (*palette)[n * 3 + 0] = image.palette[n] >> 16 & 0xff;
        (*palette)[n * 3 + 1] = image.palette[n] >> 8 & 0xff;
        (*palette)[n * 3 + 2] = image.palette[n] & 0xff;
    }

    *pwidth = image.width;
    *pheight = image.height;
    *pixels = image.pixels.p;

    status = SIXEL_OK;

end:
    sixel_allocator_unref(allocator);
    return status;
}

/* emacs Local Variables:      */
/* emacs mode: c               */
/* emacs tab-width: 4          */
/* emacs indent-tabs-mode: nil */
/* emacs c-basic-offset: 4     */
/* emacs End:                  */
/* vim: set expandtab ts=4 sts=4 sw=4 : */
/* EOF */

saitoha / libsixel / 19918707358

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous