34 #if defined _WIN32 && !defined __CYGWIN__ 40 #if defined _MSC_VER || defined __BORLANDC__ || defined __MINGW32__ 41 #include <sys/types.h> 45 #define __STDC_FORMAT_MACROS 49 #if defined _MSC_VER || defined __MINGW32__ || defined __CYGWIN__ || defined __EMX__ 56 #if defined _MSC_VER || defined __BORLANDC__ || defined __MINGW32__ 57 #if defined __BORLANDC__ 60 #include <sys/utime.h> 63 #include <sys/types.h> 92 namespace FlacNamespace
94 #if JUCE_INCLUDE_FLAC_CODE || ! defined (JUCE_INCLUDE_FLAC_CODE) 97 #define VERSION "1.3.1" 99 #define FLAC__NO_DLL 1 102 #pragma warning (disable: 4267 4127 4244 4996 4100 4701 4702 4013 4133 4206 4312 4505 4365 4005 4334 181 111) 104 #define HAVE_LROUND 1 108 #define FLAC__SYS_DARWIN 1 112 #define SIZE_MAX 0xffffffff 116 #pragma clang diagnostic push 117 #pragma clang diagnostic ignored "-Wconversion" 118 #pragma clang diagnostic ignored "-Wshadow" 119 #pragma clang diagnostic ignored "-Wdeprecated-register" 120 #if __has_warning("-Wzero-as-null-pointer-constant") 121 #pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" 127 #define FLAC__CPU_IA32 1 130 #define FLAC__CPU_X86_64 1 132 #define FLAC__HAS_X86INTRIN 1 135 #undef __STDC_LIMIT_MACROS 136 #define __STDC_LIMIT_MACROS 1 137 #define flac_max jmax 138 #define flac_min jmin 139 #undef DEBUG // (some flac code dumps debug trace if the app defines this macro) 140 #include "flac/all.h" 141 #include "flac/libFLAC/bitmath.c" 142 #include "flac/libFLAC/bitreader.c" 143 #include "flac/libFLAC/bitwriter.c" 144 #include "flac/libFLAC/cpu.c" 145 #include "flac/libFLAC/crc.c" 146 #include "flac/libFLAC/fixed.c" 147 #include "flac/libFLAC/float.c" 148 #include "flac/libFLAC/format.c" 149 #include "flac/libFLAC/lpc_flac.c" 150 #include "flac/libFLAC/md5.c" 151 #include "flac/libFLAC/memory.c" 152 #include "flac/libFLAC/stream_decoder.c" 153 #include "flac/libFLAC/stream_encoder.c" 154 #include "flac/libFLAC/stream_encoder_framing.c" 155 #include "flac/libFLAC/window_flac.c" 158 #include <FLAC/all.h> 162 #pragma clang diagnostic pop 170 static const char*
const flacFormatName =
"FLAC file";
174 class FlacReader :
public AudioFormatReader
177 FlacReader (InputStream* in) : AudioFormatReader (in, flacFormatName)
180 decoder = FlacNamespace::FLAC__stream_decoder_new();
182 ok = FLAC__stream_decoder_init_stream (decoder,
183 readCallback_, seekCallback_, tellCallback_, lengthCallback_,
184 eofCallback_, writeCallback_, metadataCallback_, errorCallback_,
185 this) == FlacNamespace::FLAC__STREAM_DECODER_INIT_STATUS_OK;
189 FLAC__stream_decoder_process_until_end_of_metadata (decoder);
191 if (lengthInSamples == 0 && sampleRate > 0)
195 scanningForLength =
true;
196 FLAC__stream_decoder_process_until_end_of_stream (decoder);
197 scanningForLength =
false;
198 auto tempLength = lengthInSamples;
200 FLAC__stream_decoder_reset (decoder);
201 FLAC__stream_decoder_process_until_end_of_metadata (decoder);
202 lengthInSamples = tempLength;
207 ~FlacReader()
override 209 FlacNamespace::FLAC__stream_decoder_delete (decoder);
212 void useMetadata (
const FlacNamespace::FLAC__StreamMetadata_StreamInfo& info)
214 sampleRate = info.sample_rate;
215 bitsPerSample = info.bits_per_sample;
216 lengthInSamples = (
unsigned int) info.total_samples;
217 numChannels = info.channels;
219 reservoir.setSize ((
int) numChannels, 2 * (
int) info.max_blocksize,
false,
false,
true);
223 bool readSamples (
int** destSamples,
int numDestChannels,
int startOffsetInDestBuffer,
224 int64 startSampleInFile,
int numSamples)
override 229 while (numSamples > 0)
231 if (startSampleInFile >= reservoirStart
232 && startSampleInFile < reservoirStart + samplesInReservoir)
234 auto num = (int) jmin ((int64) numSamples,
235 reservoirStart + samplesInReservoir - startSampleInFile);
239 for (
int i = jmin (numDestChannels, reservoir.getNumChannels()); --i >= 0;)
240 if (destSamples[i] !=
nullptr)
241 memcpy (destSamples[i] + startOffsetInDestBuffer,
242 reservoir.getReadPointer (i, (
int) (startSampleInFile - reservoirStart)),
243 sizeof (int) * (
size_t) num);
245 startOffsetInDestBuffer += num;
246 startSampleInFile += num;
251 if (startSampleInFile >= lengthInSamples)
253 samplesInReservoir = 0;
255 else if (startSampleInFile < reservoirStart
256 || startSampleInFile > reservoirStart + jmax (samplesInReservoir, 511))
260 reservoirStart = (int) (startSampleInFile & ~511);
261 samplesInReservoir = 0;
262 FLAC__stream_decoder_seek_absolute (decoder, (FlacNamespace::FLAC__uint64) reservoirStart);
266 reservoirStart += samplesInReservoir;
267 samplesInReservoir = 0;
268 FLAC__stream_decoder_process_single (decoder);
271 if (samplesInReservoir == 0)
278 for (
int i = numDestChannels; --i >= 0;)
279 if (destSamples[i] !=
nullptr)
280 zeromem (destSamples[i] + startOffsetInDestBuffer,
sizeof (
int) * (
size_t) numSamples);
286 void useSamples (
const FlacNamespace::FLAC__int32*
const buffer[],
int numSamples)
288 if (scanningForLength)
290 lengthInSamples += numSamples;
294 if (numSamples > reservoir.getNumSamples())
295 reservoir.setSize ((
int) numChannels, numSamples,
false,
false,
true);
297 auto bitsToShift = 32 - bitsPerSample;
299 for (
int i = 0; i < (int) numChannels; ++i)
301 auto* src = buffer[i];
304 while (src ==
nullptr && n > 0)
309 auto* dest =
reinterpret_cast<int*
> (reservoir.getWritePointer(i));
311 for (
int j = 0; j < numSamples; ++j)
312 dest[j] = src[j] << bitsToShift;
316 samplesInReservoir = numSamples;
321 static FlacNamespace::FLAC__StreamDecoderReadStatus readCallback_ (
const FlacNamespace::FLAC__StreamDecoder*, FlacNamespace::FLAC__byte buffer[],
size_t* bytes,
void* client_data)
323 *bytes = (size_t) static_cast<const FlacReader*> (client_data)->input->read (buffer, (
int) *bytes);
324 return FlacNamespace::FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
327 static FlacNamespace::FLAC__StreamDecoderSeekStatus seekCallback_ (
const FlacNamespace::FLAC__StreamDecoder*, FlacNamespace::FLAC__uint64 absolute_byte_offset,
void* client_data)
329 static_cast<const FlacReader*
> (client_data)->input->setPosition ((
int) absolute_byte_offset);
330 return FlacNamespace::FLAC__STREAM_DECODER_SEEK_STATUS_OK;
333 static FlacNamespace::FLAC__StreamDecoderTellStatus tellCallback_ (
const FlacNamespace::FLAC__StreamDecoder*, FlacNamespace::FLAC__uint64* absolute_byte_offset,
void* client_data)
335 *absolute_byte_offset = (uint64) static_cast<const FlacReader*> (client_data)->input->getPosition();
336 return FlacNamespace::FLAC__STREAM_DECODER_TELL_STATUS_OK;
339 static FlacNamespace::FLAC__StreamDecoderLengthStatus lengthCallback_ (
const FlacNamespace::FLAC__StreamDecoder*, FlacNamespace::FLAC__uint64* stream_length,
void* client_data)
341 *stream_length = (uint64) static_cast<const FlacReader*> (client_data)->input->getTotalLength();
342 return FlacNamespace::FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
345 static FlacNamespace::FLAC__bool eofCallback_ (
const FlacNamespace::FLAC__StreamDecoder*,
void* client_data)
347 return static_cast<const FlacReader*
> (client_data)->input->isExhausted();
350 static FlacNamespace::FLAC__StreamDecoderWriteStatus writeCallback_ (
const FlacNamespace::FLAC__StreamDecoder*,
351 const FlacNamespace::FLAC__Frame* frame,
352 const FlacNamespace::FLAC__int32*
const buffer[],
355 static_cast<FlacReader*
> (client_data)->useSamples (buffer, (
int) frame->header.blocksize);
356 return FlacNamespace::FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
359 static void metadataCallback_ (
const FlacNamespace::FLAC__StreamDecoder*,
360 const FlacNamespace::FLAC__StreamMetadata* metadata,
363 static_cast<FlacReader*
> (client_data)->useMetadata (metadata->data.stream_info);
366 static void errorCallback_ (
const FlacNamespace::FLAC__StreamDecoder*, FlacNamespace::FLAC__StreamDecoderErrorStatus,
void*)
371 FlacNamespace::FLAC__StreamDecoder* decoder;
372 AudioBuffer<float> reservoir;
373 int reservoirStart = 0, samplesInReservoir = 0;
374 bool ok =
false, scanningForLength =
false;
376 JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (FlacReader)
381 class FlacWriter :
public AudioFormatWriter
384 FlacWriter (OutputStream* out,
double rate, uint32 numChans, uint32 bits,
int qualityOptionIndex)
385 : AudioFormatWriter (out, flacFormatName, rate, numChans, bits),
386 streamStartPos (output != nullptr ? jmax (output->getPosition(), 0ll) : 0ll)
388 encoder = FlacNamespace::FLAC__stream_encoder_new();
390 if (qualityOptionIndex > 0)
391 FLAC__stream_encoder_set_compression_level (encoder, (uint32) jmin (8, qualityOptionIndex));
393 FLAC__stream_encoder_set_do_mid_side_stereo (encoder, numChannels == 2);
394 FLAC__stream_encoder_set_loose_mid_side_stereo (encoder, numChannels == 2);
395 FLAC__stream_encoder_set_channels (encoder, numChannels);
396 FLAC__stream_encoder_set_bits_per_sample (encoder, jmin ((
unsigned int) 24, bitsPerSample));
397 FLAC__stream_encoder_set_sample_rate (encoder, (
unsigned int) sampleRate);
398 FLAC__stream_encoder_set_blocksize (encoder, 0);
399 FLAC__stream_encoder_set_do_escape_coding (encoder,
true);
401 ok = FLAC__stream_encoder_init_stream (encoder,
402 encodeWriteCallback, encodeSeekCallback,
403 encodeTellCallback, encodeMetadataCallback,
404 this) == FlacNamespace::FLAC__STREAM_ENCODER_INIT_STATUS_OK;
407 ~FlacWriter()
override 411 FlacNamespace::FLAC__stream_encoder_finish (encoder);
420 FlacNamespace::FLAC__stream_encoder_delete (encoder);
424 bool write (
const int** samplesToWrite,
int numSamples)
override 429 HeapBlock<int*> channels;
431 auto bitsToShift = 32 - (int) bitsPerSample;
435 temp.malloc (numChannels * (
size_t) numSamples);
436 channels.calloc (numChannels + 1);
438 for (
unsigned int i = 0; i < numChannels; ++i)
440 if (samplesToWrite[i] ==
nullptr)
443 auto* destData = temp.get() + i * (size_t) numSamples;
444 channels[i] = destData;
446 for (
int j = 0; j < numSamples; ++j)
447 destData[j] = (samplesToWrite[i][j] >> bitsToShift);
450 samplesToWrite =
const_cast<const int**
> (channels.get());
453 return FLAC__stream_encoder_process (encoder, (
const FlacNamespace::FLAC__int32**) samplesToWrite, (
unsigned) numSamples) != 0;
456 bool writeData (
const void*
const data,
const int size)
const 458 return output->write (data, (
size_t) size);
461 static void packUint32 (FlacNamespace::FLAC__uint32 val, FlacNamespace::FLAC__byte* b,
const int bytes)
465 for (
int i = 0; i < bytes; ++i)
467 *(--b) = (FlacNamespace::FLAC__byte) (val & 0xff);
472 void writeMetaData (
const FlacNamespace::FLAC__StreamMetadata* metadata)
474 using namespace FlacNamespace;
475 auto& info = metadata->data.stream_info;
477 unsigned char buffer[FLAC__STREAM_METADATA_STREAMINFO_LENGTH];
478 const unsigned int channelsMinus1 = info.channels - 1;
479 const unsigned int bitsMinus1 = info.bits_per_sample - 1;
481 packUint32 (info.min_blocksize, buffer, 2);
482 packUint32 (info.max_blocksize, buffer + 2, 2);
483 packUint32 (info.min_framesize, buffer + 4, 3);
484 packUint32 (info.max_framesize, buffer + 7, 3);
485 buffer[10] = (uint8) ((info.sample_rate >> 12) & 0xff);
486 buffer[11] = (uint8) ((info.sample_rate >> 4) & 0xff);
487 buffer[12] = (uint8) (((info.sample_rate & 0x0f) << 4) | (channelsMinus1 << 1) | (bitsMinus1 >> 4));
488 buffer[13] = (FLAC__byte) (((bitsMinus1 & 0x0f) << 4) | (
unsigned int) ((info.total_samples >> 32) & 0x0f));
489 packUint32 ((FLAC__uint32) info.total_samples, buffer + 14, 4);
490 memcpy (buffer + 18, info.md5sum, 16);
492 const bool seekOk = output->setPosition (streamStartPos + 4);
493 ignoreUnused (seekOk);
499 output->writeIntBigEndian (FLAC__STREAM_METADATA_STREAMINFO_LENGTH);
500 output->write (buffer, FLAC__STREAM_METADATA_STREAMINFO_LENGTH);
504 static FlacNamespace::FLAC__StreamEncoderWriteStatus encodeWriteCallback (
const FlacNamespace::FLAC__StreamEncoder*,
505 const FlacNamespace::FLAC__byte buffer[],
511 return static_cast<FlacWriter*
> (client_data)->writeData (buffer, (
int) bytes)
512 ? FlacNamespace::FLAC__STREAM_ENCODER_WRITE_STATUS_OK
513 : FlacNamespace::FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
516 static FlacNamespace::FLAC__StreamEncoderSeekStatus encodeSeekCallback (
const FlacNamespace::FLAC__StreamEncoder*, FlacNamespace::FLAC__uint64,
void*)
518 return FlacNamespace::FLAC__STREAM_ENCODER_SEEK_STATUS_UNSUPPORTED;
521 static FlacNamespace::FLAC__StreamEncoderTellStatus encodeTellCallback (
const FlacNamespace::FLAC__StreamEncoder*, FlacNamespace::FLAC__uint64* absolute_byte_offset,
void* client_data)
523 if (client_data ==
nullptr)
524 return FlacNamespace::FLAC__STREAM_ENCODER_TELL_STATUS_UNSUPPORTED;
526 *absolute_byte_offset = (FlacNamespace::FLAC__uint64) static_cast<FlacWriter*> (client_data)->output->getPosition();
527 return FlacNamespace::FLAC__STREAM_ENCODER_TELL_STATUS_OK;
530 static void encodeMetadataCallback (
const FlacNamespace::FLAC__StreamEncoder*,
const FlacNamespace::FLAC__StreamMetadata* metadata,
void* client_data)
532 static_cast<FlacWriter*
> (client_data)->writeMetaData (metadata);
538 FlacNamespace::FLAC__StreamEncoder* encoder;
539 int64 streamStartPos;
541 JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (FlacWriter)
546 FlacAudioFormat::FlacAudioFormat() : AudioFormat (flacFormatName,
".flac") {}
547 FlacAudioFormat::~FlacAudioFormat() {}
551 return { 8000, 11025, 12000, 16000, 22050, 32000, 44100, 48000,
552 88200, 96000, 176400, 192000, 352800, 384000 };
566 std::unique_ptr<FlacReader> r (
new FlacReader (in));
568 if (r->sampleRate > 0)
571 if (! deleteStreamIfOpeningFails)
579 unsigned int numberOfChannels,
581 const StringPairArray& ,
582 int qualityOptionIndex)
584 if (out !=
nullptr && getPossibleBitDepths().contains (bitsPerSample))
586 std::unique_ptr<FlacWriter> w (
new FlacWriter (out, sampleRate, numberOfChannels,
587 (uint32) bitsPerSample, qualityOptionIndex));
597 return {
"0 (Fastest)",
"1",
"2",
"3",
"4",
"5 (Default)",
"6",
"7",
"8 (Highest quality)" };