deps/libchdr/flac.c

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