::FLAC__StreamDecoderWriteStatus FileDecoder::write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[])
{
//assert(InternalBufferSize == 0);
//blocksize is usually 4608, channels is usually 2
if (PresumedChannels != frame->header.channels || PresumedBlockSize != frame->header.blocksize)
CleanUp(); // things have changed so let's remake the internal buffer
if (InternalBufferHead == NULL) // if NULL, then it's the "first time" this function is run
{
PresumedChannels = frame->header.channels;
PresumedBlockSize = frame->header.blocksize;
RawInternalBufferHead = new FLAC__int32*[PresumedChannels];
for (unsigned i = 0; i < PresumedChannels; i++)
RawInternalBufferHead[i] = new FLAC__int32[PresumedBlockSize];
InternalBufferHead = new FLAC__int32[PresumedBlockSize]; // not sure why we don't need to account for PresumedChannels. Does FLAC__plugin_common__pack_pcm_signed_little_endian reduce the size of the data by PresumedChannels?
}
for (unsigned channel = 0; channel < PresumedChannels; channel++)
//assert(sizeof(buffer[0][0]) == 4);
memcpy(RawInternalBufferHead[channel], buffer[channel], sizeof(FLAC__int32) * PresumedBlockSize);
FLAC__plugin_common__pack_pcm_signed_little_endian((FLAC__byte*)InternalBufferHead, (FLAC__int32**)RawInternalBufferHead, PresumedBlockSize, PresumedChannels, MapPluginFileInfo.nBitsPerSample, MapPluginFileInfo.nBitsPerSample);
InternalBufferSize = sizeof(FLAC__int32) * PresumedBlockSize; // not sure why we don't need to account for PresumedChannels. Does FLAC__plugin_common__pack_pcm_signed_little_endian reduce the size of the data by PresumedChannels?
InternalBuffer = InternalBufferHead; // reset the position of InternalBuffer
return ::FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}
FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
{
stream_data_struct *stream_data = (stream_data_struct *)client_data;
const unsigned channels = stream_data->channels, wide_samples = frame->header.blocksize;
const unsigned bits_per_sample = stream_data->bits_per_sample;
FLAC__byte *sample_buffer_start;
(void)decoder;
if(stream_data->abort_flag)
return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
if((sample_buffer_last_ + wide_samples) > (SAMPLE_BUFFER_SIZE / (channels * stream_data->sample_format_bytes_per_sample))) {
memmove(sample_buffer_, sample_buffer_ + sample_buffer_first_ * channels * stream_data->sample_format_bytes_per_sample, (sample_buffer_last_ - sample_buffer_first_) * channels * stream_data->sample_format_bytes_per_sample);
sample_buffer_last_ -= sample_buffer_first_;
sample_buffer_first_ = 0;
}
sample_buffer_start = sample_buffer_ + sample_buffer_last_ * channels * stream_data->sample_format_bytes_per_sample;
if(stream_data->has_replaygain && flac_cfg.output.replaygain.enable) {
FLAC__replaygain_synthesis__apply_gain(
sample_buffer_start,
!is_big_endian_host_,
stream_data->sample_format_bytes_per_sample == 1, /* unsigned_data_out */
buffer,
wide_samples,
channels,
bits_per_sample,
stream_data->sample_format_bytes_per_sample * 8,
stream_data->replay_scale,
flac_cfg.output.replaygain.hard_limit,
flac_cfg.output.resolution.replaygain.dither,
&stream_data->dither_context
);
}
else if(is_big_endian_host_) {
FLAC__plugin_common__pack_pcm_signed_big_endian(
sample_buffer_start,
buffer,
wide_samples,
channels,
bits_per_sample,
stream_data->sample_format_bytes_per_sample * 8
);
}
else {
FLAC__plugin_common__pack_pcm_signed_little_endian(
sample_buffer_start,
buffer,
wide_samples,
channels,
bits_per_sample,
stream_data->sample_format_bytes_per_sample * 8
);
}
sample_buffer_last_ += wide_samples;
return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}
unsigned FLAC_plugin__decode(FLAC__StreamDecoder *decoder, stream_data_struct *stream_data, char *sample_buffer)
{
/* fill reservoir */
while (wide_samples_in_reservoir_ < SAMPLES_PER_WRITE)
{
if (FLAC__stream_decoder_get_state(decoder) == FLAC__STREAM_DECODER_END_OF_STREAM)
{
stream_data->eof = true;
break;
}
else if (!FLAC__stream_decoder_process_single(decoder))
{
FLAC_plugin__show_error("Error while processing frame (%s).", FLAC__stream_decoder_get_resolved_state_string(decoder));
stream_data->eof = true;
break;
}
if (!FLAC__stream_decoder_get_decode_position(decoder, &decode_position))
decode_position = 0;
}
/* output samples */
if (wide_samples_in_reservoir_ > 0)
{
const unsigned n = min(wide_samples_in_reservoir_, SAMPLES_PER_WRITE);
const unsigned channels = stream_data->channels;
unsigned i;
int bytes;
if (cfg.replaygain.enable && stream_data->has_replaygain)
{
bytes = FLAC__replaygain_synthesis__apply_gain(
sample_buffer,
true, /* little_endian_data_out */
stream_data->output_bits_per_sample == 8, /* unsigned_data_out */
reservoir__,
n,
channels,
stream_data->bits_per_sample,
stream_data->output_bits_per_sample,
stream_data->replay_scale,
cfg.replaygain.hard_limit,
cfg.resolution.replaygain.dither,
&stream_data->dither_context
);
}
else
{
bytes = FLAC__plugin_common__pack_pcm_signed_little_endian(
sample_buffer,
reservoir__,
n,
channels,
stream_data->bits_per_sample,
stream_data->output_bits_per_sample
);
}
wide_samples_in_reservoir_ -= n;
for (i = 0; i < channels; i++)
memmove(&reservoir_[i][0], &reservoir_[i][n], sizeof(reservoir_[0][0]) * wide_samples_in_reservoir_);
return bytes;
}
else
{
stream_data->eof = true;
return 0;
}
}
DWORD WINAPI __stdcall DecodeThread(void *b)
{
int done = 0;
while(! *((int *)b) ) {
const unsigned channels = file_info_.channels;
const unsigned bits_per_sample = file_info_.bits_per_sample;
#ifdef FLAC__DO_DITHER
const unsigned target_bps = min(bits_per_sample, 16);
#else
const unsigned target_bps = bits_per_sample;
#endif
const unsigned sample_rate = file_info_.sample_rate;
if(seek_needed_ != -1) {
const double distance = (double)seek_needed_ / (double)getlength();
const unsigned target_sample = (unsigned)(distance * (double)file_info_.total_samples);
if(FLAC__file_decoder_seek_absolute(decoder_, (FLAC__uint64)target_sample)) {
decode_pos_ms_ = (int)(distance * (double)getlength());
seek_needed_ = -1;
done = 0;
mod_.outMod->Flush(decode_pos_ms_);
}
}
if(done) {
if(!mod_.outMod->IsPlaying()) {
PostMessage(mod_.hMainWindow, WM_WA_MPEG_EOF, 0, 0);
return 0;
}
Sleep(10);
}
else if(mod_.outMod->CanWrite() >= ((int)(SAMPLES_PER_WRITE*channels*((target_bps+7)/8)) << (mod_.dsp_isactive()?1:0))) {
while(wide_samples_in_reservoir_ < SAMPLES_PER_WRITE) {
if(FLAC__file_decoder_get_state(decoder_) == FLAC__FILE_DECODER_END_OF_FILE) {
done = 1;
break;
}
else if(!FLAC__file_decoder_process_single(decoder_)) {
MessageBox(mod_.hMainWindow, FLAC__FileDecoderStateString[FLAC__file_decoder_get_state(decoder_)], "READ ERROR processing frame", 0);
done = 1;
break;
}
}
if(wide_samples_in_reservoir_ == 0) {
done = 1;
}
else {
const unsigned n = min(wide_samples_in_reservoir_, SAMPLES_PER_WRITE);
const unsigned delta = n * channels;
int bytes = (int)FLAC__plugin_common__pack_pcm_signed_little_endian(sample_buffer_, reservoir_, n, channels, bits_per_sample, target_bps);
unsigned i;
for(i = delta; i < wide_samples_in_reservoir_ * channels; i++)
reservoir_[i-delta] = reservoir_[i];
wide_samples_in_reservoir_ -= n;
do_vis((char *)sample_buffer_, channels, target_bps, decode_pos_ms_, n);
decode_pos_ms_ += (n*1000 + sample_rate/2)/sample_rate;
if(mod_.dsp_isactive())
bytes = mod_.dsp_dosamples((short *)sample_buffer_, n, target_bps, channels, sample_rate) * (channels*target_bps/8);
mod_.outMod->Write(sample_buffer_, bytes);
}
}
else Sleep(20);
}
return 0;
}
