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;
}
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 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;
}
static prMALError
SDKCloseFile(
imStdParms *stdParms,
imFileRef *file,
PrivateDataH pdH)
{
if (file && *file) //If we have a file handle, close it
{
SDKQuietFile (stdParms, file, pdH);
}
if (pdH) //If we have private data, release it and clean up
{
(*pdH)->suiteBasic->ReleaseSuite(kPrSDKAudioSuite, kPrSDKAudioSuiteVersion);
if((*pdH)->flacDecoder != NULL)
{
FLAC__stream_decoder_finish((*pdH)->flacDecoder);
FLAC__stream_decoder_delete((*pdH)->flacDecoder);
}
if((*pdH)->audioConversionBuffer)
{
stdParms->piSuites->memFuncs->disposePtr((*pdH)->audioConversionBuffer);
}
stdParms->piSuites->memFuncs->disposeHandle(reinterpret_cast<char**>(pdH));
}
return malNoError;
}
FlacReader::~FlacReader()
{
if( m_decoder )
{
FLAC__stream_decoder_delete( m_decoder );
}
}
FLACInputStream::~FLACInputStream() {
if (m_decoder) {
FLAC__stream_decoder_finish(m_decoder);
FLAC__stream_decoder_delete(m_decoder);
m_decoder = 0;
}
}
void safe_decoder_delete_(FLAC__StreamDecoder *decoder)
{
if(decoder) {
safe_decoder_finish_(decoder);
FLAC__stream_decoder_delete(decoder);
}
}
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();
}
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 ] );
}
}
}
FLACParser::~FLACParser()
{
LOGV("FLACParser::~FLACParser");
if (mDecoder != NULL) {
FLAC__stream_decoder_delete(mDecoder);
mDecoder = NULL;
}
}
void flac_close(void *client_data){
flacfile *flac;
flac=(flacfile *)client_data;
free(flac->block_buf);
free(flac->oldbuf);
FLAC__stream_decoder_delete(flac->decoder);
free(flac);
}
void FLAC_plugin__decoder_delete(FLAC__StreamDecoder *decoder)
{
if (decoder)
{
FLAC_plugin__decoder_finish(decoder);
FLAC__stream_decoder_delete(decoder);
}
}
static int stop_read(sox_format_t * const ft)
{
priv_t * p = (priv_t *)ft->priv;
if (!FLAC__stream_decoder_finish(p->decoder) && p->eof)
lsx_warn("decoder MD5 checksum mismatch.");
FLAC__stream_decoder_delete(p->decoder);
return SOX_SUCCESS;
}
static void free_flac(FEED *feed) {
FLAC_FEED *ffeed;
if (feed == NULL) return;
ffeed = (FLAC_FEED *)feed;
FLAC__stream_decoder_delete(ffeed->decoder);
free_feed(feed);
return;
}
void OAFLACReader::close()
{
if (mDecoder != nullptr)
{
FLAC__stream_decoder_finish(mDecoder);
FLAC__stream_decoder_delete(mDecoder);
mDecoder = nullptr;
}
}
void EasyFLAC__stream_decoder_delete(EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
OggFLAC__stream_decoder_delete(decoder->oggflac);
else
FLAC__stream_decoder_delete(decoder->flac);
free(decoder);
}
void SoundSourceFLAC::close() {
if (m_decoder) {
FLAC__stream_decoder_finish(m_decoder);
FLAC__stream_decoder_delete(m_decoder); // frees memory
m_decoder = nullptr;
}
m_file.close();
}
FlacDecoder::~FlacDecoder() {
if (this->decoder) {
FLAC__stream_decoder_delete(this->decoder);
this->decoder = nullptr;
}
delete this->outputBuffer;
this->outputBuffer = nullptr;
}
void SoundFileReaderFlac::close()
{
if (m_decoder)
{
FLAC__stream_decoder_finish(m_decoder);
FLAC__stream_decoder_delete(m_decoder);
m_decoder = NULL;
}
}
flac_header_extractor_c::~flac_header_extractor_c() {
FLAC__stream_decoder_reset(decoder);
FLAC__stream_decoder_delete(decoder);
ogg_sync_clear(&oy);
ogg_stream_clear(&os);
delete file;
}
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;
}
FlacDecoder::~FlacDecoder()
{
if (_opened)
{
FLAC__stream_decoder_finish(_streamdecoder);
if (_file)
{
fclose(_file);
}
}
FLAC__stream_decoder_delete(_streamdecoder);
}
static void
flac_decode_internal(struct decoder * decoder,
struct input_stream *input_stream,
bool is_ogg)
{
FLAC__StreamDecoder *flac_dec;
struct flac_data data;
flac_dec = flac_decoder_new();
if (flac_dec == NULL)
return;
flac_data_init(&data, decoder, input_stream);
data.tag = tag_new();
FLAC__StreamDecoderInitStatus status =
stream_init(flac_dec, &data, is_ogg);
if (status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
flac_data_deinit(&data);
FLAC__stream_decoder_delete(flac_dec);
#if defined(FLAC_API_VERSION_CURRENT) && FLAC_API_VERSION_CURRENT > 7
g_warning("%s", FLAC__StreamDecoderInitStatusString[status]);
#endif
return;
}
if (!flac_decoder_initialize(&data, flac_dec, 0)) {
flac_data_deinit(&data);
FLAC__stream_decoder_finish(flac_dec);
FLAC__stream_decoder_delete(flac_dec);
return;
}
flac_decoder_loop(&data, flac_dec, 0, 0);
flac_data_deinit(&data);
FLAC__stream_decoder_finish(flac_dec);
FLAC__stream_decoder_delete(flac_dec);
}
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);
}
}
int close_flac(void* in){
flac_file_t* flac_file = (flac_file_t*)in;
int i;
for (i = 0; i < flac_file->channels; i++){
free(flac_file->buf[i]);
}
free(flac_file->buf);
FLAC__stream_decoder_finish(flac_file->stream_decoder);
FLAC__stream_decoder_delete(flac_file->stream_decoder);
//free(flac);
return 0;
}
static bool DecodeFLAC(FILE *f, FILE *of)
{
fseek(f, 0, SEEK_SET);
FLAC__StreamDecoder *decoder = FLAC__stream_decoder_new();
if(decoder == nullptr)
{
return false;
}
FLAC__stream_decoder_set_metadata_respond_all(decoder);
FLACClientData client;
client.of = of;
client.started = false;
client.encoder = FLAC__stream_encoder_new();
FLAC__StreamDecoderInitStatus initStatus = FLAC__stream_decoder_init_FILE(decoder, f, write_cb, metadata_cb, error_cb, &client);
if(initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK || client.encoder == nullptr)
{
FLAC__stream_decoder_delete(decoder);
return false;
}
FLAC__stream_decoder_process_until_end_of_stream(decoder);
FLAC__stream_decoder_finish(decoder);
FLAC__stream_decoder_delete(decoder);
FLAC__stream_encoder_finish(client.encoder);
FLAC__stream_encoder_delete(client.encoder);
for(auto m = client.metadata.begin(); m != client.metadata.end(); m++)
{
FLAC__metadata_object_delete(*m);
}
return client.started;
}
FLAC_API void FLAC__seekable_stream_decoder_delete(FLAC__SeekableStreamDecoder *decoder)
{
FLAC__ASSERT(0 != decoder);
FLAC__ASSERT(0 != decoder->protected_);
FLAC__ASSERT(0 != decoder->private_);
FLAC__ASSERT(0 != decoder->private_->stream_decoder);
(void)FLAC__seekable_stream_decoder_finish(decoder);
FLAC__stream_decoder_delete(decoder->private_->stream_decoder);
free(decoder->private_);
free(decoder->protected_);
free(decoder);
}
void OggFLAC__stream_decoder_delete(OggFLAC__StreamDecoder *decoder)
{
FLAC__ASSERT(0 != decoder);
FLAC__ASSERT(0 != decoder->protected_);
FLAC__ASSERT(0 != decoder->private_);
FLAC__ASSERT(0 != decoder->private_->FLAC_stream_decoder);
OggFLAC__stream_decoder_finish(decoder);
FLAC__stream_decoder_delete(decoder->private_->FLAC_stream_decoder);
free(decoder->private_);
free(decoder->protected_);
free(decoder);
}
SoundSourceFLAC::~SoundSourceFLAC() {
if (m_flacBuffer != NULL) {
delete [] m_flacBuffer;
m_flacBuffer = NULL;
}
if (m_leftoverBuffer != NULL) {
delete [] m_leftoverBuffer;
m_leftoverBuffer = NULL;
}
if (m_decoder) {
FLAC__stream_decoder_finish(m_decoder);
FLAC__stream_decoder_delete(m_decoder); // frees memory
m_decoder = NULL;
}
}
