/*
* 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);
}
static Tuple *
wv_probe_for_tuple(const char * filename, VFSFile * fd)
{
WavpackContext *ctx;
Tuple *tu;
char error[1024];
ctx = WavpackOpenFileInputEx(&wv_readers, fd, NULL, error, OPEN_TAGS, 0);
if (ctx == NULL)
return NULL;
AUDDBG("starting probe of %p\n", (void *) fd);
vfs_rewind(fd);
tu = tuple_new_from_filename(filename);
vfs_rewind(fd);
tag_tuple_read(tu, fd);
tuple_set_int(tu, FIELD_LENGTH, NULL,
((uint64_t) WavpackGetNumSamples(ctx) * 1000) / (uint64_t) WavpackGetSampleRate(ctx));
tuple_set_str(tu, FIELD_CODEC, NULL, "WavPack");
char * quality = wv_get_quality (ctx);
tuple_set_str (tu, FIELD_QUALITY, NULL, quality);
str_unref (quality);
WavpackCloseFile(ctx);
AUDDBG("returning tuple %p for file %p\n", (void *) tu, (void *) fd);
return tu;
}
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);
}
void WvDecoder::Close()
{
if (m_Ctx != nullptr) {
WavpackCloseFile(m_Ctx);
m_Ctx = nullptr;
}
}
static gboolean
gst_wavpack_enc_sink_event (GstPad * pad, GstEvent * event)
{
GstWavpackEnc *enc = GST_WAVPACK_ENC (gst_pad_get_parent (pad));
gboolean ret = TRUE;
GST_DEBUG ("Received %s event on sinkpad", GST_EVENT_TYPE_NAME (event));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
/* Encode all remaining samples and flush them to the src pads */
WavpackFlushSamples (enc->wp_context);
/* Drop all remaining data, this is no complete block otherwise
* it would've been pushed already */
if (enc->pending_buffer) {
gst_object_unref (enc->pending_buffer);
enc->pending_buffer = NULL;
enc->pending_offset = 0;
}
/* write the MD5 sum if we have to write one */
if ((enc->md5) && (enc->md5_context)) {
guchar md5_digest[16];
MD5Final (md5_digest, enc->md5_context);
WavpackStoreMD5Sum (enc->wp_context, md5_digest);
}
/* Try to rewrite the first frame with the correct sample number */
if (enc->first_block)
gst_wavpack_enc_rewrite_first_block (enc);
/* close the context if not already happened */
if (enc->wp_context) {
WavpackCloseFile (enc->wp_context);
enc->wp_context = NULL;
}
ret = gst_pad_event_default (pad, event);
break;
case GST_EVENT_NEWSEGMENT:
if (enc->wp_context) {
GST_WARNING_OBJECT (enc, "got NEWSEGMENT after encoding "
"already started");
}
/* drop NEWSEGMENT events, we create our own when pushing
* the first buffer to the pads */
gst_event_unref (event);
ret = TRUE;
break;
default:
ret = gst_pad_event_default (pad, event);
break;
}
gst_object_unref (enc);
return ret;
}
static void wav_close (void *prv_data)
{
struct wavpack_data *data = (struct wavpack_data *)prv_data;
if (data->ok) {
WavpackCloseFile (data->wpc);
}
decoder_error_clear (&data->error);
free (data);
logit ("File closed");
}
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;
}
void
soundfile_close(soundfile_t *sf) {
dp(30, "sf=%p \n", sf);
if (sf->t == sft_libsndfile) {
sf_close(sf->p);
} else {
if (sf->m == sft_write) {
if (!WavpackFlushSamples(sf->p))
die("WavpackFlushSamples failed: %s\n", WavpackGetErrorMessage(sf->p));
WavpackCloseFile(sf->p);
fclose(sf->file);
}
}
}
~WavpackDecoder()
{
if (input != NULL) {
free(input);
input = NULL;
}
if (output != NULL) {
free(output);
output = NULL;
}
if (ctx != NULL) {
WavpackCloseFile(ctx);
ctx = NULL;
}
}
void wavpack_buffer_decoder_free(wavpack_buffer_decoder* wbd)
{
if(wbd != NULL)
{
frame_stream_reader_free(wbd->fsr);
wbd->fsr = NULL;
frame_stream_reader_free(wbd->fsrc);
wbd->fsrc = NULL;
if(wbd->wpc != NULL)
{
WavpackCloseFile(wbd->wpc);
wbd->wpc = NULL;
}
wp_free(wbd);
}
}
static gboolean
gst_wavpack_dec_stop (GstAudioDecoder * dec)
{
GstWavpackDec *wpdec = GST_WAVPACK_DEC (dec);
GST_DEBUG_OBJECT (dec, "stop");
if (wpdec->context) {
WavpackCloseFile (wpdec->context);
wpdec->context = NULL;
}
gst_wavpack_dec_reset (wpdec);
return TRUE;
}
void SoundSourceWV::close() {
if (m_wpc) {
WavpackCloseFile(m_wpc);
m_wpc = nullptr;
}
if (m_pWVFile) {
m_pWVFile->close();
delete m_pWVFile;
m_pWVFile = nullptr;
}
if (m_pWVCFile) {
m_pWVCFile->close();
delete m_pWVCFile;
m_pWVCFile = nullptr;
}
}
static void
xmms_wavpack_free_data (xmms_wavpack_data_t *data)
{
if (!data) {
return;
}
if (data->buf) {
g_free (data->buf);
}
if (data->ctx) {
WavpackCloseFile (data->ctx);
}
g_free (data);
}
void SoundSourceWV::close() {
if (m_wpc) {
WavpackCloseFile(m_wpc);
m_wpc = nullptr;
}
if (m_pWVFile) {
m_pWVFile->close();
delete m_pWVFile;
m_pWVFile = nullptr;
}
if (m_pWVCFile) {
m_pWVCFile->close();
delete m_pWVCFile;
m_pWVCFile = nullptr;
}
m_curFrameIndex = getMinFrameIndex();
}
bool WavPackDecoder::Close(CFErrorRef */*error*/)
{
if(!IsOpen()) {
LOGGER_WARNING("org.sbooth.AudioEngine.AudioDecoder.WavPack", "Close() called on an AudioDecoder that hasn't been opened");
return true;
}
memset(&mStreamReader, 0, sizeof(mStreamReader));
if(mWPC)
WavpackCloseFile(mWPC), mWPC = nullptr;
if(mBuffer)
free(mBuffer), mBuffer = nullptr;
mIsOpen = false;
return true;
}
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 WavPackDecoder::Close(CFErrorRef */*error*/)
{
if(!IsOpen()) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioDecoder.WavPack");
LOG4CXX_WARN(logger, "Close() called on an AudioDecoder that hasn't been opened");
return true;
}
memset(&mStreamReader, 0, sizeof(mStreamReader));
if(mWPC)
WavpackCloseFile(mWPC), mWPC = NULL;
if(mBuffer)
free(mBuffer), mBuffer = NULL;
mIsOpen = false;
return true;
}
static void
gst_wavpack_enc_reset (GstWavpackEnc * enc)
{
/* close and free everything stream related if we already did something */
if (enc->wp_context) {
WavpackCloseFile (enc->wp_context);
enc->wp_context = NULL;
}
if (enc->wp_config) {
g_free (enc->wp_config);
enc->wp_config = NULL;
}
if (enc->first_block) {
g_free (enc->first_block);
enc->first_block = NULL;
}
enc->first_block_size = 0;
if (enc->md5_context) {
g_checksum_free (enc->md5_context);
enc->md5_context = NULL;
}
if (enc->pending_buffer) {
gst_buffer_unref (enc->pending_buffer);
enc->pending_buffer = NULL;
enc->pending_offset = 0;
}
/* reset the last returns to GST_FLOW_OK. This is only set to something else
* while WavpackPackSamples() or more specific gst_wavpack_enc_push_block()
* so not valid anymore */
enc->srcpad_last_return = enc->wvcsrcpad_last_return = GST_FLOW_OK;
/* reset stream information */
enc->samplerate = 0;
enc->depth = 0;
enc->channels = 0;
enc->channel_mask = 0;
enc->need_channel_remap = FALSE;
enc->timestamp_offset = GST_CLOCK_TIME_NONE;
enc->next_ts = GST_CLOCK_TIME_NONE;
}
static void
wv_free (DB_fileinfo_t *_info) {
if (_info) {
wvctx_t *info = (wvctx_t *)_info;
if (info->file) {
deadbeef->fclose (info->file);
info->file = NULL;
}
#ifndef TINYWV
if (info->c_file) {
deadbeef->fclose (info->c_file);
info->c_file = NULL;
}
#endif
if (info->ctx) {
WavpackCloseFile (info->ctx);
info->ctx = NULL;
}
free (_info);
}
}
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;
}
/*
* Decodes a stream.
*/
static void
wavpack_streamdecode(struct decoder * decoder, struct input_stream *is)
{
char error[ERRORLEN];
WavpackContext *wpc;
struct input_stream *is_wvc;
int open_flags = OPEN_NORMALIZE;
struct wavpack_input isp, isp_wvc;
bool can_seek = is->seekable;
is_wvc = wavpack_open_wvc(decoder, is->uri, &isp_wvc);
if (is_wvc != NULL) {
open_flags |= OPEN_WVC;
can_seek &= is_wvc->seekable;
}
if (!can_seek) {
open_flags |= OPEN_STREAMING;
}
wavpack_input_init(&isp, decoder, is);
wpc = WavpackOpenFileInputEx(
&mpd_is_reader, &isp,
open_flags & OPEN_WVC ? &isp_wvc : NULL,
error, open_flags, 23
);
if (wpc == NULL) {
g_warning("failed to open WavPack stream: %s\n", error);
return;
}
wavpack_decode(decoder, wpc, can_seek);
WavpackCloseFile(wpc);
if (open_flags & OPEN_WVC) {
input_stream_close(is_wvc);
}
}
static GstStateChangeReturn
gst_wavpack_dec_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GstWavpackDec *dec = GST_WAVPACK_DEC (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
if (dec->context) {
WavpackCloseFile (dec->context);
dec->context = NULL;
}
gst_wavpack_dec_reset (dec);
break;
case GST_STATE_CHANGE_READY_TO_NULL:
break;
default:
break;
}
return ret;
}
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);
}
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;
}
void SoundSourceWV::close() {
if (m_wpc) {
WavpackCloseFile(m_wpc);
m_wpc = NULL;
}
}
static void wv_deattach (VFSFile * wvc_input, WavpackContext * ctx)
{
if (wvc_input != NULL)
vfs_fclose(wvc_input);
WavpackCloseFile(ctx);
}
static GstFlowReturn
gst_wavpack_enc_chain (GstPad * pad, GstBuffer * buf)
{
GstWavpackEnc *enc = GST_WAVPACK_ENC (gst_pad_get_parent (pad));
uint32_t sample_count = GST_BUFFER_SIZE (buf) / 4;
GstFlowReturn ret;
/* reset the last returns to GST_FLOW_OK. This is only set to something else
* while WavpackPackSamples() or more specific gst_wavpack_enc_push_block()
* so not valid anymore */
enc->srcpad_last_return = enc->wvcsrcpad_last_return = GST_FLOW_OK;
GST_DEBUG ("got %u raw samples", sample_count);
/* check if we already have a valid WavpackContext, otherwise make one */
if (!enc->wp_context) {
/* create raw context */
enc->wp_context =
WavpackOpenFileOutput (gst_wavpack_enc_push_block, &enc->wv_id,
(enc->correction_mode > 0) ? &enc->wvc_id : NULL);
if (!enc->wp_context) {
GST_ELEMENT_ERROR (enc, LIBRARY, INIT, (NULL),
("error creating Wavpack context"));
gst_object_unref (enc);
gst_buffer_unref (buf);
return GST_FLOW_ERROR;
}
/* set the WavpackConfig according to our parameters */
gst_wavpack_enc_set_wp_config (enc);
/* set the configuration to the context now that we know everything
* and initialize the encoder */
if (!WavpackSetConfiguration (enc->wp_context,
enc->wp_config, (uint32_t) (-1))
|| !WavpackPackInit (enc->wp_context)) {
GST_ELEMENT_ERROR (enc, LIBRARY, SETTINGS, (NULL),
("error setting up wavpack encoding context"));
WavpackCloseFile (enc->wp_context);
gst_object_unref (enc);
gst_buffer_unref (buf);
return GST_FLOW_ERROR;
}
GST_DEBUG ("setup of encoding context successfull");
}
/* Save the timestamp of the first buffer. This will be later
* used as offset for all following buffers */
if (enc->timestamp_offset == GST_CLOCK_TIME_NONE) {
if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
enc->timestamp_offset = GST_BUFFER_TIMESTAMP (buf);
enc->next_ts = GST_BUFFER_TIMESTAMP (buf);
} else {
enc->timestamp_offset = 0;
enc->next_ts = 0;
}
}
/* Check if we have a continous stream, if not drop some samples or the buffer or
* insert some silence samples */
if (enc->next_ts != GST_CLOCK_TIME_NONE &&
GST_BUFFER_TIMESTAMP (buf) < enc->next_ts) {
guint64 diff = enc->next_ts - GST_BUFFER_TIMESTAMP (buf);
guint64 diff_bytes;
GST_WARNING_OBJECT (enc, "Buffer is older than previous "
"timestamp + duration (%" GST_TIME_FORMAT "< %" GST_TIME_FORMAT
"), cannot handle. Clipping buffer.",
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
GST_TIME_ARGS (enc->next_ts));
diff_bytes =
GST_CLOCK_TIME_TO_FRAMES (diff, enc->samplerate) * enc->channels * 2;
if (diff_bytes >= GST_BUFFER_SIZE (buf)) {
gst_buffer_unref (buf);
return GST_FLOW_OK;
}
buf = gst_buffer_make_metadata_writable (buf);
GST_BUFFER_DATA (buf) += diff_bytes;
GST_BUFFER_SIZE (buf) -= diff_bytes;
GST_BUFFER_TIMESTAMP (buf) += diff;
if (GST_BUFFER_DURATION_IS_VALID (buf))
GST_BUFFER_DURATION (buf) -= diff;
}
/* Allow a diff of at most 5 ms */
if (enc->next_ts != GST_CLOCK_TIME_NONE
&& GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
if (GST_BUFFER_TIMESTAMP (buf) != enc->next_ts &&
GST_BUFFER_TIMESTAMP (buf) - enc->next_ts > 5 * GST_MSECOND) {
GST_WARNING_OBJECT (enc,
"Discontinuity detected: %" G_GUINT64_FORMAT " > %" G_GUINT64_FORMAT,
GST_BUFFER_TIMESTAMP (buf) - enc->next_ts, 5 * GST_MSECOND);
WavpackFlushSamples (enc->wp_context);
enc->timestamp_offset += (GST_BUFFER_TIMESTAMP (buf) - enc->next_ts);
}
}
if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)
&& GST_BUFFER_DURATION_IS_VALID (buf))
enc->next_ts = GST_BUFFER_TIMESTAMP (buf) + GST_BUFFER_DURATION (buf);
else
enc->next_ts = GST_CLOCK_TIME_NONE;
if (enc->need_channel_remap) {
buf = gst_buffer_make_writable (buf);
gst_wavpack_enc_fix_channel_order (enc, (gint32 *) GST_BUFFER_DATA (buf),
sample_count);
}
/* if we want to append the MD5 sum to the stream update it here
* with the current raw samples */
if (enc->md5) {
g_checksum_update (enc->md5_context, GST_BUFFER_DATA (buf),
GST_BUFFER_SIZE (buf));
}
/* encode and handle return values from encoding */
if (WavpackPackSamples (enc->wp_context, (int32_t *) GST_BUFFER_DATA (buf),
sample_count / enc->channels)) {
GST_DEBUG ("encoding samples successful");
ret = GST_FLOW_OK;
} else {
if ((enc->srcpad_last_return == GST_FLOW_RESEND) ||
(enc->wvcsrcpad_last_return == GST_FLOW_RESEND)) {
ret = GST_FLOW_RESEND;
} else if ((enc->srcpad_last_return == GST_FLOW_OK) ||
(enc->wvcsrcpad_last_return == GST_FLOW_OK)) {
ret = GST_FLOW_OK;
} else if ((enc->srcpad_last_return == GST_FLOW_NOT_LINKED) &&
(enc->wvcsrcpad_last_return == GST_FLOW_NOT_LINKED)) {
ret = GST_FLOW_NOT_LINKED;
} else if ((enc->srcpad_last_return == GST_FLOW_WRONG_STATE) &&
(enc->wvcsrcpad_last_return == GST_FLOW_WRONG_STATE)) {
ret = GST_FLOW_WRONG_STATE;
} else {
GST_ELEMENT_ERROR (enc, LIBRARY, ENCODE, (NULL),
("encoding samples failed"));
ret = GST_FLOW_ERROR;
}
}
gst_buffer_unref (buf);
gst_object_unref (enc);
return ret;
}
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);
}
