/*
* Send a message to the status bar
* - with_timer: if TRUE, the message will be displayed during 4s
* if FALSE, the message will be displayed up to the next posted message
*/
void
et_status_bar_message (EtStatusBar *self,
const gchar *message,
gboolean with_timer)
{
EtStatusBarPrivate *priv;
gchar *msg_temp;
g_return_if_fail (ET_STATUS_BAR (self));
priv = et_status_bar_get_instance_private (self);
msg_temp = Try_To_Validate_Utf8_String (message);
/* Push the given message */
if (with_timer)
{
et_status_bar_start_timer (self);
gtk_statusbar_push (GTK_STATUSBAR (self), priv->timer_context,
msg_temp);
}
else
{
gtk_statusbar_pop (GTK_STATUSBAR (self), priv->message_context);
gtk_statusbar_push (GTK_STATUSBAR (self), priv->message_context,
msg_temp);
}
g_free (msg_temp);
}
static gchar *
Picture_Info (Picture *pic)
{
const gchar *format, *desc, *type;
gchar *r, *size_str;
GString *s;
format = Picture_Format_String(Picture_Format_From_Data(pic));
if (pic->description)
desc = pic->description;
else
desc = "";
type = Picture_Type_String(pic->type);
size_str = Convert_Size_1((gfloat)pic->size);
s = g_string_new(0);
// Behaviour following the tag type...
switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
{
case MP4_TAG:
{
g_string_printf (s, "%s (%s - %d×%d %s)\n%s: %s",
format,
size_str,
pic->width, pic->height, _("pixels"),
_("Type"), type);
break;
}
// Other tag types
default:
{
g_string_printf (s, "%s (%s - %d×%d %s)\n%s: %s\n%s: %s",
format,
size_str,
pic->width, pic->height, _("pixels"),
_("Type"), type,
_("Description"), desc);
break;
}
}
r = Try_To_Validate_Utf8_String(s->str);
g_string_free(s, TRUE); // TRUE to free also 's->str'!
g_free(size_str);
return r;
}
/*
* Return time in allocated data
*/
gchar *Log_Format_Date (void)
{
struct tm *tms;
time_t nowtime;
gchar *current_date, *current_work = g_malloc0(21);
// Get current time and date
nowtime = time(NULL);
tms = localtime(&nowtime);
strftime(current_work,20,"%X",tms); // Time without date in current locale
//strftime(current_work,20,"%x",ptr); // Date without time in current locale
current_date = Try_To_Validate_Utf8_String(current_work);
g_free(current_work);
return current_date;
}
/*
* validate_field_utf8:
* @field_value: the string to validate
* @field_len: the length of the string
*
* Validate a Vorbis comment field to ensure that it is UTF-8. Either return a
* duplicate of the original (valid) string, or a converted equivalent (of an
* invalid UTF-8 string).
*
* Returns: a valid UTF-8 represenation of @field_value
*/
static gchar *
validate_field_utf8 (const gchar *field_value,
guint32 field_len)
{
gchar *result;
if (g_utf8_validate (field_value, field_len, NULL))
{
result = g_strndup (field_value, field_len);
}
else
{
gchar *field_value_tmp = g_strndup (field_value,
field_len);
/* Unnecessarily validates the field again, but this should not be the
* common case. */
result = Try_To_Validate_Utf8_String (field_value_tmp);
g_free (field_value_tmp);
}
return result;
}
/*
* 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 FLAC file using the level 1 flac interface,
* Note:
* - if field is found but contains no info (strlen(str)==0), we don't read it
*/
gboolean Flac_Tag_Read_File_Tag (gchar *filename, File_Tag *FileTag)
{
FLAC__Metadata_SimpleIterator *iter;
gchar *string = NULL;
gchar *filename_utf8 = filename_to_display(filename);
guint i;
#ifndef LEGACY_FLAC // For FLAC >= 1.1.3
Picture *prev_pic = NULL;
#endif
//gint j = 1;
if (!filename || !FileTag)
return FALSE;
flac_error_msg = NULL;
// Initialize the iterator for the blocks
iter = FLAC__metadata_simple_iterator_new();
if ( iter == NULL || !FLAC__metadata_simple_iterator_init(iter, filename, true, false) )
{
if ( iter == NULL )
{
// Error with "FLAC__metadata_simple_iterator_new"
flac_error_msg = FLAC__Metadata_SimpleIteratorStatusString[FLAC__METADATA_SIMPLE_ITERATOR_STATUS_MEMORY_ALLOCATION_ERROR];
} else
{
// Error with "FLAC__metadata_simple_iterator_init"
FLAC__Metadata_SimpleIteratorStatus status = FLAC__metadata_simple_iterator_status(iter);
flac_error_msg = FLAC__Metadata_SimpleIteratorStatusString[status];
FLAC__metadata_simple_iterator_delete(iter);
}
Log_Print(LOG_ERROR,_("ERROR while opening file: '%s' as FLAC (%s)."),filename_utf8,flac_error_msg);
g_free(filename_utf8);
return FALSE;
}
/* libFLAC is able to detect (and skip) ID3v2 tags by itself */
while (FLAC__metadata_simple_iterator_next(iter))
{
// Get block data
FLAC__StreamMetadata *block = FLAC__metadata_simple_iterator_get_block(iter);
//g_print("Read: %d %s -> block type: %d\n",j++,g_path_get_basename(filename),FLAC__metadata_simple_iterator_get_block_type(iter));
// Action to do according the type
switch ( FLAC__metadata_simple_iterator_get_block_type(iter) )
{
//
// Read the VORBIS_COMMENT block (only one should exist)
//
case FLAC__METADATA_TYPE_VORBIS_COMMENT:
{
FLAC__StreamMetadata_VorbisComment *vc;
FLAC__StreamMetadata_VorbisComment_Entry *field;
gint field_num;
gint field_len;
gchar *field_value;
gchar *field_value_tmp;
// Get comments from block
vc = &block->data.vorbis_comment;
/*********
* Title *
*********/
field_num = 0;
while ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,field_num,"TITLE")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num++];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
if (FileTag->title==NULL)
FileTag->title = g_strdup(field_value);
else
FileTag->title = g_strconcat(FileTag->title,MULTIFIELD_SEPARATOR,field_value,NULL);
g_free(field_value);
}
}
}
/**********
* Artist *
**********/
field_num = 0;
while ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,field_num,"ARTIST")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num++];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
if (FileTag->artist==NULL)
FileTag->artist = g_strdup(field_value);
else
FileTag->artist = g_strconcat(FileTag->artist,MULTIFIELD_SEPARATOR,field_value,NULL);
g_free(field_value);
}
}
}
/*********
* Album *
*********/
field_num = 0;
while ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,field_num,"ALBUM")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num++];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
if (FileTag->album==NULL)
FileTag->album = g_strdup(field_value);
else
FileTag->album = g_strconcat(FileTag->album,MULTIFIELD_SEPARATOR,field_value,NULL);
g_free(field_value);
}
}
}
/***************
* Disc Number *
***************/
if ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,0,"DISCNUMBER")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
FileTag->disc_number = field_value;
}
}
}
/********
* Year *
********/
if ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,0,"DATE")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
FileTag->year = field_value;
if (g_utf8_strlen(FileTag->year, -1) > 4)
Log_Print(LOG_WARNING,_("The year value '%s' seems to be invalid in file '%s'. The information will be lost while saving tag."),FileTag->year,filename_utf8);
}
}
}
/*************************
* Track and Total Track *
*************************/
if ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,0,"TRACKTOTAL")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
if (NUMBER_TRACK_FORMATED)
{
FileTag->track_total = g_strdup_printf("%.*d",NUMBER_TRACK_FORMATED_SPIN_BUTTON,atoi(field_value));
} else
{
FileTag->track_total = g_strdup(field_value);
}
g_free(field_value);
}
}
// Below is also filled track_total if not done here
}
if ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,0,"TRACKNUMBER")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
string = g_utf8_strchr(field_value, -1, '/');
if (NUMBER_TRACK_FORMATED)
{
// If track_total not filled before, try now...
if (string && !FileTag->track_total)
{
FileTag->track_total = g_strdup_printf("%.*d",NUMBER_TRACK_FORMATED_SPIN_BUTTON,atoi(string+1));
*string = '\0';
}
FileTag->track = g_strdup_printf("%.*d",NUMBER_TRACK_FORMATED_SPIN_BUTTON,atoi(field_value));
} else
{
if (string && !FileTag->track_total)
{
FileTag->track_total = g_strdup(string+1);
*string = '\0';
}
FileTag->track = g_strdup(field_value);
}
g_free(field_value);
}
}
}
/*********
* Genre *
*********/
field_num = 0;
while ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,field_num,"GENRE")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num++];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
if (FileTag->genre==NULL)
FileTag->genre = g_strdup(field_value);
else
FileTag->genre = g_strconcat(FileTag->genre,MULTIFIELD_SEPARATOR,field_value,NULL);
g_free(field_value);
}
}
}
/***********
* Comment *
***********/
field_num = 0;
while ( 1 )
{
gint field_num1, field_num2;
// The comment field can take two forms...
field_num1 = FLAC__metadata_object_vorbiscomment_find_entry_from(block,field_num,"DESCRIPTION");
field_num2 = FLAC__metadata_object_vorbiscomment_find_entry_from(block,field_num,"COMMENT");
if (field_num1 >= 0 && field_num2 >= 0)
// Note : We set field_num to the last "comment" field to avoid to concatenate
// the DESCRIPTION and COMMENT field if there are both present (EasyTAG writes the both...)
if (field_num1 < field_num2)
field_num = field_num2;
else
field_num = field_num1;
else if (field_num1 >= 0)
field_num = field_num1;
else if (field_num2 >= 0)
field_num = field_num2;
else
break;
/* Extract field value */
field = &vc->comments[field_num++];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
if (FileTag->comment==NULL)
FileTag->comment = g_strdup(field_value);
else
FileTag->comment = g_strconcat(FileTag->comment,MULTIFIELD_SEPARATOR,field_value,NULL);
g_free(field_value);
}
}
}
/************
* Composer *
************/
field_num = 0;
while ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,field_num,"COMPOSER")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num++];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
if (FileTag->composer==NULL)
FileTag->composer = g_strdup(field_value);
else
FileTag->composer = g_strconcat(FileTag->composer,MULTIFIELD_SEPARATOR,field_value,NULL);
g_free(field_value);
}
}
}
/*******************
* Original artist *
*******************/
field_num = 0;
while ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,field_num,"PERFORMER")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num++];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
if (FileTag->orig_artist==NULL)
FileTag->orig_artist = g_strdup(field_value);
else
FileTag->orig_artist = g_strconcat(FileTag->orig_artist,MULTIFIELD_SEPARATOR,field_value,NULL);
g_free(field_value);
}
}
}
/*************
* Copyright *
*************/
field_num = 0;
while ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,field_num,"COPYRIGHT")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num++];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
if (FileTag->copyright==NULL)
FileTag->copyright = g_strdup(field_value);
else
FileTag->copyright = g_strconcat(FileTag->copyright,MULTIFIELD_SEPARATOR,field_value,NULL);
g_free(field_value);
}
}
}
/*******
* URL *
*******/
field_num = 0;
while ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,field_num,"LICENSE")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num++];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
if (FileTag->url==NULL)
FileTag->url = g_strdup(field_value);
else
FileTag->url = g_strconcat(FileTag->url,MULTIFIELD_SEPARATOR,field_value,NULL);
g_free(field_value);
}
}
}
/**************
* Encoded by *
**************/
field_num = 0;
while ( (field_num = FLAC__metadata_object_vorbiscomment_find_entry_from(block,field_num,"ENCODED-BY")) >= 0 )
{
/* Extract field value */
field = &vc->comments[field_num++];
field_value = memchr(field->entry, '=', field->length);
if (field_value)
{
field_value++;
if ( field_value && g_utf8_strlen(field_value, -1) > 0 )
{
field_len = field->length - (field_value - (gchar*) field->entry);
field_value_tmp = g_strndup(field_value, field_len);
field_value = Try_To_Validate_Utf8_String(field_value_tmp);
g_free(field_value_tmp);
if (FileTag->encoded_by==NULL)
FileTag->encoded_by = g_strdup(field_value);
else
FileTag->encoded_by = g_strconcat(FileTag->encoded_by,MULTIFIELD_SEPARATOR,field_value,NULL);
g_free(field_value);
}
}
}
/***************************
* Save unsupported fields *
***************************/
for (i=0; i<(guint)vc->num_comments; i++)
{
field = &vc->comments[i];
if ( strncasecmp((gchar *)field->entry,"TITLE=", MIN(6, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"ARTIST=", MIN(7, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"ALBUM=", MIN(6, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"DISCNUMBER=", MIN(11, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"DATE=", MIN(5, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"TRACKNUMBER=", MIN(12, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"TRACKTOTAL=", MIN(11, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"GENRE=", MIN(6, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"DESCRIPTION=", MIN(12, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"COMMENT=", MIN(8, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"COMPOSER=", MIN(9, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"PERFORMER=", MIN(10, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"COPYRIGHT=", MIN(10, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"LICENSE=", MIN(8, field->length)) != 0
&& strncasecmp((gchar *)field->entry,"ENCODED-BY=", MIN(11, field->length)) != 0 )
{
//g_print("custom %*s\n", field->length, field->entry);
FileTag->other = g_list_append(FileTag->other,g_strndup((const gchar *)field->entry, field->length));
}
}
break;
}
//
// Read the PICTURE block (severals can exist)
//
#ifndef LEGACY_FLAC // For FLAC >= 1.1.3
case FLAC__METADATA_TYPE_PICTURE:
{
/***********
* Picture *
***********/
FLAC__StreamMetadata_Picture *p;
Picture *pic;
// Get picture data from block
p = &block->data.picture;
pic = Picture_Allocate();
if (!prev_pic)
FileTag->picture = pic;
else
prev_pic->next = pic;
prev_pic = pic;
pic->size = p->data_length;
pic->data = g_memdup(p->data,pic->size);
pic->type = p->type;
pic->description = g_strdup((gchar *)p->description);
// Not necessary: will be calculated later
//pic->height = p->height;
//pic->width = p->width;
//g_print("Picture type : %s\n",FLAC__StreamMetadata_Picture_TypeString[p->type]);
//g_print("Mime type : %s\n",p->mime_type);
break;
}
#endif
default:
break;
}
// Free block data
//FLAC__metadata_object_delete(block);
}
// Free iter
FLAC__metadata_simple_iterator_delete(iter);
#ifdef ENABLE_MP3
/* If no FLAC vorbis tag found : we try to get the ID3 tag if it exists
* (but it will be deleted when rewriting the tag) */
if ( FileTag->title == NULL
&& FileTag->artist == NULL
&& FileTag->album == NULL
&& FileTag->disc_number == NULL
&& FileTag->year == NULL
&& FileTag->track == NULL
&& FileTag->track_total == NULL
&& FileTag->genre == NULL
&& FileTag->comment == NULL
&& FileTag->composer == NULL
&& FileTag->orig_artist == NULL
&& FileTag->copyright == NULL
&& FileTag->url == NULL
&& FileTag->encoded_by == NULL
&& FileTag->picture == NULL)
{
gint rc = Id3tag_Read_File_Tag(filename,FileTag);
// If an ID3 tag has been found (and no FLAC tag), we mark the file as
// unsaved to rewrite a flac tag.
if ( FileTag->title != NULL
|| FileTag->artist != NULL
|| FileTag->album != NULL
|| FileTag->disc_number != NULL
|| FileTag->year != NULL
|| FileTag->track != NULL
|| FileTag->track_total != NULL
|| FileTag->genre != NULL
|| FileTag->comment != NULL
|| FileTag->composer != NULL
|| FileTag->orig_artist != NULL
|| FileTag->copyright != NULL
|| FileTag->url != NULL
|| FileTag->encoded_by != NULL
|| FileTag->picture != NULL)
{
FileTag->saved = FALSE;
}
g_free(filename_utf8);
return rc;
}
/* Part to get cover artist :
* If we have read the ID3 tag previously we don't arrive here (and we have
* the picture if it exists).
* Else the ID3 tag wasn't read (as there was data in FLAC tag) so we try
* to read it only to get the picture (not supported by the FLAC tag). */
/***if (WRITE_ID3_TAGS_IN_FLAC_FILE && FileTag->picture == NULL)
{
File_Tag *FileTag_tmp = ET_File_Tag_Item_New();
gint rc = Id3tag_Read_File_Tag(filename,FileTag_tmp);
if (rc && FileTag_tmp->picture)
{
// Copy picture to FileTag
FileTag->picture = Picture_Copy(FileTag_tmp->picture);
}
ET_Free_File_Tag_Item(FileTag_tmp);
return rc;
}***/
#endif
g_free(filename_utf8);
return TRUE;
}
/*
* Read tag data into an Ogg Vorbis file.
* Note:
* - if field is found but contains no info (strlen(str)==0), we don't read it
*/
gboolean Ogg_Tag_Read_File_Tag (gchar *filename, File_Tag *FileTag)
{
FILE *file;
vcedit_state *state;
vorbis_comment *vc;
gchar *string = NULL;
gchar *string1 = NULL;
gchar *string2 = NULL;
gchar *filename_utf8 = filename_to_display(filename);
guint field_num, i;
Picture *prev_pic = NULL;
if (!filename || !FileTag)
return FALSE;
ogg_error_msg = NULL;
if ( (file=fopen(filename,"rb")) == NULL )
{
Log_Print(LOG_ERROR,_("ERROR while opening file: '%s' (%s)."),filename_utf8,g_strerror(errno));
g_free(filename_utf8);
return FALSE;
}
{
// Skip the id3v2 tag
guchar tmp_id3[4];
gulong id3v2size;
// Check if there is an ID3v2 tag...
fseek(file, 0L, SEEK_SET);
if (fread(tmp_id3, 1, 4, file) == 4)
{
// Calculate ID3v2 length
if (tmp_id3[0] == 'I' && tmp_id3[1] == 'D' && tmp_id3[2] == '3' && tmp_id3[3] < 0xFF)
{
// id3v2 tag skipeer $49 44 33 yy yy xx zz zz zz zz [zz size]
fseek(file, 2, SEEK_CUR); // Size is 6-9 position
if (fread(tmp_id3, 1, 4, file) == 4)
{
id3v2size = 10 + ( (long)(tmp_id3[3]) | ((long)(tmp_id3[2]) << 7)
| ((long)(tmp_id3[1]) << 14) | ((long)(tmp_id3[0]) << 21) );
fseek(file, id3v2size, SEEK_SET);
Log_Print(LOG_ERROR,_("Warning : The Ogg Vorbis file '%s' contains an ID3v2 tag."),filename_utf8);
}else
{
fseek(file, 0L, SEEK_SET);
}
}else
{
fseek(file, 0L, SEEK_SET);
}
}else
{
fseek(file, 0L, SEEK_SET);
}
}
state = vcedit_new_state(); // Allocate memory for 'state'
if ( vcedit_open(state,file) < 0 )
{
Log_Print(LOG_ERROR,_("ERROR: Failed to open file: '%s' as vorbis (%s)."),filename_utf8,vcedit_error(state));
ogg_error_msg = vcedit_error(state);
fclose(file);
g_free(filename_utf8);
vcedit_clear(state);
return FALSE;
}
/* Get data from tag */
vc = vcedit_comments(state);
/*{
gint i;
for (i=0;i<vc->comments;i++)
g_print("%s -> Ogg vc:'%s'\n",g_path_get_basename(filename),vc->user_comments[i]);
}*/
/*********
* Title *
*********/
/* Note : don't forget to add any new field to 'Save unsupported fields' */
field_num = 0;
while ( (string = vorbis_comment_query(vc,"TITLE",field_num++)) != NULL )
{
string = Try_To_Validate_Utf8_String(string);
if ( g_utf8_strlen(string, -1) > 0 )
{
if (FileTag->title==NULL)
FileTag->title = g_strdup(string);
else
FileTag->title = g_strconcat(FileTag->title,MULTIFIELD_SEPARATOR,string,NULL);
// If strlen = 0, then no allocated data!
}
g_free(string);
}
/**********
* Artist *
**********/
field_num = 0;
while ( (string = vorbis_comment_query(vc,"ARTIST",field_num++)) != NULL )
{
string = Try_To_Validate_Utf8_String(string);
if ( g_utf8_strlen(string, -1) > 0 )
{
if (FileTag->artist==NULL)
FileTag->artist = g_strdup(string);
else
FileTag->artist = g_strconcat(FileTag->artist,MULTIFIELD_SEPARATOR,string,NULL);
}
g_free(string);
}
/****************
* Album Artist *
****************/
field_num = 0;
while ( (string = vorbis_comment_query(vc,"ALBUMARTIST",field_num++)) != NULL )
{
string = Try_To_Validate_Utf8_String(string);
if ( g_utf8_strlen(string, -1) > 0 )
{
if (FileTag->album_artist==NULL)
FileTag->album_artist = g_strdup(string);
else
FileTag->album_artist = g_strconcat(FileTag->album_artist,MULTIFIELD_SEPARATOR,string,NULL);
}
g_free(string);
}
/*********
* Album *
*********/
field_num = 0;
while ( (string = vorbis_comment_query(vc,"ALBUM",field_num++)) != NULL )
{
string = Try_To_Validate_Utf8_String(string);
if ( g_utf8_strlen(string, -1) > 0 )
{
if (FileTag->album==NULL)
FileTag->album = g_strdup(string);
else
FileTag->album = g_strconcat(FileTag->album,MULTIFIELD_SEPARATOR,string,NULL);
}
g_free(string);
}
/*******************************
* Disc Number (Part of a Set) *
*******************************/
if ( (string = vorbis_comment_query(vc,"DISCNUMBER",0)) != NULL && g_utf8_strlen(string, -1) > 0 )
{
FileTag->disc_number = g_strdup(string);
}
/********
* Year *
********/
if ( (string = vorbis_comment_query(vc,"DATE",0)) != NULL && g_utf8_strlen(string, -1) > 0 )
{
FileTag->year = g_strdup(string);
if (g_utf8_strlen(FileTag->year, -1) > 4)
Log_Print(LOG_WARNING,_("The year value '%s' seems to be invalid in file '%s'. The information will be lost while saving tag."),FileTag->year,filename_utf8);
}
/*************************
* Track and Total Track *
*************************/
if ( (string = vorbis_comment_query(vc,"TRACKNUMBER",0)) != NULL && g_utf8_strlen(string, -1) > 0 )
{
if (NUMBER_TRACK_FORMATED)
{
// Ckeck if TRACKTOTAL used, else takes it in TRACKNUMBER
if ( (string1 = vorbis_comment_query(vc,"TRACKTOTAL",0)) != NULL && g_utf8_strlen(string1, -1) > 0 )
{
FileTag->track_total = g_strdup_printf("%.*d",NUMBER_TRACK_FORMATED_SPIN_BUTTON,atoi(string1));
}else
if ( (string1 = g_utf8_strchr(string, -1, '/')) )
{
FileTag->track_total = g_strdup_printf("%.*d",NUMBER_TRACK_FORMATED_SPIN_BUTTON,atoi(string1+1));
*string1 = '\0';
}
FileTag->track = g_strdup_printf("%.*d",NUMBER_TRACK_FORMATED_SPIN_BUTTON,atoi(string));
}else
{
// Ckeck if TRACKTOTAL used, else takes it in TRACKNUMBER
if ( (string1 = vorbis_comment_query(vc,"TRACKTOTAL",0)) != NULL && g_utf8_strlen(string1, -1) > 0 )
{
FileTag->track_total = g_strdup_printf("%.*d",NUMBER_TRACK_FORMATED_SPIN_BUTTON,atoi(string1));
}else
if ( (string1 = g_utf8_strchr(string, -1, '/')) )
{
FileTag->track_total = g_strdup(string1+1);
*string1 = '\0';
}
FileTag->track = g_strdup(string);
}
}
/*********
* Genre *
*********/
field_num = 0;
while ( (string = vorbis_comment_query(vc,"GENRE",field_num++)) != NULL )
{
string = Try_To_Validate_Utf8_String(string);
if ( g_utf8_strlen(string, -1) > 0 )
{
if (FileTag->genre==NULL)
FileTag->genre = g_strdup(string);
else
FileTag->genre = g_strconcat(FileTag->genre,MULTIFIELD_SEPARATOR,string,NULL);
}
g_free(string);
}
/***********
* Comment *
***********/
field_num = 0;
string1 = NULL; // Cause it may be not updated into the 'while' condition
while ( ((string2 = vorbis_comment_query(vc,"DESCRIPTION",field_num)) != NULL ) // New specifications
|| ((string = vorbis_comment_query(vc,"COMMENT", field_num)) != NULL ) // Old : Winamp format (for EasyTAG 1.99.11 and older)
|| ((string1 = vorbis_comment_query(vc,"", field_num)) != NULL ) ) // Old : Xmms format (for EasyTAG 1.99.11 and older)
{
string = Try_To_Validate_Utf8_String(string);
string1 = Try_To_Validate_Utf8_String(string1);
string2 = Try_To_Validate_Utf8_String(string2);
if ( string2 && g_utf8_strlen(string2, -1) > 0 ) // Contains comment to new specifications format and we prefer this format (field name defined)
{
if (FileTag->comment==NULL)
FileTag->comment = g_strdup(string2);
else
FileTag->comment = g_strconcat(FileTag->comment,MULTIFIELD_SEPARATOR,string2,NULL);
// Frees allocated data
if (string && g_utf8_strlen(string, -1) > 0)
g_free(string);
if (string1 && g_utf8_strlen(string1, -1) > 0)
g_free(string1);
}else if ( string && g_utf8_strlen(string, -1) > 0 ) // Contains comment to Winamp format and we prefer this format (field name defined)
{
if (FileTag->comment==NULL)
FileTag->comment = g_strdup(string);
else
FileTag->comment = g_strconcat(FileTag->comment,MULTIFIELD_SEPARATOR,string,NULL);
// Frees allocated data
if (string1 && g_utf8_strlen(string1, -1) > 0)
g_free(string1);
}else if ( string1 && g_utf8_strlen(string1, -1) > 0 ) // Contains comment to Xmms format only
{
if (FileTag->comment==NULL)
FileTag->comment = g_strdup(string1);
else
FileTag->comment = g_strconcat(FileTag->comment,MULTIFIELD_SEPARATOR,string1,NULL);
}
g_free(string);
g_free(string1);
g_free(string2);
string = NULL;
string1 = NULL;
field_num++;
}
/************
* Composer *
************/
field_num = 0;
while ( (string = vorbis_comment_query(vc,"COMPOSER",field_num++)) != NULL )
{
string = Try_To_Validate_Utf8_String(string);
if ( g_utf8_strlen(string, -1) > 0 )
{
if (FileTag->composer==NULL)
FileTag->composer = g_strdup(string);
else
FileTag->composer = g_strconcat(FileTag->composer,MULTIFIELD_SEPARATOR,string,NULL);
}
g_free(string);
}
/*******************
* Original artist *
*******************/
field_num = 0;
while ( (string = vorbis_comment_query(vc,"PERFORMER",field_num++)) != NULL )
{
string = Try_To_Validate_Utf8_String(string);
if ( g_utf8_strlen(string, -1) > 0 )
{
if (FileTag->orig_artist==NULL)
FileTag->orig_artist = g_strdup(string);
else
FileTag->orig_artist = g_strconcat(FileTag->orig_artist,MULTIFIELD_SEPARATOR,string,NULL);
}
g_free(string);
}
/*************
* Copyright *
*************/
field_num = 0;
while ( (string = vorbis_comment_query(vc,"COPYRIGHT",field_num++)) != NULL )
{
string = Try_To_Validate_Utf8_String(string);
if ( g_utf8_strlen(string, -1) > 0 )
{
if (FileTag->copyright==NULL)
FileTag->copyright = g_strdup(string);
else
FileTag->copyright = g_strconcat(FileTag->copyright,MULTIFIELD_SEPARATOR,string,NULL);
}
g_free(string);
}
/*******
* URL *
*******/
field_num = 0;
while ( (string = vorbis_comment_query(vc,"LICENSE",field_num++)) != NULL )
{
string = Try_To_Validate_Utf8_String(string);
if ( g_utf8_strlen(string, -1) > 0 )
{
if (FileTag->url==NULL)
FileTag->url = g_strdup(string);
else
FileTag->url = g_strconcat(FileTag->url,MULTIFIELD_SEPARATOR,string,NULL);
}
g_free(string);
}
/**************
* Encoded by *
**************/
field_num = 0;
while ( (string = vorbis_comment_query(vc,"ENCODED-BY",field_num++)) != NULL )
{
string = Try_To_Validate_Utf8_String(string);
if ( g_utf8_strlen(string, -1) > 0 )
{
if (FileTag->encoded_by==NULL)
FileTag->encoded_by = g_strdup(string);
else
FileTag->encoded_by = g_strconcat(FileTag->encoded_by,MULTIFIELD_SEPARATOR,string,NULL);
}
g_free(string);
}
/**************
* Picture *
**************/
/* Non officials tags used for picture information:
* - COVERART : contains the picture data
* - COVERARTTYPE : cover front, ...
* - COVERARTDESCRIPTION : information set by user
* - COVERARTMIME : image/jpeg or image/png (written only)
*/
field_num = 0;
while ( (string = vorbis_comment_query(vc,"COVERART",field_num++)) != NULL )
{
gchar *data;
gint size;
Picture *pic;
pic = Picture_Allocate();
if (!prev_pic)
FileTag->picture = pic;
else
prev_pic->next = pic;
prev_pic = pic;
pic->data = NULL;
// Decode picture data
data = g_strdup(string);
size = base64_decode(string, data);
if ( data && (pic->data = g_memdup(data, size)) )
pic->size = size;
g_free(data);
if ( (string = vorbis_comment_query(vc,"COVERARTTYPE",field_num-1)) != NULL )
{
pic->type = atoi(string);
}
if ( (string = vorbis_comment_query(vc,"COVERARTDESCRIPTION",field_num-1)) != NULL )
{
pic->description = g_strdup(string);
}
//if ((string = vorbis_comment_query(vc,"COVERTARTMIME",field_num-1)) != NULL )
//{
// pic->description = g_strdup(string);
//}
}
/***************************
* Save unsupported fields *
***************************/
for (i=0;i<(guint)vc->comments;i++)
{
if ( strncasecmp(vc->user_comments[i],"TITLE=", 6) != 0
&& strncasecmp(vc->user_comments[i],"ARTIST=", 7) != 0
&& strncasecmp(vc->user_comments[i],"ALBUMARTIST=", 12) != 0
&& strncasecmp(vc->user_comments[i],"ALBUM=", 6) != 0
&& strncasecmp(vc->user_comments[i],"DISCNUMBER=", 11) != 0
&& strncasecmp(vc->user_comments[i],"DATE=", 5) != 0
&& strncasecmp(vc->user_comments[i],"TRACKNUMBER=", 12) != 0
&& strncasecmp(vc->user_comments[i],"TRACKTOTAL=", 11) != 0
&& strncasecmp(vc->user_comments[i],"GENRE=", 6) != 0
&& strncasecmp(vc->user_comments[i],"DESCRIPTION=", 12) != 0
&& strncasecmp(vc->user_comments[i],"COMMENT=", 8) != 0
&& strncasecmp(vc->user_comments[i],"=", 1) != 0
&& strncasecmp(vc->user_comments[i],"COMPOSER=", 9) != 0
&& strncasecmp(vc->user_comments[i],"PERFORMER=", 10) != 0
&& strncasecmp(vc->user_comments[i],"COPYRIGHT=", 10) != 0
&& strncasecmp(vc->user_comments[i],"LICENSE=", 8) != 0
&& strncasecmp(vc->user_comments[i],"ENCODED-BY=", 11) != 0
&& strncasecmp(vc->user_comments[i],"COVERART=", 9) != 0
&& strncasecmp(vc->user_comments[i],"COVERARTTYPE=", 13) != 0
&& strncasecmp(vc->user_comments[i],"COVERARTMIME=", 13) != 0
&& strncasecmp(vc->user_comments[i],"COVERARTDESCRIPTION=",20) != 0
)
{
FileTag->other = g_list_append(FileTag->other,
Try_To_Validate_Utf8_String(vc->user_comments[i]));
}
}
vcedit_clear(state);
fclose(file);
g_free(filename_utf8);
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;
}
/*
* Open the window to select and type the picture properties
*/
void Picture_Properties_Button_Clicked (GObject *object)
{
GtkWidget *ScrollWindowPictureTypes, *PictureTypesWindow;
GtkWidget *type, *label, *desc;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkListStore *store;
GtkTreeIter type_iter_to_select, iter;
GtkTreeModel *model;
GtkWindow *parent_window = NULL;
GList *selection_list = NULL;
GList *l;
gint selection_nbr, selection_i = 1;
gint response;
EtPictureType pic_type;
g_return_if_fail (PictureEntryView != NULL);
parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object)));
if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window)))
{
g_warning("Could not get parent window\n");
return;
}
model = gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));
selection_list = gtk_tree_selection_get_selected_rows(selection, NULL);
selection_nbr = gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(selection));
for (l = selection_list; l != NULL; l = g_list_next (l))
{
GtkTreePath *path = l->data;
Picture *pic = NULL;
GtkTreeSelection *selectiontype;
gchar *title;
GtkTreePath *rowPath;
gboolean valid;
// Get corresponding picture
valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path);
if (valid)
gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, PICTURE_COLUMN_DATA, &pic, -1);
title = g_strdup_printf (_("Image Properties %d/%d"), selection_i++,
selection_nbr);
PictureTypesWindow = gtk_dialog_new_with_buttons(title,
parent_window,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_free(title);
gtk_dialog_set_default_response(GTK_DIALOG(PictureTypesWindow), GTK_RESPONSE_OK);
ScrollWindowPictureTypes = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowPictureTypes),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
store = gtk_list_store_new(PICTURE_TYPE_COLUMN_COUNT, G_TYPE_STRING, G_TYPE_INT);
type = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref (store);
gtk_container_add(GTK_CONTAINER(ScrollWindowPictureTypes), type);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_title (column, _("Image Type"));
gtk_tree_view_column_set_attributes(column, renderer,
"text", PICTURE_TYPE_COLUMN_TEXT,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(type), column);
gtk_widget_set_size_request(type, 256, 256);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),ScrollWindowPictureTypes,TRUE,TRUE,0);
// Behaviour following the tag type...
switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
{
case MP4_TAG:
{
/* Load picture type (only Front Cover!). */
GtkTreeIter itertype;
gtk_list_store_insert_with_values (store, &itertype, G_MAXINT,
PICTURE_TYPE_COLUMN_TEXT,
_(Picture_Type_String (ET_PICTURE_TYPE_FRONT_COVER)),
PICTURE_TYPE_COLUMN_TYPE_CODE,
ET_PICTURE_TYPE_FRONT_COVER,
-1);
/* Line to select by default. */
type_iter_to_select = itertype;
break;
}
// Other tag types
default:
{
// Load pictures types
for (pic_type = ET_PICTURE_TYPE_OTHER; pic_type < ET_PICTURE_TYPE_UNDEFINED; pic_type++)
{
GtkTreeIter itertype;
gtk_list_store_insert_with_values (store, &itertype,
G_MAXINT,
PICTURE_TYPE_COLUMN_TEXT,
_(Picture_Type_String (pic_type)),
PICTURE_TYPE_COLUMN_TYPE_CODE,
pic_type, -1);
/* Line to select by default. */
if (pic->type == pic_type)
type_iter_to_select = itertype;
}
break;
}
}
// Select the line by default
selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type));
gtk_tree_selection_select_iter(selectiontype, &type_iter_to_select);
// Set visible the current selected line
rowPath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &type_iter_to_select);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(type), rowPath, NULL, FALSE, 0, 0);
gtk_tree_path_free(rowPath);
// Description of the picture
label = gtk_label_new (_("Image Description:"));
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),label,FALSE,FALSE,4);
// Entry for the description
desc = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),desc,FALSE,FALSE,0);
if (pic->description)
{
gchar *tmp = Try_To_Validate_Utf8_String(pic->description);
gtk_entry_set_text(GTK_ENTRY(desc), tmp);
g_free(tmp);
}
// Behaviour following the tag type...
switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
{
case MP4_TAG:
{
gtk_widget_set_sensitive(GTK_WIDGET(label), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(desc), FALSE);
break;
}
// Other tag types
default:
{
break;
}
}
gtk_widget_show_all(PictureTypesWindow);
response = gtk_dialog_run(GTK_DIALOG(PictureTypesWindow));
if (response == GTK_RESPONSE_OK)
{
GtkTreeModel *modeltype;
GtkTreeIter itertype;
modeltype = gtk_tree_view_get_model(GTK_TREE_VIEW(type));
selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type));
if (gtk_tree_selection_get_selected(selectiontype, &modeltype, &itertype))
{
gchar *buffer, *pic_info;
gint t;
gtk_tree_model_get(modeltype, &itertype,
PICTURE_TYPE_COLUMN_TYPE_CODE, &t, -1);
pic->type = t;
buffer = g_strdup(gtk_entry_get_text(GTK_ENTRY(desc)));
Strip_String(buffer);
if (pic->description)
g_free(pic->description);
/* If the entry was empty, buffer will be the empty string "".
* This can be safely passed to the underlying
* FLAC__metadata_object_picture_set_description(). See
* https://bugs.launchpad.net/ubuntu/+source/easytag/+bug/558804
* and https://bugzilla.redhat.com/show_bug.cgi?id=559828 for
* downstream bugs when 0 was passed instead. */
pic->description = buffer;
// Update value in the PictureEntryView
pic_info = Picture_Info(pic);
gtk_list_store_set(GTK_LIST_STORE(model), &iter,
PICTURE_COLUMN_TEXT, pic_info,
-1);
g_free(pic_info);
}
}
gtk_widget_destroy(PictureTypesWindow);
}
g_list_free_full (selection_list, (GDestroyNotify)gtk_tree_path_free);
}
