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); }