void wavpack_buffer_format_samples(wavpack_buffer_decoder* wbd,
uchar *dst, long *src, uint32_t samples)
{
long temp;
int bps = WavpackGetBytesPerSample(wbd->wpc);
uint32_t samcnt = samples * WavpackGetNumChannels (wbd->wpc);
switch (bps) {
case 1:
while (samcnt--)
*dst++ = (uchar)(*src++ + 128);
break;
case 2:
while (samcnt--) {
*dst++ = (uchar)(temp = *src++);
*dst++ = (uchar)(temp >> 8);
}
break;
case 3:
while (samcnt--) {
*dst++ = (uchar)(temp = *src++);
*dst++ = (uchar)(temp >> 8);
*dst++ = (uchar)(temp >> 16);
}
break;
}
}
static int wav_decode (void *prv_data, char *buf, int buf_len,
struct sound_params *sound_params)
{
struct wavpack_data *data = (struct wavpack_data *)prv_data;
int ret, i, s_num, iBps, oBps;
int8_t * buf8 = (int8_t *)buf;
int16_t * buf16 = (int16_t *)buf;
int32_t * buf32 = (int32_t *)buf;
iBps = data->channels * WavpackGetBytesPerSample (data->wpc);
oBps = (iBps == 6) ? 8 : iBps;
s_num = buf_len / oBps;
decoder_error_clear (&data->error);
int32_t *dbuf = (int32_t *)xcalloc (
s_num, data->channels * 4);
ret = WavpackUnpackSamples (data->wpc, dbuf, s_num );
if (ret == 0) {
free (dbuf);
return 0;
}
if (data->mode & MODE_FLOAT) {
sound_params->fmt = SFMT_FLOAT;
memcpy (buf, dbuf, ret * oBps);
} else {
debug ("iBps %d", iBps);
switch (iBps / data->channels){
case 4: for (i = 0; i < ret * data->channels; i++)
buf32[i] = dbuf[i];
sound_params->fmt = SFMT_S32 | SFMT_NE;
break;
case 3: for (i = 0; i < ret * data->channels; i++)
buf32[i] = dbuf[i] * 256;
sound_params->fmt = SFMT_S32 | SFMT_NE;
break;
case 2: for (i = 0; i < ret * data->channels; i++)
buf16[i] = dbuf[i];
sound_params->fmt = SFMT_S16 | SFMT_NE;
break;
case 1: for (i = 0; i < ret * data->channels; i++)
buf8[i] = dbuf[i];
sound_params->fmt = SFMT_S8 | SFMT_NE;
}
}
sound_params->channels = data->channels;
sound_params->rate = data->sample_rate;
free (dbuf);
return ret * oBps ;
}
static int decode_data(char *target, int max_size)
{
int bps, channels;
uint32_t samples_unpacked = 0;
channels = get_channels();
bps = WavpackGetBytesPerSample(wpc);
if (max_size >= 1024) {
samples_unpacked = WavpackUnpackSamples(wpc, temp_buffer, 256 / channels);
total_unpacked_samples += samples_unpacked;
if (samples_unpacked)
format_samples(bps, (uchar *)target, temp_buffer, samples_unpacked * channels);
} else {
printf("vorbis: Target buffer too small: %d < 1024\n", max_size);
}
return samples_unpacked * (WavpackGetBitsPerSample(wpc) / 4);
}
static int wavpack_assign_values(struct mpxplay_filehand_buffered_func_s *fbfs,void *fbds,struct wavpack_decoder_data *wpdi,struct mpxplay_infile_info_s *miis)
{
struct mpxplay_audio_decoder_info_s *adi=miis->audio_decoder_infos;
unsigned int encmode;
unsigned long pcmdatalen;
adi->filechannels = adi->outchannels = WavpackGetReducedChannels(wpdi->wpc);//WavpackGetNumChannels(wpdi->wpc);
if((adi->outchannels<PCM_MIN_CHANNELS) || (adi->outchannels>PCM_MAX_CHANNELS))
return 0;
adi->bits = WavpackGetBitsPerSample(wpdi->wpc);
if((adi->bits<PCM_MIN_BITS) || (adi->bits>PCM_MAX_BITS))
return 0;
adi->freq = WavpackGetSampleRate(wpdi->wpc);
wpdi->bytes_per_sample = WavpackGetBytesPerSample(wpdi->wpc);
if(!adi->freq || !wpdi->bytes_per_sample)
return 0;
pcmdatalen=WavpackGetNumSamples(wpdi->wpc);
miis->timemsec=(float)pcmdatalen*1000.0/adi->freq;
encmode=WavpackGetMode(wpdi->wpc);
if(encmode&MODE_FLOAT){
adi->infobits|=ADI_FLAG_FLOATOUT;
adi->bits=1;
wpdi->bytes_per_sample=sizeof(MPXPLAY_PCMOUT_FLOAT_T);
}
miis->longname="WavPack ";
if(encmode&MODE_HYBRID){
adi->bitrate=(long)((float)miis->filesize*8.0/1000.0*(float)adi->freq/(float)pcmdatalen);
}else{
long compr_ratio;
adi->bitratetext=malloc(MPXPLAY_ADITEXTSIZE_BITRATE+8);
if(!adi->bitratetext)
return 0;
compr_ratio=(long)(1000.0*(float)miis->filesize/(float)pcmdatalen/(float)wpdi->bytes_per_sample/(float)adi->filechannels);
sprintf(adi->bitratetext,"%2d/%2.2d.%1.1d%%",adi->bits,compr_ratio/10,compr_ratio%10);
}
return 1;
}
void wavpack_buffer_format_samples(wavpack_buffer_decoder* wbd,
uchar *dst, long *src, uint32_t samples, int float32_output)
{
long temp;
int bps = WavpackGetBytesPerSample(wbd->wpc);
uint32_t samcnt = samples * WavpackGetNumChannels (wbd->wpc);
switch (bps) {
case 1:
while (samcnt--)
*dst++ = (uchar)(*src++ + 128);
break;
case 2:
while (samcnt--) {
*dst++ = (uchar)(temp = *src++);
*dst++ = (uchar)(temp >> 8);
}
break;
case 3:
while (samcnt--) {
*dst++ = (uchar)(temp = *src++);
*dst++ = (uchar)(temp >> 8);
*dst++ = (uchar)(temp >> 16);
}
break;
case 4:
if (float32_output && !(WavpackGetMode (wbd->wpc) & MODE_FLOAT)) {
float *fdst = (float *) dst;
while (samcnt--)
*fdst++ = *src++ * 4.656612873077393e-10F;
}
break;
}
}
bool attach(const char *filename)
{
ctx = WavpackOpenFileInput(filename, error_buff, OPEN_TAGS | OPEN_WVC | OPEN_NORMALIZE, 0);
if (ctx == NULL) {
return false;
}
sample_rate = WavpackGetSampleRate(ctx);
num_channels = WavpackGetNumChannels(ctx);
bytes_per_sample = WavpackGetBytesPerSample(ctx);
input = (int32_t *)calloc(BUFFER_SIZE, num_channels * sizeof(int32_t));
output = (int16_t *)calloc(BUFFER_SIZE, num_channels * sizeof(int16_t));
memset (shaping_error, 0, sizeof (shaping_error));
mod->set_info(generate_title(filename, ctx),
(int) (WavpackGetNumSamples(ctx) / sample_rate) * 1000,
(int) WavpackGetAverageBitrate(ctx, true),
(int) sample_rate, num_channels);
play_gain = calculate_gain (ctx);
DBG("gain value = %g\n", play_gain);
return true;
}
EmErrorCode WvDecoder::Open(const std::string& url)
{
m_Ctx = WavpackOpenFileInput(url.c_str(), nullptr, 0, 0);
if (m_Ctx == nullptr)
return ErrorCode::DecoderFailedToOpen;
if (WavpackGetNumSamples(m_Ctx) == (uint32_t) -1)
return ErrorCode::DecoderFailedToInit;
m_Duration = (double)WavpackGetNumSamples(m_Ctx) / WavpackGetSampleRate(m_Ctx) * 1000;
m_Channels = WavpackGetNumChannels(m_Ctx);
m_SampleRate = WavpackGetSampleRate(m_Ctx);
m_BitsPerSample = WavpackGetBitsPerSample(m_Ctx);
m_BytesPerSample = WavpackGetBytesPerSample(m_Ctx);
// one sample may not be enough to build a full channel
m_UnitCount = WavpackGetNumSamples(m_Ctx)/m_Channels;
m_UnitIndex = 0;
m_Buf.resize(10 * m_Channels * sizeof(int32_t)); // 1~10 full-samples
return ErrorCode::Ok;
}
static GstFlowReturn
gst_wavpack_dec_handle_frame (GstAudioDecoder * bdec, GstBuffer * buf)
{
GstWavpackDec *dec;
GstBuffer *outbuf = NULL;
GstFlowReturn ret = GST_FLOW_OK;
WavpackHeader wph;
int32_t decoded, unpacked_size;
gboolean format_changed;
gint width, depth, i, j, max;
gint32 *dec_data = NULL;
guint8 *out_data;
GstMapInfo map, omap;
dec = GST_WAVPACK_DEC (bdec);
g_return_val_if_fail (buf != NULL, GST_FLOW_ERROR);
gst_buffer_map (buf, &map, GST_MAP_READ);
/* check input, we only accept framed input with complete chunks */
if (map.size < sizeof (WavpackHeader))
goto input_not_framed;
if (!gst_wavpack_read_header (&wph, map.data))
goto invalid_header;
if (map.size < wph.ckSize + 4 * 1 + 4)
goto input_not_framed;
if (!(wph.flags & INITIAL_BLOCK))
goto input_not_framed;
dec->wv_id.buffer = map.data;
dec->wv_id.length = map.size;
dec->wv_id.position = 0;
/* create a new wavpack context if there is none yet but if there
* was already one (i.e. caps were set on the srcpad) check whether
* the new one has the same caps */
if (!dec->context) {
gchar error_msg[80];
dec->context = WavpackOpenFileInputEx (dec->stream_reader,
&dec->wv_id, NULL, error_msg, OPEN_STREAMING, 0);
/* expect this to work */
if (!dec->context) {
GST_WARNING_OBJECT (dec, "Couldn't decode buffer: %s", error_msg);
goto context_failed;
}
}
g_assert (dec->context != NULL);
format_changed =
(dec->sample_rate != WavpackGetSampleRate (dec->context)) ||
(dec->channels != WavpackGetNumChannels (dec->context)) ||
(dec->depth != WavpackGetBytesPerSample (dec->context) * 8) ||
(dec->channel_mask != WavpackGetChannelMask (dec->context));
if (!gst_pad_has_current_caps (GST_AUDIO_DECODER_SRC_PAD (dec)) ||
format_changed) {
gint channel_mask;
dec->sample_rate = WavpackGetSampleRate (dec->context);
dec->channels = WavpackGetNumChannels (dec->context);
dec->depth = WavpackGetBytesPerSample (dec->context) * 8;
channel_mask = WavpackGetChannelMask (dec->context);
if (channel_mask == 0)
channel_mask = gst_wavpack_get_default_channel_mask (dec->channels);
dec->channel_mask = channel_mask;
gst_wavpack_dec_negotiate (dec);
/* send GST_TAG_AUDIO_CODEC and GST_TAG_BITRATE tags before something
* is decoded or after the format has changed */
gst_wavpack_dec_post_tags (dec);
}
/* alloc output buffer */
dec_data = g_malloc (4 * wph.block_samples * dec->channels);
/* decode */
decoded = WavpackUnpackSamples (dec->context, dec_data, wph.block_samples);
if (decoded != wph.block_samples)
goto decode_error;
unpacked_size = (dec->width / 8) * wph.block_samples * dec->channels;
outbuf = gst_buffer_new_and_alloc (unpacked_size);
/* legacy; pass along offset, whatever that might entail */
GST_BUFFER_OFFSET (outbuf) = GST_BUFFER_OFFSET (buf);
gst_buffer_map (outbuf, &omap, GST_MAP_WRITE);
out_data = omap.data;
width = dec->width;
depth = dec->depth;
max = dec->channels * wph.block_samples;
if (width == 8) {
gint8 *outbuffer = (gint8 *) out_data;
gint *reorder_map = dec->channel_reorder_map;
for (i = 0; i < max; i += dec->channels) {
for (j = 0; j < dec->channels; j++)
*outbuffer++ = (gint8) (dec_data[i + reorder_map[j]]);
}
} else if (width == 16) {
gint16 *outbuffer = (gint16 *) out_data;
gint *reorder_map = dec->channel_reorder_map;
for (i = 0; i < max; i += dec->channels) {
for (j = 0; j < dec->channels; j++)
*outbuffer++ = (gint16) (dec_data[i + reorder_map[j]]);
}
} else if (dec->width == 32) {
gint32 *outbuffer = (gint32 *) out_data;
gint *reorder_map = dec->channel_reorder_map;
if (width != depth) {
for (i = 0; i < max; i += dec->channels) {
for (j = 0; j < dec->channels; j++)
*outbuffer++ =
(gint32) (dec_data[i + reorder_map[j]] << (width - depth));
}
} else {
for (i = 0; i < max; i += dec->channels) {
for (j = 0; j < dec->channels; j++)
*outbuffer++ = (gint32) (dec_data[i + reorder_map[j]]);
}
}
} else {
g_assert_not_reached ();
}
gst_buffer_unmap (outbuf, &omap);
gst_buffer_unmap (buf, &map);
buf = NULL;
g_free (dec_data);
ret = gst_audio_decoder_finish_frame (bdec, outbuf, 1);
out:
if (buf)
gst_buffer_unmap (buf, &map);
if (G_UNLIKELY (ret != GST_FLOW_OK)) {
GST_DEBUG_OBJECT (dec, "flow: %s", gst_flow_get_name (ret));
}
return ret;
/* ERRORS */
input_not_framed:
{
GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL), ("Expected framed input"));
ret = GST_FLOW_ERROR;
goto out;
}
invalid_header:
{
GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL), ("Invalid wavpack header"));
ret = GST_FLOW_ERROR;
goto out;
}
context_failed:
{
GST_AUDIO_DECODER_ERROR (bdec, 1, LIBRARY, INIT, (NULL),
("error creating Wavpack context"), ret);
goto out;
}
decode_error:
{
const gchar *reason = "unknown";
if (dec->context) {
reason = WavpackGetErrorMessage (dec->context);
} else {
reason = "couldn't create decoder context";
}
GST_AUDIO_DECODER_ERROR (bdec, 1, STREAM, DECODE, (NULL),
("decoding error: %s", reason), ret);
g_free (dec_data);
if (ret == GST_FLOW_OK)
gst_audio_decoder_finish_frame (bdec, NULL, 1);
goto out;
}
}
static void *
DecodeThread(void *a)
{
ape_tag tag;
char *filename = (char *) a;
int bps_updateCounter = 0;
int bps;
int i;
WavpackDecoder d(&mod);
if (!d.attach(filename)) {
printf("wavpack: Error opening file: \"%s\"\n", filename);
killDecodeThread = true;
return end_thread();
}
bps = WavpackGetBytesPerSample(d.ctx) * d.num_channels;
DBG("reading %s at %d rate with %d channels\n", filename, d.sample_rate, d.num_channels);
if (!d.open_audio()) {
DBG("error opening xmms audio channel\n");
killDecodeThread = true;
AudioError = true;
openedAudio = false;
}
else {
DBG("opened xmms audio channel\n");
openedAudio = true;
}
unsigned status;
char *display = generate_title(filename, d.ctx);
int length = (int) (1000 * WavpackGetNumSamples(d.ctx));
while (!killDecodeThread) {
if (isSeek != -1) {
DBG("seeking to position %d\n", isSeek);
WavpackSeekSample(d.ctx, isSeek * d.sample_rate);
isSeek = -1;
}
if (paused == 0
&& (mod.output->buffer_free() >=
(1152 * 2 *
(16 / 8)) << (mod.output->buffer_playing()? 1 : 0))) {
status =
WavpackUnpackSamples(d.ctx, d.input, BUFFER_SIZE);
if (status == (unsigned) (-1)) {
printf("wavpack: Error decoding file.\n");
break;
}
else if (status == 0) {
killDecodeThread = true;
break;
}
else {
d.process_buffer(status);
}
}
else {
xmms_usleep(10000);
}
}
return end_thread();
}
/*
* This does the main decoding thing.
* Requires an already opened WavpackContext.
*/
static void
wavpack_decode(struct decoder *decoder, WavpackContext *wpc, bool can_seek,
struct replay_gain_info *replay_gain_info)
{
struct audio_format audio_format;
format_samples_t format_samples;
char chunk[CHUNK_SIZE];
int samples_requested, samples_got;
float total_time, current_time;
int bytes_per_sample, output_sample_size;
int position;
audio_format.sample_rate = WavpackGetSampleRate(wpc);
audio_format.channels = WavpackGetReducedChannels(wpc);
audio_format.bits = WavpackGetBitsPerSample(wpc);
/* round bitwidth to 8-bit units */
audio_format.bits = (audio_format.bits + 7) & (~7);
/* mpd handles max 24-bit samples */
if (audio_format.bits > 24) {
audio_format.bits = 24;
}
if (!audio_format_valid(&audio_format)) {
g_warning("Invalid audio format: %u:%u:%u\n",
audio_format.sample_rate,
audio_format.bits,
audio_format.channels);
return;
}
if ((WavpackGetMode(wpc) & MODE_FLOAT) == MODE_FLOAT) {
format_samples = format_samples_float;
} else {
format_samples = format_samples_int;
}
total_time = WavpackGetNumSamples(wpc);
total_time /= audio_format.sample_rate;
bytes_per_sample = WavpackGetBytesPerSample(wpc);
output_sample_size = audio_format_frame_size(&audio_format);
/* wavpack gives us all kind of samples in a 32-bit space */
samples_requested = sizeof(chunk) / (4 * audio_format.channels);
decoder_initialized(decoder, &audio_format, can_seek, total_time);
position = 0;
do {
if (decoder_get_command(decoder) == DECODE_COMMAND_SEEK) {
if (can_seek) {
int where;
where = decoder_seek_where(decoder);
where *= audio_format.sample_rate;
if (WavpackSeekSample(wpc, where)) {
position = where;
decoder_command_finished(decoder);
} else {
decoder_seek_error(decoder);
}
} else {
decoder_seek_error(decoder);
}
}
if (decoder_get_command(decoder) == DECODE_COMMAND_STOP) {
break;
}
samples_got = WavpackUnpackSamples(
wpc, (int32_t *)chunk, samples_requested
);
if (samples_got > 0) {
int bitrate = (int)(WavpackGetInstantBitrate(wpc) /
1000 + 0.5);
position += samples_got;
current_time = position;
current_time /= audio_format.sample_rate;
format_samples(
bytes_per_sample, chunk,
samples_got * audio_format.channels
);
decoder_data(
decoder, NULL, chunk,
samples_got * output_sample_size,
current_time, bitrate,
replay_gain_info
);
}
} while (samples_got > 0);
}
static DB_playItem_t *
wv_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
DB_FILE *fp = deadbeef->fopen (fname);
if (!fp) {
return NULL;
}
char error[80];
#ifdef TINYWV
WavpackContext *ctx = WavpackOpenFileInput (wv_read_stream, fp, error);
#else
WavpackContext *ctx = WavpackOpenFileInputEx (&wsr, fp, NULL, error, 0, 0);
#endif
if (!ctx) {
fprintf (stderr, "wavpack error: %s\n", error);
deadbeef->fclose (fp);
return NULL;
}
int totalsamples = WavpackGetNumSamples (ctx);
int samplerate = WavpackGetSampleRate (ctx);
float duration = (float)totalsamples / samplerate;
DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
deadbeef->pl_add_meta (it, ":FILETYPE", "wv");
deadbeef->plt_set_item_duration (plt, it, duration);
trace ("wv: totalsamples=%d, samplerate=%d, duration=%f\n", totalsamples, samplerate, duration);
#if 0
int num = WavpackGetNumTagItems (ctx);
trace ("num tag items: %d\n", num);
for (int i = 0; i < num; i++) {
char str[1024];
WavpackGetTagItemIndexed (ctx, i, str, sizeof (str));
trace ("tag item: %s\n", str);
}
#endif
int apeerr = deadbeef->junk_apev2_read (it, fp);
if (!apeerr) {
trace ("wv: ape tag found\n");
}
int v1err = deadbeef->junk_id3v1_read (it, fp);
if (!v1err) {
trace ("wv: id3v1 tag found\n");
}
deadbeef->pl_add_meta (it, "title", NULL);
char s[100];
snprintf (s, sizeof (s), "%lld", deadbeef->fgetlength (fp));
deadbeef->pl_add_meta (it, ":FILE_SIZE", s);
snprintf (s, sizeof (s), "%d", WavpackGetBytesPerSample (ctx) * 8);
deadbeef->pl_add_meta (it, ":BPS", s);
snprintf (s, sizeof (s), "%d", WavpackGetNumChannels (ctx));
deadbeef->pl_add_meta (it, ":CHANNELS", s);
snprintf (s, sizeof (s), "%d", WavpackGetSampleRate (ctx));
deadbeef->pl_add_meta (it, ":SAMPLERATE", s);
snprintf (s, sizeof (s), "%d", (int)(WavpackGetAverageBitrate (ctx, 1) / 1000));
deadbeef->pl_add_meta (it, ":BITRATE", s);
snprintf (s, sizeof (s), "%s", (WavpackGetMode (ctx) & MODE_FLOAT) ? "FLOAT" : "INTEGER");
deadbeef->pl_add_meta (it, ":WAVPACK_MODE", s);
// embedded cue
deadbeef->pl_lock ();
const char *cuesheet = deadbeef->pl_find_meta (it, "cuesheet");
if (cuesheet) {
trace ("found cuesheet: %s\n", cuesheet);
DB_playItem_t *last = deadbeef->plt_insert_cue_from_buffer (plt, after, it, cuesheet, strlen (cuesheet), totalsamples, samplerate);
if (last) {
deadbeef->pl_unlock ();
deadbeef->fclose (fp);
WavpackCloseFile (ctx);
deadbeef->pl_item_unref (it);
deadbeef->pl_item_unref (last);
return last;
}
}
deadbeef->pl_unlock ();
// cue file on disc
DB_playItem_t *cue_after = deadbeef->plt_insert_cue (plt, after, it, totalsamples, samplerate);
if (cue_after) {
deadbeef->fclose (fp);
WavpackCloseFile (ctx);
deadbeef->pl_item_unref (it);
deadbeef->pl_item_unref (cue_after);
return cue_after;
}
after = deadbeef->plt_insert_item (plt, after, it);
deadbeef->pl_item_unref (it);
deadbeef->fclose (fp);
WavpackCloseFile (ctx);
return after;
}
static int
wv_init (DB_fileinfo_t *_info, DB_playItem_t *it) {
wvctx_t *info = (wvctx_t *)_info;
deadbeef->pl_lock ();
info->file = deadbeef->fopen (deadbeef->pl_find_meta (it, ":URI"));
deadbeef->pl_unlock ();
if (!info->file) {
return -1;
}
#ifndef TINYWV
deadbeef->pl_lock ();
const char *uri = deadbeef->pl_find_meta (it, ":URI");
char *c_fname = alloca (strlen (uri) + 2);
if (c_fname) {
strcpy (c_fname, uri);
strcat (c_fname, "c");
info->c_file = deadbeef->fopen (c_fname);
}
else {
fprintf (stderr, "wavpack warning: failed to alloc memory for correction file name\n");
}
deadbeef->pl_unlock ();
#endif
char error[80];
#ifdef TINYWV
info->ctx = WavpackOpenFileInput (wv_read_stream, info->file, error);
#else
info->ctx = WavpackOpenFileInputEx (&wsr, info->file, info->c_file, error, OPEN_NORMALIZE, 0);
#endif
if (!info->ctx) {
fprintf (stderr, "wavpack error: %s\n", error);
return -1;
}
_info->plugin = &plugin;
_info->fmt.bps = WavpackGetBytesPerSample (info->ctx) * 8;
_info->fmt.channels = WavpackGetNumChannels (info->ctx);
_info->fmt.samplerate = WavpackGetSampleRate (info->ctx);
_info->fmt.is_float = (WavpackGetMode (info->ctx) & MODE_FLOAT) ? 1 : 0;
// FIXME: streamer and maybe output plugins need to be fixed to support
// arbitrary channelmask
// _info->fmt.channelmask = WavpackGetChannelMask (info->ctx);
for (int i = 0; i < _info->fmt.channels; i++) {
_info->fmt.channelmask |= 1 << i;
}
_info->readpos = 0;
if (it->endsample > 0) {
info->startsample = it->startsample;
info->endsample = it->endsample;
if (plugin.seek_sample (_info, 0) < 0) {
return -1;
}
}
else {
info->startsample = 0;
info->endsample = WavpackGetNumSamples (info->ctx)-1;
}
return 0;
}
UInt32 WavPackDecoder::ReadAudio(AudioBufferList *bufferList, UInt32 frameCount)
{
if(!IsOpen() || nullptr == bufferList || bufferList->mNumberBuffers != mFormat.mChannelsPerFrame || 0 == frameCount)
return 0;
// Reset output buffer data size
for(UInt32 i = 0; i < bufferList->mNumberBuffers; ++i)
bufferList->mBuffers[i].mDataByteSize = 0;
UInt32 framesRemaining = frameCount;
UInt32 totalFramesRead = 0;
while(0 < framesRemaining) {
UInt32 framesToRead = std::min(framesRemaining, static_cast<UInt32>(BUFFER_SIZE_FRAMES));
// Wavpack uses "complete" samples (one sample across all channels), i.e. a Core Audio frame
uint32_t samplesRead = WavpackUnpackSamples(mWPC, mBuffer, framesToRead);
if(0 == samplesRead)
break;
// The samples returned are handled differently based on the file's mode
int mode = WavpackGetMode(mWPC);
// Floating point files require no special handling other than deinterleaving
if(MODE_FLOAT & mode) {
float *inputBuffer = reinterpret_cast<float *>(mBuffer);
// Deinterleave the samples
for(UInt32 channel = 0; channel < mFormat.mChannelsPerFrame; ++channel) {
float *floatBuffer = static_cast<float *>(bufferList->mBuffers[channel].mData);
for(UInt32 sample = channel; sample < samplesRead * mFormat.mChannelsPerFrame; sample += mFormat.mChannelsPerFrame)
*floatBuffer++ = inputBuffer[sample];
bufferList->mBuffers[channel].mNumberChannels = 1;
bufferList->mBuffers[channel].mDataByteSize = static_cast<UInt32>(samplesRead * sizeof(float));
}
}
// Lossless files will be handed off as integers
else if(MODE_LOSSLESS & mode) {
// WavPack hands us 32-bit signed ints with the samples low-aligned; shift them to high alignment
UInt32 shift = static_cast<UInt32>(8 * (sizeof(int32_t) - WavpackGetBytesPerSample(mWPC)));
// Deinterleave the 32-bit samples and shift to high-alignment
for(UInt32 channel = 0; channel < mFormat.mChannelsPerFrame; ++channel) {
int32_t *shiftedBuffer = static_cast<int32_t *>(bufferList->mBuffers[channel].mData);
for(UInt32 sample = channel; sample < samplesRead * mFormat.mChannelsPerFrame; sample += mFormat.mChannelsPerFrame)
*shiftedBuffer++ = mBuffer[sample] << shift;
bufferList->mBuffers[channel].mNumberChannels = 1;
bufferList->mBuffers[channel].mDataByteSize = static_cast<UInt32>(samplesRead * sizeof(int32_t));
}
}
// Convert lossy files to float
else {
float scaleFactor = (1 << ((WavpackGetBytesPerSample(mWPC) * 8) - 1));
// Deinterleave the 32-bit samples and convert to float
for(UInt32 channel = 0; channel < mFormat.mChannelsPerFrame; ++channel) {
float *floatBuffer = static_cast<float *>(bufferList->mBuffers[channel].mData);
for(UInt32 sample = channel; sample < samplesRead * mFormat.mChannelsPerFrame; sample += mFormat.mChannelsPerFrame)
*floatBuffer++ = mBuffer[sample] / scaleFactor;
bufferList->mBuffers[channel].mNumberChannels = 1;
bufferList->mBuffers[channel].mDataByteSize = static_cast<UInt32>(samplesRead * sizeof(float));
}
}
totalFramesRead += samplesRead;
framesRemaining -= samplesRead;
}
mCurrentFrame += totalFramesRead;
return totalFramesRead;
}
/* 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;
}
HRESULT CWavPackDSDecoder::Receive(IMediaSample *pSample)
{
// Check for other streams and pass them on
AM_SAMPLE2_PROPERTIES * const pProps = m_pInput->SampleProps();
if ((pProps->dwStreamId != AM_STREAM_MEDIA) &&
(pProps->dwStreamId != AM_STREAM_BLOCK_ADDITIONNAL))
{
return m_pOutput->Deliver(pSample);
}
ASSERT(pSample);
// If no output to deliver to then no point sending us data
ASSERT(m_pOutput != NULL);
HRESULT hr = S_OK;
BYTE *pSrc, *pDst;
DWORD SrcLength = pSample->GetActualDataLength();
hr = pSample->GetPointer(&pSrc);
if(FAILED(hr))
return hr;
// Check for minimal block size
if(SrcLength < (3 * sizeof(uint32_t)))
{
return S_OK;
}
WAVEFORMATEX* pwfx = (WAVEFORMATEX*)m_pInput->CurrentMediaType().Format();
BOOL bSeveralBlocks = (pwfx->nChannels > 2);
if(pProps->dwStreamId == AM_STREAM_MEDIA)
{
REFERENCE_TIME rtStop;
if(pSample->IsSyncPoint() == S_OK)
{
pSample->GetTime(&m_rtFrameStart, &rtStop);
m_TotalSamples = 0;
}
m_MainBlockDiscontinuity = (pSample->IsDiscontinuity() == S_OK);
reconstruct_wavpack_frame(
m_MainFrame,
&m_CommonFrameData,
(char*)pSrc,
SrcLength,
TRUE,
bSeveralBlocks,
m_PrivateData.version);
if(m_HybridMode == TRUE)
{
// Stop here and wait for correction data
return S_OK;
}
}
if((m_HybridMode == TRUE) &&
(pProps->dwStreamId == AM_STREAM_BLOCK_ADDITIONNAL))
{
// rebuild correction data block
reconstruct_wavpack_frame(
m_CorrectionFrame,
&m_CommonFrameData,
(char*)pSrc,
SrcLength,
FALSE,
bSeveralBlocks,
m_PrivateData.version);
}
if(wavpack_buffer_decoder_load_frame(m_Codec, m_MainFrame->data, m_MainFrame->len,
m_HybridMode ? m_CorrectionFrame->data : NULL, m_CorrectionFrame->len) == 0)
{
// Something is wrong
return S_FALSE;
}
// We can precise the decoding mode now
if(m_HybridMode == FALSE)
{
if(m_CommonFrameData.array_flags[0] & WV_HYBRID_FLAG)
{
m_DecodingMode = DECODING_MODE_LOSSY;
}
else
{
m_DecodingMode = DECODING_MODE_LOSSLESS;
}
}
uint32_t samplesLeft = m_CommonFrameData.block_samples;
while(samplesLeft > 0)
{
// Set up the output sample
IMediaSample *pOutSample;
hr = InitializeOutputSample(pSample, &pOutSample);
if(FAILED(hr))
{
break;
}
DWORD DstLength = pOutSample->GetSize();
hr = pOutSample->GetPointer(&pDst);
if(FAILED(hr))
{
pOutSample->Release();
break;
}
DstLength &= 0xFFFFFFF8;
long samples = wavpack_buffer_decoder_unpack(m_Codec,(int32_t *)pDst, m_SamplesPerBuffer);
if(samples)
{
wavpack_buffer_format_samples(m_Codec,
(uchar *) pDst,
(long*) pDst,
samples);
DstLength = samples *
WavpackGetBytesPerSample(m_Codec->wpc) *
WavpackGetNumChannels (m_Codec->wpc);
pOutSample->SetActualDataLength(DstLength);
REFERENCE_TIME rtStart, rtStop;
rtStart = m_rtFrameStart + (REFERENCE_TIME)(((double)m_TotalSamples / WavpackGetSampleRate(m_Codec->wpc)) * 10000000);
m_TotalSamples += samples;
rtStop = m_rtFrameStart + (REFERENCE_TIME)(((double)m_TotalSamples / WavpackGetSampleRate(m_Codec->wpc)) * 10000000);
if(rtStart < 0 && rtStop < 0)
{
// No need to deliver this sample it will be skipped
pOutSample->Release();
continue;
}
pOutSample->SetTime(&rtStart, &rtStop);
pOutSample->SetSyncPoint(TRUE);
pOutSample->SetDiscontinuity(m_MainBlockDiscontinuity);
if(m_MainBlockDiscontinuity == TRUE)
{
m_MainBlockDiscontinuity = FALSE;
}
hr = m_pOutput->Deliver(pOutSample);
if(FAILED(hr))
{
pOutSample->Release();
break;
}
pOutSample->Release();
}
else
{
pOutSample->Release();
break;
}
samplesLeft -= samples;
}
m_DecodedFrames++;
m_CrcError = WavpackGetNumErrors(m_Codec->wpc);
return S_OK;
}
/*
* This does the main decoding thing.
* Requires an already opened WavpackContext.
*/
static void
wavpack_decode(struct decoder *decoder, WavpackContext *wpc, bool can_seek)
{
GError *error = NULL;
bool is_float;
enum sample_format sample_format;
struct audio_format audio_format;
format_samples_t format_samples;
float total_time;
int bytes_per_sample, output_sample_size;
is_float = (WavpackGetMode(wpc) & MODE_FLOAT) != 0;
sample_format =
wavpack_bits_to_sample_format(is_float,
WavpackGetBytesPerSample(wpc));
if (!audio_format_init_checked(&audio_format,
WavpackGetSampleRate(wpc),
sample_format,
WavpackGetNumChannels(wpc), &error)) {
g_warning("%s", error->message);
g_error_free(error);
return;
}
if (is_float) {
format_samples = format_samples_float;
} else {
format_samples = format_samples_int;
}
total_time = WavpackGetNumSamples(wpc);
total_time /= audio_format.sample_rate;
bytes_per_sample = WavpackGetBytesPerSample(wpc);
output_sample_size = audio_format_frame_size(&audio_format);
/* wavpack gives us all kind of samples in a 32-bit space */
int32_t chunk[1024];
const uint32_t samples_requested = G_N_ELEMENTS(chunk) /
audio_format.channels;
decoder_initialized(decoder, &audio_format, can_seek, total_time);
enum decoder_command cmd = decoder_get_command(decoder);
while (cmd != DECODE_COMMAND_STOP) {
if (cmd == DECODE_COMMAND_SEEK) {
if (can_seek) {
unsigned where = decoder_seek_where(decoder) *
audio_format.sample_rate;
if (WavpackSeekSample(wpc, where)) {
decoder_command_finished(decoder);
} else {
decoder_seek_error(decoder);
}
} else {
decoder_seek_error(decoder);
}
}
uint32_t samples_got = WavpackUnpackSamples(wpc, chunk,
samples_requested);
if (samples_got == 0)
break;
int bitrate = (int)(WavpackGetInstantBitrate(wpc) / 1000 +
0.5);
format_samples(bytes_per_sample, chunk,
samples_got * audio_format.channels);
cmd = decoder_data(decoder, NULL, chunk,
samples_got * output_sample_size,
bitrate);
}
}
