int read_flac_file (apr_pool_t* pool,void** file_struct, const char* file_path, encoding_options_t* enc_opt){
FLAC__StreamDecoderInitStatus status;
FLAC__bool status2;
flac_file_t* flac_file = *file_struct = (flac_file_t*) apr_pcalloc(pool, sizeof(flac_file_t));
flac_file->stream_decoder = FLAC__stream_decoder_new();
flac_file->channels = 0;
flac_file->samples = 0;
flac_file->total_samples = 0;
flac_file->rate = 0;
flac_file->buf = NULL;
status = FLAC__stream_decoder_init_file(flac_file->stream_decoder, file_path, flac_write, flac_metadata, flac_errors, flac_file);
if (status != FLAC__STREAM_DECODER_INIT_STATUS_OK){
return -1;
}
status2 = FLAC__stream_decoder_process_until_end_of_metadata(flac_file->stream_decoder);
if (status2 != true){
return -2;
}
FLAC__stream_decoder_process_single(flac_file->stream_decoder);
if (status2 != true){
return -2;
}
enc_opt->channels = flac_file->channels;
enc_opt->rate = flac_file->rate;
enc_opt->total_samples_per_channel = flac_file->total_samples;
enc_opt->samples_to_request = 1024;
return 0;
}
void play_file_from_filename(const std::string name) {
currently_playing = std::string(name);
if (audiobuf) linearFree(audiobuf);
if (name.rfind(".flac") != std::string::npos) {
if (!FLAC_decoder) {
FLAC_decoder = FLAC__stream_decoder_new();
FLAC__stream_decoder_set_md5_checking(FLAC_decoder, true);
}
audiobuf_index = 0;
decode_mode = AUDIO_MODE_FLAC;
FLAC__StreamDecoderInitStatus init_status = FLAC__stream_decoder_init_file(FLAC_decoder, name.c_str(), FLAC_write_callback, FLAC_metadata_callback, FLAC_error_callback, NULL);
if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
printf("ERROR: initializing decoder: %s\n", FLAC__StreamDecoderInitStatusString[init_status]);
}
FLAC__stream_decoder_process_until_end_of_metadata(FLAC_decoder);
} else {
decode_mode = AUDIO_MODE_VORBIS;
v = stb_vorbis_open_filename(name.c_str(), &error, NULL);
info = stb_vorbis_get_info(v);
Samples = info.sample_rate;
audiobuf_size = Samples * sizeof(s16) * 2;
audiobuf = (s16*)linearAlloc(audiobuf_size);
}
paused = false;
}
void SampleBuffer::loadFromBase64( const QString & _data )
{
char * dst = NULL;
int dsize = 0;
base64::decode( _data, &dst, &dsize );
#ifdef LMMS_HAVE_FLAC_STREAM_DECODER_H
QByteArray orig_data = QByteArray::fromRawData( dst, dsize );
QBuffer ba_reader( &orig_data );
ba_reader.open( QBuffer::ReadOnly );
QBuffer ba_writer;
ba_writer.open( QBuffer::WriteOnly );
flacStreamDecoderClientData cdata = { &ba_reader, &ba_writer } ;
FLAC__StreamDecoder * flac_dec = FLAC__stream_decoder_new();
FLAC__stream_decoder_set_read_callback( flac_dec,
flacStreamDecoderReadCallback );
FLAC__stream_decoder_set_write_callback( flac_dec,
flacStreamDecoderWriteCallback );
FLAC__stream_decoder_set_error_callback( flac_dec,
flacStreamDecoderErrorCallback );
FLAC__stream_decoder_set_metadata_callback( flac_dec,
flacStreamDecoderMetadataCallback );
FLAC__stream_decoder_set_client_data( flac_dec, &cdata );
FLAC__stream_decoder_init( flac_dec );
FLAC__stream_decoder_process_until_end_of_stream( flac_dec );
FLAC__stream_decoder_finish( flac_dec );
FLAC__stream_decoder_delete( flac_dec );
ba_reader.close();
orig_data = ba_writer.buffer();
printf("%d\n", (int) orig_data.size() );
m_origFrames = orig_data.size() / sizeof( sampleFrame );
MM_FREE( m_origData );
m_origData = MM_ALLOC( sampleFrame, m_origFrames );
memcpy( m_origData, orig_data.data(), orig_data.size() );
#else /* LMMS_HAVE_FLAC_STREAM_DECODER_H */
m_origFrames = dsize / sizeof( sampleFrame );
MM_FREE( m_origData );
m_origData = MM_ALLOC( sampleFrame, m_origFrames );
memcpy( m_origData, dst, dsize );
#endif
delete[] dst;
m_audioFile = QString();
update();
}
static gboolean
gst_flac_dec_start (GstAudioDecoder * audio_dec)
{
FLAC__StreamDecoderInitStatus s;
GstFlacDec *dec;
dec = GST_FLAC_DEC (audio_dec);
dec->adapter = gst_adapter_new ();
dec->decoder = FLAC__stream_decoder_new ();
gst_audio_info_init (&dec->info);
dec->depth = 0;
/* no point calculating MD5 since it's never checked here */
FLAC__stream_decoder_set_md5_checking (dec->decoder, false);
GST_DEBUG_OBJECT (dec, "initializing decoder");
s = FLAC__stream_decoder_init_stream (dec->decoder,
gst_flac_dec_read_stream, NULL, NULL, NULL, NULL,
gst_flac_dec_write_stream, gst_flac_dec_metadata_cb,
gst_flac_dec_error_cb, dec);
if (s != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
GST_ELEMENT_ERROR (GST_ELEMENT (dec), LIBRARY, INIT, (NULL), (NULL));
return FALSE;
}
dec->got_headers = FALSE;
return TRUE;
}
Result SoundSourceFLAC::tryOpen(const AudioSourceConfig& /*audioSrcCfg*/) {
DEBUG_ASSERT(!m_file.isOpen());
if (!m_file.open(QIODevice::ReadOnly)) {
qWarning() << "Failed to open FLAC file:" << m_file.fileName();
return ERR;
}
m_decoder = FLAC__stream_decoder_new();
if (m_decoder == NULL) {
qWarning() << "Failed to create FLAC decoder!";
return ERR;
}
FLAC__stream_decoder_set_md5_checking(m_decoder, FALSE);
const FLAC__StreamDecoderInitStatus initStatus(
FLAC__stream_decoder_init_stream(m_decoder, FLAC_read_cb,
FLAC_seek_cb, FLAC_tell_cb, FLAC_length_cb, FLAC_eof_cb,
FLAC_write_cb, FLAC_metadata_cb, FLAC_error_cb, this));
if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
qWarning() << "Failed to initialize FLAC decoder:" << initStatus;
return ERR;
}
if (!FLAC__stream_decoder_process_until_end_of_metadata(m_decoder)) {
qWarning() << "Failed to process FLAC metadata:"
<< FLAC__stream_decoder_get_state(m_decoder);
return ERR;
}
m_curFrameIndex = getMinFrameIndex();
return OK;
}
bool OAFLACReader::open(const SPtr<DataStream>& stream, AudioFileInfo& info, UINT32 offset)
{
if (stream == nullptr)
return false;
stream->seek(offset);
mDecoder = FLAC__stream_decoder_new();
if (mDecoder == nullptr)
{
LOGERR("Failed to open a FLAC file.");
return false;
}
mData.stream = stream;
mData.streamOffset = offset;
FLAC__stream_decoder_init_stream(mDecoder, &streamRead, &streamSeek, &streamTell, &streamLength, &streamEof,
&streamWrite, &streamMetadata, &streamError, &mData);
if (!FLAC__stream_decoder_process_until_end_of_metadata(mDecoder))
{
close();
LOGERR("Failed to open a FLAC file.");
return false;
}
info = mData.info;
return true;
}
static status_t HandleFLAC(const char *filename, MediaScannerClient* client)
{
status_t status = UNKNOWN_ERROR;
FLAC__StreamDecoder *decoder;
decoder = FLAC__stream_decoder_new();
if (!decoder)
return status;
FLAC__stream_decoder_set_md5_checking(decoder, false);
FLAC__stream_decoder_set_metadata_ignore_all(decoder);
FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_STREAMINFO);
FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT);
FLAC__StreamDecoderInitStatus init_status;
init_status = FLAC__stream_decoder_init_file(decoder, filename, flac_write, flac_metadata, flac_error, client);
if (init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK)
goto exit;
if (!FLAC__stream_decoder_process_until_end_of_metadata(decoder))
goto exit;
status = OK;
exit:
FLAC__stream_decoder_finish(decoder);
FLAC__stream_decoder_delete(decoder);
return status;
}
bool SoundFileReaderFlac::open(InputStream& stream, Info& info)
{
// Create the decoder
m_decoder = FLAC__stream_decoder_new();
if (!m_decoder)
{
err() << "Failed to open FLAC file (failed to allocate the decoder)" << std::endl;
return false;
}
// Initialize the decoder with our callbacks
m_clientData.stream = &stream;
FLAC__stream_decoder_init_stream(m_decoder, &streamRead, &streamSeek, &streamTell, &streamLength, &streamEof, &streamWrite, &streamMetadata, &streamError, &m_clientData);
// Read the header
if (!FLAC__stream_decoder_process_until_end_of_metadata(m_decoder))
{
close();
err() << "Failed to open FLAC file (failed to read metadata)" << std::endl;
return false;
}
// Retrieve the sound properties
info = m_clientData.info; // was filled in the "metadata" callback
// We must keep the channel count for the seek function
m_channelCount = info.channelCount;
return true;
}
SoundSource::OpenResult SoundSourceFLAC::tryOpen(
OpenMode /*mode*/,
const OpenParams& /*config*/) {
DEBUG_ASSERT(!m_file.isOpen());
if (!m_file.open(QIODevice::ReadOnly)) {
kLogger.warning() << "Failed to open FLAC file:" << m_file.fileName();
return OpenResult::Failed;
}
m_decoder = FLAC__stream_decoder_new();
if (m_decoder == nullptr) {
kLogger.warning() << "Failed to create FLAC decoder!";
return OpenResult::Failed;
}
FLAC__stream_decoder_set_md5_checking(m_decoder, false);
const FLAC__StreamDecoderInitStatus initStatus(
FLAC__stream_decoder_init_stream(m_decoder, FLAC_read_cb,
FLAC_seek_cb, FLAC_tell_cb, FLAC_length_cb, FLAC_eof_cb,
FLAC_write_cb, FLAC_metadata_cb, FLAC_error_cb, this));
if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
kLogger.warning() << "Failed to initialize FLAC decoder:" << initStatus;
return OpenResult::Failed;
}
if (!FLAC__stream_decoder_process_until_end_of_metadata(m_decoder)) {
kLogger.warning() << "Failed to process FLAC metadata:"
<< FLAC__stream_decoder_get_state(m_decoder);
return OpenResult::Failed;
}
m_curFrameIndex = frameIndexMin();
return OpenResult::Succeeded;
}
bool CFlacDec::GetMetaData(FILE *in, const bool /*nice*/, CAudioMetaData* m)
{
FLAC__StreamDecoder *vf;
vf = FLAC__stream_decoder_new();
FLAC__stream_decoder_set_metadata_ignore_all(vf);
// we need streaminfo (default on) and FLAC__METADATA_TYPE_VORBIS_COMMENT (default off) for ID3 tags
FLAC__stream_decoder_set_metadata_respond(vf, FLAC__METADATA_TYPE_STREAMINFO);
FLAC__stream_decoder_set_metadata_respond(vf, FLAC__METADATA_TYPE_VORBIS_COMMENT);
if (!Open(in, vf))
{
return false;
}
if (FLAC__stream_decoder_process_until_end_of_metadata(vf)) {
// if the metadata callback was called mMetadata should be filled with infos
if (mMetadata) {
SetMetaData(mMetadata, m);
}
}
// clean up stuff, the mMetadata may be used later again so let the decoder free it
FLAC__stream_decoder_finish(vf);
FLAC__stream_decoder_delete(vf);
return true;
}
bool do_test(const char* filename)
{
drge_timer* pTimer = drge_create_timer();
double decodeTimeReference = 1;
#ifndef DISABLE_REFERENCE_FLAC
// Reference first.
reference_data referenceData;
referenceData.pDecodedData = NULL;
referenceData.pDecodedDataWalker = NULL;
referenceData.totalSampleCount = 0;
referenceData.pDecoder = FLAC__stream_decoder_new();
FLAC__stream_decoder_init_file(referenceData.pDecoder, filename, flac__write_callback, flac__metadata_callback, flac__error_callback, &referenceData);
drge_tick_timer(pTimer);
FLAC__stream_decoder_process_until_end_of_stream(referenceData.pDecoder);
decodeTimeReference = drge_tick_timer(pTimer);
#endif
// dr_flac second.
drflac_data drflacData;
drflacData.pDecodedData = NULL;
drflacData.pFlac = drflac_open_file(filename);
drflacData.pDecodedData = malloc((size_t)drflacData.pFlac->totalSampleCount * sizeof(int32_t));
drge_tick_timer(pTimer);
drflac_read_s32(drflacData.pFlac, (size_t)drflacData.pFlac->totalSampleCount, drflacData.pDecodedData);
double decodeTime = drge_tick_timer(pTimer);
(void)decodeTimeReference;
(void)decodeTime;
// Sample-by-Sample comparison.
bool result = true;
#ifndef DISABLE_REFERENCE_FLAC
if (drflacData.pFlac->totalSampleCount != referenceData.totalSampleCount) {
result = false;
printf("TEST FAILED: %s: Total sample count differs. %lld != %lld\n", filename, drflacData.pFlac->totalSampleCount, referenceData.totalSampleCount);
goto finish_test;
}
for (uint64_t i = 0; i < drflacData.pFlac->totalSampleCount; ++i) {
if (drflacData.pDecodedData[i] != referenceData.pDecodedData[i]) {
result = false;
printf("TEST FAILED: %s: Sample at %lld differs. %d != %d\n", filename, i, drflacData.pDecodedData[i], referenceData.pDecodedData[i]);
goto finish_test;
}
}
printf("Reference Time: %f : dr_flac Time: %f - %d%%\n", decodeTimeReference, decodeTime, (int)(decodeTime/decodeTimeReference*100));
finish_test:
free(referenceData.pDecodedData);
free(drflacData.pDecodedData);
#endif
return result;
}
static void init()
{
decoder_ = FLAC__stream_decoder_new();
strcpy(lastfn_, "");
InitConfig();
ReadConfig();
InitInfobox();
}
FLAC__bool populate_seekpoint_values(const char *filename, FLAC__StreamMetadata *block, FLAC__bool *needs_write)
{
FLAC__StreamDecoder *decoder;
ClientData client_data;
FLAC__bool ok = true;
FLAC__ASSERT(0 != block);
FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_SEEKTABLE);
client_data.seektable_template = &block->data.seek_table;
client_data.samples_written = 0;
/* client_data.audio_offset must be determined later */
client_data.first_seekpoint_to_check = 0;
client_data.error_occurred = false;
decoder = FLAC__stream_decoder_new();
if(0 == decoder) {
fprintf(stderr, "%s: ERROR (--add-seekpoint) creating the decoder instance\n", filename);
return false;
}
FLAC__stream_decoder_set_md5_checking(decoder, false);
FLAC__stream_decoder_set_metadata_ignore_all(decoder);
if(FLAC__stream_decoder_init_file(decoder, filename, write_callback_, /*metadata_callback=*/0, error_callback_, &client_data) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
fprintf(stderr, "%s: ERROR (--add-seekpoint) initializing the decoder instance (%s)\n", filename, FLAC__stream_decoder_get_resolved_state_string(decoder));
ok = false;
}
if(ok && !FLAC__stream_decoder_process_until_end_of_metadata(decoder)) {
fprintf(stderr, "%s: ERROR (--add-seekpoint) decoding file (%s)\n", filename, FLAC__stream_decoder_get_resolved_state_string(decoder));
ok = false;
}
if(ok && !FLAC__stream_decoder_get_decode_position(decoder, &client_data.audio_offset)) {
fprintf(stderr, "%s: ERROR (--add-seekpoint) decoding file\n", filename);
ok = false;
}
client_data.last_offset = client_data.audio_offset;
if(ok && !FLAC__stream_decoder_process_until_end_of_stream(decoder)) {
fprintf(stderr, "%s: ERROR (--add-seekpoint) decoding file (%s)\n", filename, FLAC__stream_decoder_get_resolved_state_string(decoder));
ok = false;
}
if(ok && client_data.error_occurred) {
fprintf(stderr, "%s: ERROR (--add-seekpoint) decoding file (%u:%s)\n", filename, (unsigned)client_data.error_status, FLAC__StreamDecoderErrorStatusString[client_data.error_status]);
ok = false;
}
*needs_write = true;
FLAC__stream_decoder_delete(decoder);
return ok;
}
/**
* Main.
*/
int main(int argc, char *argv[])
{
FLAC__bool ok = true;
FLAC__StreamDecoder* decoder = 0;
FLAC__StreamDecoderInitStatus init_status;
// init system
SystemInit();
RCC_configure();
GPIO_configure();
//TODO
// setup UART, LEDs, SDIO, I2S, etc
// setup decoder
if((decoder = FLAC__stream_decoder_new()) == NULL) {
fprintf(stderr, "ERROR: allocating decoder\n");
return 1;
}
// optional MD5 check. How much cycles does this cost?
//FLAC__stream_decoder_set_md5_checking(decoder, true);
// init decoder
void* client_data = 0; //TODO
init_status = FLAC__stream_decoder_init_stream(decoder,
read_callback,
seek_callback,
tell_callback,
length_callback,
eof_callback,
write_callback,
metadata_callback,
error_callback,
client_data);
if (init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
fprintf(stderr, "ERROR: initializing decoder: %s\n", FLAC__StreamDecoderInitStatusString[init_status]);
ok = false;
}
if (ok) {
ok = FLAC__stream_decoder_process_until_end_of_stream(decoder);
fprintf(stderr, "decoding: %s\n", ok? "succeeded" : "FAILED");
fprintf(stderr, " state: %s\n", FLAC__StreamDecoderStateString[FLAC__stream_decoder_get_state(decoder)]);
}
// loop forever, just handle IRQs
while(1);
// never called but usefull to know
//FLAC__stream_decoder_delete(decoder);
return 0;
}
int __stdcall
Flac2Wav(const char *fromFlacPath, const char *toWavPath)
{
int result = F2WRT_Success;
FLAC__bool ok = true;
FLAC__StreamDecoder *decoder = NULL;
FLAC__StreamDecoderInitStatus init_status;
FlacDecodeArgs args;
memset(&args, 0, sizeof args);
args.errorCode = F2WRT_OtherError;
args.fout = fopen(toWavPath, "wb");
if (args.fout == NULL) {
result = F2WRT_WriteOpenFailed;
goto end;
}
decoder = FLAC__stream_decoder_new();
if(decoder == NULL) {
result = F2WRT_FlacStreamDecoderNewFailed;
goto end;
}
FLAC__stream_decoder_set_md5_checking(decoder, true);
init_status = FLAC__stream_decoder_init_file(
decoder, fromFlacPath, WriteCallback, MetadataCallback, ErrorCallback, &args);
if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
result = F2WRT_FlacStreamDecoderInitFailed;
goto end;
}
ok = FLAC__stream_decoder_process_until_end_of_stream(decoder);
if (!ok) {
result = args.errorCode;
goto end;
}
result = F2WRT_Success;
end:
if (NULL != decoder) {
FLAC__stream_decoder_delete(decoder);
decoder = NULL;
}
if (NULL != args.fout) {
fclose(args.fout);
args.fout = NULL;
}
return result;
}
static void flac_get_size (struct cdtoc *t)
{
FLAC__StreamDecoder *decoder = FLAC__stream_decoder_new ();
if (decoder) {
FLAC__stream_decoder_set_md5_checking (decoder, false);
int init_status = FLAC__stream_decoder_init_stream (decoder,
&file_read_callback, &file_seek_callback, &file_tell_callback,
&file_len_callback, &file_eof_callback,
&flac_write_callback, &flac_metadata_callback, &flac_error_callback, t);
FLAC__stream_decoder_process_until_end_of_metadata (decoder);
FLAC__stream_decoder_delete (decoder);
}
}
FlacDecoder::FlacDecoder()
: decoder(nullptr)
, outputBufferSize(0)
, outputBufferUsed(0)
, outputBuffer(nullptr)
, channels(0)
, sampleRate(0)
, bitsPerSample(0)
, totalSamples(0)
, duration(-1.0f)
, exhausted(false) {
this->decoder = FLAC__stream_decoder_new();
}
static void flacdecode_init(struct xlplayer *xlplayer)
{
struct flacdecode_vars *self = xlplayer->dec_data;
int src_error;
if (!(self->decoder = FLAC__stream_decoder_new()))
{
fprintf(stderr, "flacdecode_init: %s could not initialise flac decoder\n", xlplayer->playername);
goto cleanup;
}
if (FLAC__stream_decoder_init_file(self->decoder, xlplayer->pathname, flac_writer_callback, NULL, flac_error_callback, xlplayer) != FLAC__STREAM_DECODER_INIT_STATUS_OK)
{
fprintf(stderr, "flacdecode_init: %s error during flac player initialisation\n", xlplayer->playername);
FLAC__stream_decoder_delete(self->decoder);
goto cleanup;
}
if (xlplayer->seek_s)
{
self->suppress_audio_output = TRUE; /* prevent seek noise */
FLAC__stream_decoder_seek_absolute(self->decoder, ((FLAC__uint64)xlplayer->seek_s) * ((FLAC__uint64)self->metainfo.data.stream_info.sample_rate));
self->suppress_audio_output = FALSE;
}
if ((self->resample_f = (self->metainfo.data.stream_info.sample_rate != xlplayer->samplerate)))
{
fprintf(stderr, "flacdecode_init: %s configuring resampler\n", xlplayer->playername);
xlplayer->src_state = src_new(xlplayer->rsqual, self->metainfo.data.stream_info.channels, &src_error);
if (src_error)
{
fprintf(stderr, "flacdecode_init: %s src_new reports - %s\n", xlplayer->playername, src_strerror(src_error));
FLAC__stream_decoder_delete(self->decoder);
goto cleanup;
}
xlplayer->src_data.output_frames = 0;
xlplayer->src_data.data_in = xlplayer->src_data.data_out = NULL;
xlplayer->src_data.src_ratio = (double)xlplayer->samplerate / (double)self->metainfo.data.stream_info.sample_rate;
xlplayer->src_data.end_of_input = 0;
self->totalsamples = self->metainfo.data.stream_info.total_samples;
}
else
xlplayer->src_state = NULL;
self->suppress_audio_output = FALSE;
self->flbuf = NULL;
return;
cleanup:
free(self);
xlplayer->playmode = PM_STOPPED;
xlplayer->command = CMD_COMPLETE;
}
/**
* Some glue code around FLAC__stream_decoder_new().
*/
static FLAC__StreamDecoder *
flac_decoder_new(void)
{
FLAC__StreamDecoder *sd = FLAC__stream_decoder_new();
if (sd == NULL) {
g_warning("FLAC__stream_decoder_new() failed");
return NULL;
}
#if defined(FLAC_API_VERSION_CURRENT) && FLAC_API_VERSION_CURRENT > 7
if(!FLAC__stream_decoder_set_metadata_respond(sd, FLAC__METADATA_TYPE_VORBIS_COMMENT))
g_debug("FLAC__stream_decoder_set_metadata_respond() has failed");
#endif
return sd;
}
static void LongSound_init (LongSound me, MelderFile file) {
MelderFile_copy (file, & my file);
MelderFile_open (file); // BUG: should be auto, but that requires an implemented .transfer()
my f = file -> filePointer;
my audioFileType = MelderFile_checkSoundFile (file, & my numberOfChannels, & my encoding, & my sampleRate, & my startOfData, & my nx);
if (my audioFileType == 0)
Melder_throw (U"File not recognized (LongSound only supports AIFF, AIFC, WAV, NeXT/Sun, NIST and FLAC).");
if (my encoding == Melder_SHORTEN || my encoding == Melder_POLYPHONE)
Melder_throw (U"LongSound does not support sound files compressed with \"shorten\".");
if (my nx < 1)
Melder_throw (U"Audio file contains 0 samples.");
my xmin = 0.0;
my dx = 1 / my sampleRate;
my xmax = my nx * my dx;
my x1 = 0.5 * my dx;
my numberOfBytesPerSamplePoint = Melder_bytesPerSamplePoint (my encoding);
my bufferLength = prefs_bufferLength;
for (;;) {
my nmax = my bufferLength * my numberOfChannels * my sampleRate * (1 + 3 * MARGIN);
try {
my buffer = NUMvector <int16> (0, my nmax * my numberOfChannels);
break;
} catch (MelderError) {
my bufferLength *= 0.5; // try 30, 15, or 7.5 seconds
if (my bufferLength < 5.0) // too short to be good
throw;
Melder_clearError (); // delete out-of-memory message
}
}
my imin = 1;
my imax = 0;
my flacDecoder = nullptr;
if (my audioFileType == Melder_FLAC) {
my flacDecoder = FLAC__stream_decoder_new ();
FLAC__stream_decoder_init_FILE (my flacDecoder, my f, _LongSound_FLAC_write, nullptr, _LongSound_FLAC_error, me);
}
my mp3f = nullptr;
if (my audioFileType == Melder_MP3) {
my mp3f = mp3f_new ();
mp3f_set_file (my mp3f, my f);
mp3f_set_callback (my mp3f, _LongSound_MP3_convert, me);
if (! mp3f_analyze (my mp3f))
Melder_throw (U"Unable to analyze MP3 file.");
Melder_warning (U"Time measurements in MP3 files can be off by several tens of milliseconds. "
U"Please convert to WAV file if you need time precision or annotation.");
}
}
FlacReader::FlacReader( MemoryIo* source )
: m_bitdepth( 0 )
, m_channels( 0 )
, m_samplerate( 0 )
, m_decoder( 0 )
, m_source( source )
, m_sourcepos( 0 )
, m_totalsamples( 0 )
{
m_decoder = FLAC__stream_decoder_new();
if( !m_decoder )
{
throw std::runtime_error( "failed to create the flac decoder" );
}
FLAC__StreamDecoderInitStatus status = FLAC__stream_decoder_init_stream(
m_decoder,
&FlacReader::read_callback,
&FlacReader::seek_callback,
&FlacReader::tell_callback,
&FlacReader::length_callback,
&FlacReader::eof_callback,
&FlacReader::write_callback,
0,
&FlacReader::error_callback,
this );
if( status != FLAC__STREAM_DECODER_INIT_STATUS_OK )
{
FLAC__stream_decoder_delete( m_decoder );
throw std::runtime_error(
FLAC__StreamDecoderInitStatusString[ status ] );
}
if( !FLAC__stream_decoder_process_until_end_of_stream( m_decoder ) )
{
FLAC__StreamDecoderState state =
FLAC__stream_decoder_get_state( m_decoder );
FLAC__stream_decoder_delete( m_decoder );
if( m_error )
{
throw StrException( m_error );
}
else
{
throw std::runtime_error(
FLAC__StreamDecoderStateString[ state ] );
}
}
}
FlacDecoder::FlacDecoder():
MusicDecoder("FlacDecoder"),
_streamdecoder(NULL),
_file(NULL),
_data(NULL),
_dataindex(0),
_datasize(0),
_bufferpos(0),
_opened(false),
_ended(true),
_error(false)
{
_streamdecoder=FLAC__stream_decoder_new();
assert(_streamdecoder);
FLAC__stream_decoder_set_metadata_respond(_streamdecoder,FLAC__METADATA_TYPE_STREAMINFO);
FLAC__stream_decoder_set_metadata_respond(_streamdecoder,FLAC__METADATA_TYPE_VORBIS_COMMENT);
}
// soundsource overrides
Result SoundSourceFLAC::open() {
if (!m_file.open(QIODevice::ReadOnly)) {
qWarning() << "SSFLAC: Could not read file!";
return ERR;
}
m_decoder = FLAC__stream_decoder_new();
if (m_decoder == NULL) {
qWarning() << "SSFLAC: decoder allocation failed!";
return ERR;
}
FLAC__StreamDecoderInitStatus initStatus(
FLAC__stream_decoder_init_stream(
m_decoder, FLAC_read_cb, FLAC_seek_cb, FLAC_tell_cb, FLAC_length_cb,
FLAC_eof_cb, FLAC_write_cb, FLAC_metadata_cb, FLAC_error_cb,
(void*) this)
);
if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
qWarning() << "SSFLAC: decoder init failed!";
goto decoderError;
}
if (!FLAC__stream_decoder_process_until_end_of_metadata(m_decoder)) {
qWarning() << "SSFLAC: process to end of meta failed!";
qWarning() << "SSFLAC: decoder state: " << FLAC__stream_decoder_get_state(m_decoder);
goto decoderError;
} // now number of samples etc. should be populated
if (m_flacBuffer == NULL) {
// we want 2 samples per frame, see ::flacWrite code -- bkgood
m_flacBuffer = new FLAC__int16[m_maxBlocksize * 2 /*m_iChannels*/];
}
if (m_leftoverBuffer == NULL) {
m_leftoverBuffer = new FLAC__int16[m_maxBlocksize * 2 /*m_iChannels*/];
}
// qDebug() << "SSFLAC: Total samples: " << m_samples;
// qDebug() << "SSFLAC: Sampling rate: " << m_iSampleRate << " Hz";
// qDebug() << "SSFLAC: Channels: " << m_iChannels;
// qDebug() << "SSFLAC: BPS: " << m_bps;
return OK;
decoderError:
FLAC__stream_decoder_finish(m_decoder);
FLAC__stream_decoder_delete(m_decoder);
m_decoder = NULL;
qWarning() << "SSFLAC: Decoder error at file" << m_qFilename;
return ERR;
}
static uae_u8 *flac_get_data (struct cdtoc *t)
{
write_log (_T("FLAC: unpacking '%s'..\n"), zfile_getname (t->handle));
t->writeoffset = 0;
FLAC__StreamDecoder *decoder = FLAC__stream_decoder_new ();
if (decoder) {
FLAC__stream_decoder_set_md5_checking (decoder, false);
int init_status = FLAC__stream_decoder_init_stream (decoder,
&file_read_callback, &file_seek_callback, &file_tell_callback,
&file_len_callback, &file_eof_callback,
&flac_write_callback, &flac_metadata_callback, &flac_error_callback, t);
FLAC__stream_decoder_process_until_end_of_stream (decoder);
FLAC__stream_decoder_delete (decoder);
write_log (_T("FLAC: %s unpacked\n"), zfile_getname (t->handle));
}
return t->data;
}
static int play_flac(lua_State *lstate) {
FLAC_FEED *feed;
char buf[BLOCKSIZE];
int port, sock;
char *mark;
const char *host, *mount;
lua_pushstring(lstate, "host");
lua_gettable(lstate, -2);
lua_pushstring(lstate, "port");
lua_gettable(lstate, -3);
lua_pushstring(lstate, "mount");
lua_gettable(lstate, -4);
mount = lua_tostring(lstate, -1);
port = lua_tointeger(lstate, -2);
host = lua_tostring(lstate, -3);
sock = stream_connect(host, port, mount, buf, &mark);
lua_pop(lstate, 3);
if (sock == 0) {
lua_pop(lstate, 1);
return 0;
}
lua_pushstring(lstate, "intern");
lua_gettable(lstate, -2);
feed = (FLAC_FEED *)lua_touserdata(lstate, -1);
lua_pop(lstate, 1);
feed->base.sock = sock;
pthread_mutex_init(&(feed->base.thread_lock), NULL);
pthread_cond_init(&(feed->base.data_ready), NULL);
feed->decoder = FLAC__stream_decoder_new();
FLAC__stream_decoder_set_md5_checking(feed->decoder, false);
FLAC__stream_decoder_init_ogg_stream(feed->decoder,
flac_read,
NULL, //seek_callback,
NULL, // tell_callback,
NULL, //length_callback,
NULL, // eof_callback,
flac_write,
flac_metadata,
flac_error,
(void *)feed);
lua_pop(lstate, 1);
pthread_create(&(feed->base.thread_id), NULL, flac_thread, feed);
return 0;
}
int main(int argc, char *argv[])
{
FLAC__bool ok = true;
FLAC__StreamDecoder *decoder = 0;
FLAC__StreamDecoderInitStatus init_status;
FILE *fout;
if(argc != 3) {
fprintf(stderr, "usage: %s infile.flac outfile.wav\n", argv[0]);
return 1;
}
if((fout = fopen(argv[2], "wb")) == NULL) {
fprintf(stderr, "ERROR: opening %s for output\n", argv[2]);
return 1;
}
if((decoder = FLAC__stream_decoder_new()) == NULL) {
fprintf(stderr, "ERROR: allocating decoder\n");
fclose(fout);
return 1;
}
(void)FLAC__stream_decoder_set_md5_checking(decoder, true);
init_status = FLAC__stream_decoder_init_file(decoder, argv[1], write_callback, metadata_callback, error_callback, /*client_data=*/fout);
if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
fprintf(stderr, "ERROR: initializing decoder: %s\n", FLAC__StreamDecoderInitStatusString[init_status]);
ok = false;
}
if(ok) {
ok = FLAC__stream_decoder_process_until_end_of_stream(decoder);
fprintf(stderr, "decoding: %s\n", ok? "succeeded" : "FAILED");
fprintf(stderr, " state: %s\n", FLAC__StreamDecoderStateString[FLAC__stream_decoder_get_state(decoder)]);
}
FLAC__stream_decoder_delete(decoder);
fclose(fout);
return 0;
}
void GarlickDecodeFlac(GarlickFile *gf) {
const char * zz = FLAC__VERSION_STRING;
//prepare flac
FLAC__StreamDecoder *decoder = FLAC__stream_decoder_new();
FLAC__stream_decoder_init_stream(decoder, GarlickDecodeFlac_Read, 0, 0, 0, 0, GarlickDecodeFlac_Write, GarlickDecodeFlac_Metadata, GarickDecodeFlac_Error, (void*)gf);
//read the size of the flac stream
Garlick_cb_read(&gf->flac_in_counter,1,4,gf->lib);
//prep the output buffer
GarlickEnsureBuffer(gf, gf->chunkleft);
gf->buf_counter = 0;
//decode and finish
FLAC__stream_decoder_process_until_end_of_stream(decoder);
FLAC__stream_decoder_finish(decoder);
FLAC__stream_decoder_delete(decoder);
printf("%d - %d - %d\n",gf->encode_mode, gf->buf_counter,gf->chunkleft);
gf->buf_counter = 0;
}
FLAC__SeekableStreamDecoder *FLAC__seekable_stream_decoder_new()
{
FLAC__SeekableStreamDecoder *decoder;
FLAC__ASSERT(sizeof(int) >= 4); /* we want to die right away if this is not true */
decoder = (FLAC__SeekableStreamDecoder*)malloc(sizeof(FLAC__SeekableStreamDecoder));
if(decoder == 0) {
return 0;
}
memset(decoder, 0, sizeof(FLAC__SeekableStreamDecoder));
decoder->protected_ = (FLAC__SeekableStreamDecoderProtected*)malloc(sizeof(FLAC__SeekableStreamDecoderProtected));
if(decoder->protected_ == 0) {
free(decoder);
return 0;
}
memset(decoder->protected_, 0, sizeof(FLAC__SeekableStreamDecoderProtected));
decoder->private_ = (FLAC__SeekableStreamDecoderPrivate*)malloc(sizeof(FLAC__SeekableStreamDecoderPrivate));
if(decoder->private_ == 0) {
free(decoder->protected_);
free(decoder);
return 0;
}
memset(decoder->private_, 0, sizeof(FLAC__SeekableStreamDecoderPrivate));
decoder->private_->stream_decoder = FLAC__stream_decoder_new();
if(0 == decoder->private_->stream_decoder) {
free(decoder->private_);
free(decoder->protected_);
free(decoder);
return 0;
}
set_defaults_(decoder);
decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED;
return decoder;
}
bool OAFLACReader::isValid(const SPtr<DataStream>& stream, UINT32 offset)
{
stream->seek(offset);
FLAC__StreamDecoder* decoder = FLAC__stream_decoder_new();
if (!decoder)
return false;
FLACDecoderData data;
data.stream = stream;
mData.streamOffset = offset;
FLAC__stream_decoder_init_stream(decoder, &streamRead, &streamSeek, &streamTell, &streamLength, &streamEof,
&streamWrite, nullptr, &streamError, &data);
bool valid = FLAC__stream_decoder_process_until_end_of_metadata(decoder) != 0;
FLAC__stream_decoder_finish(decoder);
FLAC__stream_decoder_delete(decoder);
return valid && !data.error;
}
int flac_open(FILE *in,oe_enc_opt *opt,unsigned char *oldbuf,int buflen){
flacfile *flac;
/*Ok. At this point, we know we have a FLAC or an OggFLAC file.
Set up the FLAC decoder.*/
flac=malloc(sizeof(*flac));
flac->decoder=FLAC__stream_decoder_new();
FLAC__stream_decoder_set_md5_checking(flac->decoder,false);
/*We get STREAMINFO packets by default, but not VORBIS_COMMENT or PICTURE.*/
FLAC__stream_decoder_set_metadata_respond(flac->decoder,
FLAC__METADATA_TYPE_VORBIS_COMMENT);
FLAC__stream_decoder_set_metadata_respond(flac->decoder,
FLAC__METADATA_TYPE_PICTURE);
flac->inopt=opt;
flac->f=in;
flac->oldbuf=malloc(buflen*sizeof(*flac->oldbuf));
memcpy(flac->oldbuf,oldbuf,buflen*sizeof(*flac->oldbuf));
flac->bufpos=0;
flac->buflen=buflen;
flac->block_buf=NULL;
if((*(flac_id(oldbuf,buflen)?
FLAC__stream_decoder_init_stream:FLAC__stream_decoder_init_ogg_stream))(
flac->decoder,read_callback,NULL,NULL,NULL,eof_callback,
write_callback,metadata_callback,error_callback,flac)==
FLAC__STREAM_DECODER_INIT_STATUS_OK){
/*Decode until we get the file length, sample rate, the number of channels,
and the Vorbis comments (if any).*/
if(FLAC__stream_decoder_process_until_end_of_metadata(flac->decoder)){
opt->read_samples=flac_read;
opt->readdata=flac;
/*FLAC supports 1 to 8 channels only.*/
speex_assert(flac->channels>0&&flac->channels<=8);
/*It uses the same channel mappings as WAV.*/
flac->channel_permute=wav_permute_matrix[flac->channels-1];
return 1;
}
}
flac_close(flac);
fprintf(stderr,_("ERROR: Could not open FLAC stream.\n"));
return 0;
}
