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
flac_decoder_init(flac_decoder * decoder)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
flac_decoder_free(flac_decoder * decoder)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
flac_decoder_internal_reset(flac_decoder * decoder)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
flac_decoder_reset(flac_decoder * decoder,uint32_t sample_rate,uint8_t num_channels,uint32_t block_size,const void * buffer,uint32_t length)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
flac_decoder_decode_interleaved(flac_decoder * decoder,int16_t * samples,uint32_t num_samples,int swap_endian)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
flac_decoder_finish(flac_decoder * decoder)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
flac_decoder_read_callback_static(const FLAC__StreamDecoder * decoder,FLAC__byte buffer[],size_t * bytes,void * client_data)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
flac_decoder_read_callback(void * client_data,FLAC__byte buffer[],size_t * bytes)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
flac_decoder_metadata_callback_static(const FLAC__StreamDecoder * decoder,const FLAC__StreamMetadata * metadata,void * client_data)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
flac_decoder_tell_callback_static(const FLAC__StreamDecoder * decoder,FLAC__uint64 * absolute_byte_offset,void * client_data)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
flac_decoder_write_callback_static(const FLAC__StreamDecoder * decoder,const FLAC__Frame * frame,const FLAC__int32 * const buffer[],void * client_data)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
flac_decoder_write_callback(void * client_data,const FLAC__Frame * frame,const FLAC__int32 * const buffer[])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 < 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 < 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
flac_decoder_error_callback_static(const FLAC__StreamDecoder * decoder,FLAC__StreamDecoderErrorStatus status,void * client_data)322 void flac_decoder_error_callback_static(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
323 {
324 }
325