/*
* 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 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);
}
/**
* Locate and parse a floating point tag. Returns true if it was
* found.
*/
static bool
wavpack_tag_float(WavpackContext *wpc, const char *key, float *value_r)
{
char buffer[64];
int ret;
ret = WavpackGetTagItem(wpc, key, buffer, sizeof(buffer));
if (ret <= 0)
return false;
*value_r = atof(buffer);
return true;
}
static float calculate_gain (WavpackContext *wpc)
{
if (replaygainEnabled) {
float gain_value = 0.0, peak_value = 1.0;
char value [32];
if (albumReplaygainEnabled && WavpackGetTagItem (wpc, "replaygain_album_gain", value, sizeof (value))) {
gain_value = (float) atof (value);
if (WavpackGetTagItem (wpc, "replaygain_album_peak", value, sizeof (value)))
peak_value = (float) atof (value);
}
else if (WavpackGetTagItem (wpc, "replaygain_track_gain", value, sizeof (value))) {
gain_value = (float) atof (value);
if (WavpackGetTagItem (wpc, "replaygain_track_peak", value, sizeof (value)))
peak_value = (float) atof (value);
}
else
return 1.0;
// convert gain from dB to voltage (with +/- 20 dB limit)
if (gain_value > 20.0)
gain_value = 10.0;
else if (gain_value < -20.0)
gain_value = (float) 0.1;
else
gain_value = (float) pow (10.0, gain_value / 20.0);
if (peak_value * gain_value > 1.0 && clipPreventionEnabled)
gain_value = (float)(1.0 / peak_value);
return gain_value;
}
else
return 1.0;
}
void
load_tag(ape_tag *tag, WavpackContext *ctx)
{
memset(tag, 0, sizeof(ape_tag));
WavpackGetTagItem(ctx, "Album", tag->album, sizeof(tag->album));
WavpackGetTagItem(ctx, "Artist", tag->artist, sizeof(tag->artist));
WavpackGetTagItem(ctx, "Comment", tag->comment, sizeof(tag->comment));
WavpackGetTagItem(ctx, "Genre", tag->genre, sizeof(tag->genre));
WavpackGetTagItem(ctx, "Title", tag->title, sizeof(tag->title));
WavpackGetTagItem(ctx, "Track", tag->track, sizeof(tag->track));
WavpackGetTagItem(ctx, "Year", tag->year, sizeof(tag->year));
}
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);
}
/*
* 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;
}
/*
* Read tag data from a Wavpack file.
*/
gboolean
wavpack_tag_read_file_tag (GFile *file,
File_Tag *FileTag,
GError **error)
{
WavpackStreamReader reader = { wavpack_read_bytes, wavpack_get_pos,
wavpack_set_pos_abs, wavpack_set_pos_rel,
wavpack_push_back_byte, wavpack_get_length,
wavpack_can_seek, NULL /* No writing. */ };
EtWavpackState state;
WavpackContext *wpc;
gchar message[80];
gchar field[MAXLEN] = { 0, };
gchar *field2;
guint length;
const int open_flags = OPEN_TAGS;
g_return_val_if_fail (file != NULL && FileTag != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
state.error = NULL;
state.istream = g_file_read (file, NULL, &state.error);
if (!state.istream)
{
g_propagate_error (error, state.error);
return FALSE;
}
state.seekable = G_SEEKABLE (state.istream);
/* NULL for the WavPack correction file. */
wpc = WavpackOpenFileInputEx (&reader, &state, NULL, message, open_flags,
0);
if (wpc == NULL)
{
if (state.error)
{
g_propagate_error (error, state.error);
}
else
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "%s",
message);
}
g_object_unref (state.istream);
return FALSE;
}
/*
* Title
*/
length = WavpackGetTagItem(wpc, "title", field, MAXLEN);
if ( length > 0 && FileTag->title == NULL ) {
FileTag->title = Try_To_Validate_Utf8_String(field);
}
memset (field, '\0', MAXLEN);
/*
* Artist
*/
length = WavpackGetTagItem(wpc, "artist", field, MAXLEN);
if ( length > 0 && FileTag->artist == NULL) {
FileTag->artist = Try_To_Validate_Utf8_String(field);
}
memset (field, '\0', MAXLEN);
/* Album artist. */
length = WavpackGetTagItem (wpc, "album artist", field, MAXLEN);
if (length > 0 && FileTag->album_artist == NULL)
{
FileTag->album_artist = Try_To_Validate_Utf8_String (field);
}
memset (field, '\0', MAXLEN);
/*
* Album
*/
length = WavpackGetTagItem(wpc, "album", field, MAXLEN);
if ( length > 0 && FileTag->album == NULL ) {
FileTag->album = Try_To_Validate_Utf8_String(field);
}
memset (field, '\0', MAXLEN);
/*
* Discnumber + Disctotal.
*/
length = WavpackGetTagItem (wpc, "part", field, MAXLEN);
field2 = strchr (field, '/');
/* Need to cut off the total tracks if present */
if (field2)
{
*field2 = 0;
field2++;
}
if (field2 && FileTag->disc_total == NULL)
{
gchar *tmp;
tmp = Try_To_Validate_Utf8_String (field2);
FileTag->disc_total = et_disc_number_to_string (atoi (tmp));
g_free (tmp);
}
if (length > 0 && FileTag->disc_number == NULL)
{
gchar *tmp;
tmp = Try_To_Validate_Utf8_String (field);
FileTag->disc_number = et_disc_number_to_string (atoi (tmp));
g_free (tmp);
}
memset (field, '\0', MAXLEN);
/*
* Year
*/
length = WavpackGetTagItem(wpc, "year", field, MAXLEN);
if ( length > 0 && FileTag->year == NULL ) {
FileTag->year = Try_To_Validate_Utf8_String(field);
}
memset (field, '\0', MAXLEN);
/*
* Tracknumber + tracktotal
*/
length = WavpackGetTagItem(wpc, "track", field, MAXLEN);
field2 = strchr (field, '/');
/* Need to cut off the total tracks if present */
if (field2) {
*field2 = 0;
field2++;
}
if (field2 && FileTag->track_total == NULL)
{
gchar *tmp;
tmp = Try_To_Validate_Utf8_String (field2);
FileTag->track_total = et_track_number_to_string (atoi (tmp));
g_free (tmp);
}
if (length > 0 && FileTag->track == NULL)
{
gchar *tmp;
tmp = Try_To_Validate_Utf8_String (field);
FileTag->track = et_track_number_to_string (atoi (tmp));
g_free (tmp);
}
memset (field, '\0', MAXLEN);
/*
* Genre
*/
length = WavpackGetTagItem(wpc, "genre", field, MAXLEN);
if ( length > 0 && FileTag->genre == NULL ) {
FileTag->genre = Try_To_Validate_Utf8_String(field);
}
memset (field, '\0', MAXLEN);
/*
* Comment
*/
length = WavpackGetTagItem(wpc, "comment", field, MAXLEN);
if ( length > 0 && FileTag->comment == NULL ) {
FileTag->comment = Try_To_Validate_Utf8_String(field);
}
memset (field, '\0', MAXLEN);
/*
* Composer
*/
length = WavpackGetTagItem(wpc, "composer", field, MAXLEN);
if ( length > 0 && FileTag->composer == NULL ) {
FileTag->composer = Try_To_Validate_Utf8_String(field);
}
memset (field, '\0', MAXLEN);
/*
* Original artist
*/
length = WavpackGetTagItem(wpc, "original artist", field, MAXLEN);
if ( length > 0 && FileTag->orig_artist == NULL ) {
FileTag->orig_artist = Try_To_Validate_Utf8_String(field);
}
memset (field, '\0', MAXLEN);
/*
* Copyright
*/
length = WavpackGetTagItem(wpc, "copyright", field, MAXLEN);
if ( length > 0 && FileTag->copyright == NULL ) {
FileTag->copyright = Try_To_Validate_Utf8_String(field);
}
memset (field, '\0', MAXLEN);
/*
* URL
*/
length = WavpackGetTagItem(wpc, "copyright url", field, MAXLEN);
if ( length > 0 && FileTag->url == NULL ) {
FileTag->url = Try_To_Validate_Utf8_String(field);
}
memset (field, '\0', MAXLEN);
/*
* Encoded by
*/
length = WavpackGetTagItem(wpc, "encoded by", field, MAXLEN);
if ( length > 0 && FileTag->encoded_by == NULL ) {
FileTag->encoded_by = Try_To_Validate_Utf8_String(field);
}
WavpackCloseFile(wpc);
g_object_unref (state.istream);
return TRUE;
}
