[pcsx_rearmed.git] / deps / libchdr / src / libchdr_flac.c

/* license:BSD-3-Clause
 * copyright-holders:Aaron Giles
***************************************************************************

    flac.c

    FLAC compression wrappers

***************************************************************************/

#include <string.h>

#include <libchdr/flac.h>
#define DR_FLAC_IMPLEMENTATION
#define DR_FLAC_NO_STDIO
#include <dr_libs/dr_flac.h>

/***************************************************************************
 *  FLAC DECODER
 ***************************************************************************
 */

static size_t flac_decoder_read_callback(void *userdata, void *buffer, size_t bytes);
static drflac_bool32 flac_decoder_seek_callback(void *userdata, int offset, drflac_seek_origin origin);
static void flac_decoder_metadata_callback(void *userdata, drflac_metadata *metadata);
static void flac_decoder_write_callback(void *userdata, void *buffer, size_t bytes);


/* getters (valid after reset) */
static uint32_t sample_rate(flac_decoder *decoder)  { return decoder->sample_rate; }
static uint8_t channels(flac_decoder *decoder)  { return decoder->channels; }
static uint8_t bits_per_sample(flac_decoder *decoder) { return decoder->bits_per_sample; }

/*-------------------------------------------------
 *  flac_decoder - constructor
 *-------------------------------------------------
 */

int flac_decoder_init(flac_decoder *decoder)
{
	decoder->decoder = NULL;
	decoder->sample_rate = 0;
	decoder->channels = 0;
	decoder->bits_per_sample = 0;
	decoder->compressed_offset = 0;
	decoder->compressed_start = NULL;
	decoder->compressed_length = 0;
	decoder->compressed2_start = NULL;
	decoder->compressed2_length = 0;
	decoder->uncompressed_offset = 0;
	decoder->uncompressed_length = 0;
	decoder->uncompressed_swap = 0;
	return 0;
}

/*-------------------------------------------------
 *  flac_decoder - destructor
 *-------------------------------------------------
 */

void flac_decoder_free(flac_decoder* decoder)
{
	if ((decoder != NULL) && (decoder->decoder != NULL)) {
		drflac_close(decoder->decoder);
		decoder->decoder = NULL;
	}
}

/*-------------------------------------------------
 *  reset - reset state with the original
 *  parameters
 *-------------------------------------------------
 */

static int flac_decoder_internal_reset(flac_decoder* decoder)
{
	decoder->compressed_offset = 0;
	flac_decoder_free(decoder);
	decoder->decoder = drflac_open_with_metadata(
		flac_decoder_read_callback, flac_decoder_seek_callback,
		flac_decoder_metadata_callback, decoder, NULL);
	return (decoder->decoder != NULL);
}

/*-------------------------------------------------
 *  reset - reset state with new memory parameters
 *  and a custom-generated header
 *-------------------------------------------------
 */

int flac_decoder_reset(flac_decoder* decoder, uint32_t sample_rate, uint8_t num_channels, uint32_t block_size, const void *buffer, uint32_t length)
{
	/* modify the template header with our parameters */
	static const uint8_t s_header_template[0x2a] =
	{
		0x66, 0x4C, 0x61, 0x43,                         /* +00: 'fLaC' stream header */
		0x80,                                           /* +04: metadata block type 0 (STREAMINFO), */
								/*      flagged as last block */
		0x00, 0x00, 0x22,                               /* +05: metadata block length = 0x22 */
		0x00, 0x00,                                     /* +08: minimum block size */
		0x00, 0x00,                                     /* +0A: maximum block size */
		0x00, 0x00, 0x00,                               /* +0C: minimum frame size (0 == unknown) */
		0x00, 0x00, 0x00,                               /* +0F: maximum frame size (0 == unknown) */
		0x0A, 0xC4, 0x42, 0xF0, 0x00, 0x00, 0x00, 0x00, /* +12: sample rate (0x0ac44 == 44100), */
								/*      numchannels (2), sample bits (16), */
								/*      samples in stream (0 == unknown) */
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* +1A: MD5 signature (0 == none) */
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  /* +2A: start of stream data */
	};
	memcpy(decoder->custom_header, s_header_template, sizeof(s_header_template));
	decoder->custom_header[0x08] = decoder->custom_header[0x0a] = (block_size*num_channels) >> 8;
	decoder->custom_header[0x09] = decoder->custom_header[0x0b] = (block_size*num_channels) & 0xff;
	decoder->custom_header[0x12] = sample_rate >> 12;
	decoder->custom_header[0x13] = sample_rate >> 4;
	decoder->custom_header[0x14] = (sample_rate << 4) | ((num_channels - 1) << 1);

	/* configure the header ahead of the provided buffer */
	decoder->compressed_start = (const uint8_t *)(decoder->custom_header);
	decoder->compressed_length = sizeof(decoder->custom_header);
	decoder->compressed2_start = (const uint8_t *)(buffer);
	decoder->compressed2_length = length;
	return flac_decoder_internal_reset(decoder);
}

/*-------------------------------------------------
 *  decode_interleaved - decode to an interleaved
 *  sound stream
 *-------------------------------------------------
 */

int flac_decoder_decode_interleaved(flac_decoder* decoder, int16_t *samples, uint32_t num_samples, int swap_endian)
{
	/* configure the uncompressed buffer */
	memset(decoder->uncompressed_start, 0, sizeof(decoder->uncompressed_start));
	decoder->uncompressed_start[0] = samples;
	decoder->uncompressed_offset = 0;
	decoder->uncompressed_length = num_samples;
	decoder->uncompressed_swap = swap_endian;

#define	BUFFER	2352	/* bytes per CD audio sector */
	int16_t buffer[BUFFER];
	uint32_t buf_samples = BUFFER / channels(decoder);
	/* loop until we get everything we want */
	while (decoder->uncompressed_offset < decoder->uncompressed_length) {
		uint32_t frames = (num_samples < buf_samples ? num_samples : buf_samples);
		if (!drflac_read_pcm_frames_s16(decoder->decoder, frames, buffer))
			return 0;
		flac_decoder_write_callback(decoder, buffer, frames*sizeof(*buffer)*channels(decoder));
		num_samples -= frames;
	}
	return 1;
}

/*-------------------------------------------------
 *  finish - finish up the decode
 *-------------------------------------------------
 */

uint32_t flac_decoder_finish(flac_decoder* decoder)
{
	/* get the final decoding position and move forward */
	drflac *flac = decoder->decoder;
	uint64_t position = decoder->compressed_offset;

	/* ugh... there's no function to obtain bytes used in drflac :-/ */
	position -= DRFLAC_CACHE_L2_LINES_REMAINING(&flac->bs) * sizeof(drflac_cache_t);
	position -= DRFLAC_CACHE_L1_BITS_REMAINING(&flac->bs) / 8;
	position -= flac->bs.unalignedByteCount;

	/* adjust position if we provided the header */
	if (position == 0)
		return 0;
	if (decoder->compressed_start == (const uint8_t *)(decoder->custom_header))
		position -= decoder->compressed_length;

	flac_decoder_free(decoder);
	return position;
}

/*-------------------------------------------------
 *  read_callback - handle reads from the input
 *  stream
 *-------------------------------------------------
 */

#define MIN(x, y) ((x) < (y) ? (x) : (y))

static size_t flac_decoder_read_callback(void *userdata, void *buffer, size_t bytes)
{
	flac_decoder* decoder = (flac_decoder*)userdata;
	uint8_t *dst = buffer;

	/* copy from primary buffer first */
	uint32_t outputpos = 0;
	if (outputpos < bytes && decoder->compressed_offset < decoder->compressed_length)
	{
		uint32_t bytes_to_copy = MIN(bytes - outputpos, decoder->compressed_length - decoder->compressed_offset);
		memcpy(&dst[outputpos], decoder->compressed_start + decoder->compressed_offset, bytes_to_copy);
		outputpos += bytes_to_copy;
		decoder->compressed_offset += bytes_to_copy;
	}

	/* once we're out of that, copy from the secondary buffer */
	if (outputpos < bytes && decoder->compressed_offset < decoder->compressed_length + decoder->compressed2_length)
	{
		uint32_t bytes_to_copy = MIN(bytes - outputpos, decoder->compressed2_length - (decoder->compressed_offset - decoder->compressed_length));
		memcpy(&dst[outputpos], decoder->compressed2_start + decoder->compressed_offset - decoder->compressed_length, bytes_to_copy);
		outputpos += bytes_to_copy;
		decoder->compressed_offset += bytes_to_copy;
	}

	return outputpos;
}

/*-------------------------------------------------
 *  metadata_callback - handle STREAMINFO metadata
 *-------------------------------------------------
 */

static void flac_decoder_metadata_callback(void *userdata, drflac_metadata *metadata)
{
	flac_decoder *decoder = userdata;

	/* ignore all but STREAMINFO metadata */
	if (metadata->type != DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO)
		return;

	/* parse out the data we care about */
	decoder->sample_rate = metadata->data.streaminfo.sampleRate;
	decoder->bits_per_sample = metadata->data.streaminfo.bitsPerSample;
	decoder->channels = metadata->data.streaminfo.channels;
}

/*-------------------------------------------------
 *  write_callback - handle writes to the output
 *  stream
 *-------------------------------------------------
 */

static void flac_decoder_write_callback(void *userdata, void *buffer, size_t bytes)
{
	int sampnum, chan;
	int shift, blocksize;
	flac_decoder * decoder = (flac_decoder *)userdata;
	int16_t *sampbuf = (int16_t *)buffer;
	int sampch = channels(decoder);
	uint32_t offset = decoder->uncompressed_offset;
	uint16_t usample;

	/* interleaved case */
	shift = decoder->uncompressed_swap ? 8 : 0;
	blocksize = bytes / (sampch * sizeof(sampbuf[0]));
	if (decoder->uncompressed_start[1] == NULL)
	{
		int16_t *dest = decoder->uncompressed_start[0] + offset * sampch;
		for (sampnum = 0; sampnum < blocksize && offset < decoder->uncompressed_length; sampnum++, offset++)
			for (chan = 0; chan < sampch; chan++) {
				usample = (uint16_t)*sampbuf++;
				*dest++ = (int16_t)((usample << shift) | (usample >> shift));
			}
	}

	/* non-interleaved case */
	else
	{
		for (sampnum = 0; sampnum < blocksize && offset < decoder->uncompressed_length; sampnum++, offset++)
			for (chan = 0; chan < sampch; chan++) {
				usample = (uint16_t)*sampbuf++;
				if (decoder->uncompressed_start[chan] != NULL)
					decoder->uncompressed_start[chan][offset] = (int16_t) ((usample << shift) | (usample >> shift));
			}
	}
	decoder->uncompressed_offset = offset;
}


/*-------------------------------------------------
 *  seek_callback - handle seeks on the output
 *  stream
 *-------------------------------------------------
 */

static drflac_bool32 flac_decoder_seek_callback(void *userdata, int offset, drflac_seek_origin origin)
{
	flac_decoder * decoder = (flac_decoder *)userdata;
	uint32_t length = decoder->compressed_length + decoder->compressed2_length;

	if (origin == drflac_seek_origin_start) {
		uint32_t pos = offset;
		if (pos <= length) {
			decoder->compressed_offset = pos;
			return 1;
		}
	} else if (origin == drflac_seek_origin_current) {
		uint32_t pos = decoder->compressed_offset + offset;
		if (pos <= length) {
			decoder->compressed_offset = pos;
			return 1;
		}
	}
	return 0;
}
Commit	Line	Data
2ff0b512	1	/* license:BSD-3-Clause
	2	* copyright-holders:Aaron Giles
	3	***************************************************************************
	4
	5	flac.c
	6
	7	FLAC compression wrappers
	8
	9	***************************************************************************/
	10
2ff0b512	11	#include <string.h>
	12
	13	#include <libchdr/flac.h>
	14	#define DR_FLAC_IMPLEMENTATION
9e052883	15	#define DR_FLAC_NO_STDIO
2ff0b512	16	#include <dr_libs/dr_flac.h>
	17
	18	/***************************************************************************
	19	* FLAC DECODER
	20	***************************************************************************
	21	*/
	22
	23	static size_t flac_decoder_read_callback(void userdata, void buffer, size_t bytes);
	24	static drflac_bool32 flac_decoder_seek_callback(void *userdata, int offset, drflac_seek_origin origin);
	25	static void flac_decoder_metadata_callback(void userdata, drflac_metadata metadata);
9e052883	26	static void flac_decoder_write_callback(void userdata, void buffer, size_t bytes);
2ff0b512	27
	28
	29	/* getters (valid after reset) */
	30	static uint32_t sample_rate(flac_decoder *decoder) { return decoder->sample_rate; }
	31	static uint8_t channels(flac_decoder *decoder) { return decoder->channels; }
	32	static uint8_t bits_per_sample(flac_decoder *decoder) { return decoder->bits_per_sample; }
	33
	34	/*-------------------------------------------------
	35	* flac_decoder - constructor
	36	*-------------------------------------------------
	37	*/
	38
	39	int flac_decoder_init(flac_decoder *decoder)
	40	{
	41	decoder->decoder = NULL;
	42	decoder->sample_rate = 0;
	43	decoder->channels = 0;
	44	decoder->bits_per_sample = 0;
	45	decoder->compressed_offset = 0;
	46	decoder->compressed_start = NULL;
	47	decoder->compressed_length = 0;
	48	decoder->compressed2_start = NULL;
	49	decoder->compressed2_length = 0;
	50	decoder->uncompressed_offset = 0;
	51	decoder->uncompressed_length = 0;
	52	decoder->uncompressed_swap = 0;
	53	return 0;
	54	}
	55
	56	/*-------------------------------------------------
	57	* flac_decoder - destructor
	58	*-------------------------------------------------
	59	*/
	60
	61	void flac_decoder_free(flac_decoder* decoder)
	62	{
9e052883	63	if ((decoder != NULL) && (decoder->decoder != NULL)) {
2ff0b512	64	drflac_close(decoder->decoder);
9e052883	65	decoder->decoder = NULL;
9e052883	66	}
2ff0b512	67	}
	68
	69	/*-------------------------------------------------
	70	* reset - reset state with the original
	71	* parameters
	72	*-------------------------------------------------
	73	*/
	74
	75	static int flac_decoder_internal_reset(flac_decoder* decoder)
	76	{
	77	decoder->compressed_offset = 0;
	78	flac_decoder_free(decoder);
	79	decoder->decoder = drflac_open_with_metadata(
	80	flac_decoder_read_callback, flac_decoder_seek_callback,
	81	flac_decoder_metadata_callback, decoder, NULL);
	82	return (decoder->decoder != NULL);
	83	}
	84
	85	/*-------------------------------------------------
	86	* reset - reset state with new memory parameters
	87	* and a custom-generated header
	88	*-------------------------------------------------
	89	*/
	90
	91	int flac_decoder_reset(flac_decoder* decoder, uint32_t sample_rate, uint8_t num_channels, uint32_t block_size, const void *buffer, uint32_t length)
	92	{
	93	/* modify the template header with our parameters */
	94	static const uint8_t s_header_template[0x2a] =
	95	{
	96	0x66, 0x4C, 0x61, 0x43, /* +00: 'fLaC' stream header */
	97	0x80, /* +04: metadata block type 0 (STREAMINFO), */
	98	/* flagged as last block */
	99	0x00, 0x00, 0x22, /* +05: metadata block length = 0x22 */
	100	0x00, 0x00, /* +08: minimum block size */
	101	0x00, 0x00, /* +0A: maximum block size */
	102	0x00, 0x00, 0x00, /* +0C: minimum frame size (0 == unknown) */
	103	0x00, 0x00, 0x00, /* +0F: maximum frame size (0 == unknown) */
	104	0x0A, 0xC4, 0x42, 0xF0, 0x00, 0x00, 0x00, 0x00, /* +12: sample rate (0x0ac44 == 44100), */
	105	/* numchannels (2), sample bits (16), */
	106	/* samples in stream (0 == unknown) */
	107	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* +1A: MD5 signature (0 == none) */
	108	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 /* +2A: start of stream data */
	109	};
	110	memcpy(decoder->custom_header, s_header_template, sizeof(s_header_template));
	111	decoder->custom_header[0x08] = decoder->custom_header[0x0a] = (block_size*num_channels) >> 8;
	112	decoder->custom_header[0x09] = decoder->custom_header[0x0b] = (block_size*num_channels) & 0xff;
	113	decoder->custom_header[0x12] = sample_rate >> 12;
	114	decoder->custom_header[0x13] = sample_rate >> 4;
	115	decoder->custom_header[0x14] = (sample_rate << 4) \| ((num_channels - 1) << 1);
	116
	117	/* configure the header ahead of the provided buffer */
	118	decoder->compressed_start = (const uint8_t *)(decoder->custom_header);
	119	decoder->compressed_length = sizeof(decoder->custom_header);
	120	decoder->compressed2_start = (const uint8_t *)(buffer);
	121	decoder->compressed2_length = length;
	122	return flac_decoder_internal_reset(decoder);
	123	}
	124
	125	/*-------------------------------------------------
	126	* decode_interleaved - decode to an interleaved
	127	* sound stream
	128	*-------------------------------------------------
	129	*/
	130
131	int flac_decoder_decode_interleaved(flac_decoder* decoder, int16_t *samples, uint32_t num_samples, int swap_endian)
132	{
133	/* configure the uncompressed buffer */
134	memset(decoder->uncompressed_start, 0, sizeof(decoder->uncompressed_start));
135	decoder->uncompressed_start[0] = samples;
136	decoder->uncompressed_offset = 0;
137	decoder->uncompressed_length = num_samples;
138	decoder->uncompressed_swap = swap_endian;
139
140	#define BUFFER 2352 /* bytes per CD audio sector */
141	int16_t buffer[BUFFER];
142	uint32_t buf_samples = BUFFER / channels(decoder);
143	/* loop until we get everything we want */
144	while (decoder->uncompressed_offset < decoder->uncompressed_length) {
145	uint32_t frames = (num_samples < buf_samples ? num_samples : buf_samples);
146	if (!drflac_read_pcm_frames_s16(decoder->decoder, frames, buffer))
147	return 0;
148	flac_decoder_write_callback(decoder, buffer, framessizeof(buffer)*channels(decoder));
149	num_samples -= frames;
150	}
151	return 1;
152	}
153
154	/*-------------------------------------------------
155	* finish - finish up the decode
156	*-------------------------------------------------
157	*/
158
159	uint32_t flac_decoder_finish(flac_decoder* decoder)
160	{
161	/* get the final decoding position and move forward */
162	drflac *flac = decoder->decoder;
163	uint64_t position = decoder->compressed_offset;
164
165	/* ugh... there's no function to obtain bytes used in drflac :-/ */
166	position -= DRFLAC_CACHE_L2_LINES_REMAINING(&flac->bs) * sizeof(drflac_cache_t);
167	position -= DRFLAC_CACHE_L1_BITS_REMAINING(&flac->bs) / 8;
168	position -= flac->bs.unalignedByteCount;
169
170	/* adjust position if we provided the header */
171	if (position == 0)
172	return 0;
173	if (decoder->compressed_start == (const uint8_t *)(decoder->custom_header))
174	position -= decoder->compressed_length;
175
176	flac_decoder_free(decoder);
177	return position;
178	}
179
180	/*-------------------------------------------------
181	* read_callback - handle reads from the input
182	* stream
183	*-------------------------------------------------
184	*/
185
186	#define MIN(x, y) ((x) < (y) ? (x) : (y))
187
188	static size_t flac_decoder_read_callback(void userdata, void buffer, size_t bytes)
189	{
190	flac_decoder* decoder = (flac_decoder*)userdata;
191	uint8_t *dst = buffer;
192
193	/* copy from primary buffer first */
194	uint32_t outputpos = 0;
195	if (outputpos < bytes && decoder->compressed_offset < decoder->compressed_length)
196	{
197	uint32_t bytes_to_copy = MIN(bytes - outputpos, decoder->compressed_length - decoder->compressed_offset);
198	memcpy(&dst[outputpos], decoder->compressed_start + decoder->compressed_offset, bytes_to_copy);
199	outputpos += bytes_to_copy;
200	decoder->compressed_offset += bytes_to_copy;
201	}
202
203	/* once we're out of that, copy from the secondary buffer */
204	if (outputpos < bytes && decoder->compressed_offset < decoder->compressed_length + decoder->compressed2_length)
205	{
206	uint32_t bytes_to_copy = MIN(bytes - outputpos, decoder->compressed2_length - (decoder->compressed_offset - decoder->compressed_length));
207	memcpy(&dst[outputpos], decoder->compressed2_start + decoder->compressed_offset - decoder->compressed_length, bytes_to_copy);
208	outputpos += bytes_to_copy;
209	decoder->compressed_offset += bytes_to_copy;
210	}
211
212	return outputpos;
213	}
214
215	/*-------------------------------------------------
216	* metadata_callback - handle STREAMINFO metadata
217	*-------------------------------------------------
218	*/
219
220	static void flac_decoder_metadata_callback(void userdata, drflac_metadata metadata)
221	{
222	flac_decoder *decoder = userdata;
223
224	/* ignore all but STREAMINFO metadata */
225	if (metadata->type != DRFLAC_METADATA_BLOCK_TYPE_STREAMINFO)
226	return;
227
228	/* parse out the data we care about */
229	decoder->sample_rate = metadata->data.streaminfo.sampleRate;
230	decoder->bits_per_sample = metadata->data.streaminfo.bitsPerSample;
231	decoder->channels = metadata->data.streaminfo.channels;
232	}
233
234	/*-------------------------------------------------
235	* write_callback - handle writes to the output
236	* stream
237	*-------------------------------------------------
238	*/
239
240	static void flac_decoder_write_callback(void userdata, void buffer, size_t bytes)
241	{
242	int sampnum, chan;
243	int shift, blocksize;
244	flac_decoder * decoder = (flac_decoder *)userdata;
245	int16_t sampbuf = (int16_t )buffer;
246	int sampch = channels(decoder);
247	uint32_t offset = decoder->uncompressed_offset;
248	uint16_t usample;
249
250	/* interleaved case */
251	shift = decoder->uncompressed_swap ? 8 : 0;
252	blocksize = bytes / (sampch * sizeof(sampbuf[0]));
253	if (decoder->uncompressed_start[1] == NULL)
254	{
255	int16_t dest = decoder->uncompressed_start[0] + offset sampch;
256	for (sampnum = 0; sampnum < blocksize && offset < decoder->uncompressed_length; sampnum++, offset++)
257	for (chan = 0; chan < sampch; chan++) {
258	usample = (uint16_t)*sampbuf++;
259	*dest++ = (int16_t)((usample << shift) \| (usample >> shift));
260	}
261	}
262
263	/* non-interleaved case */
264	else
265	{
266	for (sampnum = 0; sampnum < blocksize && offset < decoder->uncompressed_length; sampnum++, offset++)
267	for (chan = 0; chan < sampch; chan++) {
268	usample = (uint16_t)*sampbuf++;
269	if (decoder->uncompressed_start[chan] != NULL)
270	decoder->uncompressed_start[chan][offset] = (int16_t) ((usample << shift) \| (usample >> shift));
271	}
272	}
273	decoder->uncompressed_offset = offset;
274	}
275
276
277	/*-------------------------------------------------
278	* seek_callback - handle seeks on the output
279	* stream
280	*-------------------------------------------------
281	*/
282
283	static drflac_bool32 flac_decoder_seek_callback(void *userdata, int offset, drflac_seek_origin origin)
284	{
285	flac_decoder * decoder = (flac_decoder *)userdata;
286	uint32_t length = decoder->compressed_length + decoder->compressed2_length;
287
288	if (origin == drflac_seek_origin_start) {
289	uint32_t pos = offset;
290	if (pos <= length) {
291	decoder->compressed_offset = pos;
292	return 1;
293	}
294	} else if (origin == drflac_seek_origin_current) {
295	uint32_t pos = decoder->compressed_offset + offset;
296	if (pos <= length) {
297	decoder->compressed_offset = pos;
298	return 1;
299	}
300	}
301	return 0;
302	}
303