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

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 voidflac_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 __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);	}}

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