From fd3b2704efc2b206784615c1a23eb25501842259 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Thu, 5 Sep 2024 15:14:37 +0200 Subject: Adding upstream version 1.4.3+ds. Signed-off-by: Daniel Baumann --- examples/cpp/decode/file/main.cpp | 195 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 195 insertions(+) create mode 100644 examples/cpp/decode/file/main.cpp (limited to 'examples/cpp/decode/file/main.cpp') diff --git a/examples/cpp/decode/file/main.cpp b/examples/cpp/decode/file/main.cpp new file mode 100644 index 0000000..d1c2995 --- /dev/null +++ b/examples/cpp/decode/file/main.cpp @@ -0,0 +1,195 @@ +/* example_cpp_decode_file - Simple FLAC file decoder using libFLAC + * Copyright (C) 2007-2009 Josh Coalson + * Copyright (C) 2011-2023 Xiph.Org Foundation + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +/* + * This example shows how to use libFLAC++ to decode a FLAC file to a WAVE + * file. It only supports 16-bit stereo files. + * + * Complete API documentation can be found at: + * http://xiph.org/flac/api/ + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include + +#include "FLAC++/decoder.h" +#include "share/compat.h" + +static FLAC__uint64 total_samples = 0; +static uint32_t sample_rate = 0; +static uint32_t channels = 0; +static uint32_t bps = 0; + +static bool write_little_endian_uint16(FILE *f, FLAC__uint16 x) +{ + return + fputc(x, f) != EOF && + fputc(x >> 8, f) != EOF + ; +} + +static bool write_little_endian_int16(FILE *f, FLAC__int16 x) +{ + return write_little_endian_uint16(f, (FLAC__uint16)x); +} + +static bool write_little_endian_uint32(FILE *f, FLAC__uint32 x) +{ + return + fputc(x, f) != EOF && + fputc(x >> 8, f) != EOF && + fputc(x >> 16, f) != EOF && + fputc(x >> 24, f) != EOF + ; +} + +class OurDecoder: public FLAC::Decoder::File { +public: + OurDecoder(FILE *f_): FLAC::Decoder::File(), f(f_) { } +protected: + FILE *f; + + virtual ::FLAC__StreamDecoderWriteStatus write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[]); + virtual void metadata_callback(const ::FLAC__StreamMetadata *metadata); + virtual void error_callback(::FLAC__StreamDecoderErrorStatus status); +private: + OurDecoder(const OurDecoder&); + OurDecoder&operator=(const OurDecoder&); +}; + +int main(int argc, char *argv[]) +{ + bool ok = true; + 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; + } + + OurDecoder decoder(fout); + + if(!decoder) { + fprintf(stderr, "ERROR: allocating decoder\n"); + fclose(fout); + return 1; + } + + (void)decoder.set_md5_checking(true); + + FLAC__StreamDecoderInitStatus init_status = decoder.init(argv[1]); + 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 = decoder.process_until_end_of_stream(); + fprintf(stderr, "decoding: %s\n", ok? "succeeded" : "FAILED"); + fprintf(stderr, " state: %s\n", decoder.get_state().resolved_as_cstring(decoder)); + } + + fclose(fout); + + return 0; +} + +::FLAC__StreamDecoderWriteStatus OurDecoder::write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[]) +{ + const FLAC__uint32 total_size = (FLAC__uint32)(total_samples * channels * (bps/8)); + size_t i; + + // Update data + channels = OurDecoder::get_channels(); + bps = OurDecoder::get_bits_per_sample(); + + if(total_samples == 0) { + fprintf(stderr, "ERROR: this example only works for FLAC files that have a total_samples count in STREAMINFO\n"); + return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; + } + if(channels != 2 || bps != 16) { + fprintf(stderr, "ERROR: this example only supports 16bit stereo streams\n"); + return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; + } + + /* write WAVE header before we write the first frame */ + if(frame->header.number.sample_number == 0) { + if( + fwrite("RIFF", 1, 4, f) < 4 || + !write_little_endian_uint32(f, total_size + 36) || + fwrite("WAVEfmt ", 1, 8, f) < 8 || + !write_little_endian_uint32(f, 16) || + !write_little_endian_uint16(f, 1) || + !write_little_endian_uint16(f, (FLAC__uint16)channels) || + !write_little_endian_uint32(f, sample_rate) || + !write_little_endian_uint32(f, sample_rate * channels * (bps/8)) || + !write_little_endian_uint16(f, (FLAC__uint16)(channels * (bps/8))) || /* block align */ + !write_little_endian_uint16(f, (FLAC__uint16)bps) || + fwrite("data", 1, 4, f) < 4 || + !write_little_endian_uint32(f, total_size) + ) { + fprintf(stderr, "ERROR: write error\n"); + return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; + } + } + + /* write decoded PCM samples */ + for(i = 0; i < frame->header.blocksize; i++) { + if( + !write_little_endian_int16(f, (FLAC__int16)buffer[0][i]) || /* left channel */ + !write_little_endian_int16(f, (FLAC__int16)buffer[1][i]) /* right channel */ + ) { + fprintf(stderr, "ERROR: write error\n"); + return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; + } + } + + return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; +} + +void OurDecoder::metadata_callback(const ::FLAC__StreamMetadata *metadata) +{ + /* print some stats */ + if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) { + /* save for later */ + total_samples = metadata->data.stream_info.total_samples; + sample_rate = metadata->data.stream_info.sample_rate; + channels = metadata->data.stream_info.channels; + bps = metadata->data.stream_info.bits_per_sample; + + fprintf(stderr, "sample rate : %u Hz\n", sample_rate); + fprintf(stderr, "channels : %u\n", channels); + fprintf(stderr, "bits per sample: %u\n", bps); + fprintf(stderr, "total samples : %" PRIu64 "\n", total_samples); + } +} + +void OurDecoder::error_callback(::FLAC__StreamDecoderErrorStatus status) +{ + fprintf(stderr, "Got error callback: %s\n", FLAC__StreamDecoderErrorStatusString[status]); +} -- cgit v1.2.3