saf.h

#ifndef SAF_H
#define SAF_H

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#define SAF_VERSION_MAJOR 1
#define SAF_VERSION_MINOR 0
#define SAF_VERSION_PATCH 0
#define SAF_VERSION "1.0.0"

typedef struct saf_header
{
    uint32_t sample_rate;
    uint8_t channels;
    uint8_t bit_depth;
} SAF_Header;

typedef enum saf_return_codes
{
    SAF_OK = 0,
    SAF_ERR_OPEN,
    SAF_ERR_WRITE,
    SAF_ERR_READ,
    SAF_ERR_MEM,
} SAF_RetCode;

SAF_RetCode saf_write(const char *filename, SAF_Header header, const void *samples, size_t sample_count);
SAF_RetCode saf_read(const char *filename, SAF_Header *header, void **samples, size_t *sample_count);
void saf_free(void **samples);
const char *saf_strerror(SAF_RetCode code);

#ifdef SAF_IMPL

SAF_RetCode saf_write(const char *filename, SAF_Header header, const void *samples, size_t sample_count)
{
    FILE *file = fopen(filename, "wb");
    if (!file)
        return SAF_ERR_OPEN;

    uint8_t buf[6];
    buf[0] = (header.sample_rate) & 0xFF;
    buf[1] = (header.sample_rate >> 8) & 0xFF;
    buf[2] = (header.sample_rate >> 16) & 0xFF;
    buf[3] = (header.sample_rate >> 24) & 0xFF;
    buf[4] = header.channels;
    buf[5] = header.bit_depth;

    if (fwrite(buf, 1, 6, file) < 6)
    {
        fclose(file);
        return SAF_ERR_WRITE;
    }

    size_t byte_count = sample_count * header.channels * (header.bit_depth / 8);
    if (fwrite(samples, 1, byte_count, file) < byte_count)
    {
        fclose(file);
        return SAF_ERR_WRITE;
    }

    fclose(file);
    return SAF_OK;
}

SAF_RetCode saf_read(const char *filename, SAF_Header *header, void **samples, size_t *sample_count)
{
    FILE *file = fopen(filename, "rb");
    if (!file)
        return SAF_ERR_OPEN;

    uint8_t buf[6];
    if (fread(buf, 1, 6, file) < 6)
    {
        fclose(file);
        return SAF_ERR_READ;
    }

    header->sample_rate = (uint32_t)buf[0] | (uint32_t)buf[1] << 8 | (uint32_t)buf[2] << 16 | (uint32_t)buf[3] << 24;
    header->channels = buf[4];
    header->bit_depth = buf[5];

    fseek(file, 0, SEEK_END);
    size_t data_bytes = (size_t)ftell(file) - 6;
    fseek(file, 6, SEEK_SET);

    *samples = malloc(data_bytes);
    if (!*samples)
    {
        fclose(file);
        return SAF_ERR_MEM;
    }

    if (fread(*samples, 1, data_bytes, file) < data_bytes)
    {
        free(*samples);
        *samples = NULL;
        fclose(file);
        return SAF_ERR_READ;
    }

    *sample_count = data_bytes / (header->channels * (header->bit_depth / 8));

    fclose(file);
    return SAF_OK;
}

void saf_free(void **samples)
{
    free(*samples);
    *samples = NULL;
}

const char *saf_strerror(SAF_RetCode code)
{
    switch (code)
    {
    case SAF_OK:
        return "OK";
    case SAF_ERR_OPEN:
        return "Failed to open file";
    case SAF_ERR_WRITE:
        return "Failed to write file";
    case SAF_ERR_READ:
        return "Failed to read file";
    case SAF_ERR_MEM:
        return "Memory allocation failed";
    default:
        return "Unknown error";
    }
}

#endif // SAF_IMPL

#endif // SAF_H