FLAC__bool EasyFLAC__process_until_end_of_stream(EasyFLAC__StreamDecoder *decoder) { if (decoder->is_oggflac) return OggFLAC__stream_decoder_process_until_end_of_stream(decoder->oggflac); else return FLAC__stream_decoder_process_until_end_of_stream(decoder->flac); }
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(); }
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; }
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; }
bool flac_header_extractor_c::extract() { mxverb(2, "flac_header_extraction: extract\n"); if (!read_page()) { mxverb(2, "flac_header_extraction: read_page() failed.\n"); return false; } int result = (int)FLAC__stream_decoder_process_until_end_of_stream(decoder); mxverb(2, boost::format("flac_header_extraction: extract, result: %1%, mdp: %2%, num_header_packets: %3%\n") % result % metadata_parsed % num_header_packets); return metadata_parsed; }
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 ] ); } } }
static void gst_flac_dec_flush (GstAudioDecoder * audio_dec, gboolean hard) { GstFlacDec *dec = GST_FLAC_DEC (audio_dec); if (!hard) { guint available = gst_adapter_available (dec->adapter); if (available > 0) { GST_INFO_OBJECT (dec, "draining, %u bytes left in adapter", available); FLAC__stream_decoder_process_until_end_of_stream (dec->decoder); } } FLAC__stream_decoder_flush (dec->decoder); gst_adapter_clear (dec->adapter); }
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; }
FLAC_API FLAC__bool FLAC__seekable_stream_decoder_process_until_end_of_stream(FLAC__SeekableStreamDecoder *decoder) { FLAC__bool ret; FLAC__ASSERT(0 != decoder); if(decoder->private_->stream_decoder->protected_->state == FLAC__STREAM_DECODER_END_OF_STREAM) decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM; if(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM) return true; FLAC__ASSERT(decoder->protected_->state == FLAC__SEEKABLE_STREAM_DECODER_OK); ret = FLAC__stream_decoder_process_until_end_of_stream(decoder->private_->stream_decoder); if(!ret) decoder->protected_->state = FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR; return ret; }
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; }
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; }
static int private_load_flac ( LISndSample* self, const char* file) { void* buffer; ALenum format; FLAC__uint32 bps; FLAC__uint32 channels; FLAC__uint32 length; FLAC__uint32 rate; FLAC__StreamDecoder* decoder; FLAC__StreamDecoderInitStatus status; LIArcWriter* writer; /* Create decoder. */ decoder = FLAC__stream_decoder_new (); if (decoder == NULL) { lisys_error_set (ENOMEM, NULL); return 0; } /* Allocate temporary storage. */ writer = liarc_writer_new (); if (writer == NULL) { FLAC__stream_decoder_delete (decoder); return 0; } /* Decode file. */ status = FLAC__stream_decoder_init_file (decoder, file, private_flac_stream_callback, NULL, private_flac_error_callback, writer); if (status != FLAC__STREAM_DECODER_INIT_STATUS_OK) { lisys_error_set (EINVAL, "FLAC decoder cannot open file `%s'", file); liarc_writer_free (writer); FLAC__stream_decoder_delete (decoder); return 0; } if (!FLAC__stream_decoder_process_until_end_of_stream (decoder)) { lisys_error_set (EINVAL, "FLAC decoder failed to process file `%s'", file); liarc_writer_free (writer); FLAC__stream_decoder_finish (decoder); FLAC__stream_decoder_delete (decoder); return 0; } /* Stream format. */ bps = FLAC__stream_decoder_get_bits_per_sample (decoder); channels = FLAC__stream_decoder_get_channels (decoder); length = liarc_writer_get_length (writer); rate = FLAC__stream_decoder_get_sample_rate (decoder); /* Upload format. */ if (channels == 1 && bps == 8) format = AL_FORMAT_MONO8; else if (channels == 1 && bps == 16) format = AL_FORMAT_MONO16; else if (channels == 2 && bps == 8) format = AL_FORMAT_STEREO8; else if (channels == 2 && bps == 16) format = AL_FORMAT_STEREO16; else { lisys_error_set (EINVAL, "FLAC stream format unsupported in file `%s'", file); liarc_writer_free (writer); FLAC__stream_decoder_finish (decoder); FLAC__stream_decoder_delete (decoder); return 0; } /* Upload to OpenAL. */ buffer = lisys_calloc (length, sizeof (uint8_t)); if (buffer != NULL) { memcpy (buffer, liarc_writer_get_buffer (writer), length); private_load_raw (self, format, buffer, length, rate); lisys_free (buffer); } /* Finish reading. */ liarc_writer_free (writer); FLAC__stream_decoder_finish (decoder); FLAC__stream_decoder_delete (decoder); return 1; }
FLAC__bool OggFLAC__stream_decoder_process_until_end_of_stream(OggFLAC__StreamDecoder *decoder) { FLAC__ASSERT(0 != decoder); FLAC__ASSERT(0 != decoder->private_); return FLAC__stream_decoder_process_until_end_of_stream(decoder->private_->FLAC_stream_decoder); }
/* read mode: * 0 - no read after seek * 1 - read 2 frames * 2 - read until end */ static FLAC__bool seek_barrage(FLAC__bool is_ogg, const char *filename, off_t filesize, unsigned count, FLAC__int64 total_samples, unsigned read_mode) { FLAC__StreamDecoder *decoder; DecoderClientData decoder_client_data; unsigned i; long int n; decoder_client_data.got_data = false; decoder_client_data.total_samples = 0; decoder_client_data.quiet = false; decoder_client_data.ignore_errors = false; decoder_client_data.error_occurred = false; printf("\n+++ seek test: FLAC__StreamDecoder (%s FLAC, read_mode=%u)\n\n", is_ogg? "Ogg":"native", read_mode); decoder = FLAC__stream_decoder_new(); if(0 == decoder) return die_("FLAC__stream_decoder_new() FAILED, returned NULL\n"); if(is_ogg) { if(FLAC__stream_decoder_init_ogg_file(decoder, filename, write_callback_, metadata_callback_, error_callback_, &decoder_client_data) != FLAC__STREAM_DECODER_INIT_STATUS_OK) return die_s_("FLAC__stream_decoder_init_file() FAILED", decoder); } else { if(FLAC__stream_decoder_init_file(decoder, filename, write_callback_, metadata_callback_, error_callback_, &decoder_client_data) != FLAC__STREAM_DECODER_INIT_STATUS_OK) return die_s_("FLAC__stream_decoder_init_file() FAILED", decoder); } if(!FLAC__stream_decoder_process_until_end_of_metadata(decoder)) return die_s_("FLAC__stream_decoder_process_until_end_of_metadata() FAILED", decoder); if(!is_ogg) { /* not necessary to do this for Ogg because of its seeking method */ /* process until end of stream to make sure we can still seek in that state */ decoder_client_data.quiet = true; if(!FLAC__stream_decoder_process_until_end_of_stream(decoder)) return die_s_("FLAC__stream_decoder_process_until_end_of_stream() FAILED", decoder); decoder_client_data.quiet = false; printf("stream decoder state is %s\n", FLAC__stream_decoder_get_resolved_state_string(decoder)); if(FLAC__stream_decoder_get_state(decoder) != FLAC__STREAM_DECODER_END_OF_STREAM) return die_s_("expected FLAC__STREAM_DECODER_END_OF_STREAM", decoder); } #ifdef _MSC_VER printf("file's total_samples is %I64u\n", decoder_client_data.total_samples); #else printf("file's total_samples is %llu\n", (unsigned long long)decoder_client_data.total_samples); #endif #if !defined _MSC_VER && !defined __MINGW32__ && !defined __EMX__ if (decoder_client_data.total_samples > (FLAC__uint64)RAND_MAX) { printf("ERROR: must be total_samples < %u\n", (unsigned)RAND_MAX); return false; } #endif n = (long int)decoder_client_data.total_samples; if(n == 0 && total_samples >= 0) n = (long int)total_samples; /* if we don't have a total samples count, just guess based on the file size */ /* @@@ for is_ogg we should get it from last page's granulepos */ if(n == 0) { /* 8 would imply no compression, 9 guarantees that we will get some samples off the end of the stream to test that case */ n = 9 * filesize / (decoder_client_data.channels * decoder_client_data.bits_per_sample); #if !defined _MSC_VER && !defined __MINGW32__ if(n > RAND_MAX) n = RAND_MAX; #endif } printf("Begin seek barrage, count=%u\n", count); for (i = 0; !stop_signal_ && (count == 0 || i < count); i++) { FLAC__uint64 pos; /* for the first 10, seek to the first 10 samples */ if (n >= 10 && i < 10) { pos = i; } /* for the second 10, seek to the last 10 samples */ else if (n >= 10 && i < 20) { pos = n - 1 - (i-10); } /* for the third 10, seek past the end and make sure we fail properly as expected */ else if (i < 30) { pos = n + (i-20); } else { #if !defined _MSC_VER && !defined __MINGW32__ pos = (FLAC__uint64)(random() % n); #else /* RAND_MAX is only 32767 in my MSVC */ pos = (FLAC__uint64)((rand()<<15|rand()) % n); #endif } #ifdef _MSC_VER printf("seek(%I64u)... ", pos); #else printf("seek(%llu)... ", (unsigned long long)pos); #endif fflush(stdout); if(!FLAC__stream_decoder_seek_absolute(decoder, pos)) { if(pos >= (FLAC__uint64)n) printf("seek past end failed as expected... "); else if(decoder_client_data.total_samples == 0 && total_samples <= 0) printf("seek failed, assuming it was past EOF... "); else return die_s_("FLAC__stream_decoder_seek_absolute() FAILED", decoder); if(!FLAC__stream_decoder_flush(decoder)) return die_s_("FLAC__stream_decoder_flush() FAILED", decoder); } else if(read_mode == 1) { printf("decode_frame... "); fflush(stdout); if(!FLAC__stream_decoder_process_single(decoder)) return die_s_("FLAC__stream_decoder_process_single() FAILED", decoder); printf("decode_frame... "); fflush(stdout); if(!FLAC__stream_decoder_process_single(decoder)) return die_s_("FLAC__stream_decoder_process_single() FAILED", decoder); } else if(read_mode == 2) { printf("decode_all... "); fflush(stdout); decoder_client_data.quiet = true; if(!FLAC__stream_decoder_process_until_end_of_stream(decoder)) return die_s_("FLAC__stream_decoder_process_until_end_of_stream() FAILED", decoder); decoder_client_data.quiet = false; } printf("OK\n"); fflush(stdout); } if(FLAC__stream_decoder_get_state(decoder) != FLAC__STREAM_DECODER_UNINITIALIZED) { if(!FLAC__stream_decoder_finish(decoder)) return die_s_("FLAC__stream_decoder_finish() FAILED", decoder); } FLAC__stream_decoder_delete(decoder); printf("\nPASSED!\n"); return true; }
int __stdcall WWFlacRW_DecodeAll(const wchar_t *path) { FLAC__bool ok = true; FILE *fp = NULL; errno_t ercd; FLAC__StreamDecoderInitStatus initStatus = FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE; FlacDecodeInfo *fdi = FlacTInfoNew<FlacDecodeInfo>(g_flacDecodeInfoMap); if (NULL == fdi) { return FRT_OtherError; } fdi->errorCode = FRT_Success; fdi->decoder = FLAC__stream_decoder_new(); if(fdi->decoder == NULL) { fdi->errorCode = FRT_FlacStreamDecoderNewFailed; dprintf("%s Flac decode error %d. set complete event.\n", __FUNCTION__, fdi->errorCode); goto end; } wcsncpy_s(fdi->path, path, (sizeof fdi->path)/2-1); FLAC__stream_decoder_set_md5_checking(fdi->decoder, true); FLAC__stream_decoder_set_metadata_respond(fdi->decoder, FLAC__METADATA_TYPE_STREAMINFO); FLAC__stream_decoder_set_metadata_respond(fdi->decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT); FLAC__stream_decoder_set_metadata_respond(fdi->decoder, FLAC__METADATA_TYPE_PICTURE); FLAC__stream_decoder_set_metadata_respond(fdi->decoder, FLAC__METADATA_TYPE_CUESHEET); // Windowsでは、この方法でファイルを開かなければならぬ。 ercd = _wfopen_s(&fp, fdi->path, L"rb"); if (ercd != 0 || NULL == fp) { fdi->errorCode = FRT_FileOpenError; goto end; } initStatus = FLAC__stream_decoder_init_FILE( fdi->decoder, fp, WriteCallback, MetadataCallback, ErrorCallback, fdi); // FLAC__stream_decoder_finish()がfcloseしてくれるので、忘れる。 fp = NULL; if(initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) { fdi->errorCode = FRT_FlacStreamDecoderInitFailed; dprintf("%s Flac decode error %d. set complete event.\n", __FUNCTION__, fdi->errorCode); goto end; } fdi->errorCode = FRT_Success; ok = FLAC__stream_decoder_process_until_end_of_metadata(fdi->decoder); if (!ok) { if (fdi->errorCode == FRT_Success) { fdi->errorCode = FRT_DecorderProcessFailed; } dprintf("%s Flac metadata process error fdi->errorCode=%d\n", __FUNCTION__, fdi->errorCode); goto end; } ok = FLAC__stream_decoder_process_until_end_of_stream(fdi->decoder); if (!ok) { if (fdi->errorCode == FRT_Success) { fdi->errorCode = FRT_DecorderProcessFailed; } dprintf("%s Flac decode error fdi->errorCode=%d\n", __FUNCTION__, fdi->errorCode); goto end; } fdi->errorCode = FRT_Completed; end: if (fdi->errorCode < 0) { if (NULL != fdi->decoder) { if (initStatus == FLAC__STREAM_DECODER_INIT_STATUS_OK) { FLAC__stream_decoder_finish(fdi->decoder); } FLAC__stream_decoder_delete(fdi->decoder); fdi->decoder = NULL; } int result = fdi->errorCode; FlacTInfoDelete<FlacDecodeInfo>(g_flacDecodeInfoMap, fdi); fdi = NULL; return result; } return fdi->id; }
static FLAC__bool test_stream_decoder(Layer layer, FLAC__bool is_ogg) { FLAC__StreamDecoder *decoder; FLAC__StreamDecoderInitStatus init_status; FLAC__StreamDecoderState state; StreamDecoderClientData decoder_client_data; FLAC__bool expect; decoder_client_data.layer = layer; printf("\n+++ libFLAC unit test: FLAC__StreamDecoder (layer: %s, format: %s)\n\n", LayerString[layer], is_ogg? "Ogg FLAC" : "FLAC"); printf("testing FLAC__stream_decoder_new()... "); decoder = FLAC__stream_decoder_new(); if(0 == decoder) { printf("FAILED, returned NULL\n"); return false; } printf("OK\n"); printf("testing FLAC__stream_decoder_delete()... "); FLAC__stream_decoder_delete(decoder); printf("OK\n"); printf("testing FLAC__stream_decoder_new()... "); decoder = FLAC__stream_decoder_new(); if(0 == decoder) { printf("FAILED, returned NULL\n"); return false; } printf("OK\n"); switch(layer) { case LAYER_STREAM: case LAYER_SEEKABLE_STREAM: printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":""); init_status = is_ogg? FLAC__stream_decoder_init_ogg_stream(decoder, 0, 0, 0, 0, 0, 0, 0, 0, 0) : FLAC__stream_decoder_init_stream(decoder, 0, 0, 0, 0, 0, 0, 0, 0, 0); break; case LAYER_FILE: printf("testing FLAC__stream_decoder_init_%sFILE()... ", is_ogg? "ogg_":""); init_status = is_ogg? FLAC__stream_decoder_init_ogg_FILE(decoder, stdin, 0, 0, 0, 0) : FLAC__stream_decoder_init_FILE(decoder, stdin, 0, 0, 0, 0); break; case LAYER_FILENAME: printf("testing FLAC__stream_decoder_init_%sfile()... ", is_ogg? "ogg_":""); init_status = is_ogg? FLAC__stream_decoder_init_ogg_file(decoder, flacfilename(is_ogg), 0, 0, 0, 0) : FLAC__stream_decoder_init_file(decoder, flacfilename(is_ogg), 0, 0, 0, 0); break; default: die_("internal error 003"); return false; } if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS) return die_s_(0, decoder); printf("OK\n"); printf("testing FLAC__stream_decoder_delete()... "); FLAC__stream_decoder_delete(decoder); printf("OK\n"); num_expected_ = 0; expected_metadata_sequence_[num_expected_++] = &streaminfo_; printf("testing FLAC__stream_decoder_new()... "); decoder = FLAC__stream_decoder_new(); if(0 == decoder) { printf("FAILED, returned NULL\n"); return false; } printf("OK\n"); if(is_ogg) { printf("testing FLAC__stream_decoder_set_ogg_serial_number()... "); if(!FLAC__stream_decoder_set_ogg_serial_number(decoder, file_utils__ogg_serial_number)) return die_s_("returned false", decoder); printf("OK\n"); } printf("testing FLAC__stream_decoder_set_md5_checking()... "); if(!FLAC__stream_decoder_set_md5_checking(decoder, true)) return die_s_("returned false", decoder); printf("OK\n"); if(layer < LAYER_FILENAME) { printf("opening %sFLAC file... ", is_ogg? "Ogg ":""); decoder_client_data.file = fopen(flacfilename(is_ogg), "rb"); if(0 == decoder_client_data.file) { printf("ERROR (%s)\n", strerror(errno)); return false; } printf("OK\n"); } switch(layer) { case LAYER_STREAM: printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":""); init_status = is_ogg? FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) : FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data); break; case LAYER_SEEKABLE_STREAM: printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":""); init_status = is_ogg? FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) : FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data); break; case LAYER_FILE: printf("testing FLAC__stream_decoder_init_%sFILE()... ", is_ogg? "ogg_":""); init_status = is_ogg? FLAC__stream_decoder_init_ogg_FILE(decoder, decoder_client_data.file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) : FLAC__stream_decoder_init_FILE(decoder, decoder_client_data.file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data); break; case LAYER_FILENAME: printf("testing FLAC__stream_decoder_init_%sfile()... ", is_ogg? "ogg_":""); init_status = is_ogg? FLAC__stream_decoder_init_ogg_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) : FLAC__stream_decoder_init_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data); break; default: die_("internal error 009"); return false; } if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) return die_s_(0, decoder); printf("OK\n"); printf("testing FLAC__stream_decoder_get_state()... "); state = FLAC__stream_decoder_get_state(decoder); printf("returned state = %u (%s)... OK\n", state, FLAC__StreamDecoderStateString[state]); decoder_client_data.current_metadata_number = 0; decoder_client_data.ignore_errors = false; decoder_client_data.error_occurred = false; printf("testing FLAC__stream_decoder_get_md5_checking()... "); if(!FLAC__stream_decoder_get_md5_checking(decoder)) { printf("FAILED, returned false, expected true\n"); return false; } printf("OK\n"); printf("testing FLAC__stream_decoder_process_until_end_of_metadata()... "); if(!FLAC__stream_decoder_process_until_end_of_metadata(decoder)) return die_s_("returned false", decoder); printf("OK\n"); printf("testing FLAC__stream_decoder_process_single()... "); if(!FLAC__stream_decoder_process_single(decoder)) return die_s_("returned false", decoder); printf("OK\n"); printf("testing FLAC__stream_decoder_skip_single_frame()... "); if(!FLAC__stream_decoder_skip_single_frame(decoder)) return die_s_("returned false", decoder); printf("OK\n"); if(layer < LAYER_FILE) { printf("testing FLAC__stream_decoder_flush()... "); if(!FLAC__stream_decoder_flush(decoder)) return die_s_("returned false", decoder); printf("OK\n"); decoder_client_data.ignore_errors = true; printf("testing FLAC__stream_decoder_process_single()... "); if(!FLAC__stream_decoder_process_single(decoder)) return die_s_("returned false", decoder); printf("OK\n"); decoder_client_data.ignore_errors = false; } expect = (layer != LAYER_STREAM); printf("testing FLAC__stream_decoder_seek_absolute()... "); if(FLAC__stream_decoder_seek_absolute(decoder, 0) != expect) return die_s_(expect? "returned false" : "returned true", decoder); printf("OK\n"); printf("testing FLAC__stream_decoder_process_until_end_of_stream()... "); if(!FLAC__stream_decoder_process_until_end_of_stream(decoder)) return die_s_("returned false", decoder); printf("OK\n"); expect = (layer != LAYER_STREAM); printf("testing FLAC__stream_decoder_seek_absolute()... "); if(FLAC__stream_decoder_seek_absolute(decoder, 0) != expect) return die_s_(expect? "returned false" : "returned true", decoder); printf("OK\n"); printf("testing FLAC__stream_decoder_get_channels()... "); { unsigned channels = FLAC__stream_decoder_get_channels(decoder); if(channels != streaminfo_.data.stream_info.channels) { printf("FAILED, returned %u, expected %u\n", channels, streaminfo_.data.stream_info.channels); return false; } } printf("OK\n"); printf("testing FLAC__stream_decoder_get_bits_per_sample()... "); { unsigned bits_per_sample = FLAC__stream_decoder_get_bits_per_sample(decoder); if(bits_per_sample != streaminfo_.data.stream_info.bits_per_sample) { printf("FAILED, returned %u, expected %u\n", bits_per_sample, streaminfo_.data.stream_info.bits_per_sample); return false; } } printf("OK\n"); printf("testing FLAC__stream_decoder_get_sample_rate()... "); { unsigned sample_rate = FLAC__stream_decoder_get_sample_rate(decoder); if(sample_rate != streaminfo_.data.stream_info.sample_rate) { printf("FAILED, returned %u, expected %u\n", sample_rate, streaminfo_.data.stream_info.sample_rate); return false; } } printf("OK\n"); printf("testing FLAC__stream_decoder_get_blocksize()... "); { unsigned blocksize = FLAC__stream_decoder_get_blocksize(decoder); /* value could be anything since we're at the last block, so accept any reasonable answer */ printf("returned %u... %s\n", blocksize, blocksize>0? "OK" : "FAILED"); if(blocksize == 0) return false; } printf("testing FLAC__stream_decoder_get_channel_assignment()... "); { FLAC__ChannelAssignment ca = FLAC__stream_decoder_get_channel_assignment(decoder); printf("returned %u (%s)... OK\n", (unsigned)ca, FLAC__ChannelAssignmentString[ca]); } if(layer < LAYER_FILE) { printf("testing FLAC__stream_decoder_reset()... "); if(!FLAC__stream_decoder_reset(decoder)) { state = FLAC__stream_decoder_get_state(decoder); printf("FAILED, returned false, state = %u (%s)\n", state, FLAC__StreamDecoderStateString[state]); return false; } printf("OK\n"); if(layer == LAYER_STREAM) { /* after a reset() we have to rewind the input ourselves */ printf("rewinding input... "); if(fseeko(decoder_client_data.file, 0, SEEK_SET) < 0) { printf("FAILED, errno = %d\n", errno); return false; } printf("OK\n"); } decoder_client_data.current_metadata_number = 0; printf("testing FLAC__stream_decoder_process_until_end_of_stream()... "); if(!FLAC__stream_decoder_process_until_end_of_stream(decoder)) return die_s_("returned false", decoder); printf("OK\n"); } printf("testing FLAC__stream_decoder_finish()... "); if(!FLAC__stream_decoder_finish(decoder)) return die_s_("returned false", decoder); printf("OK\n"); /* * respond all */ printf("testing FLAC__stream_decoder_set_metadata_respond_all()... "); if(!FLAC__stream_decoder_set_metadata_respond_all(decoder)) return die_s_("returned false", decoder); printf("OK\n"); num_expected_ = 0; if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */ expected_metadata_sequence_[num_expected_++] = &streaminfo_; expected_metadata_sequence_[num_expected_++] = &vorbiscomment_; expected_metadata_sequence_[num_expected_++] = &padding_; expected_metadata_sequence_[num_expected_++] = &seektable_; expected_metadata_sequence_[num_expected
static FLAC__bool stream_decoder_test_respond_(FLAC__StreamDecoder *decoder, StreamDecoderClientData *dcd, FLAC__bool is_ogg) { FLAC__StreamDecoderInitStatus init_status; if(!FLAC__stream_decoder_set_md5_checking(decoder, true)) return die_s_("at FLAC__stream_decoder_set_md5_checking(), returned false", decoder); /* for FLAC__stream_encoder_init_FILE(), the FLAC__stream_encoder_finish() closes the file so we have to keep re-opening: */ if(dcd->layer == LAYER_FILE) { printf("opening %sFLAC file... ", is_ogg? "Ogg ":""); dcd->file = fopen(flacfilename(is_ogg), "rb"); if(0 == dcd->file) { printf("ERROR (%s)\n", strerror(errno)); return false; } printf("OK\n"); } switch(dcd->layer) { case LAYER_STREAM: printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":""); init_status = is_ogg? FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) : FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) ; break; case LAYER_SEEKABLE_STREAM: printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":""); init_status = is_ogg? FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) : FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd); break; case LAYER_FILE: printf("testing FLAC__stream_decoder_init_%sFILE()... ", is_ogg? "ogg_":""); init_status = is_ogg? FLAC__stream_decoder_init_ogg_FILE(decoder, dcd->file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) : FLAC__stream_decoder_init_FILE(decoder, dcd->file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd); break; case LAYER_FILENAME: printf("testing FLAC__stream_decoder_init_%sfile()... ", is_ogg? "ogg_":""); init_status = is_ogg? FLAC__stream_decoder_init_ogg_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) : FLAC__stream_decoder_init_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd); break; default: die_("internal error 000"); return false; } if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) return die_s_(0, decoder); printf("OK\n"); dcd->current_metadata_number = 0; if(dcd->layer < LAYER_FILE && fseeko(dcd->file, 0, SEEK_SET) < 0) { printf("FAILED rewinding input, errno = %d\n", errno); return false; } printf("testing FLAC__stream_decoder_process_until_end_of_stream()... "); if(!FLAC__stream_decoder_process_until_end_of_stream(decoder)) return die_s_("returned false", decoder); printf("OK\n"); printf("testing FLAC__stream_decoder_finish()... "); if(!FLAC__stream_decoder_finish(decoder)) return die_s_("returned false", decoder); printf("OK\n"); return true; }