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;
}
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;
}
void play_file_from_filename(const std::string name) {
currently_playing = std::string(name);
if (audiobuf) linearFree(audiobuf);
if (name.rfind(".flac") != std::string::npos) {
if (!FLAC_decoder) {
FLAC_decoder = FLAC__stream_decoder_new();
FLAC__stream_decoder_set_md5_checking(FLAC_decoder, true);
}
audiobuf_index = 0;
decode_mode = AUDIO_MODE_FLAC;
FLAC__StreamDecoderInitStatus init_status = FLAC__stream_decoder_init_file(FLAC_decoder, name.c_str(), FLAC_write_callback, FLAC_metadata_callback, FLAC_error_callback, NULL);
if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
printf("ERROR: initializing decoder: %s\n", FLAC__StreamDecoderInitStatusString[init_status]);
}
FLAC__stream_decoder_process_until_end_of_metadata(FLAC_decoder);
} else {
decode_mode = AUDIO_MODE_VORBIS;
v = stb_vorbis_open_filename(name.c_str(), &error, NULL);
info = stb_vorbis_get_info(v);
Samples = info.sample_rate;
audiobuf_size = Samples * sizeof(s16) * 2;
audiobuf = (s16*)linearAlloc(audiobuf_size);
}
paused = false;
}
static status_t HandleFLAC(const char *filename, MediaScannerClient* client)
{
status_t status = UNKNOWN_ERROR;
FLAC__StreamDecoder *decoder;
decoder = FLAC__stream_decoder_new();
if (!decoder)
return status;
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);
FLAC__StreamDecoderInitStatus init_status;
init_status = FLAC__stream_decoder_init_file(decoder, filename, flac_write, flac_metadata, flac_error, client);
if (init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK)
goto exit;
if (!FLAC__stream_decoder_process_until_end_of_metadata(decoder))
goto exit;
status = OK;
exit:
FLAC__stream_decoder_finish(decoder);
FLAC__stream_decoder_delete(decoder);
return status;
}
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;
}
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;
}
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;
}
FLAC__bool FLAC_plugin__decoder_init(FLAC__StreamDecoder *decoder, const char *filename, FLAC__int64 filesize, stream_data_struct *stream_data, output_config_t *config)
{
FLAC__StreamDecoderInitStatus init_status;
FLAC__ASSERT(decoder);
FLAC_plugin__decoder_finish(decoder);
/* init 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 ((init_status = FLAC__stream_decoder_init_file(decoder, filename, write_callback, metadata_callback, error_callback, /*client_data=*/stream_data)) != FLAC__STREAM_DECODER_INIT_STATUS_OK)
{
FLAC_plugin__show_error("Error while initializing decoder (%s [%s]).", FLAC__StreamDecoderInitStatusString[init_status], FLAC__stream_decoder_get_resolved_state_string(decoder));
return false;
}
/* process */
cfg = *config;
wide_samples_in_reservoir_ = 0;
stream_data->is_playing = false;
stream_data->abort_flag = false;
stream_data->has_replaygain = false;
if (!FLAC__stream_decoder_process_until_end_of_metadata(decoder))
{
FLAC_plugin__show_error("Error while processing metadata (%s).", FLAC__stream_decoder_get_resolved_state_string(decoder));
return false;
}
/* check results */
if (stream_data->abort_flag) return false; /* metadata callback already popped up the error dialog */
/* init replaygain */
stream_data->output_bits_per_sample = stream_data->has_replaygain && cfg.replaygain.enable ?
cfg.resolution.replaygain.bps_out :
cfg.resolution.normal.dither_24_to_16 ? min(stream_data->bits_per_sample, 16) : stream_data->bits_per_sample;
if (stream_data->has_replaygain && cfg.replaygain.enable && cfg.resolution.replaygain.dither)
FLAC__replaygain_synthesis__init_dither_context(&stream_data->dither_context, stream_data->bits_per_sample, cfg.resolution.replaygain.noise_shaping);
/* more inits */
stream_data->eof = false;
stream_data->seek_to = -1;
stream_data->is_playing = true;
stream_data->average_bps = (unsigned)(filesize / (125.*(double)(FLAC__int64)stream_data->total_samples/(double)stream_data->sample_rate));
bh_index_last_w = 0;
bh_index_last_o = BITRATE_HIST_SIZE;
decode_position = 0;
decode_position_last = 0;
written_time_last = 0;
return true;
}
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;
}
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);
}
}
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;
}
static int play_flac(lua_State *lstate) {
FLAC_FEED *feed;
char buf[BLOCKSIZE];
int port, sock;
char *mark;
const char *host, *mount;
lua_pushstring(lstate, "host");
lua_gettable(lstate, -2);
lua_pushstring(lstate, "port");
lua_gettable(lstate, -3);
lua_pushstring(lstate, "mount");
lua_gettable(lstate, -4);
mount = lua_tostring(lstate, -1);
port = lua_tointeger(lstate, -2);
host = lua_tostring(lstate, -3);
sock = stream_connect(host, port, mount, buf, &mark);
lua_pop(lstate, 3);
if (sock == 0) {
lua_pop(lstate, 1);
return 0;
}
lua_pushstring(lstate, "intern");
lua_gettable(lstate, -2);
feed = (FLAC_FEED *)lua_touserdata(lstate, -1);
lua_pop(lstate, 1);
feed->base.sock = sock;
pthread_mutex_init(&(feed->base.thread_lock), NULL);
pthread_cond_init(&(feed->base.data_ready), NULL);
feed->decoder = FLAC__stream_decoder_new();
FLAC__stream_decoder_set_md5_checking(feed->decoder, false);
FLAC__stream_decoder_init_ogg_stream(feed->decoder,
flac_read,
NULL, //seek_callback,
NULL, // tell_callback,
NULL, //length_callback,
NULL, // eof_callback,
flac_write,
flac_metadata,
flac_error,
(void *)feed);
lua_pop(lstate, 1);
pthread_create(&(feed->base.thread_id), NULL, flac_thread, feed);
return 0;
}
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;
}
int flac_open(FILE *in,oe_enc_opt *opt,unsigned char *oldbuf,int buflen){
flacfile *flac;
/*Ok. At this point, we know we have a FLAC or an OggFLAC file.
Set up the FLAC decoder.*/
flac=malloc(sizeof(*flac));
flac->decoder=FLAC__stream_decoder_new();
FLAC__stream_decoder_set_md5_checking(flac->decoder,false);
/*We get STREAMINFO packets by default, but not VORBIS_COMMENT or PICTURE.*/
FLAC__stream_decoder_set_metadata_respond(flac->decoder,
FLAC__METADATA_TYPE_VORBIS_COMMENT);
FLAC__stream_decoder_set_metadata_respond(flac->decoder,
FLAC__METADATA_TYPE_PICTURE);
flac->inopt=opt;
flac->f=in;
flac->oldbuf=malloc(buflen*sizeof(*flac->oldbuf));
memcpy(flac->oldbuf,oldbuf,buflen*sizeof(*flac->oldbuf));
flac->bufpos=0;
flac->buflen=buflen;
flac->block_buf=NULL;
if((*(flac_id(oldbuf,buflen)?
FLAC__stream_decoder_init_stream:FLAC__stream_decoder_init_ogg_stream))(
flac->decoder,read_callback,NULL,NULL,NULL,eof_callback,
write_callback,metadata_callback,error_callback,flac)==
FLAC__STREAM_DECODER_INIT_STATUS_OK){
/*Decode until we get the file length, sample rate, the number of channels,
and the Vorbis comments (if any).*/
if(FLAC__stream_decoder_process_until_end_of_metadata(flac->decoder)){
opt->read_samples=flac_read;
opt->readdata=flac;
/*FLAC supports 1 to 8 channels only.*/
speex_assert(flac->channels>0&&flac->channels<=8);
/*It uses the same channel mappings as WAV.*/
flac->channel_permute=wav_permute_matrix[flac->channels-1];
return 1;
}
}
flac_close(flac);
fprintf(stderr,_("ERROR: Could not open FLAC stream.\n"));
return 0;
}
static int start_read(sox_format_t * const ft)
{
priv_t * p = (priv_t *)ft->priv;
lsx_debug("API version %u", FLAC_API_VERSION_CURRENT);
p->decoder = FLAC__stream_decoder_new();
if (p->decoder == NULL) {
lsx_fail_errno(ft, SOX_ENOMEM, "FLAC ERROR creating the decoder instance");
return SOX_EOF;
}
FLAC__stream_decoder_set_md5_checking(p->decoder, sox_true);
FLAC__stream_decoder_set_metadata_respond_all(p->decoder);
if (FLAC__stream_decoder_init_FILE(p->decoder, ft->fp, /* Not using SoX IO */
FLAC__frame_decode_callback, FLAC__decoder_metadata_callback,
FLAC__decoder_error_callback, ft) != FLAC__STREAM_DECODER_INIT_STATUS_OK){
lsx_fail_errno(ft, SOX_EHDR, "FLAC ERROR initialising decoder");
return SOX_EOF;
}
ft->fp = NULL; /* Transfer ownership of fp to FLAC */
if (!FLAC__stream_decoder_process_until_end_of_metadata(p->decoder)) {
lsx_fail_errno(ft, SOX_EHDR, "FLAC ERROR whilst decoding metadata");
return SOX_EOF;
}
if (FLAC__stream_decoder_get_state(p->decoder) > FLAC__STREAM_DECODER_END_OF_STREAM) {
lsx_fail_errno(ft, SOX_EHDR, "FLAC ERROR during metadata decoding");
return SOX_EOF;
}
ft->encoding.encoding = SOX_ENCODING_FLAC;
ft->signal.rate = p->sample_rate;
ft->encoding.bits_per_sample = p->bits_per_sample;
ft->signal.channels = p->channels;
ft->signal.length = p->total_samples * p->channels;
return SOX_SUCCESS;
}
/*
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;
}
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 int start_read(sox_format_t * const ft)
{
priv_t * p = (priv_t *)ft->priv;
lsx_debug("API version %u", FLAC_API_VERSION_CURRENT);
p->decoder = FLAC__stream_decoder_new();
if (p->decoder == NULL) {
lsx_fail_errno(ft, SOX_ENOMEM, "FLAC ERROR creating the decoder instance");
return SOX_EOF;
}
FLAC__stream_decoder_set_md5_checking(p->decoder, sox_true);
FLAC__stream_decoder_set_metadata_respond_all(p->decoder);
#if FLAC_API_VERSION_CURRENT <= 7
/* This is wrong: not using SoX IO, and there will be 2 FILEs open;
* however, it's an old FLAC API, so not worth fixing now. */
FLAC__file_decoder_set_filename(p->decoder, ft->filename);
FLAC__file_decoder_set_write_callback(p->decoder, FLAC__frame_decode_callback);
FLAC__file_decoder_set_metadata_callback(p->decoder, FLAC__decoder_metadata_callback);
FLAC__file_decoder_set_error_callback(p->decoder, FLAC__decoder_error_callback);
FLAC__file_decoder_set_client_data(p->decoder, ft);
if (FLAC__file_decoder_init(p->decoder) != FLAC__FILE_DECODER_OK) {
lsx_fail_errno(ft, SOX_EHDR, "FLAC ERROR initialising decoder");
return SOX_EOF;
}
#else
if (FLAC__stream_decoder_init_FILE(p->decoder, ft->fp, /* Not using SoX IO */
FLAC__frame_decode_callback, FLAC__decoder_metadata_callback,
FLAC__decoder_error_callback, ft) != FLAC__STREAM_DECODER_INIT_STATUS_OK){
lsx_fail_errno(ft, SOX_EHDR, "FLAC ERROR initialising decoder");
return SOX_EOF;
}
ft->fp = NULL; /* Transfer ownership of fp to FLAC */
#endif
if (!FLAC__stream_decoder_process_until_end_of_metadata(p->decoder)) {
lsx_fail_errno(ft, SOX_EHDR, "FLAC ERROR whilst decoding metadata");
return SOX_EOF;
}
#if FLAC_API_VERSION_CURRENT <= 7
if (FLAC__file_decoder_get_state(p->decoder) != FLAC__FILE_DECODER_OK && FLAC__file_decoder_get_state(p->decoder) != FLAC__FILE_DECODER_END_OF_FILE) {
#else
if (FLAC__stream_decoder_get_state(p->decoder) > FLAC__STREAM_DECODER_END_OF_STREAM) {
#endif
lsx_fail_errno(ft, SOX_EHDR, "FLAC ERROR during metadata decoding");
return SOX_EOF;
}
ft->encoding.encoding = SOX_ENCODING_FLAC;
ft->signal.rate = p->sample_rate;
ft->encoding.bits_per_sample = p->bits_per_sample;
ft->signal.channels = p->channels;
ft->signal.length = p->total_samples * p->channels;
return SOX_SUCCESS;
}
static size_t read_samples(sox_format_t * const ft, sox_sample_t * sampleBuffer, size_t const requested)
{
priv_t * p = (priv_t *)ft->priv;
size_t actual = 0;
while (!p->eof && actual < requested) {
if (p->wide_sample_number >= p->number_of_wide_samples)
FLAC__stream_decoder_process_single(p->decoder);
if (p->wide_sample_number >= p->number_of_wide_samples)
p->eof = sox_true;
else {
unsigned channel;
for (channel = 0; channel < p->channels; channel++, actual++) {
FLAC__int32 d = p->decoded_wide_samples[channel][p->wide_sample_number];
switch (p->bits_per_sample) {
case 8: *sampleBuffer++ = SOX_SIGNED_8BIT_TO_SAMPLE(d,); break;
case 16: *sampleBuffer++ = SOX_SIGNED_16BIT_TO_SAMPLE(d,); break;
case 24: *sampleBuffer++ = SOX_SIGNED_24BIT_TO_SAMPLE(d,); break;
case 32: *sampleBuffer++ = SOX_SIGNED_32BIT_TO_SAMPLE(d,); break;
}
}
++p->wide_sample_number;
}
}
return actual;
}
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;
}
