Full Code of phoboslab/qoa for AI

Repository: phoboslab/qoa
Branch: master
Commit: af36bdf312f2
Files: 7
Total size: 44.8 KB

Directory structure:
gitextract_g3f1s87l/

├── .gitignore
├── LICENSE
├── Makefile
├── README.md
├── qoa.h
├── qoaconv.c
└── qoaplay.c

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitignore
================================================
tests/
dr_flac.h
sokol_audio.h
dr_mp3.h
qoaconv
qoaplay


================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) 2023 Dominic Szablewski

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.


================================================
FILE: Makefile
================================================
CC ?= gcc

# QOACONV

TARGET_CONV ?= qoaconv
CFLAGS_CONV ?= -std=c99 -O3
LFLAGS_CONV ?= -lm

# Call `make HAS_DRLIBS=true` to compile with mp3/flac support
# Requires header files from https://github.com/mackron/dr_libs
# curl https://raw.githubusercontent.com/mackron/dr_libs/refs/heads/master/dr_mp3.h -o dr_mp3.h
# curl https://raw.githubusercontent.com/mackron/dr_libs/refs/heads/master/dr_flac.h -o dr_flac.h
ifeq ($(HAS_DRLIBS), true)
	CFLAGS_CONV := $(CFLAGS_CONV) -D QOACONV_HAS_DRMP3 -D QOACONV_HAS_DRFLAC
endif

# QOAPLAY
# Requires
# - https://github.com/floooh/sokol/blob/master/sokol_audio.h
# FIXME: not yet tested on Windows/macOS
TARGET_PLAY ?= qoaplay
CFLAGS_PLAY ?= -std=gnu99 -O3

ifeq ($(OS),Windows_NT)
	LFLAGS_PLAY ?= # defined in #pragma() in sokol_audio.h
else
	UNAME_S := $(shell uname -s)
	ifeq ($(UNAME_S),Darwin)
		LFLAGS_PLAY ?= -pthread -framework AudioToolbox
	else
		LFLAGS_PLAY ?= -pthread -lasound
	endif
endif

all: $(TARGET_PLAY) $(TARGET_CONV)

play: $(TARGET_PLAY)
$(TARGET_PLAY):$(TARGET_PLAY).c qoa.h
	$(CC) $(CFLAGS_PLAY) $(TARGET_PLAY).c -o $(TARGET_PLAY) $(LFLAGS_PLAY)

conv: $(TARGET_CONV)
$(TARGET_CONV):$(TARGET_CONV).c qoa.h
	$(CC) $(CFLAGS_CONV) $(TARGET_CONV).c -o $(TARGET_CONV) $(LFLAGS_CONV)

.PHONY: clean
clean:
	$(RM) $(TARGET_PLAY) $(TARGET_CONV)


================================================
FILE: README.md
================================================
![QOA Logo](https://qoaformat.org/qoa-logo-new.svg)

# QOA - The “Quite OK Audio Format” for fast, lossy audio compression

Single-file MIT licensed library for C/C++

See [qoa.h](https://github.com/phoboslab/qoa/blob/master/qoa.h) for
the documentation and format specification.

More info at: https://qoaformat.org

Audio samples in WAV & QOA format can be found at: https://qoaformat.org/samples/


⚠️ This implementation has not yet been fuzzed. Don't use it with untrusted input.


## Compiling

Call `make` to build `qoaconv` and `qoaplay`. By default `qoaconv` is compiled 
without MP3 and FLAC support. 

To compile `qoaconv` with MP3 and FLAC support, download the 
[dr_*.h files](https://github.com/mackron/dr_libs) and pass `HAS_DRLIBS=true`
to make:

```bash
curl https://raw.githubusercontent.com/mackron/dr_libs/refs/heads/master/dr_mp3.h -o dr_mp3.h
curl https://raw.githubusercontent.com/mackron/dr_libs/refs/heads/master/dr_flac.h -o dr_flac.h
make HAS_DRLIBS=true
```


## Alternative Implementations of QOA

- [pfusik/qoa-fu](https://github.com/pfusik/qoa-fu) - Fusion, transpiling to
[C](https://github.com/pfusik/qoa-fu/blob/master/transpiled/QOA.c),
[C++](https://github.com/pfusik/qoa-fu/blob/master/transpiled/QOA.cpp),
[C#](https://github.com/pfusik/qoa-fu/blob/master/transpiled/QOA.cs),
[D](https://github.com/pfusik/qoa-fu/blob/master/transpiled/QOA.d),
[Java](https://github.com/pfusik/qoa-fu/blob/master/transpiled/QOADecoder.java),
[JavaScript](https://github.com/pfusik/qoa-fu/blob/master/transpiled/QOA.js),
[Python](https://github.com/pfusik/qoa-fu/blob/master/transpiled/QOA.py),
[Swift](https://github.com/pfusik/qoa-fu/blob/master/transpiled/QOA.swift)
and [TypeScript](https://github.com/pfusik/qoa-fu/blob/master/transpiled/QOA.ts)
- [qoa-format](https://github.com/mattdesl/qoa-format) - JavaScript encoder/decoder
- [JohannesFriedrich/qoa4R](https://github.com/JohannesFriedrich/qoa4R) - R
- [rafaelcaricio/qoaudio](https://github.com/rafaelcaricio/qoaudio) - Pure Rust zero-dependency decoder implementation
- [AuburnSounds/audio-formats](https://github.com/AuburnSounds/audio-formats) - D library, supports QOA
- [braheezy/goqoa](https://github.com/braheezy/goqoa) - Go library and CLI tool
- [HaxelWorks/qoa-python](https://github.com/HaxelWorks/qoa-python) - Python wrapper using cffi
- [Cl Qoa](https://shinmera.github.io/cl-qoa/) - Common Lisp
- [Resona QOA](https://github.com/MatusOllah/resona/tree/main/codec/qoa) - Pure Go decoder and encoder implementation

## QOA Support in Other Software

- [Godot Engine](https://godotengine.org) - supports compressing WAV files into QOA since 4.3
- [raylib](https://github.com/raysan5/raylib) - supports decoding QOA samples through its [raudio module](https://github.com/raysan5/raylib/blob/master/src/raudio.c)
- [SerenityOS](https://github.com/SerenityOS/serenity) supports QOA system wide through [QOALoader.h](https://github.com/SerenityOS/serenity/blob/master/Userland/Libraries/LibAudio/QOALoader.h)
- [Qmmp](https://github.com/TTK-qmmp/qmmp-qoa) - supports decoding QOA samples
- [Visual Studio Code](https://github.com/microsoft/vscode): supports playing QOA files with the [QOA Preview extension](https://github.com/braheezy/vscode-qoa-preview)
- [OpenCubicPlayer](https://github.com/mywave82/opencubicplayer) - supports playing QOA files
- [file](https://github.com/file/file): identify QOA files
  


================================================
FILE: qoa.h
================================================
/*

Copyright (c) 2023, Dominic Szablewski - https://phoboslab.org
SPDX-License-Identifier: MIT

QOA - The "Quite OK Audio" format for fast, lossy audio compression


-- Data Format

QOA encodes pulse-code modulated (PCM) audio data with up to 255 channels, 
sample rates from 1 up to 16777215 hertz and a bit depth of 16 bits.

The compression method employed in QOA is lossy; it discards some information
from the uncompressed PCM data. For many types of audio signals this compression
is "transparent", i.e. the difference from the original file is often not
audible.

QOA encodes 20 samples of 16 bit PCM data into slices of 64 bits. A single
sample therefore requires 3.2 bits of storage space, resulting in a 5x
compression (16 / 3.2).

A QOA file consists of an 8 byte file header, followed by a number of frames.
Each frame contains an 8 byte frame header, the current 16 byte en-/decoder
state per channel and 256 slices per channel. Each slice is 8 bytes wide and
encodes 20 samples of audio data.

All values, including the slices, are big endian. The file layout is as follows:

struct {
	struct {
		char     magic[4];         // magic bytes "qoaf"
		uint32_t samples;          // samples per channel in this file
	} file_header;

	struct {
		struct {
			uint8_t  num_channels; // no. of channels
			uint24_t samplerate;   // samplerate in hz
			uint16_t fsamples;     // samples per channel in this frame
			uint16_t fsize;        // frame size (includes this header)
		} frame_header;

		struct {
			int16_t history[4];    // most recent last
			int16_t weights[4];    // most recent last
		} lms_state[num_channels];

		qoa_slice_t slices[256][num_channels];

	} frames[ceil(samples / (256 * 20))];
} qoa_file_t;

Each `qoa_slice_t` contains a quantized scalefactor `sf_quant` and 20 quantized
residuals `qrNN`:

.- QOA_SLICE -- 64 bits, 20 samples --------------------------/  /------------.
|        Byte[0]         |        Byte[1]         |  Byte[2]  \  \  Byte[7]   |
| 7  6  5  4  3  2  1  0 | 7  6  5  4  3  2  1  0 | 7  6  5   /  /    2  1  0 |
|------------+--------+--------+--------+---------+---------+-\  \--+---------|
|  sf_quant  |  qr00  |  qr01  |  qr02  |  qr03   |  qr04   | /  /  |  qr19   |
`-------------------------------------------------------------\  \------------`

Each frame except the last must contain exactly 256 slices per channel. The last
frame may contain between 1 .. 256 (inclusive) slices per channel. The last
slice (for each channel) in the last frame may contain less than 20 samples; the
slice still must be 8 bytes wide, with the unused samples zeroed out.

Channels are interleaved per slice. E.g. for 2 channel stereo:
slice[0] = L, slice[1] = R, slice[2] = L, slice[3] = R ...

A valid QOA file or stream must have at least one frame. Each frame must contain
at least one channel and one sample with a samplerate between 1 .. 16777215
(inclusive).

If the total number of samples is not known by the encoder, the samples in the
file header may be set to 0x00000000 to indicate that the encoder is
"streaming". In a streaming context, the samplerate and number of channels may
differ from frame to frame. For static files (those with samples set to a
non-zero value), each frame must have the same number of channels and same
samplerate.

Note that this implementation of QOA only handles files with a known total
number of samples.

A decoder should support at least 8 channels. The channel layout for channel
counts 1 .. 8 is:

	1. Mono
	2. L, R
	3. L, R, C
	4. FL, FR, B/SL, B/SR
	5. FL, FR, C, B/SL, B/SR
	6. FL, FR, C, LFE, B/SL, B/SR
	7. FL, FR, C, LFE, B, SL, SR
	8. FL, FR, C, LFE, BL, BR, SL, SR

QOA predicts each audio sample based on the previously decoded ones using a
"Sign-Sign Least Mean Squares Filter" (LMS). This prediction plus the
dequantized residual forms the final output sample.

*/



/* -----------------------------------------------------------------------------
	Header - Public functions */

#ifndef QOA_H
#define QOA_H

#ifdef __cplusplus
extern "C" {
#endif

#define QOA_MIN_FILESIZE 16
#define QOA_MAX_CHANNELS 8

#define QOA_SLICE_LEN 20
#define QOA_SLICES_PER_FRAME 256
#define QOA_FRAME_LEN (QOA_SLICES_PER_FRAME * QOA_SLICE_LEN)
#define QOA_LMS_LEN 4
#define QOA_MAGIC 0x716f6166 /* 'qoaf' */

#define QOA_FRAME_SIZE(channels, slices) \
	(8 + QOA_LMS_LEN * 4 * channels + 8 * slices * channels)

typedef struct {
	int history[QOA_LMS_LEN];
	int weights[QOA_LMS_LEN];
} qoa_lms_t;

typedef struct {
	unsigned int channels;
	unsigned int samplerate;
	unsigned int samples;
	qoa_lms_t lms[QOA_MAX_CHANNELS];
	#ifdef QOA_RECORD_TOTAL_ERROR
		double error;
	#endif
} qoa_desc;

unsigned int qoa_encode_header(qoa_desc *qoa, unsigned char *bytes);
unsigned int qoa_encode_frame(const short *sample_data, qoa_desc *qoa, unsigned int frame_len, unsigned char *bytes);
void *qoa_encode(const short *sample_data, qoa_desc *qoa, unsigned int *out_len);

unsigned int qoa_max_frame_size(qoa_desc *qoa);
unsigned int qoa_decode_header(const unsigned char *bytes, int size, qoa_desc *qoa);
unsigned int qoa_decode_frame(const unsigned char *bytes, unsigned int size, qoa_desc *qoa, short *sample_data, unsigned int *frame_len);
short *qoa_decode(const unsigned char *bytes, int size, qoa_desc *file);

#ifndef QOA_NO_STDIO

int qoa_write(const char *filename, const short *sample_data, qoa_desc *qoa);
void *qoa_read(const char *filename, qoa_desc *qoa);

#endif /* QOA_NO_STDIO */


#ifdef __cplusplus
}
#endif
#endif /* QOA_H */


/* -----------------------------------------------------------------------------
	Implementation */

#ifdef QOA_IMPLEMENTATION
#include <stdlib.h>

#ifndef QOA_MALLOC
	#define QOA_MALLOC(sz) malloc(sz)
	#define QOA_FREE(p) free(p)
#endif

typedef unsigned long long qoa_uint64_t;


/* The quant_tab provides an index into the dequant_tab for residuals in the
range of -8 .. 8. It maps this range to just 3bits and becomes less accurate at
the higher end. Note that the residual zero is identical to the lowest positive
value. This is mostly fine, since the qoa_div() function always rounds away
from zero. */

static const int qoa_quant_tab[17] = {
	7, 7, 7, 5, 5, 3, 3, 1, /* -8..-1 */
	0,                      /*  0     */
	0, 2, 2, 4, 4, 6, 6, 6  /*  1.. 8 */
};


/* We have 16 different scalefactors. Like the quantized residuals these become
less accurate at the higher end. In theory, the highest scalefactor that we
would need to encode the highest 16bit residual is (2**16)/8 = 8192. However we
rely on the LMS filter to predict samples accurately enough that a maximum
residual of one quarter of the 16 bit range is sufficient. I.e. with the
scalefactor 2048 times the quant range of 8 we can encode residuals up to 2**14.

The scalefactor values are computed as:
scalefactor_tab[s] <- round(pow(s + 1, 2.75)) */

static const int qoa_scalefactor_tab[16] = {
	1, 7, 21, 45, 84, 138, 211, 304, 421, 562, 731, 928, 1157, 1419, 1715, 2048
};


/* The reciprocal_tab maps each of the 16 scalefactors to their rounded
reciprocals 1/scalefactor. This allows us to calculate the scaled residuals in
the encoder with just one multiplication instead of an expensive division. We
do this in .16 fixed point with integers, instead of floats.

The reciprocal_tab is computed as:
reciprocal_tab[s] <- ((1<<16) + scalefactor_tab[s] - 1) / scalefactor_tab[s] */

static const int qoa_reciprocal_tab[16] = {
	65536, 9363, 3121, 1457, 781, 475, 311, 216, 156, 117, 90, 71, 57, 47, 39, 32
};


/* The dequant_tab maps each of the scalefactors and quantized residuals to
their unscaled & dequantized version.

Since qoa_div rounds away from the zero, the smallest entries are mapped to 3/4
instead of 1. The dequant_tab assumes the following dequantized values for each
of the quant_tab indices and is computed as:
float dqt[8] = {0.75, -0.75, 2.5, -2.5, 4.5, -4.5, 7, -7};
dequant_tab[s][q] <- round_ties_away_from_zero(scalefactor_tab[s] * dqt[q])

The rounding employed here is "to nearest, ties away from zero",  i.e. positive
and negative values are treated symmetrically.
*/

static const int qoa_dequant_tab[16][8] = {
	{   1,    -1,    3,    -3,    5,    -5,     7,     -7},
	{   5,    -5,   18,   -18,   32,   -32,    49,    -49},
	{  16,   -16,   53,   -53,   95,   -95,   147,   -147},
	{  34,   -34,  113,  -113,  203,  -203,   315,   -315},
	{  63,   -63,  210,  -210,  378,  -378,   588,   -588},
	{ 104,  -104,  345,  -345,  621,  -621,   966,   -966},
	{ 158,  -158,  528,  -528,  950,  -950,  1477,  -1477},
	{ 228,  -228,  760,  -760, 1368, -1368,  2128,  -2128},
	{ 316,  -316, 1053, -1053, 1895, -1895,  2947,  -2947},
	{ 422,  -422, 1405, -1405, 2529, -2529,  3934,  -3934},
	{ 548,  -548, 1828, -1828, 3290, -3290,  5117,  -5117},
	{ 696,  -696, 2320, -2320, 4176, -4176,  6496,  -6496},
	{ 868,  -868, 2893, -2893, 5207, -5207,  8099,  -8099},
	{1064, -1064, 3548, -3548, 6386, -6386,  9933,  -9933},
	{1286, -1286, 4288, -4288, 7718, -7718, 12005, -12005},
	{1536, -1536, 5120, -5120, 9216, -9216, 14336, -14336},
};


/* The Least Mean Squares Filter is the heart of QOA. It predicts the next
sample based on the previous 4 reconstructed samples. It does so by continuously
adjusting 4 weights based on the residual of the previous prediction.

The next sample is predicted as the sum of (weight[i] * history[i]).

The adjustment of the weights is done with a "Sign-Sign-LMS" that adds or
subtracts the residual to each weight, based on the corresponding sample from
the history. This, surprisingly, is sufficient to get worthwhile predictions.

This is all done with fixed point integers. Hence the right-shifts when updating
the weights and calculating the prediction. */

static int qoa_lms_predict(qoa_lms_t *lms) {
	int prediction = 0;
	for (int i = 0; i < QOA_LMS_LEN; i++) {
		prediction += lms->weights[i] * lms->history[i];
	}
	return prediction >> 13;
}

static void qoa_lms_update(qoa_lms_t *lms, int sample, int residual) {
	int delta = residual >> 4;
	for (int i = 0; i < QOA_LMS_LEN; i++) {
		lms->weights[i] += lms->history[i] < 0 ? -delta : delta;
	}

	for (int i = 0; i < QOA_LMS_LEN-1; i++) {
		lms->history[i] = lms->history[i+1];
	}
	lms->history[QOA_LMS_LEN-1] = sample;
}


/* qoa_div() implements a rounding division, but avoids rounding to zero for
small numbers. E.g. 0.1 will be rounded to 1. Note that 0 itself still
returns as 0, which is handled in the qoa_quant_tab[].
qoa_div() takes an index into the .16 fixed point qoa_reciprocal_tab as an
argument, so it can do the division with a cheaper integer multiplication. */

static inline int qoa_div(int v, int scalefactor) {
	int reciprocal = qoa_reciprocal_tab[scalefactor];
	int n = (v * reciprocal + (1 << 15)) >> 16;
	n = n + ((v > 0) - (v < 0)) - ((n > 0) - (n < 0)); /* round away from 0 */
	return n;
}

static inline int qoa_clamp(int v, int min, int max) {
	if (v < min) { return min; }
	if (v > max) { return max; }
	return v;
}

/* This specialized clamp function for the signed 16 bit range improves decode
performance quite a bit. The extra if() statement works nicely with the CPUs
branch prediction as this branch is rarely taken. */

static inline int qoa_clamp_s16(int v) {
	if ((unsigned int)(v + 32768) > 65535) {
		if (v < -32768) { return -32768; }
		if (v >  32767) { return  32767; }
	}
	return v;
}

static inline qoa_uint64_t qoa_read_u64(const unsigned char *bytes, unsigned int *p) {
	bytes += *p;
	*p += 8;
	return 
		((qoa_uint64_t)(bytes[0]) << 56) | ((qoa_uint64_t)(bytes[1]) << 48) |
		((qoa_uint64_t)(bytes[2]) << 40) | ((qoa_uint64_t)(bytes[3]) << 32) |
		((qoa_uint64_t)(bytes[4]) << 24) | ((qoa_uint64_t)(bytes[5]) << 16) |
		((qoa_uint64_t)(bytes[6]) <<  8) | ((qoa_uint64_t)(bytes[7]) <<  0);
}

static inline void qoa_write_u64(qoa_uint64_t v, unsigned char *bytes, unsigned int *p) {
	bytes += *p;
	*p += 8;
	bytes[0] = (v >> 56) & 0xff;
	bytes[1] = (v >> 48) & 0xff;
	bytes[2] = (v >> 40) & 0xff;
	bytes[3] = (v >> 32) & 0xff;
	bytes[4] = (v >> 24) & 0xff;
	bytes[5] = (v >> 16) & 0xff;
	bytes[6] = (v >>  8) & 0xff;
	bytes[7] = (v >>  0) & 0xff;
}


/* -----------------------------------------------------------------------------
	Encoder */

unsigned int qoa_encode_header(qoa_desc *qoa, unsigned char *bytes) {
	unsigned int p = 0;
	qoa_write_u64(((qoa_uint64_t)QOA_MAGIC << 32) | qoa->samples, bytes, &p);
	return p;
}

unsigned int qoa_encode_frame(const short *sample_data, qoa_desc *qoa, unsigned int frame_len, unsigned char *bytes) {
	unsigned int channels = qoa->channels;

	unsigned int p = 0;
	unsigned int slices = (frame_len + QOA_SLICE_LEN - 1) / QOA_SLICE_LEN;
	unsigned int frame_size = QOA_FRAME_SIZE(channels, slices);
	int prev_scalefactor[QOA_MAX_CHANNELS] = {0};

	/* Write the frame header */
	qoa_write_u64((
		(qoa_uint64_t)qoa->channels   << 56 |
		(qoa_uint64_t)qoa->samplerate << 32 |
		(qoa_uint64_t)frame_len       << 16 |
		(qoa_uint64_t)frame_size
	), bytes, &p);

	
	for (unsigned int c = 0; c < channels; c++) {
		/* Write the current LMS state */
		qoa_uint64_t weights = 0;
		qoa_uint64_t history = 0;
		for (int i = 0; i < QOA_LMS_LEN; i++) {
			history = (history << 16) | (qoa->lms[c].history[i] & 0xffff);
			weights = (weights << 16) | (qoa->lms[c].weights[i] & 0xffff);
		}
		qoa_write_u64(history, bytes, &p);
		qoa_write_u64(weights, bytes, &p);
	}

	/* We encode all samples with the channels interleaved on a slice level.
	E.g. for stereo: (ch-0, slice 0), (ch 1, slice 0), (ch 0, slice 1), ...*/
	for (unsigned int sample_index = 0; sample_index < frame_len; sample_index += QOA_SLICE_LEN) {

		for (unsigned int c = 0; c < channels; c++) {
			int slice_len = qoa_clamp(QOA_SLICE_LEN, 0, frame_len - sample_index);
			int slice_start = sample_index * channels + c;
			int slice_end = (sample_index + slice_len) * channels + c;

			/* Brute force search for the best scalefactor. Just go through all
			16 scalefactors, encode all samples for the current slice and
			meassure the total squared error. */
			qoa_uint64_t best_rank = -1;
			#ifdef QOA_RECORD_TOTAL_ERROR
				qoa_uint64_t best_error = -1;
			#endif
			qoa_uint64_t best_slice = 0;
			qoa_lms_t best_lms;
			int best_scalefactor = 0;

			for (int sfi = 0; sfi < 16; sfi++) {
				/* There is a strong correlation between the scalefactors of
				neighboring slices. As an optimization, start testing
				the best scalefactor of the previous slice first. */
				int scalefactor = (sfi + prev_scalefactor[c]) & (16 - 1);

				/* We have to reset the LMS state to the last known good one
				before trying each scalefactor, as each pass updates the LMS
				state when encoding. */
				qoa_lms_t lms = qoa->lms[c];
				qoa_uint64_t slice = scalefactor;
				qoa_uint64_t current_rank = 0;
				#ifdef QOA_RECORD_TOTAL_ERROR
					qoa_uint64_t current_error = 0;
				#endif

				for (int si = slice_start; si < slice_end; si += channels) {
					int sample = sample_data[si];
					int predicted = qoa_lms_predict(&lms);

					int residual = sample - predicted;
					int scaled = qoa_div(residual, scalefactor);
					int clamped = qoa_clamp(scaled, -8, 8);
					int quantized = qoa_quant_tab[clamped + 8];
					int dequantized = qoa_dequant_tab[scalefactor][quantized];
					int reconstructed = qoa_clamp_s16(predicted + dequantized);


					/* If the weights have grown too large, we introduce a penalty
					here. This prevents pops/clicks in certain problem cases */
					int weights_penalty = ((
						lms.weights[0] * lms.weights[0] + 
						lms.weights[1] * lms.weights[1] + 
						lms.weights[2] * lms.weights[2] + 
						lms.weights[3] * lms.weights[3]
					) >> 18) - 0x8ff;
					if (weights_penalty < 0) {
						weights_penalty = 0;
					}

					long long error = (sample - reconstructed);
					qoa_uint64_t error_sq = error * error;

					current_rank += error_sq + weights_penalty * weights_penalty;
					#ifdef QOA_RECORD_TOTAL_ERROR
						current_error += error_sq;
					#endif
					if (current_rank > best_rank) {
						break;
					}

					qoa_lms_update(&lms, reconstructed, dequantized);
					slice = (slice << 3) | quantized;
				}

				if (current_rank < best_rank) {
					best_rank = current_rank;
					#ifdef QOA_RECORD_TOTAL_ERROR
						best_error = current_error;
					#endif
					best_slice = slice;
					best_lms = lms;
					best_scalefactor = scalefactor;
				}
			}

			prev_scalefactor[c] = best_scalefactor;

			qoa->lms[c] = best_lms;
			#ifdef QOA_RECORD_TOTAL_ERROR
				qoa->error += best_error;
			#endif

			/* If this slice was shorter than QOA_SLICE_LEN, we have to left-
			shift all encoded data, to ensure the rightmost bits are the empty
			ones. This should only happen in the last frame of a file as all
			slices are completely filled otherwise. */
			best_slice <<= (QOA_SLICE_LEN - slice_len) * 3;
			qoa_write_u64(best_slice, bytes, &p);
		}
	}
	
	return p;
}

void *qoa_encode(const short *sample_data, qoa_desc *qoa, unsigned int *out_len) {
	if (
		qoa->samples == 0 || 
		qoa->samplerate == 0 || qoa->samplerate > 0xffffff ||
		qoa->channels == 0 || qoa->channels > QOA_MAX_CHANNELS
	) {
		return NULL;
	}

	/* Calculate the encoded size and allocate */
	unsigned int num_frames = (qoa->samples + QOA_FRAME_LEN-1) / QOA_FRAME_LEN;
	unsigned int num_slices = (qoa->samples + QOA_SLICE_LEN-1) / QOA_SLICE_LEN;
	unsigned int encoded_size = 8 +                    /* 8 byte file header */
		num_frames * 8 +                               /* 8 byte frame headers */
		num_frames * QOA_LMS_LEN * 4 * qoa->channels + /* 4 * 4 bytes lms state per channel */
		num_slices * 8 * qoa->channels;                /* 8 byte slices */

	unsigned char *bytes = QOA_MALLOC(encoded_size);

	for (unsigned int c = 0; c < qoa->channels; c++) {
		/* Set the initial LMS weights to {0, 0, -1, 2}. This helps with the 
		prediction of the first few ms of a file. */
		qoa->lms[c].weights[0] = 0;
		qoa->lms[c].weights[1] = 0;
		qoa->lms[c].weights[2] = -(1<<13);
		qoa->lms[c].weights[3] =  (1<<14);

		/* Explicitly set the history samples to 0, as we might have some
		garbage in there. */
		for (int i = 0; i < QOA_LMS_LEN; i++) {
			qoa->lms[c].history[i] = 0;
		}
	}


	/* Encode the header and go through all frames */
	unsigned int p = qoa_encode_header(qoa, bytes);
	#ifdef QOA_RECORD_TOTAL_ERROR
		qoa->error = 0;
	#endif

	int frame_len = QOA_FRAME_LEN;
	for (unsigned int sample_index = 0; sample_index < qoa->samples; sample_index += frame_len) {
		frame_len = qoa_clamp(QOA_FRAME_LEN, 0, qoa->samples - sample_index);		
		const short *frame_samples = sample_data + sample_index * qoa->channels;
		unsigned int frame_size = qoa_encode_frame(frame_samples, qoa, frame_len, bytes + p);
		p += frame_size;
	}

	*out_len = p;
	return bytes;
}



/* -----------------------------------------------------------------------------
	Decoder */

unsigned int qoa_max_frame_size(qoa_desc *qoa) {
	return QOA_FRAME_SIZE(qoa->channels, QOA_SLICES_PER_FRAME);
}

unsigned int qoa_decode_header(const unsigned char *bytes, int size, qoa_desc *qoa) {
	unsigned int p = 0;
	if (size < QOA_MIN_FILESIZE) {
		return 0;
	}


	/* Read the file header, verify the magic number ('qoaf') and read the 
	total number of samples. */
	qoa_uint64_t file_header = qoa_read_u64(bytes, &p);

	if ((file_header >> 32) != QOA_MAGIC) {
		return 0;
	}

	qoa->samples = file_header & 0xffffffff;
	if (!qoa->samples) {
		return 0;
	}

	/* Peek into the first frame header to get the number of channels and
	the samplerate. */
	qoa_uint64_t frame_header = qoa_read_u64(bytes, &p);
	qoa->channels   = (frame_header >> 56) & 0x0000ff;
	qoa->samplerate = (frame_header >> 32) & 0xffffff;

	if (
		qoa->channels == 0 || qoa->samples == 0 || qoa->samplerate == 0 ||
		qoa->channels > QOA_MAX_CHANNELS
	) {
		return 0;
	}

	return 8;
}

unsigned int qoa_decode_frame(const unsigned char *bytes, unsigned int size, qoa_desc *qoa, short *sample_data, unsigned int *frame_len) {
	unsigned int p = 0;
	if (frame_len) {
		*frame_len = 0;
	}

	if (size < 8 + QOA_LMS_LEN * 4 * qoa->channels) {
		return 0;
	}

	/* Read and verify the frame header */
	qoa_uint64_t frame_header = qoa_read_u64(bytes, &p);
	unsigned int channels   = (frame_header >> 56) & 0x0000ff;
	unsigned int samplerate = (frame_header >> 32) & 0xffffff;
	unsigned int samples    = (frame_header >> 16) & 0x00ffff;
	unsigned int frame_size = (frame_header      ) & 0x00ffff;

	unsigned int header_size = 8 + QOA_LMS_LEN * 4 * channels;
	unsigned int data_size = frame_size - header_size;
	unsigned int max_total_slices = data_size / 8;
	unsigned int num_slices = (samples + QOA_SLICE_LEN - 1) / QOA_SLICE_LEN;
	
	if (
		channels != qoa->channels || 
		samplerate != qoa->samplerate ||
		frame_size < header_size ||
		frame_size > size ||
		num_slices > QOA_SLICES_PER_FRAME ||
		num_slices * channels > max_total_slices
	) {
		return 0;
	}


	/* Read the LMS state: 4 x 2 bytes history, 4 x 2 bytes weights per channel */
	for (unsigned int c = 0; c < channels; c++) {
		qoa_uint64_t history = qoa_read_u64(bytes, &p);
		qoa_uint64_t weights = qoa_read_u64(bytes, &p);
		for (int i = 0; i < QOA_LMS_LEN; i++) {
			qoa->lms[c].history[i] = ((signed short)(history >> 48));
			history <<= 16;
			qoa->lms[c].weights[i] = ((signed short)(weights >> 48));
			weights <<= 16;
		}
	}


	/* Decode all slices for all channels in this frame */
	for (unsigned int sample_index = 0; sample_index < samples; sample_index += QOA_SLICE_LEN) {
		for (unsigned int c = 0; c < channels; c++) {
			qoa_uint64_t slice = qoa_read_u64(bytes, &p);

			int scalefactor = (slice >> 60) & 0xf;
			slice <<= 4;

			int slice_start = sample_index * channels + c;
			int slice_end = qoa_clamp(sample_index + QOA_SLICE_LEN, 0, samples) * channels + c;

			for (int si = slice_start; si < slice_end; si += channels) {
				int predicted = qoa_lms_predict(&qoa->lms[c]);
				int quantized = (slice >> 61) & 0x7;
				int dequantized = qoa_dequant_tab[scalefactor][quantized];
				int reconstructed = qoa_clamp_s16(predicted + dequantized);
				
				sample_data[si] = reconstructed;
				slice <<= 3;

				qoa_lms_update(&qoa->lms[c], reconstructed, dequantized);
			}
		}
	}

	if (frame_len) {
		*frame_len = samples;
	}
	return p;
}

short *qoa_decode(const unsigned char *bytes, int size, qoa_desc *qoa) {
	unsigned int p = qoa_decode_header(bytes, size, qoa);
	if (!p) {
		return NULL;
	}

	/* Calculate the required size of the sample buffer and allocate, round up to full frames */
	int total_samples = ((qoa->samples + QOA_FRAME_LEN - 1) / QOA_FRAME_LEN) * QOA_FRAME_LEN * qoa->channels;
	short *sample_data = QOA_MALLOC(total_samples * sizeof(short));

	unsigned int sample_index = 0;
	unsigned int frame_len;
	unsigned int frame_size;

	/* Decode all frames */
	do {
		short *sample_ptr = sample_data + sample_index * qoa->channels;
		frame_size = qoa_decode_frame(bytes + p, size - p, qoa, sample_ptr, &frame_len);

		p += frame_size;
		sample_index += frame_len;
	} while (frame_size && sample_index < qoa->samples);

	qoa->samples = sample_index;
	return sample_data;
}



/* -----------------------------------------------------------------------------
	File read/write convenience functions */

#ifndef QOA_NO_STDIO
#include <stdio.h>

int qoa_write(const char *filename, const short *sample_data, qoa_desc *qoa) {
	FILE *f = fopen(filename, "wb");
	unsigned int size;
	void *encoded;

	if (!f) {
		return 0;
	}

	encoded = qoa_encode(sample_data, qoa, &size);
	if (!encoded) {
		fclose(f);
		return 0;
	}

	fwrite(encoded, 1, size, f);
	fclose(f);

	QOA_FREE(encoded);
	return size;
}

void *qoa_read(const char *filename, qoa_desc *qoa) {
	FILE *f = fopen(filename, "rb");
	int size, bytes_read;
	void *data;
	short *sample_data;

	if (!f) {
		return NULL;
	}

	fseek(f, 0, SEEK_END);
	size = ftell(f);
	if (size <= 0) {
		fclose(f);
		return NULL;
	}
	fseek(f, 0, SEEK_SET);

	data = QOA_MALLOC(size);
	if (!data) {
		fclose(f);
		return NULL;
	}

	bytes_read = fread(data, 1, size, f);
	fclose(f);

	sample_data = qoa_decode(data, bytes_read, qoa);
	QOA_FREE(data);
	return sample_data;
}

#endif /* QOA_NO_STDIO */
#endif /* QOA_IMPLEMENTATION */


================================================
FILE: qoaconv.c
================================================
/*

Copyright (c) 2023, Dominic Szablewski - https://phoboslab.org
SPDX-License-Identifier: MIT


Command line tool to convert FLAC, MP3, WAV to QOA and QOA to WAV

Define QOACONV_HAS_DRMP3 and QOACONV_HAS_DRFLAC for MP3 and FLAC support
 -"dr_mp3.h" (https://github.com/mackron/dr_libs/blob/master/dr_mp3.h)
 -"dr_flac.h" (https://github.com/mackron/dr_libs/blob/master/dr_flac.h)

Compile with: 
	gcc qoaconv.c -std=gnu99 -lm -O3 -o qoaconv

*/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>

#ifdef QOACONV_HAS_DRMP3
	/* https://github.com/mackron/dr_libs/blob/master/dr_mp3.h */
	#define DR_MP3_IMPLEMENTATION
	#include "dr_mp3.h"
#endif

#ifdef QOACONV_HAS_DRFLAC
	/* https://github.com/mackron/dr_libs/blob/master/dr_flac.h */
	#define DR_FLAC_IMPLEMENTATION
	#include "dr_flac.h"
#endif

#define QOA_IMPLEMENTATION
#define QOA_RECORD_TOTAL_ERROR
#include "qoa.h"

#define QOACONV_STRINGIFY(x) #x
#define QOACONV_TOSTRING(x) QOACONV_STRINGIFY(x)
#define QOACONV_ABORT(...) \
	printf("Abort at line " QOACONV_TOSTRING(__LINE__) ": " __VA_ARGS__); \
	printf("\n"); \
	exit(1)
#define QOACONV_ASSERT(TEST, ...) \
	if (!(TEST)) { \
		QOACONV_ABORT(__VA_ARGS__); \
	}

#define QOACONV_STR_ENDS_WITH(S, E) (strcmp(S + strlen(S) - (sizeof(E)-1), E) == 0)



/* -----------------------------------------------------------------------------
	WAV reader / writer */

#define QOACONV_CHUNK_ID(S) \
	(((unsigned int)(S[3])) << 24 | ((unsigned int)(S[2])) << 16 | \
	 ((unsigned int)(S[1])) <<  8 | ((unsigned int)(S[0])))

void qoaconv_fwrite_u32_le(unsigned int v, FILE *fh) {
	unsigned char buf[sizeof(unsigned int)];
	buf[0] = 0xff & (v      );
	buf[1] = 0xff & (v >>  8);
	buf[2] = 0xff & (v >> 16);
	buf[3] = 0xff & (v >> 24);
	int wrote = fwrite(buf, sizeof(unsigned int), 1, fh);
	QOACONV_ASSERT(wrote, "Write error");
}

void qoaconv_fwrite_u16_le(unsigned short v, FILE *fh) {
	unsigned char buf[sizeof(unsigned short)];
	buf[0] = 0xff & (v      );
	buf[1] = 0xff & (v >>  8);
	int wrote = fwrite(buf, sizeof(unsigned short), 1, fh);
	QOACONV_ASSERT(wrote, "Write error");
}

unsigned int qoaconv_fread_u32_le(FILE *fh) {
	unsigned char buf[sizeof(unsigned int)];
	int read = fread(buf, sizeof(unsigned int), 1, fh);
	QOACONV_ASSERT(read, "Read error or unexpected end of file");
	return (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
}

unsigned short qoaconv_fread_u16_le(FILE *fh) {
	unsigned char buf[sizeof(unsigned short)];
	int read = fread(buf, sizeof(unsigned short), 1, fh);
	QOACONV_ASSERT(read, "Read error or unexpected end of file");
	return (buf[1] << 8) | buf[0];
}

int qoaconv_wav_write(const char *path, short *sample_data, qoa_desc *desc) {
	unsigned int data_size = desc->samples * desc->channels * sizeof(short);
	unsigned int samplerate = desc->samplerate;
	short bits_per_sample = 16;
	short channels = desc->channels;

	/* Lifted from https://www.jonolick.com/code.html - public domain
	Made endian agnostic using qoaconv_fwrite() */
	FILE *fh = fopen(path, "wb");
	QOACONV_ASSERT(fh, "Can't open %s for writing", path);
	fwrite("RIFF", 1, 4, fh);
	qoaconv_fwrite_u32_le(data_size + 44 - 8, fh);
	fwrite("WAVEfmt \x10\x00\x00\x00\x01\x00", 1, 14, fh);
	qoaconv_fwrite_u16_le(channels, fh);
	qoaconv_fwrite_u32_le(samplerate, fh);
	qoaconv_fwrite_u32_le(channels * samplerate * bits_per_sample/8, fh);
	qoaconv_fwrite_u16_le(channels * bits_per_sample/8, fh);
	qoaconv_fwrite_u16_le(bits_per_sample, fh);
	fwrite("data", 1, 4, fh);
	qoaconv_fwrite_u32_le(data_size, fh);
	fwrite((void*)sample_data, data_size, 1, fh);
	fclose(fh);
	return data_size  + 44 - 8;
}

short *qoaconv_wav_read(const char *path, qoa_desc *desc) {
	FILE *fh = fopen(path, "rb");
	QOACONV_ASSERT(fh, "Can't open %s for reading", path);

	unsigned int container_type = qoaconv_fread_u32_le(fh);
	QOACONV_ASSERT(container_type == QOACONV_CHUNK_ID("RIFF"), "Not a RIFF container");

	unsigned int wav_size = qoaconv_fread_u32_le(fh);
	unsigned int wavid = qoaconv_fread_u32_le(fh);
	QOACONV_ASSERT(wavid == QOACONV_CHUNK_ID("WAVE"), "No WAVE id found");

	unsigned int data_size = 0;
	unsigned int format_length = 0;
	unsigned int format_type = 0;
	unsigned int channels = 0;
	unsigned int samplerate = 0;
	unsigned int byte_rate = 0;
	unsigned int block_align = 0;
	unsigned int bits_per_sample = 0;

	/* Find the fmt and data chunk, skip all others */
	while (1) {
		unsigned int chunk_type = qoaconv_fread_u32_le(fh);
		unsigned int chunk_size = qoaconv_fread_u32_le(fh);

		if (chunk_type == QOACONV_CHUNK_ID("fmt ")) {
			QOACONV_ASSERT(chunk_size == 16 || chunk_size == 18, "WAV fmt chunk size missmatch");

			format_type = qoaconv_fread_u16_le(fh);
			channels = qoaconv_fread_u16_le(fh);
			samplerate = qoaconv_fread_u32_le(fh);
			byte_rate = qoaconv_fread_u32_le(fh);
			block_align = qoaconv_fread_u16_le(fh);
			bits_per_sample = qoaconv_fread_u16_le(fh);

			if (chunk_size == 18) {
				unsigned short extra_params = qoaconv_fread_u16_le(fh);
				QOACONV_ASSERT(extra_params == 0, "WAV fmt extra params not supported");
			}
		}
		else if (chunk_type == QOACONV_CHUNK_ID("data")) {
			data_size = chunk_size;
			break;
		}
		else {
			int seek_result = fseek(fh, chunk_size, SEEK_CUR);
			QOACONV_ASSERT(seek_result == 0, "Malformed RIFF header");
		}
	}

	QOACONV_ASSERT(format_type == 1, "Type in fmt chunk is not PCM");
	QOACONV_ASSERT(bits_per_sample == 16, "Bits per samples != 16");
	QOACONV_ASSERT(data_size, "No data chunk");

	unsigned char *wav_bytes = malloc(data_size);
	QOACONV_ASSERT(wav_bytes, "Malloc for %d bytes failed", data_size);
	int read = fread(wav_bytes, data_size, 1, fh);
	QOACONV_ASSERT(read, "Read error or unexpected end of file for %d bytes", data_size);
	fclose(fh);

	desc->samplerate = samplerate;
	desc->samples = data_size / (channels * (bits_per_sample/8));
	desc->channels = channels;

	return (short*)wav_bytes;
}



/* -----------------------------------------------------------------------------
	MP3 decode wrapper */

#ifdef QOACONV_HAS_DRMP3
	short *qoaconv_mp3_read(const char *path, qoa_desc *desc) {
		drmp3_uint64 samples;

		drmp3_config mp3;
		short* sample_data = drmp3_open_file_and_read_pcm_frames_s16(path, &mp3, &samples, NULL);
		QOACONV_ASSERT(sample_data, "Can't decode MP3");

		desc->samplerate = mp3.sampleRate;
		desc->channels = mp3.channels;
		desc->samples = samples;

		return sample_data;
	}
#endif



/* -----------------------------------------------------------------------------
	FLAC decode wrapper */

#ifdef QOACONV_HAS_DRFLAC
	short *qoaconv_flac_read(const char *path, qoa_desc *desc) {
		unsigned int channels;
		unsigned int samplerate;
		drflac_uint64 samples;
		short* sample_data = drflac_open_file_and_read_pcm_frames_s16(path, &channels, &samplerate, &samples, NULL);
		QOACONV_ASSERT(sample_data, "Can't decode FLAC");

		desc->samplerate = samplerate;
		desc->channels = channels;
		desc->samples = samples;

		return sample_data;
	}
#endif



/* -----------------------------------------------------------------------------
	Main */

int main(int argc, char **argv) {
	QOACONV_ASSERT(argc >= 3, "\nUsage: qoaconv in.{wav,mp3,flac,qoa} out.{wav,qoa}")

	qoa_desc desc;
	short *sample_data = NULL;


	/* Decode input */

	clock_t start_decode = clock();

	if (QOACONV_STR_ENDS_WITH(argv[1], ".wav")) {
		sample_data = qoaconv_wav_read(argv[1], &desc);
	}
	else if (QOACONV_STR_ENDS_WITH(argv[1], ".mp3")) {
		#ifdef QOACONV_HAS_DRMP3
			sample_data = qoaconv_mp3_read(argv[1], &desc);
		#else
			QOACONV_ABORT("qoaconv was not compiled with an MP3 decoder (QOACONV_HAS_DRMP3)");
		#endif
	}
	else if (QOACONV_STR_ENDS_WITH(argv[1], ".flac")) {
		#ifdef QOACONV_HAS_DRFLAC
			sample_data = qoaconv_flac_read(argv[1], &desc);
		#else
			QOACONV_ABORT("qoaconv was not compiled with a FLAC decoder (QOACONV_HAS_DRFLAC)");
		#endif
	}
	else if (QOACONV_STR_ENDS_WITH(argv[1], ".qoa")) {
		sample_data = qoa_read(argv[1], &desc);
	}
	else {
		QOACONV_ABORT("Unknown file type for %s", argv[1]);
	}

	clock_t end_decode = clock();

	QOACONV_ASSERT(sample_data, "Can't load/decode %s", argv[1]);

	printf(
		"%s: channels: %d, samplerate: %d hz, samples per channel: %d, duration: %d sec (took %.2f seconds)\n",
		argv[1], desc.channels, desc.samplerate, desc.samples, desc.samples/desc.samplerate,
		(double)(end_decode - start_decode) / CLOCKS_PER_SEC
	);


	/* Encode output */

	clock_t start_encode = clock();

	int bytes_written = 0;
	double psnr = INFINITY;
	if (QOACONV_STR_ENDS_WITH(argv[2], ".wav")) {
		bytes_written = qoaconv_wav_write(argv[2], sample_data, &desc);
	}
	else if (QOACONV_STR_ENDS_WITH(argv[2], ".qoa")) {
		bytes_written = qoa_write(argv[2], sample_data, &desc);
		#ifdef QOA_RECORD_TOTAL_ERROR
			if (desc.error) {
				psnr = -20.0 * log10(sqrt(desc.error/(desc.samples * desc.channels)) / 32768.0);
			}
		#endif
	}
	else {
		QOACONV_ABORT("Unknown file type for %s", argv[2]);
	}

	clock_t end_encode = clock();

	QOACONV_ASSERT(bytes_written, "Can't write/encode %s", argv[2]);
	free(sample_data);

	printf(
		"%s: size: %d kb (%d bytes) = %.2f kbit/s, psnr: %.2f db (took %.2f seconds)\n",
		argv[2], bytes_written/1024, bytes_written, 
		(((float)bytes_written*8)/((float)desc.samples/(float)desc.samplerate))/1024, psnr,
		(double)(end_encode - start_encode) / CLOCKS_PER_SEC
	);

	return 0;
}


================================================
FILE: qoaplay.c
================================================
/*

Copyright (c) 2023, Dominic Szablewski - https://phoboslab.org
SPDX-License-Identifier: MIT


Command line tool to play QOA files

Requires:
	-"sokol_audio.h" (https://github.com/floooh/sokol/blob/master/sokol_audio.h)

Compile with: 
	gcc qoaplay.c -std=gnu99 -lasound -pthread -O3 -o qoaplay

*/


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

#define SOKOL_AUDIO_IMPL
#include "sokol_audio.h"

#define QOA_IMPLEMENTATION
#include "qoa.h"


/* -----------------------------------------------------------------------------
	qoaplay */

/* qoaplay is a tiny abstraction to read and decode a QOA file "on the fly".
It reads and decodes one frame at a time with minimal memory requirements.
qoaplay also provides some functions to seek to a specific frame. */

typedef struct {
	qoa_desc info;
	FILE *file;

	unsigned int first_frame_pos;
	unsigned int sample_pos;

	unsigned int buffer_len;
	unsigned char *buffer;

	unsigned int sample_data_pos;
	unsigned int sample_data_len;
	short *sample_data;
} qoaplay_desc;

qoaplay_desc *qoaplay_open(const char *path) {
	FILE *file = fopen(path, "rb");
	if (!file) {
		return NULL;
	}

	/* Read and decode the file header */

	unsigned char header[QOA_MIN_FILESIZE];
	int read = fread(header, QOA_MIN_FILESIZE, 1, file);
	if (!read) {
		return NULL;
	}

	qoa_desc qoa;
	unsigned int first_frame_pos = qoa_decode_header(header, QOA_MIN_FILESIZE, &qoa);
	if (!first_frame_pos) {
		return NULL;
	}

	/* Rewind the file back to beginning of the first frame */

	fseek(file, first_frame_pos, SEEK_SET);

	/* Allocate one chunk of memory for the qoaplay_desc struct, the sample data
	for one frame and a buffer to hold one frame of encoded data. */

	unsigned int buffer_size = qoa_max_frame_size(&qoa);
	unsigned int sample_data_size = qoa.channels * QOA_FRAME_LEN * sizeof(short) * 2;

	qoaplay_desc *qp = malloc(sizeof(qoaplay_desc) + buffer_size + sample_data_size);
	memset(qp, 0, sizeof(qoaplay_desc));
	
	qp->first_frame_pos = first_frame_pos;
	qp->file = file;
	qp->buffer = ((unsigned char *)qp) + sizeof(qoaplay_desc);
	qp->sample_data = (short *)(((unsigned char *)qp) + sizeof(qoaplay_desc) + buffer_size);

	qp->info.channels = qoa.channels;
	qp->info.samplerate = qoa.samplerate;
	qp->info.samples = qoa.samples;
	return qp;
}

void qoaplay_close(qoaplay_desc *qp) {
	fclose(qp->file);
	free(qp);
}

unsigned int qoaplay_decode_frame(qoaplay_desc *qp) {
	qp->buffer_len = fread(qp->buffer, 1, qoa_max_frame_size(&qp->info), qp->file);

	unsigned int frame_len;
	qoa_decode_frame(qp->buffer, qp->buffer_len, &qp->info, qp->sample_data, &frame_len);
	qp->sample_data_pos = 0;
	qp->sample_data_len = frame_len;
	return frame_len;
}

void qoaplay_rewind(qoaplay_desc *qp) {
	fseek(qp->file, qp->first_frame_pos, SEEK_SET);
	qp->sample_pos = 0;
	qp->sample_data_len = 0;
	qp->sample_data_pos = 0;
}

unsigned int qoaplay_decode(qoaplay_desc *qp, float *sample_data, int num_samples) {
	int src_index = qp->sample_data_pos * qp->info.channels;
	int dst_index = 0;
	for (int i = 0; i < num_samples; i++) {

		/* Do we have to decode more samples? */
		if (qp->sample_data_len - qp->sample_data_pos == 0) {
			if (!qoaplay_decode_frame(qp)) {
				// Loop to the beginning
				qoaplay_rewind(qp);
				qoaplay_decode_frame(qp);
			}
			src_index = 0;
		}

		/* Normalize to -1..1 floats and write to dest */
		for (int c = 0; c < qp->info.channels; c++) {
			sample_data[dst_index++] = qp->sample_data[src_index++] / 32768.0;
		}
		qp->sample_data_pos++;
		qp->sample_pos++;
	}
	return num_samples;
}

double qoaplay_get_duration(qoaplay_desc *qp) {
	return (double)qp->info.samples / (double)qp->info.samplerate;
}

double qoaplay_get_time(qoaplay_desc *qp) {
	return (double)qp->sample_pos / (double)qp->info.samplerate;
}

int qoaplay_get_frame(qoaplay_desc *qp) {
	return qp->sample_pos / QOA_FRAME_LEN;
}

void qoaplay_seek_frame(qoaplay_desc *qp, int frame) {
	if (frame < 0) {
		frame = 0;
	}
	if (frame > qp->info.samples / QOA_FRAME_LEN) {
		frame = qp->info.samples / QOA_FRAME_LEN;
	}

	qp->sample_pos = frame * QOA_FRAME_LEN;
	qp->sample_data_len = 0;
	qp->sample_data_pos = 0;

	unsigned int offset = qp->first_frame_pos + frame * qoa_max_frame_size(&qp->info);
	fseek(qp->file, offset, SEEK_SET);
}




/* -----------------------------------------------------------------------------
	The application code */

/* getch() for windows/mac/linux */

#if defined(_WIN32)
	#include <conio.h>
#else
	#if defined(__APPLE__)
		#include <unistd.h>
	#endif
	#include <termios.h>
	int getch(void) {
		struct termios oldattr, newattr;
		int ch;
		tcgetattr(STDIN_FILENO, &oldattr);
		newattr = oldattr;
		newattr.c_lflag &= ~(ICANON | ECHO);
		tcsetattr(STDIN_FILENO, TCSANOW, &newattr);
		ch = getchar();
		tcsetattr(STDIN_FILENO, TCSANOW, &oldattr);
		return ch;
	}
#endif


/* Sokol Audio callback. This gets called whenever sokol needs more samples to
hand over to the platform's audio API. All file IO and decoding is done here. */

static void sokol_audio_cb(float* sample_data, int num_samples, int num_channels, void *user_data) {
	qoaplay_desc *qoaplay = (qoaplay_desc *)user_data;
	if (num_channels != qoaplay->info.channels) {
		printf("Audio cb channels %d not equal qoa channels %d\n", num_channels, qoaplay->info.channels);
		exit(1);
	}

	qoaplay_decode(qoaplay, sample_data, num_samples);

	printf("\r %6.2f / %.2f sec", qoaplay_get_time(qoaplay), qoaplay_get_duration(qoaplay));
	fflush(stdout);
}


int main(int argc, char **argv) {
	if (argc < 2) {
		printf("Usage: qoaplay <file.qoa>\n");
		exit(1);
	}

	qoaplay_desc *qoaplay = qoaplay_open(argv[1]);

	if (!qoaplay) {
		printf("Failed to load %s\n", argv[1]);
		exit(1);
	}

	printf(
		"%s: channels: %d, samplerate: %d hz, samples per channel: %d, duration: %d sec\n",
		argv[1], 
		qoaplay->info.channels,
		qoaplay->info.samplerate,
		qoaplay->info.samples, 
		qoaplay->info.samples/qoaplay->info.samplerate
	);
	printf("Controls: [x] rewind / [c] skip / [q] quit\n");

	saudio_setup(&(saudio_desc){
		.sample_rate = qoaplay->info.samplerate,
		.num_channels = qoaplay->info.channels,
		.stream_userdata_cb = sokol_audio_cb,
		.user_data = qoaplay
	});

	int wants_to_quit = 0;
	while (!wants_to_quit) {
		char c = getch();
		switch (c) {
			case 'c': qoaplay_seek_frame(qoaplay, qoaplay_get_frame(qoaplay) + 48); break;
			case 'x': qoaplay_seek_frame(qoaplay, qoaplay_get_frame(qoaplay) - 48); break;
			case 'q': wants_to_quit = 1; break;
		}
	}

	saudio_shutdown();
	qoaplay_close(qoaplay);

	printf("\n");
	return 0;
}