double WavpackGetProgress (WavpackContext *wpc)
{
if (wpc && wpc->total_samples != (uint32_t) -1 && wpc->total_samples != 0)
return (double) WavpackGetSampleIndex (wpc) / wpc->total_samples;
else
return -1.0;
}
SINT SoundSourceWV::seekSampleFrame(SINT frameIndex) {
DEBUG_ASSERT(isValidFrameIndex(frameIndex));
if (WavpackSeekSample(m_wpc, frameIndex) == true) {
return frameIndex;
} else {
qDebug() << "SSWV::seek : could not seek to frame #" << frameIndex;
return WavpackGetSampleIndex(m_wpc);
}
}
static int
wv_seek_sample (DB_fileinfo_t *_info, int sample) {
#ifndef TINYWV
wvctx_t *info = (wvctx_t *)_info;
WavpackSeekSample (info->ctx, sample + info->startsample);
_info->readpos = (float)(WavpackGetSampleIndex (info->ctx) - info->startsample) / WavpackGetSampleRate (info->ctx);
#endif
return 0;
}
ReadableSampleFrames SoundSourceWV::readSampleFramesClamped(
WritableSampleFrames writableSampleFrames) {
const SINT firstFrameIndex = writableSampleFrames.frameIndexRange().start();
if (m_curFrameIndex != firstFrameIndex) {
if (WavpackSeekSample(m_wpc, firstFrameIndex)) {
m_curFrameIndex = firstFrameIndex;
} else {
kLogger.warning()
<< "Could not seek to first frame index"
<< firstFrameIndex;
m_curFrameIndex = WavpackGetSampleIndex(m_wpc);
return ReadableSampleFrames(IndexRange::between(m_curFrameIndex, m_curFrameIndex));
}
}
DEBUG_ASSERT(m_curFrameIndex == firstFrameIndex);
const SINT numberOfFramesTotal = writableSampleFrames.frameLength();
static_assert(sizeof(CSAMPLE) == sizeof(int32_t),
"CSAMPLE and int32_t must have the same size");
CSAMPLE* pOutputBuffer = writableSampleFrames.writableData();
SINT unpackCount = WavpackUnpackSamples(m_wpc,
reinterpret_cast<int32_t*>(pOutputBuffer), numberOfFramesTotal);
DEBUG_ASSERT(unpackCount >= 0);
DEBUG_ASSERT(unpackCount <= numberOfFramesTotal);
if (!(WavpackGetMode(m_wpc) & MODE_FLOAT)) {
// signed integer -> float
const SINT sampleCount = frames2samples(unpackCount);
for (SINT i = 0; i < sampleCount; ++i) {
const int32_t sampleValue =
*reinterpret_cast<int32_t*>(pOutputBuffer);
*pOutputBuffer++ = CSAMPLE(sampleValue) * m_sampleScaleFactor;
}
}
const auto resultRange = IndexRange::forward(m_curFrameIndex, unpackCount);
m_curFrameIndex += unpackCount;
return ReadableSampleFrames(
resultRange,
SampleBuffer::ReadableSlice(
writableSampleFrames.writableData(),
frames2samples(unpackCount)));
}
SINT SoundSourceWV::seekSampleFrame(SINT frameIndex) {
DEBUG_ASSERT(isValidFrameIndex(m_curFrameIndex));
if (frameIndex >= getMaxFrameIndex()) {
// EOF reached
m_curFrameIndex = getMaxFrameIndex();
return m_curFrameIndex;
}
if (frameIndex == m_curFrameIndex) {
return m_curFrameIndex;
}
if (WavpackSeekSample(m_wpc, frameIndex) == true) {
m_curFrameIndex = frameIndex;
return frameIndex;
} else {
kLogger.debug() << "could not seek to frame #" << frameIndex;
return WavpackGetSampleIndex(m_wpc);
}
}
/* this is called for each file to process */
enum codec_status codec_run(void)
{
WavpackContext *wpc;
char error [80];
/* rockbox: comment 'set but unused' variables
int bps;
*/
int nchans, sr_100;
intptr_t param;
if (codec_init())
return CODEC_ERROR;
ci->seek_buffer (ci->id3->offset);
/* Create a decoder instance */
wpc = WavpackOpenFileInput (read_callback, error);
if (!wpc)
return CODEC_ERROR;
ci->configure(DSP_SWITCH_FREQUENCY, WavpackGetSampleRate (wpc));
codec_set_replaygain(ci->id3);
/* bps = WavpackGetBytesPerSample (wpc); */
nchans = WavpackGetReducedChannels (wpc);
ci->configure(DSP_SET_STEREO_MODE, nchans == 2 ? STEREO_INTERLEAVED : STEREO_MONO);
sr_100 = ci->id3->frequency / 100;
ci->set_elapsed (WavpackGetSampleIndex (wpc) / sr_100 * 10);
/* The main decoder loop */
while (1) {
int32_t nsamples;
enum codec_command_action action = ci->get_command(¶m);
if (action == CODEC_ACTION_HALT)
break;
if (action == CODEC_ACTION_SEEK_TIME) {
int curpos_ms = WavpackGetSampleIndex (wpc) / sr_100 * 10;
int n, d, skip;
if (param > curpos_ms) {
n = param - curpos_ms;
d = ci->id3->length - curpos_ms;
skip = (int)((int64_t)(ci->filesize - ci->curpos) * n / d);
ci->seek_buffer (ci->curpos + skip);
}
else if (curpos_ms != 0) {
n = curpos_ms - param;
d = curpos_ms;
skip = (int)((int64_t) ci->curpos * n / d);
ci->seek_buffer (ci->curpos - skip);
}
wpc = WavpackOpenFileInput (read_callback, error);
if (!wpc)
{
ci->seek_complete();
break;
}
ci->set_elapsed (WavpackGetSampleIndex (wpc) / sr_100 * 10);
ci->seek_complete();
}
nsamples = WavpackUnpackSamples (wpc, temp_buffer, BUFFER_SIZE / nchans);
if (!nsamples)
break;
ci->pcmbuf_insert (temp_buffer, NULL, nsamples);
ci->set_elapsed (WavpackGetSampleIndex (wpc) / sr_100 * 10);
}
return CODEC_OK;
}
static bool_t wv_play (InputPlayback * playback, const char * filename,
VFSFile * file, int start_time, int stop_time, bool_t pause)
{
if (file == NULL)
return FALSE;
int32_t *input = NULL;
void *output = NULL;
int sample_rate, num_channels, bits_per_sample;
unsigned num_samples;
WavpackContext *ctx = NULL;
VFSFile *wvc_input = NULL;
bool_t error = FALSE;
if (! wv_attach (filename, file, & wvc_input, & ctx, NULL, OPEN_TAGS |
OPEN_WVC))
{
fprintf (stderr, "Error opening Wavpack file '%s'.", filename);
error = TRUE;
goto error_exit;
}
sample_rate = WavpackGetSampleRate(ctx);
num_channels = WavpackGetNumChannels(ctx);
bits_per_sample = WavpackGetBitsPerSample(ctx);
num_samples = WavpackGetNumSamples(ctx);
if (!playback->output->open_audio(SAMPLE_FMT(bits_per_sample), sample_rate, num_channels))
{
fprintf (stderr, "Error opening audio output.");
error = TRUE;
goto error_exit;
}
if (pause)
playback->output->pause(TRUE);
input = malloc(BUFFER_SIZE * num_channels * sizeof(uint32_t));
output = malloc(BUFFER_SIZE * num_channels * SAMPLE_SIZE(bits_per_sample));
if (input == NULL || output == NULL)
goto error_exit;
playback->set_gain_from_playlist(playback);
pthread_mutex_lock (& mutex);
playback->set_params(playback, (int) WavpackGetAverageBitrate(ctx, num_channels),
sample_rate, num_channels);
seek_value = (start_time > 0) ? start_time : -1;
stop_flag = FALSE;
playback->set_pb_ready(playback);
pthread_mutex_unlock (& mutex);
while (!stop_flag && (stop_time < 0 ||
playback->output->written_time () < stop_time))
{
int ret;
unsigned samples_left;
/* Handle seek and pause requests */
pthread_mutex_lock (& mutex);
if (seek_value >= 0)
{
playback->output->flush (seek_value);
WavpackSeekSample (ctx, (int64_t) seek_value * sample_rate / 1000);
seek_value = -1;
}
pthread_mutex_unlock (& mutex);
/* Decode audio data */
samples_left = num_samples - WavpackGetSampleIndex(ctx);
ret = WavpackUnpackSamples(ctx, input, BUFFER_SIZE);
if (samples_left == 0)
stop_flag = TRUE;
else if (ret < 0)
{
fprintf (stderr, "Error decoding file.\n");
break;
}
else
{
/* Perform audio data conversion and output */
unsigned i;
int32_t *rp = input;
int8_t *wp = output;
int16_t *wp2 = output;
int32_t *wp4 = output;
if (bits_per_sample == 8)
{
for (i = 0; i < ret * num_channels; i++, wp++, rp++)
*wp = *rp & 0xff;
}
else if (bits_per_sample == 16)
{
for (i = 0; i < ret * num_channels; i++, wp2++, rp++)
*wp2 = *rp & 0xffff;
}
else if (bits_per_sample == 24 || bits_per_sample == 32)
{
for (i = 0; i < ret * num_channels; i++, wp4++, rp++)
*wp4 = *rp;
}
playback->output->write_audio(output, ret * num_channels * SAMPLE_SIZE(bits_per_sample));
}
}
error_exit:
free(input);
free(output);
wv_deattach (wvc_input, ctx);
stop_flag = TRUE;
return ! error;
}
static int
wv_read (DB_fileinfo_t *_info, char *bytes, int size) {
wvctx_t *info = (wvctx_t *)_info;
int currentsample = WavpackGetSampleIndex (info->ctx);
int samplesize = _info->fmt.channels * _info->fmt.bps / 8;
if (size / samplesize + currentsample > info->endsample) {
size = (info->endsample - currentsample + 1) * samplesize;
trace ("wv: size truncated to %d bytes (%d samples), cursample=%d, endsample=%d\n", size, info->endsample - currentsample + 1, currentsample, info->endsample);
if (size <= 0) {
return 0;
}
}
int initsize = size;
int n;
if (WavpackGetMode (info->ctx) & MODE_FLOAT) {
_info->fmt.is_float = 1;
}
if (_info->fmt.is_float || _info->fmt.bps == 32) {
n = WavpackUnpackSamples (info->ctx, (int32_t *)bytes, size / samplesize);
size -= n * samplesize;
}
else {
int32_t buffer[size/(_info->fmt.bps / 8)];
n = WavpackUnpackSamples (info->ctx, (int32_t *)buffer, size / samplesize);
size -= n * samplesize;
n *= _info->fmt.channels;
// convert from int32 to input (what???)
int32_t *p = buffer;
if (_info->fmt.bps == 16) {
while (n > 0) {
*((int16_t *)bytes) = (int16_t)(*p);
bytes += sizeof (int16_t);
p++;
n--;
}
}
else if (_info->fmt.bps == 8) {
while (n > 0) {
*bytes++ = (char)(*p);
p++;
n--;
}
}
else if (_info->fmt.bps == 24) {
while (n > 0) {
*bytes++ = (*p)&0xff;
*bytes++ = ((*p)&0xff00)>>8;
*bytes++ = ((*p)&0xff0000)>>16;
p++;
n--;
}
}
}
_info->readpos = (float)(WavpackGetSampleIndex (info->ctx)-info->startsample)/WavpackGetSampleRate (info->ctx);
#ifndef TINYWV
deadbeef->streamer_set_bitrate (WavpackGetInstantBitrate (info->ctx) / 1000);
#endif
return initsize-size;
}
/* this is the codec entry point */
enum codec_status codec_main(void)
{
WavpackContext *wpc;
char error [80];
int bps, nchans, sr_100;
int retval;
/* Generic codec initialisation */
ci->configure(DSP_SET_SAMPLE_DEPTH, 28);
next_track:
if (codec_init()) {
retval = CODEC_ERROR;
goto exit;
}
while (!*ci->taginfo_ready && !ci->stop_codec)
ci->sleep(1);
/* Create a decoder instance */
wpc = WavpackOpenFileInput (read_callback, error);
if (!wpc) {
retval = CODEC_ERROR;
goto done;
}
ci->configure(DSP_SWITCH_FREQUENCY, WavpackGetSampleRate (wpc));
codec_set_replaygain(ci->id3);
bps = WavpackGetBytesPerSample (wpc);
nchans = WavpackGetReducedChannels (wpc);
ci->configure(DSP_SET_STEREO_MODE, nchans == 2 ? STEREO_INTERLEAVED : STEREO_MONO);
sr_100 = ci->id3->frequency / 100;
ci->set_elapsed (0);
/* The main decoder loop */
while (1) {
int32_t nsamples;
if (ci->seek_time && ci->taginfo_ready && ci->id3->length) {
ci->seek_time--;
int curpos_ms = WavpackGetSampleIndex (wpc) / sr_100 * 10;
int n, d, skip;
if (ci->seek_time > curpos_ms) {
n = ci->seek_time - curpos_ms;
d = ci->id3->length - curpos_ms;
skip = (int)((int64_t)(ci->filesize - ci->curpos) * n / d);
ci->seek_buffer (ci->curpos + skip);
}
else {
n = curpos_ms - ci->seek_time;
d = curpos_ms;
skip = (int)((int64_t) ci->curpos * n / d);
ci->seek_buffer (ci->curpos - skip);
}
wpc = WavpackOpenFileInput (read_callback, error);
ci->seek_complete();
if (!wpc)
break;
ci->set_elapsed (WavpackGetSampleIndex (wpc) / sr_100 * 10);
ci->yield ();
}
nsamples = WavpackUnpackSamples (wpc, temp_buffer, BUFFER_SIZE / nchans);
if (!nsamples || ci->stop_codec || ci->new_track)
break;
ci->yield ();
if (ci->stop_codec || ci->new_track)
break;
ci->pcmbuf_insert (temp_buffer, NULL, nsamples);
ci->set_elapsed (WavpackGetSampleIndex (wpc) / sr_100 * 10);
ci->yield ();
}
retval = CODEC_OK;
done:
if (ci->request_next_track())
goto next_track;
exit:
return retval;
}
static gboolean wv_play (InputPlayback * playback, const gchar * filename,
VFSFile * file, gint start_time, gint stop_time, gboolean pause)
{
if (file == NULL)
return FALSE;
gint32 *input = NULL;
void *output = NULL;
gint sample_rate, num_channels, bits_per_sample;
guint num_samples;
WavpackContext *ctx = NULL;
VFSFile *wvc_input = NULL;
gboolean error = FALSE;
if (! wv_attach (filename, file, & wvc_input, & ctx, NULL, OPEN_TAGS |
OPEN_WVC))
{
g_warning("Error opening Wavpack file '%s'.", filename);
error = TRUE;
goto error_exit;
}
sample_rate = WavpackGetSampleRate(ctx);
num_channels = WavpackGetNumChannels(ctx);
bits_per_sample = WavpackGetBitsPerSample(ctx);
num_samples = WavpackGetNumSamples(ctx);
if (!playback->output->open_audio(SAMPLE_FMT(bits_per_sample), sample_rate, num_channels))
{
g_warning("Error opening audio output.");
error = TRUE;
goto error_exit;
}
if (pause)
playback->output->pause(TRUE);
input = g_malloc(BUFFER_SIZE * num_channels * sizeof(guint32));
output = g_malloc(BUFFER_SIZE * num_channels * SAMPLE_SIZE(bits_per_sample));
if (input == NULL || output == NULL)
goto error_exit;
playback->set_gain_from_playlist(playback);
g_mutex_lock(ctrl_mutex);
playback->set_params(playback, (gint) WavpackGetAverageBitrate(ctx, num_channels),
sample_rate, num_channels);
seek_value = (start_time > 0) ? start_time : -1;
stop_flag = FALSE;
playback->set_pb_ready(playback);
g_mutex_unlock(ctrl_mutex);
while (!stop_flag && (stop_time < 0 ||
playback->output->written_time () < stop_time))
{
gint ret;
guint samples_left;
/* Handle seek and pause requests */
g_mutex_lock(ctrl_mutex);
if (seek_value >= 0)
{
playback->output->flush (seek_value);
WavpackSeekSample (ctx, (gint64) seek_value * sample_rate / 1000);
seek_value = -1;
g_cond_signal(ctrl_cond);
}
g_mutex_unlock(ctrl_mutex);
/* Decode audio data */
samples_left = num_samples - WavpackGetSampleIndex(ctx);
ret = WavpackUnpackSamples(ctx, input, BUFFER_SIZE);
if (samples_left == 0)
stop_flag = TRUE;
else if (ret < 0)
{
g_warning("Error decoding file.\n");
break;
}
else
{
/* Perform audio data conversion and output */
guint i;
gint32 *rp = input;
gint8 *wp = output;
gint16 *wp2 = output;
gint32 *wp4 = output;
if (bits_per_sample == 8)
{
for (i = 0; i < ret * num_channels; i++, wp++, rp++)
*wp = *rp & 0xff;
}
else if (bits_per_sample == 16)
{
for (i = 0; i < ret * num_channels; i++, wp2++, rp++)
*wp2 = *rp & 0xffff;
}
else if (bits_per_sample == 24 || bits_per_sample == 32)
{
for (i = 0; i < ret * num_channels; i++, wp4++, rp++)
*wp4 = *rp;
}
playback->output->write_audio(output, ret * num_channels * SAMPLE_SIZE(bits_per_sample));
}
}
/* Flush buffer */
g_mutex_lock(ctrl_mutex);
while (!stop_flag && playback->output->buffer_playing())
g_usleep(20000);
g_cond_signal(ctrl_cond);
g_mutex_unlock(ctrl_mutex);
error_exit:
g_free(input);
g_free(output);
wv_deattach (wvc_input, ctx);
stop_flag = TRUE;
playback->output->close_audio();
return ! error;
}
