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 | } |