qoi_enc_n64.h

Go to the documentation of this file.

 
#ifndef QOI_ENC_N64_H
#define QOI_ENC_N64_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
 
#define QOI_ALLOW_MEM_ALLOC 1
#define QOI_ALLOW_MEM_FREE 1
 
#if QOI_ALLOW_MEM_ALLOC
#include <stdlib.h>
#endif
 
/* QOI OPCODES */

#define QOI_TAG      0xC0 
#define QOI_TAG_MASK 0x3F 

#define QOI_OP_RGB   0xFE 
#define QOI_OP_RGBA  0xFF 
#define QOI_OP_INDEX 0x00 
#define QOI_OP_DIFF  0x40 
#define QOI_OP_LUMA  0x80 
#define QOI_OP_RUN   0xC0
 
enum qoi_pixel_color {QOI_RED, QOI_GREEN, QOI_BLUE, QOI_ALPHA};
enum qoi_channels {QOI_WHITESPACE = 3, QOI_TRANSPARENT = 4};
enum qoi_colorspace {QOI_SRGB, QOI_LINEAR};

static const uint8_t QOI_MAGIC[4] = {'q', 'o', 'i', 'f'};

static const uint8_t QOI_PADDING[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};

typedef struct
{
    uint32_t width;
    uint32_t height;
    uint8_t channels;
    uint8_t colorspace;
} qoi_desc_t;

typedef union
{
    struct {
        uint8_t red;
        uint8_t green;
        uint8_t blue;
        uint8_t alpha;
    };

    uint8_t channels[4];
    uint32_t concatenated_pixel_values;
} qoi_pixel_t;
 

typedef struct
{
    qoi_pixel_t pix_buffer[64];

    qoi_pixel_t prev_pixel;

    uint8_t* enc_buffer;
    uint32_t buffer_offset;
    uint32_t buffer_len;

    uint32_t pixel_offset;
    uint32_t pixels_written;
    uint32_t len;
    uint8_t run;
} qoi_enc_t;
 
 
/* Machine specific code */
 
static inline uint32_t qoi_get_be32(uint32_t value);
static inline uint32_t qoi_to_be32(uint32_t value);
 
/* Pixel related code */
 
void qoi_set_pixel_rgb(qoi_pixel_t* pixel, uint8_t red, uint8_t green, uint8_t blue);
void qoi_set_pixel_rgba(qoi_pixel_t* pixel, uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha);
 
void qoi_initalize_pixel(qoi_pixel_t* pixel);
static bool qoi_cmp_pixel(qoi_pixel_t pixel1, qoi_pixel_t pixel2, const uint8_t channels);
static inline int32_t qoi_get_index_position(qoi_pixel_t pixel);
 
/* QOI descriptor functions */
 
bool qoi_desc_init(qoi_desc_t *desc);
 
void qoi_set_dimensions(qoi_desc_t *desc, uint32_t width, uint32_t height);
void qoi_set_channels(qoi_desc_t* desc, uint8_t channels);
void qoi_set_colorspace(qoi_desc_t* desc, uint8_t colorspace);
 
void write_qoi_header(qoi_desc_t *desc, void* dest);
bool read_qoi_header(qoi_desc_t *desc, void* data);
 
/* QOI encoder functions */
 
bool qoi_enc_init(qoi_desc_t* desc, qoi_enc_t* enc);
 
#if QOI_ALLOW_MEM_ALLOC
bool qoi_enc_alloc_buffer(qoi_enc_t *enc, uint32_t data_len, bool shouldFreePrevBuffer);
bool qoi_enc_set_buffer(qoi_enc_t *enc, void* newBuffer, uint32_t len, bool shouldFreePrevBuffer);
bool qoi_enc_free_buffer(qoi_enc_t *enc);
#else
bool qoi_enc_set_buffer(qoi_enc_t *enc, void* newBuffer, uint32_t len);
#endif
 
bool qoi_enc_reset_buffer(qoi_enc_t* enc);
 
void qoi_encode_chunk(qoi_desc_t *desc, qoi_enc_t *enc, void *qoi_pixel_bytes);
 
static inline void qoi_enc_rgb(qoi_enc_t *enc, qoi_pixel_t px);
static inline void qoi_enc_rgba(qoi_enc_t *enc, qoi_pixel_t px);
 
static inline void qoi_enc_index(qoi_enc_t *enc, uint8_t index_pos);
static inline void qoi_enc_diff(qoi_enc_t *enc, uint8_t red_diff, uint8_t green_diff, uint8_t blue_diff);
static inline void qoi_enc_luma(qoi_enc_t *enc, uint8_t green_diff, uint8_t dr_dg, uint8_t db_dg);
static inline void qoi_enc_run(qoi_enc_t *enc);

static inline uint32_t qoi_get_be32(uint32_t value)
{
    uint8_t* bytes = (uint8_t*)&value;
    uint32_t be_value = (uint32_t) (
            (bytes[0] << 24) |
            (bytes[1] << 16) |
            (bytes[2] << 8) |
            (bytes[3])
        );
    
    return be_value;
}

static inline uint32_t qoi_to_be32(uint32_t value)
{
    uint8_t bytes[4];
 
    bytes[0] = (value >> 24);
    bytes[1] = (value >> 16);
    bytes[2] = (value >> 8);
    bytes[3] = (value);
    
    return *((uint32_t*)bytes);
}

static bool qoi_cmp_pixel(qoi_pixel_t pixel1, qoi_pixel_t pixel2, const uint8_t channels)
{
    if (channels < 4) /* RGB pixels have three channels; RGBA pixels have four channels for the alpha channel */
    {
        /* O2 optimization will mask out these alpha values using OR instruction so it compares only the colors of a pixel */
        pixel1.alpha = 255;
        pixel2.alpha = 255;
    }
 
    return pixel1.concatenated_pixel_values == pixel2.concatenated_pixel_values; /* compare pixels */
}

inline void qoi_set_pixel_rgb(qoi_pixel_t* pixel, uint8_t red, uint8_t green, uint8_t blue)
{
    pixel->red = red;
    pixel->green = green;
    pixel->blue = blue;
}

inline void qoi_set_pixel_rgba(qoi_pixel_t* pixel, uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha)
{
    pixel->red = red;
    pixel->green = green;
    pixel->blue = blue;
    pixel->alpha = alpha;
}

void qoi_initalize_pixel(qoi_pixel_t* pixel)
{
    if (pixel == NULL) return;
    *pixel = (qoi_pixel_t){0};
}

static inline int32_t qoi_get_index_position(qoi_pixel_t pixel)
{
    return (pixel.red * 3 + pixel.green * 5 + pixel.blue * 7 + pixel.alpha * 11) % 64;
}

bool qoi_desc_init(qoi_desc_t *desc)
{
    if (desc == NULL) return false;
 
    desc->width = 0;
    desc->height = 0;
    desc->channels = 0;
    desc->colorspace = 0;
 
    return true;
}

inline void qoi_set_dimensions(qoi_desc_t* desc, uint32_t width, uint32_t height)
{
    desc->width = width;
    desc->height = height;
}

inline void qoi_set_channels(qoi_desc_t* desc, uint8_t channels)
{
    desc->channels = channels;
}

inline void qoi_set_colorspace(qoi_desc_t *desc, uint8_t colorspace)
{
    desc->colorspace = colorspace;
}

void write_qoi_header(qoi_desc_t *desc, void* dest)
{
    if (dest == NULL || desc == NULL) return;
 
    uint8_t *byte = (uint8_t*)dest;
 
    /* Write the magic characters to the file first */
    *(uint32_t*)byte = *(uint32_t*)QOI_MAGIC;
 
    /* Writes all the metadata information about the image to the file */
 
    uint32_t* dimension_ptr = (uint32_t*)&byte[4];
 
    /* Writes the width and height values of the image to QOI header which stores them in big endian */
    dimension_ptr[0] = qoi_to_be32(desc->width);
    dimension_ptr[1] = qoi_to_be32(desc->height);
 
    byte[12] = desc->channels;
    byte[13] = desc->colorspace;
}

static inline void qoi_enc_rgb(qoi_enc_t *enc, qoi_pixel_t px)
{
    enc->enc_buffer[enc->buffer_offset + 0] = QOI_OP_RGB;
    enc->enc_buffer[enc->buffer_offset + 1] = px.red;
    enc->enc_buffer[enc->buffer_offset + 2] = px.green;
    enc->enc_buffer[enc->buffer_offset + 3] = px.blue;
    enc->buffer_offset += 4;
}

static inline void qoi_enc_rgba(qoi_enc_t *enc, qoi_pixel_t px)
{
    enc->enc_buffer[enc->buffer_offset + 0] = QOI_OP_RGBA;
    enc->enc_buffer[enc->buffer_offset + 1] = px.red;
    enc->enc_buffer[enc->buffer_offset + 2] = px.green;
    enc->enc_buffer[enc->buffer_offset + 3] = px.blue;
    enc->enc_buffer[enc->buffer_offset + 4] = px.alpha;
    enc->buffer_offset += 5;
}

static inline void qoi_enc_index(qoi_enc_t *enc, uint8_t index_pos)
{
    /* The run-length is stored with a bias of -1 */
    uint8_t tag = QOI_OP_INDEX | index_pos;
    enc->enc_buffer[enc->buffer_offset++] = tag;
}

static inline void qoi_enc_diff(qoi_enc_t *enc, uint8_t red_diff, uint8_t green_diff, uint8_t blue_diff)
{
    uint8_t tag =
        QOI_OP_DIFF |
        (uint8_t)(red_diff + 2) << 4 |
        (uint8_t)(green_diff + 2) << 2 |
        (uint8_t)(blue_diff + 2);
 
        enc->enc_buffer[enc->buffer_offset++] = tag;
}

static inline void qoi_enc_luma(qoi_enc_t *enc, uint8_t green_diff, uint8_t dr_dg, uint8_t db_dg)
{
    enc->enc_buffer[enc->buffer_offset + 0] = QOI_OP_LUMA | (uint8_t)(green_diff + 32);
    enc->enc_buffer[enc->buffer_offset + 1] = (uint8_t)(dr_dg + 8) << 4 | (uint8_t)(db_dg + 8);
 
    enc->buffer_offset += 2;
}

static inline void qoi_enc_run(qoi_enc_t *enc)
{
    /* The run-length is stored with a bias of -1 */
    uint8_t tag = QOI_OP_RUN | (enc->run - 1);
    enc->run = 0;
    
    enc->enc_buffer[enc->buffer_offset++] = tag;
}

void qoi_encode_chunk(qoi_desc_t *desc, qoi_enc_t *enc, void *qoi_pixel_bytes)
{
 
    /* 
        Assume that the pixel byte order is the following below
        bytes[0] = red;
        bytes[1] = green;
        bytes[2] = blue;
        bytes[3] = alpha;
    */
 
    qoi_pixel_t cur_pixel = *((qoi_pixel_t*)qoi_pixel_bytes);
 
    /* Assume an RGB pixel with three channels has an alpha value that makes pixels opaque */
    if (desc->channels < 4) 
        cur_pixel.alpha = 255;
 
    uint8_t index_pos = qoi_get_index_position(cur_pixel);
    enc->pixels_written++;
 
    /* Increment run length by 1 if pixels are the same */
    if (qoi_cmp_pixel(cur_pixel, enc->prev_pixel, desc->channels))
    {
        /*  Note that the runlengths 63 and 64 (b111110 and b111111) are illegal as they are
            occupied by the QOI_OP_RGB and QOI_OP_RGBA tags. */
        if (++enc->run >= 62 || enc->pixels_written >= enc->len)
        {
            qoi_enc_run(enc);
        }
    }
    else
    {
        if (enc->run > 0)
        {
            /*  Write opcode for because there are differences in pixels
                The run-length is stored with a bias of -1 */
            qoi_enc_run(enc);
        }
        
        /* Check if pixels exist in one of the pixel hash buffers */
        if (qoi_cmp_pixel(enc->pix_buffer[index_pos], cur_pixel, 4))
        {
            qoi_enc_index(enc, index_pos);
        }
        else
        {
            enc->pix_buffer[index_pos] = cur_pixel;
 
            /* QOI doesn't have opcodes for alpha values so check alpha values between two pixels first */
            if (desc->channels > 3 && cur_pixel.alpha != enc->prev_pixel.alpha)
            {
                qoi_enc_rgba(enc, cur_pixel);
            }
            else
            {
                /* Check the difference between color values to determine opcode */
                int8_t red_diff, green_diff, blue_diff;
                int8_t dr_dg, db_dg;
 
                red_diff = cur_pixel.red - enc->prev_pixel.red;
                green_diff = cur_pixel.green - enc->prev_pixel.green;
                blue_diff = cur_pixel.blue - enc->prev_pixel.blue;
                
                dr_dg = red_diff - green_diff;
                db_dg = blue_diff - green_diff;
 
                if (
                    red_diff >= -2 && red_diff <= 1 &&
                    green_diff >= -2 && green_diff <= 1 &&
                    blue_diff >= -2 && blue_diff <= 1
                )
                {
                    qoi_enc_diff(enc, red_diff, green_diff, blue_diff);
                }
 
                else if (
                    dr_dg >= -8 && dr_dg <= 7 &&
                    green_diff >= -32 && green_diff <= 31 &&
                    db_dg >= -8 && db_dg <= 7
                )
                {
                    qoi_enc_luma(enc, green_diff, dr_dg, db_dg);
                }
 
                /* otherwise write an RGB tag containting the RGB values of a pixel */
                else
                {
                    qoi_enc_rgb(enc, cur_pixel);
                }
            }
 
        }
    }
 
    /* Advance the pixel offset by one and sets the previous pixel to the current pixel */
    enc->prev_pixel = cur_pixel;
 
}

bool qoi_enc_init(qoi_desc_t* desc, qoi_enc_t* enc)
{
    if (enc == NULL || desc == NULL) return false;
 
    for (uint8_t element = 0; element < 64; element++) {
        /* Initalize all the pixels in the buffer to zero for each channel of each pixels */
        qoi_initalize_pixel(&enc->pix_buffer[element]); 
    }
 
    enc->len = (uint32_t)desc->width * (uint32_t)desc->height;
 
    enc->run = 0;
    enc->pixels_written = 0;
 
    /*  
        The decoder and encoder start with 
        {r: 0, g: 0, b: 0, a: 255}
        as the previous pixel value. 
    */
    qoi_set_pixel_rgba(&enc->prev_pixel, 0, 0, 0, 255);
 
    return true;
}
 
#if QOI_ALLOW_MEM_ALLOC
bool qoi_enc_set_buffer(qoi_enc_t *enc, void* newBuffer, uint32_t len, bool shouldFreePrevBuffer) 
#else
bool qoi_enc_set_buffer(qoi_enc_t *enc, void* newBuffer, uint32_t len)
#endif
{
    if (enc == NULL || newBuffer == NULL || len == 0) return false;
    
    #if QOI_ALLOW_MEM_ALLOC
    if (shouldFreePrevBuffer == true && enc->enc_buffer)
    {
        free(enc->enc_buffer);
    }
    #endif
 
    enc->enc_buffer = (uint8_t*)newBuffer;
    enc->buffer_len = len;
 
    qoi_enc_reset_buffer(enc);
 
    return true;
}

#if QOI_ALLOW_MEM_ALLOC
bool qoi_enc_alloc_buffer(qoi_enc_t *enc, uint32_t len, bool shouldFreePrevBuffer)
{
    if (enc == NULL || len == 0) return false;
 
    uint8_t *newBuffer = (uint8_t*)malloc(len * sizeof(uint8_t));;
    
    if (newBuffer == NULL) 
    {
        return false;
    }
 
    if (shouldFreePrevBuffer == true && enc->enc_buffer) {
        free(enc->enc_buffer);
    }
 
    enc->enc_buffer = newBuffer;
    enc->buffer_len = len;
 
    qoi_enc_reset_buffer(enc);
 
    return true;
}
#endif
 
 
#if QOI_ALLOW_MEM_ALLOC
bool qoi_enc_free_buffer(qoi_enc_t *enc)
{
    if (enc == NULL || enc->enc_buffer == NULL) 
        goto qoi_enc_free_buffer_skip;
 
    free(enc->enc_buffer);
 
    enc->enc_buffer = NULL;
    enc->buffer_len = 0;
 
    qoi_enc_reset_buffer(enc);
 
qoi_enc_free_buffer_skip:
    return true;
}
#endif

bool qoi_enc_reset_buffer(qoi_enc_t* enc)
{
    if (enc == NULL) return false;
 
    enc->buffer_offset = 0;
 
    return true;
}
 
#ifdef __cplusplus
}
#endif
 
#endif // QOI_ENC_N64_H