[pcsx_rearmed.git] / deps / libretro-common / formats / libchdr / libchdr_flac.c

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

    flac.c

    FLAC compression wrappers

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

#include <assert.h>
#include <string.h>
#include <libchdr/flac.h>
#include <libchdr/minmax.h>
#include <retro_miscellaneous.h>

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

static FLAC__StreamDecoderReadStatus flac_decoder_read_callback_static(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data);
FLAC__StreamDecoderReadStatus flac_decoder_read_callback(void* client_data, FLAC__byte buffer[], size_t *bytes);
static void flac_decoder_metadata_callback_static(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
static FLAC__StreamDecoderTellStatus flac_decoder_tell_callback_static(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
static FLAC__StreamDecoderWriteStatus flac_decoder_write_callback_static(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(void* client_data, const FLAC__Frame *frame, const FLAC__int32 * const buffer[]);
static void flac_decoder_error_callback_static(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);

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

void flac_decoder_init(flac_decoder *decoder)
{
	decoder->decoder = FLAC__stream_decoder_new();
	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;
}

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

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

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

static int flac_decoder_internal_reset(flac_decoder* decoder)
{
	decoder->compressed_offset = 0;
	if (FLAC__stream_decoder_init_stream(decoder->decoder,
				&flac_decoder_read_callback_static,
				NULL,
				&flac_decoder_tell_callback_static,
				NULL,
				NULL,
				&flac_decoder_write_callback_static,
				&flac_decoder_metadata_callback_static,
				&flac_decoder_error_callback_static, decoder) != FLAC__STREAM_DECODER_INIT_STATUS_OK)
		return 0;
	return FLAC__stream_decoder_process_until_end_of_metadata(decoder->decoder);
}

/*-------------------------------------------------
 *  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 >> 8;
	decoder->custom_header[0x09] = decoder->custom_header[0x0b] = block_size & 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 FLAC__byte *)(decoder->custom_header);
	decoder->compressed_length = sizeof(decoder->custom_header);
	decoder->compressed2_start = (const FLAC__byte *)(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;

	/* loop until we get everything we want */
	while (decoder->uncompressed_offset < decoder->uncompressed_length)
		if (!FLAC__stream_decoder_process_single(decoder->decoder))
			return 0;
	return 1;
}

#if 0
/*-------------------------------------------------
 *  decode - decode to an multiple independent
 *  data streams
 *-------------------------------------------------
 */

bool flac_decoder::decode(int16_t **samples, uint32_t num_samples, bool swap_endian)
{
	/* make sure we don't have too many channels */
	int chans = channels();
	if (chans > ARRAY_SIZE(m_uncompressed_start))
		return false;

	/* configure the uncompressed buffer */
	memset(m_uncompressed_start, 0, sizeof(m_uncompressed_start));
	for (int curchan = 0; curchan < chans; curchan++)
		m_uncompressed_start[curchan] = samples[curchan];
	m_uncompressed_offset = 0;
	m_uncompressed_length = num_samples;
	m_uncompressed_swap = swap_endian;

	/* loop until we get everything we want */
	while (m_uncompressed_offset < m_uncompressed_length)
		if (!FLAC__stream_decoder_process_single(m_decoder))
			return false;
	return true;
}
#endif

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

uint32_t flac_decoder_finish(flac_decoder* decoder)
{
	/* get the final decoding position and move forward */
	FLAC__uint64 position = 0;
	FLAC__stream_decoder_get_decode_position(decoder->decoder, &position);
	FLAC__stream_decoder_finish(decoder->decoder);

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

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

FLAC__StreamDecoderReadStatus flac_decoder_read_callback_static(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
{
	return flac_decoder_read_callback(client_data, buffer, bytes);
}

FLAC__StreamDecoderReadStatus flac_decoder_read_callback(void* client_data, FLAC__byte buffer[], size_t *bytes)
{
	flac_decoder* decoder = (flac_decoder*)client_data;

	uint32_t expected     = (uint32_t)*bytes;

	/* copy from primary buffer first */
	uint32_t outputpos    = 0;
    
	if (outputpos < *bytes && decoder->compressed_offset < decoder->compressed_length)
	{
		uint32_t bytes_to_copy = (uint32_t)MIN(*bytes - outputpos, decoder->compressed_length - decoder->compressed_offset);
		memcpy(&buffer[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 = (uint32_t)MIN(*bytes - outputpos, decoder->compressed2_length - (decoder->compressed_offset - decoder->compressed_length));
		memcpy(&buffer[outputpos], decoder->compressed2_start + decoder->compressed_offset - decoder->compressed_length, bytes_to_copy);
		outputpos += bytes_to_copy;
		decoder->compressed_offset += bytes_to_copy;
	}
	*bytes = outputpos;

	/* return based on whether we ran out of data */
	return (*bytes < expected) ? FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM : FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
}

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

void flac_decoder_metadata_callback_static(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
{
   flac_decoder *fldecoder;
	/* ignore all but STREAMINFO metadata */
	if (metadata->type != FLAC__METADATA_TYPE_STREAMINFO)
		return;

	/* parse out the data we care about */
	fldecoder = (flac_decoder *)(client_data);
	fldecoder->sample_rate = metadata->data.stream_info.sample_rate;
	fldecoder->bits_per_sample = metadata->data.stream_info.bits_per_sample;
	fldecoder->channels = metadata->data.stream_info.channels;
}

/*-------------------------------------------------
 *  tell_callback - handle requests to find out
 *  where in the input stream we are
 *-------------------------------------------------
 */

FLAC__StreamDecoderTellStatus flac_decoder_tell_callback_static(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
{
	*absolute_byte_offset = ((flac_decoder *)client_data)->compressed_offset;
	return FLAC__STREAM_DECODER_TELL_STATUS_OK;
}

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

FLAC__StreamDecoderWriteStatus flac_decoder_write_callback_static(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
{
	return flac_decoder_write_callback(client_data, frame, buffer);
}

FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(void *client_data, const FLAC__Frame *frame, const FLAC__int32 * const buffer[])
{
	int sampnum, chan;
   int shift, blocksize;
	flac_decoder * decoder = (flac_decoder *)client_data;

	assert(frame->header.channels == decoder->channels);

	/* interleaved case */
	shift = decoder->uncompressed_swap ? 8 : 0;
	blocksize = frame->header.blocksize;
	if (decoder->uncompressed_start[1] == NULL)
	{
		int16_t *dest = decoder->uncompressed_start[0] + decoder->uncompressed_offset * frame->header.channels;
		for (sampnum = 0; sampnum < blocksize && decoder->uncompressed_offset < decoder->uncompressed_length; sampnum++, decoder->uncompressed_offset++)
			for (chan = 0; chan < (int)frame->header.channels; chan++)
				*dest++ = (int16_t)((((uint16_t)buffer[chan][sampnum]) << shift) | (((uint16_t)buffer[chan][sampnum]) >> shift));
	}

	/* non-interleaved case */
	else
	{
		for (sampnum = 0; sampnum < blocksize && decoder->uncompressed_offset < decoder->uncompressed_length; sampnum++, decoder->uncompressed_offset++)
			for (chan = 0; chan < (int)frame->header.channels; chan++)
				if (decoder->uncompressed_start[chan] != NULL)
					decoder->uncompressed_start[chan][decoder->uncompressed_offset] = (int16_t) ( (((uint16_t)(buffer[chan][sampnum])) << shift) | ( ((uint16_t)(buffer[chan][sampnum])) >> shift) );
	}
	return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}

/**
 * @fn  void flac_decoder::error_callback_static(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
 *
 * @brief   -------------------------------------------------
 *            error_callback - handle errors (ignore them)
 *          -------------------------------------------------.
 *
 * @param   decoder             The decoder.
 * @param   status              The status.
 * @param [in,out]  client_data If non-null, information describing the client.
 */

void flac_decoder_error_callback_static(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
{
}
Commit	Line	Data
3719602c PC	1	/* license:BSD-3-Clause
	2	* copyright-holders:Aaron Giles
	3	***************************************************************************
	4
	5	flac.c
	6
	7	FLAC compression wrappers
	8
	9	***************************************************************************/
	10
	11	#include <assert.h>
	12	#include <string.h>
	13	#include <libchdr/flac.h>
	14	#include <libchdr/minmax.h>
	15	#include <retro_miscellaneous.h>
	16
	17	/***************************************************************************
	18	* FLAC DECODER
	19	***************************************************************************
	20	*/
	21
	22	static FLAC__StreamDecoderReadStatus flac_decoder_read_callback_static(const FLAC__StreamDecoder decoder, FLAC__byte buffer[], size_t bytes, void *client_data);
	23	FLAC__StreamDecoderReadStatus flac_decoder_read_callback(void* client_data, FLAC__byte buffer[], size_t *bytes);
	24	static void flac_decoder_metadata_callback_static(const FLAC__StreamDecoder decoder, const FLAC__StreamMetadata metadata, void *client_data);
	25	static FLAC__StreamDecoderTellStatus flac_decoder_tell_callback_static(const FLAC__StreamDecoder decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
	26	static FLAC__StreamDecoderWriteStatus flac_decoder_write_callback_static(const FLAC__StreamDecoder decoder, const FLAC__Frame frame, const FLAC__int32 * const buffer[], void *client_data);
	27	FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(void* client_data, const FLAC__Frame frame, const FLAC__int32 const buffer[]);
	28	static void flac_decoder_error_callback_static(const FLAC__StreamDecoder decoder, FLAC__StreamDecoderErrorStatus status, void client_data);
	29
	30	/*-------------------------------------------------
	31	* flac_decoder - constructor
	32	*-------------------------------------------------
	33	*/
	34
	35	void flac_decoder_init(flac_decoder *decoder)
	36	{
	37	decoder->decoder = FLAC__stream_decoder_new();
	38	decoder->sample_rate = 0;
	39	decoder->channels = 0;
	40	decoder->bits_per_sample = 0;
	41	decoder->compressed_offset = 0;
	42	decoder->compressed_start = NULL;
	43	decoder->compressed_length = 0;
	44	decoder->compressed2_start = NULL;
	45	decoder->compressed2_length = 0;
	46	decoder->uncompressed_offset = 0;
	47	decoder->uncompressed_length = 0;
	48	decoder->uncompressed_swap = 0;
	49	}
	50
	51	/*-------------------------------------------------
	52	* flac_decoder - destructor
	53	*-------------------------------------------------
	54	*/
	55
	56	void flac_decoder_free(flac_decoder* decoder)
	57	{
	58	if ((decoder != NULL) && (decoder->decoder != NULL))
	59	FLAC__stream_decoder_delete(decoder->decoder);
	60	}
	61
	62	/*-------------------------------------------------
	63	* reset - reset state with the original
	64	* parameters
65	*-------------------------------------------------
66	*/
67
68	static int flac_decoder_internal_reset(flac_decoder* decoder)
69	{
70	decoder->compressed_offset = 0;
71	if (FLAC__stream_decoder_init_stream(decoder->decoder,
72	&flac_decoder_read_callback_static,
73	NULL,
74	&flac_decoder_tell_callback_static,
75	NULL,
76	NULL,
77	&flac_decoder_write_callback_static,
78	&flac_decoder_metadata_callback_static,
79	&flac_decoder_error_callback_static, decoder) != FLAC__STREAM_DECODER_INIT_STATUS_OK)
80	return 0;
81	return FLAC__stream_decoder_process_until_end_of_metadata(decoder->decoder);
82	}
83
84	/*-------------------------------------------------
85	* reset - reset state with new memory parameters
86	* and a custom-generated header
87	*-------------------------------------------------
88	*/
89
90	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)
91	{
92	/* modify the template header with our parameters */
93	static const uint8_t s_header_template[0x2a] =
94	{
95	0x66, 0x4C, 0x61, 0x43, /* +00: 'fLaC' stream header */
96	0x80, /* +04: metadata block type 0 (STREAMINFO), */
97	/* flagged as last block */
98	0x00, 0x00, 0x22, /* +05: metadata block length = 0x22 */
99	0x00, 0x00, /* +08: minimum block size */
100	0x00, 0x00, /* +0A: maximum block size */
101	0x00, 0x00, 0x00, /* +0C: minimum frame size (0 == unknown) */
102	0x00, 0x00, 0x00, /* +0F: maximum frame size (0 == unknown) */
103	0x0A, 0xC4, 0x42, 0xF0, 0x00, 0x00, 0x00, 0x00, /* +12: sample rate (0x0ac44 == 44100), */
104	/* numchannels (2), sample bits (16), */
105	/* samples in stream (0 == unknown) */
106	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* +1A: MD5 signature (0 == none) */
107	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 /* +2A: start of stream data */
108	};
109	memcpy(decoder->custom_header, s_header_template, sizeof(s_header_template));
110	decoder->custom_header[0x08] = decoder->custom_header[0x0a] = block_size >> 8;
111	decoder->custom_header[0x09] = decoder->custom_header[0x0b] = block_size & 0xff;
112	decoder->custom_header[0x12] = sample_rate >> 12;
113	decoder->custom_header[0x13] = sample_rate >> 4;
114	decoder->custom_header[0x14] = (sample_rate << 4) \| ((num_channels - 1) << 1);
115
116	/* configure the header ahead of the provided buffer */
117	decoder->compressed_start = (const FLAC__byte *)(decoder->custom_header);
118	decoder->compressed_length = sizeof(decoder->custom_header);
119	decoder->compressed2_start = (const FLAC__byte *)(buffer);
120	decoder->compressed2_length = length;
121	return flac_decoder_internal_reset(decoder);
122	}
123
124	/*-------------------------------------------------
125	* decode_interleaved - decode to an interleaved
126	* sound stream
127	*-------------------------------------------------
128	*/
129
130	int flac_decoder_decode_interleaved(flac_decoder* decoder, int16_t *samples, uint32_t num_samples, int swap_endian)
131	{
132	/* configure the uncompressed buffer */
133	memset(decoder->uncompressed_start, 0, sizeof(decoder->uncompressed_start));
134	decoder->uncompressed_start[0] = samples;
135	decoder->uncompressed_offset = 0;
136	decoder->uncompressed_length = num_samples;
137	decoder->uncompressed_swap = swap_endian;
138
139	/* loop until we get everything we want */
140	while (decoder->uncompressed_offset < decoder->uncompressed_length)
141	if (!FLAC__stream_decoder_process_single(decoder->decoder))
142	return 0;
143	return 1;
144	}
145
146	#if 0
147	/*-------------------------------------------------
148	* decode - decode to an multiple independent
149	* data streams
150	*-------------------------------------------------
151	*/
152
153	bool flac_decoder::decode(int16_t **samples, uint32_t num_samples, bool swap_endian)
154	{
155	/* make sure we don't have too many channels */
156	int chans = channels();
157	if (chans > ARRAY_SIZE(m_uncompressed_start))
158	return false;
159
160	/* configure the uncompressed buffer */
161	memset(m_uncompressed_start, 0, sizeof(m_uncompressed_start));
162	for (int curchan = 0; curchan < chans; curchan++)
163	m_uncompressed_start[curchan] = samples[curchan];
164	m_uncompressed_offset = 0;
165	m_uncompressed_length = num_samples;
166	m_uncompressed_swap = swap_endian;
167
168	/* loop until we get everything we want */
169	while (m_uncompressed_offset < m_uncompressed_length)
170	if (!FLAC__stream_decoder_process_single(m_decoder))
171	return false;
172	return true;
173	}
174	#endif
175
176	/*-------------------------------------------------
177	* finish - finish up the decode
178	*-------------------------------------------------
179	*/
180
181	uint32_t flac_decoder_finish(flac_decoder* decoder)
182	{
183	/* get the final decoding position and move forward */
184	FLAC__uint64 position = 0;
185	FLAC__stream_decoder_get_decode_position(decoder->decoder, &position);
186	FLAC__stream_decoder_finish(decoder->decoder);
187
188	/* adjust position if we provided the header */
189	if (position == 0)
190	return 0;
191	if (decoder->compressed_start == (const FLAC__byte *)(decoder->custom_header))
192	position -= decoder->compressed_length;
193	return (uint32_t)position;
194	}
195
196	/*-------------------------------------------------
197	* read_callback - handle reads from the input
198	* stream
199	*-------------------------------------------------
200	*/
201
202	FLAC__StreamDecoderReadStatus flac_decoder_read_callback_static(const FLAC__StreamDecoder decoder, FLAC__byte buffer[], size_t bytes, void *client_data)
203	{
204	return flac_decoder_read_callback(client_data, buffer, bytes);
205	}
206
207	FLAC__StreamDecoderReadStatus flac_decoder_read_callback(void* client_data, FLAC__byte buffer[], size_t *bytes)
208	{
209	flac_decoder* decoder = (flac_decoder*)client_data;
210
211	uint32_t expected = (uint32_t)*bytes;
212
213	/* copy from primary buffer first */
214	uint32_t outputpos = 0;
215
216	if (outputpos < *bytes && decoder->compressed_offset < decoder->compressed_length)
217	{
218	uint32_t bytes_to_copy = (uint32_t)MIN(*bytes - outputpos, decoder->compressed_length - decoder->compressed_offset);
219	memcpy(&buffer[outputpos], decoder->compressed_start + decoder->compressed_offset, bytes_to_copy);
220	outputpos += bytes_to_copy;
221	decoder->compressed_offset += bytes_to_copy;
222	}
223
224	/* once we're out of that, copy from the secondary buffer */
225	if (outputpos < *bytes && decoder->compressed_offset < decoder->compressed_length + decoder->compressed2_length)
226	{
227	uint32_t bytes_to_copy = (uint32_t)MIN(*bytes - outputpos, decoder->compressed2_length - (decoder->compressed_offset - decoder->compressed_length));
228	memcpy(&buffer[outputpos], decoder->compressed2_start + decoder->compressed_offset - decoder->compressed_length, bytes_to_copy);
229	outputpos += bytes_to_copy;
230	decoder->compressed_offset += bytes_to_copy;
231	}
232	*bytes = outputpos;
233
234	/* return based on whether we ran out of data */
235	return (*bytes < expected) ? FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM : FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
236	}
237
238	/*-------------------------------------------------
239	* metadata_callback - handle STREAMINFO metadata
240	*-------------------------------------------------
241	*/
242
243	void flac_decoder_metadata_callback_static(const FLAC__StreamDecoder decoder, const FLAC__StreamMetadata metadata, void *client_data)
244	{
245	flac_decoder *fldecoder;
246	/* ignore all but STREAMINFO metadata */
247	if (metadata->type != FLAC__METADATA_TYPE_STREAMINFO)
248	return;
249
250	/* parse out the data we care about */
251	fldecoder = (flac_decoder *)(client_data);
252	fldecoder->sample_rate = metadata->data.stream_info.sample_rate;
253	fldecoder->bits_per_sample = metadata->data.stream_info.bits_per_sample;
254	fldecoder->channels = metadata->data.stream_info.channels;
255	}
256
257	/*-------------------------------------------------
258	* tell_callback - handle requests to find out
259	* where in the input stream we are
260	*-------------------------------------------------
261	*/
262
263	FLAC__StreamDecoderTellStatus flac_decoder_tell_callback_static(const FLAC__StreamDecoder decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
264	{
265	absolute_byte_offset = ((flac_decoder )client_data)->compressed_offset;
266	return FLAC__STREAM_DECODER_TELL_STATUS_OK;
267	}
268
269	/*-------------------------------------------------
270	* write_callback - handle writes to the output
271	* stream
272	*-------------------------------------------------
273	*/
274
275	FLAC__StreamDecoderWriteStatus flac_decoder_write_callback_static(const FLAC__StreamDecoder decoder, const FLAC__Frame frame, const FLAC__int32 * const buffer[], void *client_data)
276	{
277	return flac_decoder_write_callback(client_data, frame, buffer);
278	}
279
280	FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(void client_data, const FLAC__Frame frame, const FLAC__int32 * const buffer[])
281	{
282	int sampnum, chan;
283	int shift, blocksize;
284	flac_decoder * decoder = (flac_decoder *)client_data;
285
286	assert(frame->header.channels == decoder->channels);
287
288	/* interleaved case */
289	shift = decoder->uncompressed_swap ? 8 : 0;
290	blocksize = frame->header.blocksize;
291	if (decoder->uncompressed_start[1] == NULL)
292	{
293	int16_t dest = decoder->uncompressed_start[0] + decoder->uncompressed_offset frame->header.channels;
294	for (sampnum = 0; sampnum < blocksize && decoder->uncompressed_offset < decoder->uncompressed_length; sampnum++, decoder->uncompressed_offset++)
295	for (chan = 0; chan < (int)frame->header.channels; chan++)
296	*dest++ = (int16_t)((((uint16_t)buffer[chan][sampnum]) << shift) \| (((uint16_t)buffer[chan][sampnum]) >> shift));
297	}
298
299	/* non-interleaved case */
300	else
301	{
302	for (sampnum = 0; sampnum < blocksize && decoder->uncompressed_offset < decoder->uncompressed_length; sampnum++, decoder->uncompressed_offset++)
303	for (chan = 0; chan < (int)frame->header.channels; chan++)
304	if (decoder->uncompressed_start[chan] != NULL)
305	decoder->uncompressed_start[chan][decoder->uncompressed_offset] = (int16_t) ( (((uint16_t)(buffer[chan][sampnum])) << shift) \| ( ((uint16_t)(buffer[chan][sampnum])) >> shift) );
306	}
307	return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
308	}
309
310	/**
311	* @fn void flac_decoder::error_callback_static(const FLAC__StreamDecoder decoder, FLAC__StreamDecoderErrorStatus status, void client_data)
312	*
313	* @brief -------------------------------------------------
314	* error_callback - handle errors (ignore them)
315	* -------------------------------------------------.
316	*
317	* @param decoder The decoder.
318	* @param status The status.
319	* @param [in,out] client_data If non-null, information describing the client.
320	*/
321
322	void flac_decoder_error_callback_static(const FLAC__StreamDecoder decoder, FLAC__StreamDecoderErrorStatus status, void client_data)
323	{
324	}