自学教程：C++ FLAC__stream_decoder_new函数代码示例

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 gbooleangst_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 __stdcallFlac2Wav(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 overridesResult 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;}

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