mlx_xpm42.c File Reference

#include "MLX42/MLX42_Int.h"

Include dependency graph for mlx_xpm42.c:

Go to the source code of this file.

Functions
static uint8_t	mlx_parse_hex_channel (char *channel)
static bool	mlx_insert_xpm_entry (xpm_t *xpm, char *line, uint32_t *ctable, size_t s)
static bool	mlx_read_data (xpm_t *xpm, FILE *file, uint32_t *ctable, size_t s)
static bool	mlx_read_table (xpm_t *xpm, FILE *file)
static bool	mlx_read_xpm_header (xpm_t *xpm, FILE *file)
xpm_t *	mlx_load_xpm42 (const char *path)
void	mlx_delete_xpm42 (xpm_t *xpm)

Function Documentation

mlx_delete_xpm42()

void mlx_delete_xpm42

(

xpm_t *

xpm

)

Deletes an XPM42 texture by freeing its allocated data.

This will not remove any already drawn XPMs, it simply deletes the XPM buffer.

Parameters

[in]

xpm

The xpm texture to delete.

Definition at line 203 of file mlx_xpm42.c.

{
    MLX_NONNULL(xpm);
    free(xpm->texture.pixels);
    free(xpm);
}

mlx_insert_xpm_entry()

static bool mlx_insert_xpm_entry ( xpm_t *  xpm, char *  line, uint32_t *  ctable, size_t  s  )

static

Parses the XPM color value entry e.g: ".X #00FF00FF" into the color table while also verifying the format.

Parameters

xpm	The XPM.
line	The line to parse.
ctable	The color hash table.
s	Size of the hash table

Returns

True or false depending on if it successfully parsed the line.

Definition at line 64 of file mlx_xpm42.c.

{
    // NOTE: uintptr because windows likes to complain...
    // Verify the length of the Pixel string by checking backwards for the first
    // occurrence of a space and then check the distance by comparing with cpp.
    if (((uintptr_t)strrchr(line, ' ') - (uintptr_t)line) != (uint64_t)xpm->cpp)
        return (false);
    if (!isspace(line[xpm->cpp]) || line[xpm->cpp + 1] != '#' || !isalnum(line[xpm->cpp + 2]))
        return (false);
 
    uint32_t color = 0;
    size_t start_offset = xpm->cpp + 2;
    color |= mlx_parse_hex_channel(line + start_offset) << 24;
    color |= mlx_parse_hex_channel(line + start_offset + 2) << 16;
    color |= mlx_parse_hex_channel(line + start_offset + 4) << 8;
    color |= mlx_parse_hex_channel(line + start_offset + 6);
    
    int32_t index = mlx_fnv_hash(line, xpm->cpp) % s;
    ctable[index] = xpm->mode == 'm' ? mlx_rgba_to_mono(color) : color;
    return (true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_load_xpm42()

xpm_t * mlx_load_xpm42

(

const char *

path

)

Loads an XPM42 texture from the given file path.

Parameters

[in]

path

The file path to the XPM texture.

Returns

The XPM texture struct containing its information.

Definition at line 181 of file mlx_xpm42.c.

{
    FILE* file;
    xpm_t* xpm = NULL;
 
    MLX_NONNULL(path);
    if (!strstr(path, ".xpm42"))
        return ((void*)mlx_error(MLX_INVEXT));
    if (!(file = fopen(path, "r")))
        return ((void*)mlx_error(MLX_INVFILE));
    if (!(xpm = calloc(1, sizeof(xpm_t))))
        return ((void*)mlx_error(MLX_MEMFAIL));
    if (!mlx_read_xpm_header(xpm, file))
    {
        mlx_freen(2, xpm->texture.pixels, xpm);
        mlx_error(MLX_INVXPM);
        xpm = NULL;
    }
    fclose(file);
    return (xpm);
}

Here is the call graph for this function:

mlx_parse_hex_channel()

static uint8_t mlx_parse_hex_channel ( char *  channel )

static

XPM is an obscure image format which can't seem to make up its mind whether it wants to be written in C code or not.

https://en.wikipedia.org/wiki/X_PixMap

This might anger some but instead I decided to write my own image format, very similar to XPM2, which seems to be the better option between the 3 versions. The only difference is in the header which carries the file type, width, height, color count and finally color type aka 'c' for RGBA8 or 'm' for monochrome output.

The changes, in my opinion, very much simplify the XPM format into something literally anybody can use without much guessing as to what does what.

Additionally with the C style format, the idea is that you simply include it directly into the compilation of the program (since it's just C).

As convenient as this is, I just find it hideous especially the XPM3 variant. By sticking to the XPM style format, conversion should be very easy and straightforward to this format however. Parses HEX color channel e.g: "0F"

Parameters

channel

The 2 character string to parse.

Returns

Int value of the channel.

Definition at line 48 of file mlx_xpm42.c.

{
    char temp_chan[] = {channel[0], channel[1], '\0'};
    return (strtol(temp_chan, NULL, 16));
}

Here is the caller graph for this function:

mlx_read_data()

static bool mlx_read_data ( xpm_t *  xpm, FILE *  file, uint32_t *  ctable, size_t  s  )

static

Retrieves the pixel data line by line and then processes each pixel by hashing the characters and looking it up from the color table.

Parameters

xpm	The XPM.
file	The filepath to the XPM42 file.
ctable	The color hash table.
s	Size of the hash table.

Returns

True or false depending on if it successfully parsed the line.

Definition at line 96 of file mlx_xpm42.c.

{
    size_t line_len;
    char* line = NULL;
 
    for (int64_t y_xpm = 0; y_xpm < xpm->texture.height; y_xpm++)
    {
        if (!mlx_getline(&line, &line_len, file))
            return (free(line), false);
        if (line[line_len - 1] == '\n')
            line_len--;
        if (line_len != xpm->texture.width * xpm->cpp)
            return (free(line), false);
 
        // NOTE: Copy pixel by pixel as we need to retrieve the hash table.
        for (int64_t x_xpm = 0, x_line = 0; x_xpm < xpm->texture.width; x_xpm++, x_line += xpm->cpp)
        {
            uint8_t* pixelstart = &xpm->texture.pixels[(y_xpm * xpm->texture.width + x_xpm) * BPP];
            mlx_draw_pixel(pixelstart, ctable[mlx_fnv_hash(&line[x_line], xpm->cpp) % s]);
        }
    }
    free(line);
    return (true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_read_table()

static bool mlx_read_table ( xpm_t *  xpm, FILE *  file  )

static

For quick lookups we basically create a stack allocated lookup table with every ascii character in it. This should help avoid a O(n) case and give us a O(1) for very fast look ups.

Downside is we still need to iterate over each pixel to solve its color. So I hope this makes it at least a bit faster.

TODO: This buffer might be way to big! Do actual collision checks, for now just straight up raw dog this.

Definition at line 132 of file mlx_xpm42.c.

{
    char* line = NULL;
    size_t line_len;
    uint32_t ctable[UINT16_MAX] = {0};
 
    for (int32_t i = 0; i < xpm->color_count; i++)
    {
        if (!mlx_getline(&line, &line_len, file))
            return (free(line), false);
        if (!mlx_insert_xpm_entry(xpm, line, ctable, (sizeof(ctable) / BPP)))
            return (free(line), false);
    }
    free(line);
    return (mlx_read_data(xpm, file, ctable, (sizeof(ctable) / BPP)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_read_xpm_header()

static bool mlx_read_xpm_header ( xpm_t *  xpm, FILE *  file  )

static

Reads the XPM42 file header which usually consists of a file type declaration of "!XPM42" followed by the next line containing image information such as width, height, unique color count and finally the color mode. Which is either c for Color or m for Monochrome.

Definition at line 156 of file mlx_xpm42.c.

{
    int32_t flagc;
    char    buffer[64] = {0};
 
    // Check file type dec...
    if (!fgets(buffer, sizeof(buffer), file))
        return (false);
    if (strncmp(buffer, "!XPM42\n", sizeof(buffer)) != 0)
        return (false);
 
    // Get header info ...
    if (!fgets(buffer, sizeof(buffer), file))
        return (false);
    flagc = sscanf(buffer, "%i %i %i %i %c\n", &xpm->texture.width, &xpm->texture.height, &xpm->color_count, &xpm->cpp, &xpm->mode);
    if (flagc < 4 || xpm->texture.width > INT16_MAX || xpm->texture.height > INT16_MAX || \
        !(xpm->mode == 'c' || xpm->mode == 'm') || xpm->cpp > 10)
        return (false);
    xpm->texture.bytes_per_pixel = BPP;
    xpm->texture.pixels = calloc(xpm->texture.width * xpm->texture.height, sizeof(int32_t));
    return (xpm->texture.pixels != NULL ? mlx_read_table(xpm, file) : false);
}

Here is the call graph for this function:

Here is the caller graph for this function: