FLAC__bool FLAC__file_decoder_set_md5_checking(FLAC__FileDecoder *decoder, FLAC__bool value)
{
FLAC__ASSERT(0 != decoder);
FLAC__ASSERT(0 != decoder->private_);
FLAC__ASSERT(0 != decoder->protected_);
FLAC__ASSERT(0 != decoder->private_->seekable_stream_decoder);
if(decoder->protected_->state != FLAC__FILE_DECODER_UNINITIALIZED)
return false;
return FLAC__seekable_stream_decoder_set_md5_checking(decoder->private_->seekable_stream_decoder, value);
}
int main(int argc, char *argv[])
{
if (argc!=2)
{
fprintf(stderr, "usage: %s flacfile\n", argv[0]);
return -1;
}
myfile = fopen(argv[1], "ro");
if (!myfile)
{
perror("fopen()");
return -1;
}
decoder = FLAC__seekable_stream_decoder_new();
if (!decoder)
{
fprintf(stderr, "FLAC__seekable_stream_decoder_new() failed, out of memory?\n");
return 1;
}
FLAC__seekable_stream_decoder_set_md5_checking(decoder, 0);
FLAC__seekable_stream_decoder_set_read_callback(decoder, read_callback);
FLAC__seekable_stream_decoder_set_write_callback(decoder, write_callback);
FLAC__seekable_stream_decoder_set_metadata_callback(decoder, metadata_callback);
FLAC__seekable_stream_decoder_set_seek_callback(decoder, seek_callback);
FLAC__seekable_stream_decoder_set_tell_callback(decoder, tell_callback);
FLAC__seekable_stream_decoder_set_length_callback(decoder, length_callback);
FLAC__seekable_stream_decoder_set_eof_callback(decoder, eof_callback);
FLAC__seekable_stream_decoder_set_client_data(decoder, myvar);
FLAC__seekable_stream_decoder_set_error_callback(decoder, error_callback);
switch (FLAC__seekable_stream_decoder_init(decoder))
{
case FLAC__SEEKABLE_STREAM_DECODER_OK:
fprintf(stderr, "init ok\n");
break;
case FLAC__SEEKABLE_STREAM_DECODER_SEEKING:
fprintf(stderr, "seeking\n");
break;
case FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM:
fprintf(stderr, "eof\n");
break;
case FLAC__SEEKABLE_STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
fprintf(stderr, "malloc failed\n");
break;
case FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR:
fprintf(stderr, "decoder error\n");
break;
case FLAC__SEEKABLE_STREAM_DECODER_READ_ERROR:
fprintf(stderr, "read error\n");
break;
case FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR:
fprintf(stderr, "seek error\n");
break;
case FLAC__SEEKABLE_STREAM_DECODER_ALREADY_INITIALIZED:
fprintf(stderr, "already init'ed\n");
break;
case FLAC__SEEKABLE_STREAM_DECODER_INVALID_CALLBACK:
fprintf(stderr, "invalid callback\n");
break;
case FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED:
fprintf(stderr, "decoder uninted\n");
break;
default:
fprintf(stderr, "init not ok\n");
break;
}
FLAC__seekable_stream_decoder_process_until_end_of_metadata(decoder);
FLAC__seekable_stream_decoder_process_single(decoder);
fprintf(stderr, "channels=%d\n", FLAC__seekable_stream_decoder_get_channels(decoder));
fprintf(stderr, "bits per sample=%d\n", FLAC__seekable_stream_decoder_get_bits_per_sample(decoder));
/*
fprintf(stderr, "position=%d\n", FLAC__seekable_stream_decoder_get_decode_position(decoder));
*/
FLAC__seekable_stream_decoder_finish(decoder);
FLAC__seekable_stream_decoder_delete(decoder);
fclose(myfile);
return 0;
}
int FlacPcm::processData(MediaInfo *infos, ChunkList *chunk_list, bool *killswitch)
{
reader = infos->getReader();
if(reader == 0)
return 0;
if(decoder == 0) {
decoder = FLAC__seekable_stream_decoder_new();
if(decoder == 0)
return 0;
FLAC__seekable_stream_decoder_set_md5_checking(decoder, false);
FLAC__seekable_stream_decoder_set_read_callback(decoder, readCallback_);
FLAC__seekable_stream_decoder_set_seek_callback(decoder, seekCallback_);
FLAC__seekable_stream_decoder_set_tell_callback(decoder, tellCallback_);
FLAC__seekable_stream_decoder_set_length_callback(decoder, lengthCallback_);
FLAC__seekable_stream_decoder_set_eof_callback(decoder, eofCallback_);
FLAC__seekable_stream_decoder_set_write_callback(decoder, writeCallback_);
FLAC__seekable_stream_decoder_set_metadata_callback(decoder, metadataCallback_);
FLAC__seekable_stream_decoder_set_error_callback(decoder, errorCallback_);
FLAC__seekable_stream_decoder_set_client_data(decoder, this);
if(FLAC__seekable_stream_decoder_init(decoder) != FLAC__SEEKABLE_STREAM_DECODER_OK) {
cleanup();
return 0;
}
if(!FLAC__seekable_stream_decoder_process_until_end_of_metadata(decoder)) {
cleanup();
return 0;
}
}
if(needs_seek) {
FLAC__seekable_stream_decoder_seek_absolute(decoder, seek_sample);
needs_seek = false;
}
bool eof = false;
while(samples_in_reservoir < 576) {
if(FLAC__seekable_stream_decoder_get_state(decoder) == FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM) {
eof = true;
break;
}
else if(!FLAC__seekable_stream_decoder_process_single(decoder)) {
//@@@ how to do this? MessageBox(mod_.hMainWindow, FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder_)], "READ ERROR processing frame", 0);
eof = true;
break;
}
}
if(samples_in_reservoir == 0) {
eof = true;
}
else {
const unsigned channels = streaminfo.data.stream_info.channels;
const unsigned bits_per_sample = streaminfo.data.stream_info.bits_per_sample;
const unsigned bytes_per_sample = (bits_per_sample+7)/8;
const unsigned sample_rate = streaminfo.data.stream_info.sample_rate;
unsigned i, n = min(samples_in_reservoir, 576), delta;
signed short *ssbuffer = (signed short*)output;
for(i = 0; i < n*channels; i++)
ssbuffer[i] = reservoir[i];
delta = i;
for( ; i < samples_in_reservoir*channels; i++)
reservoir[i-delta] = reservoir[i];
samples_in_reservoir -= n;
const int bytes = n * channels * bytes_per_sample;
ChunkInfosI *ci=new ChunkInfosI();
ci->addInfo("srate", sample_rate);
ci->addInfo("bps", bits_per_sample);
ci->addInfo("nch", channels);
chunk_list->setChunk("PCM", output, bytes, ci);
}
if(eof)
return 0;
return 1;
}
