util.h

Go to the documentation of this file.

#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#pragma region math

float tiny_fabsf(float x);

float tiny_sqrtf(float x);

float tiny_floorf(float x);

float tiny_ceilf(float x);

float tiny_truncf(float x);

float tiny_roundf(float x);

float tiny_fmodf(float x, float y);

float tiny_expf(float x);

float tiny_logf(float x);

float tiny_powf(float x, float y);

float tiny_sinf(float x);

float tiny_cosf(float x);

float tiny_atan2f(float y, float x);

static inline uint8_t tiny_clamp_u8(int32_t v) {
    return (uint8_t) (v < 0 ? 0 : (v > 255 ? 255 : v));
}

static inline uint8_t tiny_clamp_u8f(float v) {
    return (uint8_t) (v <= 0.0f ? 0
                                : (v >= 255.0f ? 255 : (int32_t) (v + 0.5f)));
}

static inline float tiny_clampf(float v, float lo, float hi) {
    return v < lo ? lo : (v > hi ? hi : v);
}

static inline int32_t tiny_clampi(int32_t v, int32_t lo, int32_t hi) {
    return v < lo ? lo : (v > hi ? hi : v);
}

static inline uint32_t tiny_min_u32(uint32_t a, uint32_t b) {
    return a < b ? a : b;
}

static inline uint32_t tiny_max_u32(uint32_t a, uint32_t b) {
    return a > b ? a : b;
}
 
#pragma endregion
 
#pragma region lookup tables

void tiny_lut_identity(uint8_t* lut);

void tiny_lut_gamma(uint8_t* lut, float gamma);

void tiny_lut_srgb(uint8_t* lut, int encode);

void tiny_lut_compose(
    uint8_t* out, const uint8_t* first, const uint8_t* second
);
 
#pragma endregion
 
#pragma region checksums

uint32_t tiny_crc32(uint32_t crc, const uint8_t* data, size_t size);

uint32_t tiny_adler32(uint32_t adler, const uint8_t* data, size_t size);
 
#pragma endregion
 
#pragma region strings

size_t tiny_strlen(const char* s);

int tiny_strcmp(const char* a, const char* b);

int tiny_strcopy(char* dest, const char* src, size_t capacity);
 
#pragma endregion
 
#pragma region huffman

int tiny_huffman_lengths(
    const uint32_t* frequencies, uint32_t count, uint32_t limit,
    uint8_t* lengths
);
 
#pragma endregion
 
#pragma region byte writer

typedef struct {
    uint8_t* data;
    size_t size;
    size_t capacity;
    int error;
} TinyWriter;

int tiny_writer_init(TinyWriter* writer, size_t initial);

void tiny_writer_free(TinyWriter* writer);

uint8_t* tiny_writer_detach(TinyWriter* writer, size_t* size);

int tiny_writer_reserve(TinyWriter* writer, size_t extra);

int tiny_writer_write(TinyWriter* writer, const void* bytes, size_t size);

int tiny_writer_fill(TinyWriter* writer, uint8_t value, size_t count);

int tiny_writer_u8(TinyWriter* writer, uint8_t value);

int tiny_writer_le16(TinyWriter* writer, uint16_t value);

int tiny_writer_le32(TinyWriter* writer, uint32_t value);

int tiny_writer_be16(TinyWriter* writer, uint16_t value);

int tiny_writer_be32(TinyWriter* writer, uint32_t value);

uint32_t tiny_writer_sizeof(void);

uint8_t* tiny_writer_data(const TinyWriter* writer);

uint32_t tiny_writer_size(const TinyWriter* writer);
 
#pragma endregion
 
#pragma region bit io

typedef struct {
    const uint8_t* data;
    size_t size;
    size_t pos;
    uint32_t accumulator;
    uint32_t count;
    uint32_t phantom;
    int overrun;
} TinyBitReader;

void tiny_bits_init(TinyBitReader* reader, const uint8_t* data, size_t size);

uint32_t tiny_bits_msb(TinyBitReader* reader, uint32_t count);

uint32_t tiny_bits_peek_msb(TinyBitReader* reader, uint32_t count);

uint32_t tiny_bits_lsb(TinyBitReader* reader, uint32_t count);

uint32_t tiny_bits_peek_lsb(TinyBitReader* reader, uint32_t count);

void tiny_bits_skip_msb(TinyBitReader* reader, uint32_t count);

void tiny_bits_skip_lsb(TinyBitReader* reader, uint32_t count);

void tiny_bits_align_msb(TinyBitReader* reader);

void tiny_bits_align_lsb(TinyBitReader* reader);

size_t tiny_bits_remaining(const TinyBitReader* reader);

typedef struct {
    TinyWriter* out;
    uint32_t accumulator;
    uint32_t count;
} TinyBitWriter;

void tiny_bitwriter_init(TinyBitWriter* writer, TinyWriter* out);

void tiny_bitwriter_msb(TinyBitWriter* writer, uint32_t value, uint32_t count);

void tiny_bitwriter_lsb(TinyBitWriter* writer, uint32_t value, uint32_t count);

void tiny_bitwriter_flush_msb(TinyBitWriter* writer);

void tiny_bitwriter_flush_lsb(TinyBitWriter* writer);
 
#pragma endregion
 
#ifdef __cplusplus
}
#endif