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