double FlacDecoder::length() const { if (!_opened) { return static_cast<double>(FLAC__stream_decoder_get_total_samples(_streamdecoder))/static_cast<double>(_sampleRate); } return 0.; }
bool FlacDecoder::_open(const string_t& filename) { #if defined(LIBTOOLS_WINDOWS) && defined(string_t_w_available) _file=_wfopen(string_t_to_stdw(filename).c_str(),L"rb"); #else _file=fopen(string_t_to_std(filename).c_str(),"rb"); #endif if (!_file) { #ifndef NDEBUG std::cerr << "FlacDecoder cannot open file: " << string_t_to_std(filename) << std::endl; #endif return false; } _error=false; FLAC__StreamDecoderInitStatus init_status= FLAC__stream_decoder_init_FILE(_streamdecoder,_file, &FlacDecoder::_write_callback, &FlacDecoder::_metadata_callback, &FlacDecoder::_error_callback, (void*) this); assert(init_status==FLAC__STREAM_DECODER_INIT_STATUS_OK); FLAC__stream_decoder_set_metadata_respond(_streamdecoder,FLAC__METADATA_TYPE_STREAMINFO); FLAC__stream_decoder_set_metadata_respond(_streamdecoder,FLAC__METADATA_TYPE_VORBIS_COMMENT); if (!FLAC__stream_decoder_process_until_end_of_metadata(_streamdecoder) || _error) { _error=false; FLAC__stream_decoder_finish(_streamdecoder); init_status= FLAC__stream_decoder_init_ogg_FILE(_streamdecoder,_file, &FlacDecoder::_write_callback, &FlacDecoder::_metadata_callback, &FlacDecoder::_error_callback, (void*) this); assert(init_status==FLAC__STREAM_DECODER_INIT_STATUS_OK); FLAC__stream_decoder_set_metadata_respond(_streamdecoder,FLAC__METADATA_TYPE_STREAMINFO); FLAC__stream_decoder_set_metadata_respond(_streamdecoder,FLAC__METADATA_TYPE_VORBIS_COMMENT); if (!FLAC__stream_decoder_process_until_end_of_metadata(_streamdecoder)||_error) { #ifndef NDEBUG std::cerr << "FlacDecoder file: " << string_t_to_std(filename) << " is not a FLAC or OGG FLAC file" << std::endl; #endif FLAC__stream_decoder_finish(_streamdecoder); fclose(_file); return false; } } uint64_t music_len=FLAC__stream_decoder_get_total_samples(_streamdecoder); _bufferl.reserve(music_len); _bufferr.reserve(music_len); _opened=true; _ended=false; return true; }
static size_t audiosourceflac_Length(struct audiosource* source) { struct audiosourceflac_internaldata* idata = source->internaldata; if (idata->eof && idata->returnerroroneof) { return 0; } if (!idata->flacopened) { return 0; } return FLAC__stream_decoder_get_total_samples(idata->decoder); }
clFLACDataProvider::clFLACDataProvider( const std::shared_ptr<clBlob>& Data ) : m_Data( Data ) , m_Format() , m_StreamData( std::make_shared<sFLACStreamData>() ) , m_DecodingBuffer() , m_BufferUsed( 0 ) , m_IsEndOfStream( false ) { { FLAC__StreamDecoderInitStatus Status = FLAC__stream_decoder_init_stream( m_StreamData->m_Decoder, &flacRead, &flacSeek, &flacTell, &flacLength, &flacEof, &flacWrite, &flacMeta, &flacError, this ); } FLAC__bool Status = FLAC__stream_decoder_process_until_end_of_metadata( m_StreamData->m_Decoder ); if ( !Status ) return; if ( !FLAC__stream_decoder_process_single( m_StreamData->m_Decoder ) ) return; m_Format.m_NumChannels = FLAC__stream_decoder_get_channels( m_StreamData->m_Decoder ); m_Format.m_SamplesPerSecond = FLAC__stream_decoder_get_sample_rate( m_StreamData->m_Decoder ); m_Format.m_BitsPerSample = FLAC__stream_decoder_get_bits_per_sample( m_StreamData->m_Decoder ); int BufSize = FLAC__stream_decoder_get_blocksize( m_StreamData->m_Decoder ) * m_Format.m_BitsPerSample * 8 * m_Format.m_NumChannels; // store two blocks m_DecodingBuffer.resize( BufSize * 2 ); int TotalSamples = FLAC__stream_decoder_get_total_samples( m_StreamData->m_Decoder ); }
/* Populate the imFileInfoRec8 structure describing this file instance to Premiere. Check file validity, allocate any private instance data to share between different calls. */ prMALError SDKGetInfo8( imStdParms *stdParms, imFileAccessRec8 *fileAccessInfo, imFileInfoRec8 *fileInfo) { prMALError result = malNoError; PrivateDataH pdH = reinterpret_cast<PrivateDataH>(fileInfo->privatedata); stdParms->piSuites->memFuncs->lockHandle(reinterpret_cast<char**>(pdH)); //Lock private data (*pdH)->flacErrorCode = 0; (*pdH)->flacDecoder = 0; char filepathASCII[255]; int stringLength = (int)wcslen(reinterpret_cast<const wchar_t*>(fileAccessInfo->filepath)); wcstombs_s( NULL, reinterpret_cast<char*>(filepathASCII), sizeof (filepathASCII), fileAccessInfo->filepath, stringLength); FLAC__bool ok = true; FLAC__StreamDecoderInitStatus init_status; if(((*pdH)->flacDecoder = FLAC__stream_decoder_new()) == NULL) { (*pdH)->flacErrorCode = 1; } FLAC__stream_decoder_set_md5_checking((*pdH)->flacDecoder, true); init_status = FLAC__stream_decoder_init_file((*pdH)->flacDecoder, filepathASCII, write_callback, NULL, error_callback, pdH); if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK ) { return imBadFile; //Error, bail out } FLAC__stream_decoder_process_until_end_of_metadata((*pdH)->flacDecoder); FLAC__stream_decoder_process_single((*pdH)->flacDecoder); (*pdH)->audioChannels = FLAC__stream_decoder_get_channels((*pdH)->flacDecoder); (*pdH)->audioNumberOfSamples = FLAC__stream_decoder_get_total_samples((*pdH)->flacDecoder); (*pdH)->audioNumberOfSamplesPerSecond = FLAC__stream_decoder_get_sample_rate((*pdH)->flacDecoder); (*pdH)->audioBytesPerSample = FLAC__stream_decoder_get_bits_per_sample((*pdH)->flacDecoder) / 8; (*pdH)->audioPosition = 0; //Fill out the general file info fileInfo->accessModes = kSeparateSequentialAudio; fileInfo->hasDataRate = kPrFalse; fileInfo->hasVideo = kPrFalse; fileInfo->hasAudio = kPrTrue; fileInfo->alwaysUnquiet = 0; fileInfo->highMemUsage = 0; fileInfo->audInfo.numChannels = (*pdH)->audioChannels; fileInfo->audInfo.sampleRate = (float)(*pdH)->audioNumberOfSamplesPerSecond; fileInfo->audDuration = (*pdH)->audioNumberOfSamples; if((*pdH)->audioBytesPerSample == 1) { fileInfo->audInfo.sampleType = kPrAudioSampleType_8BitInt; } else if((*pdH)->audioBytesPerSample == 2) { fileInfo->audInfo.sampleType = kPrAudioSampleType_16BitInt; } else if((*pdH)->audioBytesPerSample == 3) { fileInfo->audInfo.sampleType = kPrAudioSampleType_24BitInt; } else if((*pdH)->audioBytesPerSample == 4) { fileInfo->audInfo.sampleType = kPrAudioSampleType_32BitInt; } else { fileInfo->audInfo.sampleType = kPrAudioSampleType_Other; } (*pdH)->suiteBasic = stdParms->piSuites->utilFuncs->getSPBasicSuite(); //Allocate an audio suite if ((*pdH)->suiteBasic) { (*pdH)->suiteBasic->AcquireSuite (kPrSDKAudioSuite, kPrSDKAudioSuiteVersion, (const void**)&(*pdH)->suiteAudio); } stdParms->piSuites->memFuncs->unlockHandle(reinterpret_cast<char**>(pdH)); //Unlock private data return result; }
FLAC__StreamDecoderWriteStatus FlacReader::write_callback( const FLAC__StreamDecoder* decoder, const FLAC__Frame* frame, const FLAC__int32* const* buffer, void* client_data ) { FlacReader* reader = ( FlacReader* )client_data; try { if( reader->m_channels == 0 ) { reader->m_channels = frame->header.channels; } if( reader->m_bitdepth == 0 ) { reader->m_bitdepth = frame->header.bits_per_sample; } if( reader->m_samplerate == 0 ) { reader->m_samplerate = frame->header.sample_rate; } if( reader->m_channels != int( frame->header.channels ) || reader->m_bitdepth != int( frame->header.bits_per_sample ) || reader->m_samplerate != int( frame->header.sample_rate ) ) { reader->m_error = "unsupported FLAC stream"; return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; } if( !reader->m_target ) { uint64_t samples = FLAC__stream_decoder_get_total_samples( decoder ); if( samples != 0 ) { reader->m_target = DataBuffer::create( 0, samples * reader->m_channels * 4, 0 ); } else { reader->m_target = DataBuffer::create( 0, frame->header.blocksize * reader->m_channels * 4, 0 ); } } if( ( reader->m_totalsamples + frame->header.blocksize ) * reader->m_channels * 4 > reader->m_target->m_capacity ) { reader->m_target = DataBuffer::create( reader->m_target->m_length, reader->m_target->m_capacity * 2, reader->m_target->m_data ); } int32_t* targetbuffer = ( int32_t* )reader->m_target->m_data + reader->m_totalsamples * reader->m_channels; if( reader->m_channels == 1 ) { memcpy( targetbuffer, buffer[ 0 ], frame->header.blocksize * 4 ); } else if( reader->m_channels == 2 ) { for( size_t i = 0; i < frame->header.blocksize; ++i ) { targetbuffer[ i * 2 ] = buffer[ 0 ][ i ]; targetbuffer[ i * 2 + 1 ] = buffer[ 1 ][ i ]; } } else { for( size_t i = 0; i < frame->header.blocksize; ++i ) { for( size_t ch = 0; ch < size_t( reader->m_channels ); ++ch ) { targetbuffer[ i * reader->m_channels + ch ] = buffer[ ch ][ i ]; } } } reader->m_totalsamples += frame->header.blocksize; reader->m_target->m_length = reader->m_totalsamples * reader->m_channels * 4; return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; } catch( std::exception const& e ) { reader->m_error = e.what(); return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT ; } catch( ... ) { reader->m_error = "Unknown error"; return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT ; } }