bool OAFLACReader::open(const SPtr<DataStream>& stream, AudioFileInfo& info, UINT32 offset)
{
if (stream == nullptr)
return false;
stream->seek(offset);
mDecoder = FLAC__stream_decoder_new();
if (mDecoder == nullptr)
{
LOGERR("Failed to open a FLAC file.");
return false;
}
mData.stream = stream;
mData.streamOffset = offset;
FLAC__stream_decoder_init_stream(mDecoder, &streamRead, &streamSeek, &streamTell, &streamLength, &streamEof,
&streamWrite, &streamMetadata, &streamError, &mData);
if (!FLAC__stream_decoder_process_until_end_of_metadata(mDecoder))
{
close();
LOGERR("Failed to open a FLAC file.");
return false;
}
info = mData.info;
return true;
}
SoundSource::OpenResult SoundSourceFLAC::tryOpen(
OpenMode /*mode*/,
const OpenParams& /*config*/) {
DEBUG_ASSERT(!m_file.isOpen());
if (!m_file.open(QIODevice::ReadOnly)) {
kLogger.warning() << "Failed to open FLAC file:" << m_file.fileName();
return OpenResult::Failed;
}
m_decoder = FLAC__stream_decoder_new();
if (m_decoder == nullptr) {
kLogger.warning() << "Failed to create FLAC decoder!";
return OpenResult::Failed;
}
FLAC__stream_decoder_set_md5_checking(m_decoder, false);
const FLAC__StreamDecoderInitStatus initStatus(
FLAC__stream_decoder_init_stream(m_decoder, FLAC_read_cb,
FLAC_seek_cb, FLAC_tell_cb, FLAC_length_cb, FLAC_eof_cb,
FLAC_write_cb, FLAC_metadata_cb, FLAC_error_cb, this));
if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
kLogger.warning() << "Failed to initialize FLAC decoder:" << initStatus;
return OpenResult::Failed;
}
if (!FLAC__stream_decoder_process_until_end_of_metadata(m_decoder)) {
kLogger.warning() << "Failed to process FLAC metadata:"
<< FLAC__stream_decoder_get_state(m_decoder);
return OpenResult::Failed;
}
m_curFrameIndex = frameIndexMin();
return OpenResult::Succeeded;
}
Result SoundSourceFLAC::tryOpen(const AudioSourceConfig& /*audioSrcCfg*/) {
DEBUG_ASSERT(!m_file.isOpen());
if (!m_file.open(QIODevice::ReadOnly)) {
qWarning() << "Failed to open FLAC file:" << m_file.fileName();
return ERR;
}
m_decoder = FLAC__stream_decoder_new();
if (m_decoder == NULL) {
qWarning() << "Failed to create FLAC decoder!";
return ERR;
}
FLAC__stream_decoder_set_md5_checking(m_decoder, FALSE);
const FLAC__StreamDecoderInitStatus initStatus(
FLAC__stream_decoder_init_stream(m_decoder, FLAC_read_cb,
FLAC_seek_cb, FLAC_tell_cb, FLAC_length_cb, FLAC_eof_cb,
FLAC_write_cb, FLAC_metadata_cb, FLAC_error_cb, this));
if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
qWarning() << "Failed to initialize FLAC decoder:" << initStatus;
return ERR;
}
if (!FLAC__stream_decoder_process_until_end_of_metadata(m_decoder)) {
qWarning() << "Failed to process FLAC metadata:"
<< FLAC__stream_decoder_get_state(m_decoder);
return ERR;
}
m_curFrameIndex = getMinFrameIndex();
return OK;
}
static gboolean
gst_flac_dec_start (GstAudioDecoder * audio_dec)
{
FLAC__StreamDecoderInitStatus s;
GstFlacDec *dec;
dec = GST_FLAC_DEC (audio_dec);
dec->adapter = gst_adapter_new ();
dec->decoder = FLAC__stream_decoder_new ();
gst_audio_info_init (&dec->info);
dec->depth = 0;
/* no point calculating MD5 since it's never checked here */
FLAC__stream_decoder_set_md5_checking (dec->decoder, false);
GST_DEBUG_OBJECT (dec, "initializing decoder");
s = FLAC__stream_decoder_init_stream (dec->decoder,
gst_flac_dec_read_stream, NULL, NULL, NULL, NULL,
gst_flac_dec_write_stream, gst_flac_dec_metadata_cb,
gst_flac_dec_error_cb, dec);
if (s != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
GST_ELEMENT_ERROR (GST_ELEMENT (dec), LIBRARY, INIT, (NULL), (NULL));
return FALSE;
}
dec->got_headers = FALSE;
return TRUE;
}
bool SoundFileReaderFlac::open(InputStream& stream, Info& info)
{
// Create the decoder
m_decoder = FLAC__stream_decoder_new();
if (!m_decoder)
{
err() << "Failed to open FLAC file (failed to allocate the decoder)" << std::endl;
return false;
}
// Initialize the decoder with our callbacks
m_clientData.stream = &stream;
FLAC__stream_decoder_init_stream(m_decoder, &streamRead, &streamSeek, &streamTell, &streamLength, &streamEof, &streamWrite, &streamMetadata, &streamError, &m_clientData);
// Read the header
if (!FLAC__stream_decoder_process_until_end_of_metadata(m_decoder))
{
close();
err() << "Failed to open FLAC file (failed to read metadata)" << std::endl;
return false;
}
// Retrieve the sound properties
info = m_clientData.info; // was filled in the "metadata" callback
// We must keep the channel count for the seek function
m_channelCount = info.channelCount;
return true;
}
FLAC__bool safe_decoder_init_(const char *filename, FLAC__StreamDecoder *decoder)
{
if(decoder == 0)
return false;
safe_decoder_finish_(decoder);
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);
if(stream_data_.is_http_source) {
flac_http_open(filename, 0);
if(FLAC__stream_decoder_init_stream(decoder, http_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, write_callback_, metadata_callback_, error_callback_, /*client_data=*/&stream_data_) != FLAC__STREAM_DECODER_INIT_STATUS_OK)
return false;
}
else {
if(FLAC__stream_decoder_init_file(decoder, filename, write_callback_, metadata_callback_, error_callback_, /*client_data=*/&stream_data_) != FLAC__STREAM_DECODER_INIT_STATUS_OK)
return false;
}
if(!FLAC__stream_decoder_process_until_end_of_metadata(decoder))
return false;
return true;
}
static FLAC__StreamDecoderInitStatus
stream_init_flac(FLAC__StreamDecoder *flac_dec, struct flac_data *data)
{
return FLAC__stream_decoder_init_stream(flac_dec,
flac_read_cb, flac_seek_cb,
flac_tell_cb, flac_length_cb,
flac_eof_cb, flac_write_cb,
flacMetadata,
flac_error_cb,
data);
}
/**
* 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;
}
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);
}
}
bool CFlacDec::Open(FILE* in, FLAC__StreamDecoder* vf)
{
FLAC__StreamDecoderInitStatus rval;
mIn = in;
/* we need to use our own functions, because we have */
/* the netfile layer hooked in here. If we would not */
/* provide callbacks, the tremor lib and the netfile */
/* layer would clash and steal each other the data */
/* from the stream ! */
/* test the dope ... */
rval = FLAC__stream_decoder_init_stream(vf,
flac_read,
flac_seek,
flac_tell,
flac_length,
flac_eof,
flac_write,
flac_metadata,
flac_error,
(void *)this);
/* and tell our friends about the quality of the stuff */
// initialize the sound device here
if(rval<0)
{
switch(rval)
{
/* err_txt from netfile.cpp */
case FLAC__STREAM_DECODER_INIT_STATUS_OK: sprintf(err_txt, "Initialization was successful"); break;
case FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER: sprintf(err_txt, "The library was not compiled with support for the given container format"); break;
case FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS: sprintf(err_txt, "A required callback was not supplied"); break;
case FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR: sprintf(err_txt, "An error occurred allocating memory"); break;
case FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE: sprintf(err_txt, "fopen() failed in FLAC__stream_decoder_init_file() or FLAC__stream_decoder_init_ogg_file()"); break;
case FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED: sprintf(err_txt, "FLAC__stream_decoder_init_*() was called when the decoder was already initialized, usually because FLAC__stream_decoder_finish() was not called"); break;
default: sprintf(err_txt, "unknown error, code: %d", rval);
}
// fprintf(stderr,"%s: %s\n", ProgName, err_txt);
printf("%s: %s\n", ProgName, err_txt);
return false;
}
/* finish the opening and ignite the joint */
// mSeekable = true;
mSeekable = false;
return true;
}
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 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;
}
// soundsource overrides
Result SoundSourceFLAC::open() {
if (!m_file.open(QIODevice::ReadOnly)) {
qWarning() << "SSFLAC: Could not read file!";
return ERR;
}
m_decoder = FLAC__stream_decoder_new();
if (m_decoder == NULL) {
qWarning() << "SSFLAC: decoder allocation failed!";
return ERR;
}
FLAC__StreamDecoderInitStatus initStatus(
FLAC__stream_decoder_init_stream(
m_decoder, FLAC_read_cb, FLAC_seek_cb, FLAC_tell_cb, FLAC_length_cb,
FLAC_eof_cb, FLAC_write_cb, FLAC_metadata_cb, FLAC_error_cb,
(void*) this)
);
if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
qWarning() << "SSFLAC: decoder init failed!";
goto decoderError;
}
if (!FLAC__stream_decoder_process_until_end_of_metadata(m_decoder)) {
qWarning() << "SSFLAC: process to end of meta failed!";
qWarning() << "SSFLAC: decoder state: " << FLAC__stream_decoder_get_state(m_decoder);
goto decoderError;
} // now number of samples etc. should be populated
if (m_flacBuffer == NULL) {
// we want 2 samples per frame, see ::flacWrite code -- bkgood
m_flacBuffer = new FLAC__int16[m_maxBlocksize * 2 /*m_iChannels*/];
}
if (m_leftoverBuffer == NULL) {
m_leftoverBuffer = new FLAC__int16[m_maxBlocksize * 2 /*m_iChannels*/];
}
// qDebug() << "SSFLAC: Total samples: " << m_samples;
// qDebug() << "SSFLAC: Sampling rate: " << m_iSampleRate << " Hz";
// qDebug() << "SSFLAC: Channels: " << m_iChannels;
// qDebug() << "SSFLAC: BPS: " << m_bps;
return OK;
decoderError:
FLAC__stream_decoder_finish(m_decoder);
FLAC__stream_decoder_delete(m_decoder);
m_decoder = NULL;
qWarning() << "SSFLAC: Decoder error at file" << m_qFilename;
return ERR;
}
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;
}
bool OAFLACReader::isValid(const SPtr<DataStream>& stream, UINT32 offset)
{
stream->seek(offset);
FLAC__StreamDecoder* decoder = FLAC__stream_decoder_new();
if (!decoder)
return false;
FLACDecoderData data;
data.stream = stream;
mData.streamOffset = offset;
FLAC__stream_decoder_init_stream(decoder, &streamRead, &streamSeek, &streamTell, &streamLength, &streamEof,
&streamWrite, nullptr, &streamError, &data);
bool valid = FLAC__stream_decoder_process_until_end_of_metadata(decoder) != 0;
FLAC__stream_decoder_finish(decoder);
FLAC__stream_decoder_delete(decoder);
return valid && !data.error;
}
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 );
}
bool SoundFileReaderFlac::check(InputStream& stream)
{
// Create a decoder
FLAC__StreamDecoder* decoder = FLAC__stream_decoder_new();
if (!decoder)
return false;
// Initialize the decoder with our callbacks
ClientData data;
data.stream = &stream;
data.error = false;
FLAC__stream_decoder_init_stream(decoder, &streamRead, &streamSeek, &streamTell, &streamLength, &streamEof, &streamWrite, NULL, &streamError, &data);
// Read the header
bool valid = FLAC__stream_decoder_process_until_end_of_metadata(decoder) != 0;
// Destroy the decoder
FLAC__stream_decoder_finish(decoder);
FLAC__stream_decoder_delete(decoder);
return valid && !data.error;
}
flac_header_extractor_c::flac_header_extractor_c(const std::string &file_name,
int64_t p_sid,
oggflac_mode_e p_mode)
: metadata_parsed(false)
, sid(p_sid)
, num_packets(0)
, num_header_packets(0)
, done(false)
, mode(p_mode)
{
file = new mm_file_io_c(file_name);
decoder = FLAC__stream_decoder_new();
if (!decoder)
mxerror(Y("flac_header_extraction: FLAC__stream_decoder_new() failed.\n"));
if (!FLAC__stream_decoder_set_metadata_respond_all(decoder))
mxerror(Y("flac_header_extraction: Could not set metadata_respond_all.\n"));
if (FLAC__stream_decoder_init_stream(decoder, fhe_read_cb, nullptr, nullptr, nullptr, nullptr, fhe_write_cb, fhe_metadata_cb, fhe_error_cb, this) != FLAC__STREAM_DECODER_INIT_STATUS_OK)
mxerror(Y("flac_header_extraction: Could not initialize the FLAC decoder.\n"));
ogg_sync_init(&oy);
}
static int audiosourceflac_InitFLAC(struct audiosource* source) {
struct audiosourceflac_internaldata* idata =
source->internaldata;
// open up FLAC decoder:
idata->decoder = FLAC__stream_decoder_new();
if (!idata->decoder) {
return 0;
}
idata->flacopened = 1;
// initialise decoder:
if (FLAC__stream_decoder_init_stream(idata->decoder,
flacread,
flacseek,
flactell,
flaclength,
flaceof,
flacwrite,
flacmetadata,
flacerror,
source
) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
return 0;
}
// run decoder up to first audio frame:
while (idata->decodedbytes == 0) {
FLAC__bool b;
if ((b = FLAC__stream_decoder_process_single(idata->decoder)) == false
|| FLAC__stream_decoder_get_state(idata->decoder) ==
FLAC__STREAM_DECODER_END_OF_STREAM) {
return 0;
}
}
// we should have some information now
return 1;
}
static bool_t flac_init (void)
{
FLAC__StreamDecoderInitStatus ret;
/* Callback structure and decoder for main decoding loop */
if ((info = init_callback_info()) == NULL)
{
FLACNG_ERROR("Could not initialize the main callback structure!\n");
return FALSE;
}
if ((decoder = FLAC__stream_decoder_new()) == NULL)
{
FLACNG_ERROR("Could not create the main FLAC decoder instance!\n");
return FALSE;
}
if (FLAC__STREAM_DECODER_INIT_STATUS_OK != (ret = FLAC__stream_decoder_init_stream(
decoder,
read_callback,
seek_callback,
tell_callback,
length_callback,
eof_callback,
write_callback,
metadata_callback,
error_callback,
info)))
{
FLACNG_ERROR("Could not initialize the main FLAC decoder: %s(%d)\n",
FLAC__StreamDecoderInitStatusString[ret], ret);
return FALSE;
}
AUDDBG("Plugin initialized.\n");
return TRUE;
}
bool FlacDecoder::Open(musik::core::sdk::IDataStream *stream){
this->stream = stream;
FLAC__StreamDecoderInitStatus init_status =
FLAC__stream_decoder_init_stream(
this->decoder,
FlacDecoder::FlacRead,
FlacDecoder::FlacSeek,
FlacDecoder::FlacTell,
FlacDecoder::FlacFileSize,
FlacDecoder::FlacEof,
FlacDecoder::FlacWrite,
FlacDecoder::FlacMetadata,
FlacDecoder::FlacError,
this);
if (init_status == FLAC__STREAM_DECODER_INIT_STATUS_OK) {
FLAC__stream_decoder_process_until_end_of_metadata(this->decoder);
return true;
}
return false;
}
status_t FLACParser::init()
{
// setup libFLAC parser
mDecoder = FLAC__stream_decoder_new();
if (mDecoder == NULL) {
// The new should succeed, since probably all it does is a malloc
// that always succeeds in Android. But to avoid dependence on the
// libFLAC internals, we check and log here.
LOGE("new failed");
return NO_INIT;
}
FLAC__stream_decoder_set_md5_checking(mDecoder, false);
FLAC__stream_decoder_set_metadata_ignore_all(mDecoder);
FLAC__stream_decoder_set_metadata_respond(
mDecoder, FLAC__METADATA_TYPE_STREAMINFO);
FLAC__stream_decoder_set_metadata_respond(
mDecoder, FLAC__METADATA_TYPE_PICTURE);
FLAC__stream_decoder_set_metadata_respond(
mDecoder, FLAC__METADATA_TYPE_VORBIS_COMMENT);
FLAC__StreamDecoderInitStatus initStatus;
initStatus = FLAC__stream_decoder_init_stream(
mDecoder,
read_callback, seek_callback, tell_callback,
length_callback, eof_callback, write_callback,
metadata_callback, error_callback, (void *) this);
if (initStatus != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
// A failure here probably indicates a programming error and so is
// unlikely to happen. But we check and log here similarly to above.
LOGE("init_stream failed %d", initStatus);
return NO_INIT;
}
// parse all metadata
if (!FLAC__stream_decoder_process_until_end_of_metadata(mDecoder)) {
LOGE("end_of_metadata failed");
return NO_INIT;
}
if (mStreamInfoValid) {
// check channel count
switch (getChannels()) {
case 1:
case 2:
break;
default:
LOGE("unsupported channel count %u", getChannels());
return NO_INIT;
}
// check bit depth
switch (getBitsPerSample()) {
case 8:
case 16:
case 24:
break;
default:
LOGE("unsupported bits per sample %u", getBitsPerSample());
return NO_INIT;
}
// check sample rate
switch (getSampleRate()) {
case 8000:
case 11025:
case 12000:
case 16000:
case 22050:
case 24000:
case 32000:
case 44100:
case 48000:
break;
default:
// 96000 would require a proper downsampler in AudioFlinger
LOGE("unsupported sample rate %u", getSampleRate());
return NO_INIT;
}
// configure the appropriate copy function, defaulting to trespass
static const struct {
unsigned mChannels;
unsigned mBitsPerSample;
void (*mCopy)(short *dst, const int *const *src, unsigned nSamples);
} table[] = {
{ 1, 8, copyMono8 },
{ 2, 8, copyStereo8 },
{ 1, 16, copyMono16 },
{ 2, 16, copyStereo16 },
{ 1, 24, copyMono24 },
{ 2, 24, copyStereo24 },
};
for (unsigned i = 0; i < sizeof(table)/sizeof(table[0]); ++i) {
if (table[i].mChannels == getChannels() &&
table[i].mBitsPerSample == getBitsPerSample()) {
mCopy = table[i].mCopy;
break;
}
}
// populate track metadata
if (mTrackMetadata != 0) {
mTrackMetadata->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_RAW);
mTrackMetadata->setInt32(kKeyChannelCount, getChannels());
mTrackMetadata->setInt32(kKeySampleRate, getSampleRate());
// sample rate is non-zero, so division by zero not possible
mTrackMetadata->setInt64(kKeyDuration,
(getTotalSamples() * 1000000LL) / getSampleRate());
}
} else {
LOGE("missing STREAMINFO");
return NO_INIT;
}
if (mFileMetadata != 0) {
mFileMetadata->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_FLAC);
}
return OK;
}
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 gboolean
xmms_flac_init (xmms_xform_t *xform)
{
xmms_flac_data_t *data;
xmms_sample_format_t sample_fmt;
FLAC__bool retval;
#if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT <= 7
FLAC__StreamDecoderState init_status;
#else
FLAC__StreamDecoderInitStatus init_status;
#endif
gint filesize;
const gchar *metakey;
g_return_val_if_fail (xform, FALSE);
data = g_new0 (xmms_flac_data_t, 1);
xmms_xform_private_data_set (xform, data);
data->flacdecoder = FLAC__stream_decoder_new ();
/* we don't need to explicitly tell the decoder to respond to
* FLAC__METADATA_TYPE_STREAMINFO here, it always does.
*/
#if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT <= 7
FLAC__seekable_stream_decoder_set_metadata_respond (data->flacdecoder,
FLAC__METADATA_TYPE_VORBIS_COMMENT);
FLAC__seekable_stream_decoder_set_eof_callback (data->flacdecoder,
flac_callback_eof);
FLAC__seekable_stream_decoder_set_read_callback (data->flacdecoder,
flac_callback_read);
FLAC__seekable_stream_decoder_set_seek_callback (data->flacdecoder,
flac_callback_seek);
FLAC__seekable_stream_decoder_set_tell_callback (data->flacdecoder,
flac_callback_tell);
FLAC__seekable_stream_decoder_set_write_callback (data->flacdecoder,
flac_callback_write);
FLAC__seekable_stream_decoder_set_error_callback (data->flacdecoder,
flac_callback_error);
FLAC__seekable_stream_decoder_set_length_callback (data->flacdecoder,
flac_callback_length);
FLAC__seekable_stream_decoder_set_metadata_callback (data->flacdecoder,
flac_callback_metadata);
FLAC__seekable_stream_decoder_set_client_data (data->flacdecoder, xform);
init_status = FLAC__seekable_stream_decoder_init (data->flacdecoder);
if (init_status != FLAC__SEEKABLE_STREAM_DECODER_OK) {
const gchar *errmsg = FLAC__seekable_stream_decoder_get_resolved_state_string (data->flacdecoder);
XMMS_DBG ("FLAC init failed: %s", errmsg);
goto err;
}
#else
FLAC__stream_decoder_set_metadata_respond (data->flacdecoder,
FLAC__METADATA_TYPE_VORBIS_COMMENT);
FLAC__stream_decoder_set_metadata_respond (data->flacdecoder,
FLAC__METADATA_TYPE_PICTURE);
init_status =
FLAC__stream_decoder_init_stream (data->flacdecoder,
flac_callback_read,
flac_callback_seek,
flac_callback_tell,
flac_callback_length,
flac_callback_eof,
flac_callback_write,
flac_callback_metadata,
flac_callback_error,
xform);
if (init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
XMMS_DBG ("FLAC init failed: %s",
FLAC__stream_decoder_get_resolved_state_string (data->flacdecoder));
goto err;
}
#endif
retval = FLAC__stream_decoder_process_until_end_of_metadata (data->flacdecoder);
if (!retval)
goto err;
if (data->vorbiscomment) {
handle_comments (xform, data);
}
metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_BITRATE;
xmms_xform_metadata_set_int (xform, metakey, (gint) data->bit_rate);
metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE;
if (xmms_xform_metadata_get_int (xform, metakey, &filesize)) {
gint32 val = (gint32) data->total_samples / data->sample_rate * 1000;
metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION;
xmms_xform_metadata_set_int (xform, metakey, val);
}
if (data->bits_per_sample == 8) {
sample_fmt = XMMS_SAMPLE_FORMAT_S8;
} else if (data->bits_per_sample == 16) {
sample_fmt = XMMS_SAMPLE_FORMAT_S16;
} else if (data->bits_per_sample == 24) {
sample_fmt = XMMS_SAMPLE_FORMAT_S32;
} else if (data->bits_per_sample == 32) {
sample_fmt = XMMS_SAMPLE_FORMAT_S32;
} else {
goto err;
}
xmms_xform_outdata_type_add (xform,
XMMS_STREAM_TYPE_MIMETYPE,
"audio/pcm",
XMMS_STREAM_TYPE_FMT_FORMAT,
sample_fmt,
XMMS_STREAM_TYPE_FMT_CHANNELS,
data->channels,
XMMS_STREAM_TYPE_FMT_SAMPLERATE,
data->sample_rate,
XMMS_STREAM_TYPE_END);
data->buffer = g_string_new (NULL);
return TRUE;
err:
FLAC__stream_decoder_finish (data->flacdecoder);
FLAC__stream_decoder_delete (data->flacdecoder);
g_free (data);
xmms_xform_private_data_set (xform, NULL);
return FALSE;
}
bool
FLACInputStream::initialize(FilePtr file) {
m_file = file;
// initialize the decoder
m_decoder = FLAC__stream_decoder_new();
if (!m_decoder) {
m_file = 0;
return false;
}
// initialize the stream decoder!
FLAC__StreamDecoderInitStatus state = FLAC__stream_decoder_init_stream(
m_decoder,
read_callback,
seek_callback,
tell_callback,
length_callback,
eof_callback,
write_callback,
metadata_callback,
error_callback,
this);
if (state != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
FLAC__stream_decoder_finish(m_decoder);
FLAC__stream_decoder_delete(m_decoder);
m_decoder = 0;
m_file = 0;
return false;
}
// make sure we have metadata before we return!
if (!FLAC__stream_decoder_process_until_end_of_metadata(m_decoder)) {
FLAC__stream_decoder_finish(m_decoder);
FLAC__stream_decoder_delete(m_decoder);
m_decoder = 0;
m_file = 0;
return false;
}
// process one frame so we can do something!
if (!FLAC__stream_decoder_process_single(m_decoder)) {
FLAC__stream_decoder_finish(m_decoder);
FLAC__stream_decoder_delete(m_decoder);
m_decoder = 0;
m_file = 0;
return false;
}
// get info about the flac file
m_channel_count = FLAC__stream_decoder_get_channels(m_decoder);
m_sample_rate = FLAC__stream_decoder_get_sample_rate(m_decoder);
int bps = FLAC__stream_decoder_get_bits_per_sample(m_decoder);
if (bps == 16) {
m_sample_format = SF_S16;
} else if (bps == 8) {
m_sample_format = SF_U8;
} else {
return false;
}
return true;
}
static void
flac_decode_internal(struct decoder * decoder,
struct input_stream *input_stream,
bool is_ogg)
{
FLAC__StreamDecoder *flac_dec;
struct flac_data data;
const char *err = NULL;
flac_dec = flac_decoder_new();
if (flac_dec == NULL)
return;
flac_data_init(&data, decoder, input_stream);
data.tag = tag_new();
if (is_ogg) {
#if defined(FLAC_API_VERSION_CURRENT) && FLAC_API_VERSION_CURRENT > 7
FLAC__StreamDecoderInitStatus status =
FLAC__stream_decoder_init_ogg_stream(flac_dec,
flac_read_cb,
flac_seek_cb,
flac_tell_cb,
flac_length_cb,
flac_eof_cb,
flac_write_cb,
flacMetadata,
flac_error_cb,
(void *)&data);
if (status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
err = "doing Ogg init()";
goto fail;
}
#else
goto fail;
#endif
} else {
FLAC__StreamDecoderInitStatus status =
FLAC__stream_decoder_init_stream(flac_dec,
flac_read_cb,
flac_seek_cb,
flac_tell_cb,
flac_length_cb,
flac_eof_cb,
flac_write_cb,
flacMetadata,
flac_error_cb,
(void *)&data);
if (status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
err = "doing init()";
goto fail;
}
}
if (!flac_decoder_initialize(&data, flac_dec, 0)) {
flac_data_deinit(&data);
FLAC__stream_decoder_delete(flac_dec);
return;
}
flac_decoder_loop(&data, flac_dec, 0, 0);
fail:
flac_data_deinit(&data);
FLAC__stream_decoder_delete(flac_dec);
if (err)
g_warning("%s\n", err);
}
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;
}
bool
flac_reader_c::parse_file() {
FLAC__StreamDecoder *decoder;
FLAC__StreamDecoderState state;
flac_block_t block;
uint64_t u, old_pos;
int result, progress, old_progress;
bool ok;
m_in->setFilePointer(0);
metadata_parsed = false;
mxinfo(Y("+-> Parsing the FLAC file. This can take a LONG time.\n"));
decoder = FLAC__stream_decoder_new();
if (decoder == NULL)
mxerror(Y("flac_reader: FLAC__stream_decoder_new() failed.\n"));
if (!FLAC__stream_decoder_set_metadata_respond_all(decoder))
mxerror(Y("flac_reader: Could not set metadata_respond_all.\n"));
if (FLAC__stream_decoder_init_stream(decoder, flac_read_cb, flac_seek_cb, flac_tell_cb, flac_length_cb, flac_eof_cb, flac_write_cb,
flac_metadata_cb, flac_error_cb, this) != FLAC__STREAM_DECODER_INIT_STATUS_OK)
mxerror(Y("flac_reader: Could not initialize the FLAC decoder.\n"));
result = FLAC__stream_decoder_process_until_end_of_metadata(decoder);
mxverb(2, boost::format("flac_reader: extract->metadata, result: %1%, mdp: %2%, num blocks: %3%\n") % result % metadata_parsed % blocks.size());
if (!metadata_parsed)
mxerror_fn(m_ti.m_fname, Y("No metadata block found. This file is broken.\n"));
FLAC__stream_decoder_get_decode_position(decoder, &u);
block.type = FLAC_BLOCK_TYPE_HEADERS;
block.filepos = 0;
block.len = u;
old_pos = u;
blocks.push_back(block);
mxverb(2, boost::format("flac_reader: headers: block at %1% with size %2%\n") % block.filepos % block.len);
old_progress = -5;
ok = FLAC__stream_decoder_skip_single_frame(decoder);
while (ok) {
state = FLAC__stream_decoder_get_state(decoder);
progress = m_in->getFilePointer() * 100 / m_size;
if ((progress - old_progress) >= 5) {
mxinfo(boost::format(Y("+-> Pre-parsing FLAC file: %1%%%%2%")) % progress % "\r");
old_progress = progress;
}
if (FLAC__stream_decoder_get_decode_position(decoder, &u) && (u != old_pos)) {
block.type = FLAC_BLOCK_TYPE_DATA;
block.filepos = old_pos;
block.len = u - old_pos;
old_pos = u;
blocks.push_back(block);
mxverb(2, boost::format("flac_reader: skip/decode frame, block at %1% with size %2%\n") % block.filepos % block.len);
}
if (state > FLAC__STREAM_DECODER_READ_FRAME)
break;
ok = FLAC__stream_decoder_skip_single_frame(decoder);
}
if (100 != old_progress)
mxinfo(Y("+-> Pre-parsing FLAC file: 100%\n"));
else
mxinfo("\n");
if ((blocks.size() == 0) || (blocks[0].type != FLAC_BLOCK_TYPE_HEADERS))
mxerror(Y("flac_reader: Could not read all header packets.\n"));
FLAC__stream_decoder_reset(decoder);
FLAC__stream_decoder_delete(decoder);
m_in->setFilePointer(0);
blocks[0].len -= 4;
blocks[0].filepos = 4;
return metadata_parsed;
}
int32_t MV_PlayFLAC
(
char *ptr,
uint32_t ptrlength,
int32_t loopstart,
int32_t loopend,
int32_t pitchoffset,
int32_t vol,
int32_t left,
int32_t right,
int32_t priority,
uint32_t callbackval
)
{
VoiceNode *voice;
flac_data * fd = 0;
FLAC__Metadata_Chain* metadata_chain;
UNREFERENCED_PARAMETER(loopend);
if ( !MV_Installed )
{
MV_SetErrorCode( MV_NotInstalled );
return MV_Error;
}
fd = (flac_data *) malloc( sizeof(flac_data) );
if (!fd) {
MV_SetErrorCode( MV_InvalidFLACFile );
return MV_Error;
}
memset(fd, 0, sizeof(flac_data));
fd->ptr = ptr;
fd->pos = 0;
fd->blocksize = 0;
fd->length = ptrlength;
fd->block = NULL;
fd->stream = FLAC__stream_decoder_new();
fd->sample_pos = 0;
FLAC__stream_decoder_set_metadata_ignore_all(fd->stream);
if (FLAC__stream_decoder_init_stream(fd->stream,
read_flac_stream,
seek_flac_stream,
tell_flac_stream,
length_flac_stream,
eof_flac_stream,
write_flac_stream,
/*metadata_flac_stream*/ NULL,
error_flac_stream,
(void*) fd) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
MV_Printf("MV_PlayFLAC: %s\n", FLAC__stream_decoder_get_resolved_state_string(fd->stream));
MV_SetErrorCode( MV_InvalidFLACFile );
return MV_Error;
}
// Request a voice from the voice pool
voice = MV_AllocVoice( priority );
if ( voice == NULL )
{
FLAC__stream_decoder_finish(fd->stream);
FLAC__stream_decoder_delete(fd->stream);
free(fd);
MV_SetErrorCode( MV_NoVoices );
return MV_Error;
}
fd->owner = voice;
voice->wavetype = FLAC;
voice->extra = (void*)fd;
voice->GetSound = MV_GetNextFLACBlock;
voice->NextBlock = fd->block;
voice->DemandFeed = NULL;
voice->LoopCount = 0;
voice->BlockLength = 0;
voice->PitchScale = PITCH_GetScale( pitchoffset );
voice->next = NULL;
voice->prev = NULL;
voice->priority = priority;
voice->callbackval = callbackval;
voice->Playing = TRUE;
voice->Paused = FALSE;
voice->LoopStart = 0;
voice->LoopEnd = 0;
voice->LoopSize = (loopstart >= 0 ? 1 : 0);
// parse metadata
// loop parsing designed with multiple repetitions in mind
// In retrospect, it may be possible to MV_GetVorbisCommentLoops(voice, (vorbis_comment *) tags->data.vorbis_comment)
// but libvorbisfile may be confused by the signedness of char* vs FLAC__byte* and this code does not depend on HAVE_VORBIS.
metadata_chain = FLAC__metadata_chain_new();
if (metadata_chain != NULL)
{
if (FLAC__metadata_chain_read_with_callbacks(metadata_chain, fd, flac_callbacks))
{
FLAC__Metadata_Iterator* metadata_iterator = FLAC__metadata_iterator_new();
if (metadata_iterator != NULL)
{
char *vc_loopstart = NULL;
char *vc_loopend = NULL;
char *vc_looplength = NULL;
FLAC__metadata_iterator_init(metadata_iterator, metadata_chain);
do
{
FLAC__StreamMetadata *tags = FLAC__metadata_iterator_get_block(metadata_iterator);
if (tags->type == FLAC__METADATA_TYPE_STREAMINFO)
{
const FLAC__StreamMetadata_StreamInfo *info = &tags->data.stream_info;
if (info->channels != 1 && info->channels != 2) {
FLAC__metadata_object_delete(tags);
FLAC__metadata_iterator_delete(metadata_iterator);
// FLAC__metadata_chain_delete(metadata_chain);
FLAC__stream_decoder_finish(fd->stream);
FLAC__stream_decoder_delete(fd->stream);
free(fd);
MV_SetErrorCode( MV_InvalidFLACFile );
return MV_Error;
}
voice->channels = info->channels;
voice->bits = info->bits_per_sample;
voice->SamplingRate = info->sample_rate;
}
// load loop tags from metadata
if (tags->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
{
FLAC__uint32 comment;
uint8_t loopTagCount;
for (comment = 0; comment < tags->data.vorbis_comment.num_comments; ++comment)
{
const char *entry = (const char *) tags->data.vorbis_comment.comments[comment].entry;
if (entry != NULL && entry[0] != '\0')
{
const char *value = strchr(entry,'=');
const size_t field = value-entry;
value += 1;
for (loopTagCount = 0; loopTagCount < loopStartTagCount && vc_loopstart == NULL; ++loopTagCount)
if (strncasecmp(entry, loopStartTags[loopTagCount], field) == 0)
vc_loopstart = strdup(value);
for (loopTagCount = 0; loopTagCount < loopEndTagCount && vc_loopend == NULL; ++loopTagCount)
if (strncasecmp(entry, loopEndTags[loopTagCount], field) == 0)
vc_loopend = strdup(value);
for (loopTagCount = 0; loopTagCount < loopLengthTagCount && vc_looplength == NULL; ++loopTagCount)
if (strncasecmp(entry, loopLengthTags[loopTagCount], field) == 0)
vc_looplength = strdup(value);
}
}
}
FLAC__metadata_object_delete(tags); // If it wasn't for this I would assign pointers instead of strdup().
}
while (FLAC__metadata_iterator_next(metadata_iterator));
if (vc_loopstart != NULL)
{
{
const FLAC__int64 flac_loopstart = atol(vc_loopstart);
if (flac_loopstart >= 0) // a loop starting at 0 is valid
{
voice->LoopStart = (const char *) (intptr_t) flac_loopstart;
voice->LoopSize = 1;
}
}
free(vc_loopstart);
}
if (vc_loopend != NULL)
{
if (voice->LoopSize > 0)
{
const FLAC__int64 flac_loopend = atol(vc_loopend);
if (flac_loopend > 0) // a loop ending at 0 is invalid
voice->LoopEnd = (const char *) (intptr_t) flac_loopend;
}
free(vc_loopend);
}
if (vc_looplength != NULL)
{
if (voice->LoopSize > 0 && voice->LoopEnd == 0)
{
const FLAC__int64 flac_looplength = atol(vc_looplength);
if (flac_looplength > 0) // a loop of length 0 is invalid
voice->LoopEnd = (const char *) ((intptr_t) flac_looplength + (intptr_t) voice->LoopStart);
}
free(vc_looplength);
}
FLAC__metadata_iterator_delete(metadata_iterator);
}
else
MV_Printf("Error allocating FLAC__Metadata_Iterator!\n");
}
else
MV_Printf("%s\n", FLAC__Metadata_ChainStatusString[FLAC__metadata_chain_status(metadata_chain)]);
// FLAC__metadata_chain_delete(metadata_chain); // when run with GDB, this throws SIGTRAP about freed heap memory being modified
}
else
MV_Printf("Error allocating FLAC__Metadata_Chain!\n");
// CODEDUP multivoc.c MV_SetVoicePitch
voice->RateScale = ( voice->SamplingRate * voice->PitchScale ) / MV_MixRate;
voice->FixedPointBufferSize = ( voice->RateScale * MV_MIXBUFFERSIZE ) -
voice->RateScale;
MV_SetVoiceMixMode( voice );
MV_SetVoiceVolume( voice, vol, left, right );
MV_PlayVoice( voice );
return voice->handle;
}
