static int WAVPACK_infile_open(struct mpxplay_filehand_buffered_func_s *fbfs,void *fbds,char *filename,struct mpxplay_infile_info_s *miis,mpxp_uint32_t openmode)
{
struct wavpack_decoder_data *wpdi=NULL;
char errstr[128];
if(!fbfs->fopen(fbds,filename,O_RDONLY|O_BINARY,0))
return MPXPLAY_ERROR_INFILE_FILEOPEN;
miis->filesize=fbfs->filelength(fbds);
if(miis->filesize<127)
goto err_out_check;
wpdi=(struct wavpack_decoder_data *)calloc(1,sizeof(struct wavpack_decoder_data));
if(!wpdi)
goto err_out_check;
miis->private_data=wpdi;
wpdi->wpc=(WavpackContext *)calloc(1,sizeof(WavpackContext));
if(!wpdi->wpc)
goto err_out_check;
if(!WavpackOpenFileInput(wpdi->wpc, fbfs->fread, fbds, errstr))
goto err_out_check;
if(!wavpack_assign_values(fbfs,fbds,wpdi,miis))
goto err_out_check;
return MPXPLAY_ERROR_INFILE_OK;
err_out_check:
return MPXPLAY_ERROR_INFILE_CANTOPEN;
}
/*
* Decodes a file.
*/
static void
wavpack_filedecode(struct decoder *decoder, const char *fname)
{
char error[ERRORLEN];
WavpackContext *wpc;
struct replay_gain_info *replay_gain_info;
wpc = WavpackOpenFileInput(
fname, error,
OPEN_TAGS | OPEN_WVC | OPEN_2CH_MAX | OPEN_NORMALIZE, 23
);
if (wpc == NULL) {
g_warning(
"failed to open WavPack file \"%s\": %s\n",
fname, error
);
return;
}
replay_gain_info = wavpack_replaygain(wpc);
wavpack_decode(decoder, wpc, true, replay_gain_info);
if (replay_gain_info) {
replay_gain_info_free(replay_gain_info);
}
WavpackCloseFile(wpc);
}
void
delete_tag(char *filename)
{
WavpackContext *ctx;
char error_buff [80];
char text [256];
ctx = WavpackOpenFileInput (filename, error_buff, OPEN_TAGS | OPEN_EDIT_TAGS, 0);
if (!ctx) {
sprintf(text, "File \"%s\" not found or is read protected!\n",
filename);
xmms_show_message("File-Error", (gchar *) text, "Ok", FALSE, NULL,
NULL);
return;
}
while (WavpackGetTagItemIndexed (ctx, 0, text, sizeof (text)))
WavpackDeleteTagItem (ctx, text);
if (!WavpackWriteTag (ctx)) {
char text[256];
sprintf(text, "Couldn't write tag to \"%s\"!\n",
filename);
xmms_show_message("File-Error", (gchar *) text, "Ok", FALSE, NULL,
NULL);
}
WavpackCloseFile (ctx);
}
Result SoundSourceWV::tryOpen(const AudioSourceConfig& audioSrcCfg) {
DEBUG_ASSERT(!m_wpc);
char msg[80]; // hold possible error message
int openFlags = OPEN_WVC | OPEN_NORMALIZE;
if ((kChannelCountMono == audioSrcCfg.channelCountHint) ||
(kChannelCountStereo == audioSrcCfg.channelCountHint)) {
openFlags |= OPEN_2CH_MAX;
}
m_wpc = WavpackOpenFileInput(
getLocalFileNameBytes().constData(), msg, openFlags, 0);
if (!m_wpc) {
qDebug() << "SSWV::open: failed to open file : " << msg;
return ERR;
}
setChannelCount(WavpackGetReducedChannels(m_wpc));
setFrameRate(WavpackGetSampleRate(m_wpc));
setFrameCount(WavpackGetNumSamples(m_wpc));
if (WavpackGetMode(m_wpc) & MODE_FLOAT) {
m_sampleScaleFactor = CSAMPLE_PEAK;
} else {
const int bitsPerSample = WavpackGetBitsPerSample(m_wpc);
const uint32_t wavpackPeakSampleValue = uint32_t(1)
<< (bitsPerSample - 1);
m_sampleScaleFactor = CSAMPLE_PEAK / CSAMPLE(wavpackPeakSampleValue);
}
return OK;
}
soundfile_t *
soundfile_open_read(const char *path) {
dp(30, "path=%s \n", path);
soundfile_t *s = salloc(sizeof *s);
s->m = sft_read;
if (g_regex_match_simple ("\\.wv$", path, 0, 0)) {
char error[80] = {0};
int flags = 0;
int norm_offset = 0;
s->t = sft_wavpack;
s->p = WavpackOpenFileInput(path, error, flags, norm_offset);
if (!s->p)
die("can not open input file '%s'", path);
s->bits_per_sample = WavpackGetBitsPerSample(s->p);
s->channels = WavpackGetNumChannels(s->p);
s->samplerate = WavpackGetSampleRate(s->p);
s->frames = WavpackGetNumSamples(s->p);
} else {
SF_INFO infile_info = {0};
if (strcmp(path, "-"))
s->p = sf_open(path, SFM_READ, &infile_info);
else
s->p = sf_open_fd(0, SFM_READ, &infile_info, 0);
if (!s->p)
die("can not open input file '%s'", path);
s->t = sft_libsndfile;
s->channels = infile_info.channels;
s->samplerate = infile_info.samplerate;
s->frames = infile_info.frames;
}
return s;
}
static void wav_info (const char *file_name, struct file_tags *info,
const int tags_sel)
{
char wv_error[100];
char *tag;
int tag_len;
WavpackContext *wpc;
wpc = WavpackOpenFileInput (file_name, wv_error, OPEN_TAGS, 0);
if (wpc == NULL) {
logit ("wv_open error: %s", wv_error);
return;
}
int duration = WavpackGetNumSamples (wpc) / WavpackGetSampleRate (wpc);
if(tags_sel & TAGS_TIME) {
info->time = duration;
info->filled |= TAGS_TIME;
}
if(tags_sel & TAGS_COMMENTS) {
if ((tag_len = WavpackGetTagItem (wpc, "title", NULL, 0)) > 0) {
info->title = (char *)xmalloc (++tag_len);
WavpackGetTagItem (wpc, "title", info->title, tag_len);
}
if ((tag_len = WavpackGetTagItem (wpc, "artist", NULL, 0)) > 0) {
info->artist = (char *)xmalloc (++tag_len);
WavpackGetTagItem (wpc, "artist", info->artist, tag_len);
}
if ((tag_len = WavpackGetTagItem (wpc, "album", NULL, 0)) > 0) {
info->album = (char *)xmalloc (++tag_len);
WavpackGetTagItem (wpc, "album", info->album, tag_len);
}
if ((tag_len = WavpackGetTagItem (wpc, "track", NULL, 0)) > 0) {
tag = (char *)xmalloc (++tag_len);
WavpackGetTagItem (wpc, "track", tag, tag_len);
info->track = atoi (tag);
free (tag);
}
info->filled |= TAGS_COMMENTS;
}
WavpackCloseFile (wpc);
}
/*
* Reads metainfo from the specified file.
*/
static struct tag *
wavpack_tagdup(const char *fname)
{
WavpackContext *wpc;
struct tag *tag;
char error[ERRORLEN];
char *s;
int size, allocated_size;
wpc = WavpackOpenFileInput(fname, error, OPEN_TAGS, 0);
if (wpc == NULL) {
g_warning(
"failed to open WavPack file \"%s\": %s\n",
fname, error
);
return NULL;
}
tag = tag_new();
tag->time = WavpackGetNumSamples(wpc);
tag->time /= WavpackGetSampleRate(wpc);
allocated_size = 0;
s = NULL;
for (unsigned i = 0; i < G_N_ELEMENTS(tagtypes); ++i) {
size = WavpackGetTagItem(wpc, tagtypes[i].name, NULL, 0);
if (size > 0) {
++size; /* EOS */
if (s == NULL) {
s = g_malloc(size);
allocated_size = size;
} else if (size > allocated_size) {
char *t = (char *)g_realloc(s, size);
allocated_size = size;
s = t;
}
WavpackGetTagItem(wpc, tagtypes[i].name, s, size);
tag_add_item(tag, tagtypes[i].type, s);
}
}
g_free(s);
WavpackCloseFile(wpc);
return tag;
}
static int open_file(char *filename)
{
char error[80];
wdprintf(V_INFO, "wavpack", "Opening %s ...", filename);
wpc = 0;
if ((file = fopen(filename, "r"))) {
wpc = WavpackOpenFileInput(read_bytes, error);
total_unpacked_samples = 0;
wdprintf(V_DEBUG, "wavpack", "Status: %s", wpc ? "OK" : "Error");
/*if (wpc) {
total_samples = WavpackGetNumSamples (wpc);
bps = WavpackGetBytesPerSample (wpc);
}*/
}
return (wpc ? 1 : 0);
}
static int open_file(char *filename)
{
char error[80];
printf("wavpack: Opening %s ...", filename);
wpc = 0;
if ((file = fopen(filename, "r"))) {
wpc = WavpackOpenFileInput(read_bytes, error);
total_unpacked_samples = 0;
if (wpc) printf("ok\n"); else printf("error!\n");
/*if (wpc) {
total_samples = WavpackGetNumSamples (wpc);
bps = WavpackGetBytesPerSample (wpc);
}*/
}
return (wpc ? 1 : 0);
}
static void
wv_get_song_info(char *filename, char **title, int *length)
{
assert(filename != NULL);
char error_buff[80];
WavpackContext *ctx = WavpackOpenFileInput(filename, error_buff, OPEN_TAGS | OPEN_WVC, 0);
if (ctx == NULL) {
printf("wavpack: Error opening file: \"%s: %s\"\n", filename, error_buff);
return;
}
int sample_rate = WavpackGetSampleRate(ctx);
int num_channels = WavpackGetNumChannels(ctx);
DBG("reading %s at %d rate with %d channels\n", filename, sample_rate, num_channels);
*length = (int)(WavpackGetNumSamples(ctx) / sample_rate) * 1000,
*title = generate_title(filename, ctx);
DBG("title for %s = %s\n", filename, *title);
WavpackCloseFile(ctx);
}
bool AKSampler_Plugin::loadCompressedSampleFile(AKSampleFileDescriptor& sfd, float volBoostDb)
{
char errMsg[100];
WavpackContext* wpc = WavpackOpenFileInput(sfd.path, errMsg, OPEN_2CH_MAX, 0);
if (wpc == 0)
{
printf("Wavpack error loading %s: %s\n", sfd.path, errMsg);
return false;
}
AKSampleDataDescriptor sdd;
sdd.sampleDescriptor = sfd.sampleDescriptor;
sdd.sampleRate = (float)WavpackGetSampleRate(wpc);
sdd.channelCount = WavpackGetReducedChannels(wpc);
sdd.sampleCount = WavpackGetNumSamples(wpc);
sdd.isInterleaved = sdd.channelCount > 1;
sdd.data = new float[sdd.channelCount * sdd.sampleCount];
int mode = WavpackGetMode(wpc);
WavpackUnpackSamples(wpc, (int32_t*)sdd.data, sdd.sampleCount);
if ((mode & MODE_FLOAT) == 0)
{
// convert samples to floating-point
int bps = WavpackGetBitsPerSample(wpc);
float scale = 1.0f / (1 << (bps - 1));
float* pf = sdd.data;
int32_t* pi = (int32_t*)pf;
for (int i = 0; i < (sdd.sampleCount * sdd.channelCount); i++)
*pf++ = scale * *pi++;
}
if (volBoostDb != 0.0f)
{
float scale = exp(volBoostDb / 20.0f);
float* pf = sdd.data;
for (int i = 0; i < (sdd.sampleCount * sdd.channelCount); i++)
*pf++ *= scale;
}
loadSampleData(sdd);
delete[] sdd.data;
return true;
}
static void *wav_open (const char *file)
{
struct wavpack_data *data;
data = (struct wavpack_data *)xmalloc (sizeof(struct wavpack_data));
data->ok = 0;
decoder_error_init (&data->error);
int o_flags = OPEN_2CH_MAX | OPEN_WVC;
char wv_error[100];
if ((data->wpc = WavpackOpenFileInput(file,
wv_error, o_flags, 0)) == NULL) {
decoder_error (&data->error, ERROR_FATAL, 0, "%s", wv_error);
logit ("wv_open error: %s", wv_error);
}
else
wav_data_init (data);
return data;
}
gboolean Wavpack_Header_Read_File_Info(gchar *filename, ET_File_Info *ETFileInfo)
{
WavpackContext *wpc;
wpc = WavpackOpenFileInput(filename, NULL, 0, 0);
if ( wpc == NULL ) {
return FALSE;
}
ETFileInfo->version = WavpackGetVersion(wpc);
/* .wvc correction file not counted */
ETFileInfo->bitrate = WavpackGetAverageBitrate(wpc, 0)/1000;
ETFileInfo->samplerate = WavpackGetSampleRate(wpc);
ETFileInfo->mode = WavpackGetNumChannels(wpc);
ETFileInfo->size = WavpackGetFileSize(wpc);
ETFileInfo->duration = WavpackGetNumSamples(wpc)/ETFileInfo->samplerate;
WavpackCloseFile(wpc);
return TRUE;
}
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;
}
void read_wavpack_file (gchar *filename)
{
WavpackContext *wpc;
gchar *field;
guint length;
int open_flags = OPEN_TAGS;
wpc = WavpackOpenFileInput(filename, NULL, open_flags, 0);
if ( wpc == NULL ) {
fprintf (stderr, "Error: open %s as wavpack failed\n", filename);
return;
}
/* title */
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "title", field, MAXLEN);
if ( length > 0 )
printf ("title: %s\n", field);
g_free (field);
WavpackCloseFile(wpc);
}
int snd_load_wv(const char *filename)
{
SAMPLE *snd;
int sid = -1;
char error[100];
WavpackContext *context;
/* don't waste memory on sound when we are stress testing */
if(config.dbg_stress)
return -1;
/* no need to load sound when we are running with no sound */
if(!sound_enabled)
return 1;
file = engine_openfile(filename, IOFLAG_READ); /* TODO: use system.h stuff for this */
if(!file)
{
dbg_msg("sound/wv", "failed to open %s", filename);
return -1;
}
sid = snd_alloc_id();
if(sid < 0)
return -1;
snd = &samples[sid];
context = WavpackOpenFileInput(read_data, error);
if (context)
{
int samples = WavpackGetNumSamples(context);
int bitspersample = WavpackGetBitsPerSample(context);
unsigned int samplerate = WavpackGetSampleRate(context);
int channels = WavpackGetNumChannels(context);
int *data;
int *src;
short *dst;
int i;
snd->channels = channels;
snd->rate = samplerate;
if(snd->channels > 2)
{
dbg_msg("sound/wv", "file is not mono or stereo. filename='%s'", filename);
return -1;
}
/*
if(snd->rate != 44100)
{
dbg_msg("sound/wv", "file is %d Hz, not 44100 Hz. filename='%s'", snd->rate, filename);
return -1;
}*/
if(bitspersample != 16)
{
dbg_msg("sound/wv", "bps is %d, not 16, filname='%s'", bitspersample, filename);
return -1;
}
data = (int *)mem_alloc(4*samples*channels, 1);
WavpackUnpackSamples(context, data, samples); /* TODO: check return value */
src = data;
snd->data = (short *)mem_alloc(2*samples*channels, 1);
dst = snd->data;
for (i = 0; i < samples*channels; i++)
*dst++ = (short)*src++;
mem_free(data);
snd->num_frames = samples;
snd->loop_start = -1;
snd->loop_end = -1;
}
else
{
dbg_msg("sound/wv", "failed to open %s: %s", filename, error);
}
io_close(file);
file = NULL;
if(config.debug)
dbg_msg("sound/wv", "loaded %s", filename);
rate_convert(sid);
return sid;
}
int CSound::DecodeWV(int SampleID, const void *pData, unsigned DataSize)
{
if(SampleID == -1 || SampleID >= NUM_SAMPLES)
return -1;
CSample *pSample = &m_aSamples[SampleID];
char aError[100];
WavpackContext *pContext;
ms_pWVBuffer = pData;
ms_WVBufferSize = DataSize;
ms_WVBufferPosition = 0;
pContext = WavpackOpenFileInput(ReadData, aError);
if (pContext)
{
int NumSamples = WavpackGetNumSamples(pContext);
int BitsPerSample = WavpackGetBitsPerSample(pContext);
unsigned int SampleRate = WavpackGetSampleRate(pContext);
int NumChannels = WavpackGetNumChannels(pContext);
int *pSrc;
short *pDst;
int i;
pSample->m_Channels = NumChannels;
pSample->m_Rate = SampleRate;
if(pSample->m_Channels > 2)
{
dbg_msg("sound/wv", "file is not mono or stereo.");
return -1;
}
if(BitsPerSample != 16)
{
dbg_msg("sound/wv", "bps is %d, not 16", BitsPerSample);
return -1;
}
int *pBuffer = (int *)mem_alloc(4*NumSamples*NumChannels, 1);
WavpackUnpackSamples(pContext, pBuffer, NumSamples); // TODO: check return value
pSrc = pBuffer;
pSample->m_pData = (short *)mem_alloc(2*NumSamples*NumChannels, 1);
pDst = pSample->m_pData;
for (i = 0; i < NumSamples*NumChannels; i++)
*pDst++ = (short)*pSrc++;
mem_free(pBuffer);
pSample->m_NumFrames = NumSamples;
pSample->m_LoopStart = -1;
pSample->m_LoopEnd = -1;
pSample->m_PausedAt = 0;
}
else
{
dbg_msg("sound/wv", "failed to decode sample (%s)", aError);
return -1;
}
return SampleID;
}
/* 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;
}
gboolean Wavpack_Tag_Write_File_Tag (ET_File *ETFile)
{
WavpackContext *wpc;
gchar *filename = ((File_Name *)((GList *)ETFile->FileNameCur)->data)->value;
File_Tag *FileTag = (File_Tag *)ETFile->FileTag->data;
gchar *buffer;
int open_flags = OPEN_EDIT_TAGS;
g_return_val_if_fail (ETFile != NULL && ETFile->FileTag != NULL, FALSE);
wpc = WavpackOpenFileInput(filename, NULL, open_flags, 0);
if ( wpc == NULL ) {
return FALSE;
}
/*
* Title
*/
if (FileTag->title && WavpackAppendTagItem(wpc, "title", FileTag->title, strlen(FileTag->title)) == 0) {
return FALSE;
}
/*
* Artist
*/
if (FileTag->artist && WavpackAppendTagItem(wpc, "artist", FileTag->artist, strlen(FileTag->artist)) == 0) {
return FALSE;
}
/*
* Album
*/
if (FileTag->album && WavpackAppendTagItem(wpc, "album", FileTag->album, strlen(FileTag->album)) == 0) {
return FALSE;
}
/*
* Discnumber
*/
if (FileTag->disc_number && FileTag->disc_total)
{
buffer = g_strdup_printf ("%s/%s", FileTag->disc_number,
FileTag->disc_total);
if (WavpackAppendTagItem (wpc, "part", buffer, strlen (buffer)) == 0)
{
g_free (buffer);
return FALSE;
}
else
{
g_free (buffer);
}
}
else
{
if (FileTag->disc_number && WavpackAppendTagItem (wpc, "part",
FileTag->disc_number,
strlen (FileTag->disc_number)) == 0)
{
return FALSE;
}
}
/*
* Year
*/
if (FileTag->year && WavpackAppendTagItem(wpc, "year", FileTag->year, strlen(FileTag->year)) == 0) {
return FALSE;
}
/*
* Tracknumber + tracktotal
*/
if (FileTag->track_total) {
buffer = g_strdup_printf("%s/%s", FileTag->track, FileTag->track_total);
if (FileTag->track && WavpackAppendTagItem(wpc, "track", buffer, strlen(buffer)) == 0) {
g_free(buffer);
return FALSE;
} else {
g_free(buffer);
}
} else {
if (FileTag->track && WavpackAppendTagItem(wpc, "track", FileTag->track, strlen(FileTag->track)) == 0) {
return FALSE;
}
}
/*
* Genre
*/
if (FileTag->genre && WavpackAppendTagItem(wpc, "genre", FileTag->genre, strlen(FileTag->genre)) == 0) {
return FALSE;
}
/*
* Comment
*/
if (FileTag->comment && WavpackAppendTagItem(wpc, "comment", FileTag->comment, strlen(FileTag->comment)) == 0) {
return FALSE;
}
/*
* Composer
*/
if (FileTag->composer && WavpackAppendTagItem(wpc, "composer", FileTag->composer, strlen(FileTag->composer)) == 0) {
return FALSE;
}
/*
* Original artist
*/
if (FileTag->orig_artist && WavpackAppendTagItem(wpc, "original artist", FileTag->orig_artist, strlen(FileTag->orig_artist)) == 0) {
return FALSE;
}
/*
* Copyright
*/
if (FileTag->copyright && WavpackAppendTagItem(wpc, "copyright", FileTag->copyright, strlen(FileTag->copyright)) == 0) {
return FALSE;
}
/*
* URL
*/
if (FileTag->url && WavpackAppendTagItem(wpc, "copyright url", FileTag->url, strlen(FileTag->url)) == 0) {
return FALSE;
}
/*
* Encoded by
*/
if (FileTag->encoded_by && WavpackAppendTagItem(wpc, "encoded by", FileTag->encoded_by, strlen(FileTag->encoded_by)) == 0) {
return FALSE;
}
WavpackWriteTag(wpc);
WavpackCloseFile(wpc);
return TRUE;
}
/*
* Read tag data from a Wavpack file.
*/
gboolean Wavpack_Tag_Read_File_Tag (gchar *filename, File_Tag *FileTag)
{
WavpackContext *wpc;
gchar *field, *field2;
guint length;
int open_flags = OPEN_TAGS;
g_return_val_if_fail (filename != NULL && FileTag != NULL, FALSE);
wpc = WavpackOpenFileInput(filename, NULL, open_flags, 0);
if ( wpc == NULL ) {
return FALSE;
}
/*
* Title
*/
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "title", field, MAXLEN);
if ( length > 0 && FileTag->title == NULL ) {
FileTag->title = Try_To_Validate_Utf8_String(field);
}
g_free (field);
/*
* Artist
*/
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "artist", field, MAXLEN);
if ( length > 0 && FileTag->artist == NULL) {
FileTag->artist = Try_To_Validate_Utf8_String(field);
}
g_free (field);
/*
* Album
*/
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "album", field, MAXLEN);
if ( length > 0 && FileTag->album == NULL ) {
FileTag->album = Try_To_Validate_Utf8_String(field);
}
g_free (field);
/*
* Discnumber + Disctotal.
*/
field = g_malloc0 (sizeof (char) * MAXLEN);
length = WavpackGetTagItem (wpc, "part", field, MAXLEN);
field2 = g_utf8_strchr (field, -1, '/');
/* Need to cut off the total tracks if present */
if (field2)
{
*field2 = 0;
field2++;
}
if (field2 && FileTag->disc_total == NULL)
{
FileTag->disc_total = et_disc_number_to_string (atoi (Try_To_Validate_Utf8_String (field2)));
}
if (length > 0 && FileTag->disc_number == NULL)
{
FileTag->disc_number = et_disc_number_to_string (atoi (Try_To_Validate_Utf8_String (field)));
}
g_free (field);
/*
* Year
*/
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "year", field, MAXLEN);
if ( length > 0 && FileTag->year == NULL ) {
FileTag->year = Try_To_Validate_Utf8_String(field);
}
g_free (field);
/*
* Tracknumber + tracktotal
*/
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "track", field, MAXLEN);
field2 = g_utf8_strchr(field, -1, '/');
/* Need to cut off the total tracks if present */
if (field2) {
*field2 = 0;
field2++;
}
if (field2 && FileTag->track_total == NULL)
{
FileTag->track_total = et_track_number_to_string (atoi (Try_To_Validate_Utf8_String (field2)));
}
if (length > 0 && FileTag->track == NULL)
{
FileTag->track = et_track_number_to_string (atoi (Try_To_Validate_Utf8_String (field)));
}
g_free (field);
/*
* Genre
*/
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "genre", field, MAXLEN);
if ( length > 0 && FileTag->genre == NULL ) {
FileTag->genre = Try_To_Validate_Utf8_String(field);
}
g_free (field);
/*
* Comment
*/
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "comment", field, MAXLEN);
if ( length > 0 && FileTag->comment == NULL ) {
FileTag->comment = Try_To_Validate_Utf8_String(field);
}
g_free (field);
/*
* Composer
*/
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "composer", field, MAXLEN);
if ( length > 0 && FileTag->composer == NULL ) {
FileTag->composer = Try_To_Validate_Utf8_String(field);
}
g_free (field);
/*
* Original artist
*/
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "original artist", field, MAXLEN);
if ( length > 0 && FileTag->orig_artist == NULL ) {
FileTag->orig_artist = Try_To_Validate_Utf8_String(field);
}
g_free (field);
/*
* Copyright
*/
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "copyright", field, MAXLEN);
if ( length > 0 && FileTag->copyright == NULL ) {
FileTag->copyright = Try_To_Validate_Utf8_String(field);
}
g_free (field);
/*
* URL
*/
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "copyright url", field, MAXLEN);
if ( length > 0 && FileTag->url == NULL ) {
FileTag->url = Try_To_Validate_Utf8_String(field);
}
g_free (field);
/*
* Encoded by
*/
field = g_malloc0(sizeof(char) * MAXLEN);
length = WavpackGetTagItem(wpc, "encoded by", field, MAXLEN);
if ( length > 0 && FileTag->encoded_by == NULL ) {
FileTag->encoded_by = Try_To_Validate_Utf8_String(field);
}
g_free (field);
WavpackCloseFile(wpc);
return TRUE;
}
/* 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;
}
int CSound::LoadWV(const char *pFilename)
{
CSample *pSample;
int SampleID = -1;
char aError[100];
WavpackContext *pContext;
// don't waste memory on sound when we are stress testing
if(g_Config.m_DbgStress)
return -1;
// no need to load sound when we are running with no sound
if(!m_SoundEnabled)
return 1;
if(!m_pStorage)
return -1;
ms_File = m_pStorage->OpenFile(pFilename, IOFLAG_READ, IStorage::TYPE_ALL);
if(!ms_File)
{
dbg_msg("sound/wv", "failed to open file. filename='%s'", pFilename);
return -1;
}
SampleID = AllocID();
if(SampleID < 0)
return -1;
pSample = &m_aSamples[SampleID];
pContext = WavpackOpenFileInput(ReadData, aError);
if (pContext)
{
int m_aSamples = WavpackGetNumSamples(pContext);
int BitsPerSample = WavpackGetBitsPerSample(pContext);
unsigned int SampleRate = WavpackGetSampleRate(pContext);
int m_aChannels = WavpackGetNumChannels(pContext);
int *pData;
int *pSrc;
short *pDst;
int i;
pSample->m_Channels = m_aChannels;
pSample->m_Rate = SampleRate;
if(pSample->m_Channels > 2)
{
dbg_msg("sound/wv", "file is not mono or stereo. filename='%s'", pFilename);
return -1;
}
/*
if(snd->rate != 44100)
{
dbg_msg("sound/wv", "file is %d Hz, not 44100 Hz. filename='%s'", snd->rate, filename);
return -1;
}*/
if(BitsPerSample != 16)
{
dbg_msg("sound/wv", "bps is %d, not 16, filname='%s'", BitsPerSample, pFilename);
return -1;
}
pData = (int *)mem_alloc(4*m_aSamples*m_aChannels, 1);
WavpackUnpackSamples(pContext, pData, m_aSamples); // TODO: check return value
pSrc = pData;
pSample->m_pData = (short *)mem_alloc(2*m_aSamples*m_aChannels, 1);
pDst = pSample->m_pData;
for (i = 0; i < m_aSamples*m_aChannels; i++)
*pDst++ = (short)*pSrc++;
mem_free(pData);
pSample->m_NumFrames = m_aSamples;
pSample->m_LoopStart = -1;
pSample->m_LoopEnd = -1;
pSample->m_PausedAt = 0;
}
else
{
dbg_msg("sound/wv", "failed to open %s: %s", pFilename, aError);
}
io_close(ms_File);
ms_File = NULL;
if(g_Config.m_Debug)
dbg_msg("sound/wv", "loaded %s", pFilename);
RateConvert(SampleID);
return SampleID;
}
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;
}
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;
}
void
update_tag(ape_tag *tag, char *filename)
{
WavpackContext *ctx;
char error_buff [80];
ctx = WavpackOpenFileInput (filename, error_buff, OPEN_TAGS | OPEN_EDIT_TAGS, 0);
if (!ctx) {
char text[256];
sprintf(text, "File \"%s\" not found or is read protected!\n",
filename);
xmms_show_message("File-Error", (gchar *) text, "Ok", FALSE, NULL,
NULL);
return;
}
if (strlen (tag->album))
WavpackAppendTagItem (ctx, "Album", tag->album, strlen (tag->album));
else
WavpackDeleteTagItem (ctx, "Album");
if (strlen (tag->artist))
WavpackAppendTagItem (ctx, "Artist", tag->artist, strlen (tag->artist));
else
WavpackDeleteTagItem (ctx, "Artist");
if (strlen (tag->comment))
WavpackAppendTagItem (ctx, "Comment", tag->comment, strlen (tag->comment));
else
WavpackDeleteTagItem (ctx, "Comment");
if (strlen (tag->genre))
WavpackAppendTagItem (ctx, "Genre", tag->genre, strlen (tag->genre));
else
WavpackDeleteTagItem (ctx, "Genre");
if (strlen (tag->title))
WavpackAppendTagItem (ctx, "Title", tag->title, strlen (tag->title));
else
WavpackDeleteTagItem (ctx, "Title");
if (strlen (tag->track))
WavpackAppendTagItem (ctx, "Track", tag->track, strlen (tag->track));
else
WavpackDeleteTagItem (ctx, "Track");
if (strlen (tag->year))
WavpackAppendTagItem (ctx, "Year", tag->year, strlen (tag->year));
else
WavpackDeleteTagItem (ctx, "Year");
if (!WavpackWriteTag (ctx)) {
char text[256];
sprintf(text, "Couldn't write tag to \"%s\"!\n",
filename);
xmms_show_message("File-Error", (gchar *) text, "Ok", FALSE, NULL,
NULL);
}
WavpackCloseFile (ctx);
}
