/* Load the tag editor */
gboolean
gimmix_tag_editor_populate (const gchar *song)
{
GtkTreeModel *genre_model;
gchar *info;
gint min;
gint sec;
gint n;
const TagLib_AudioProperties *properties;
if (!song)
return FALSE;
if (!g_file_test (song, G_FILE_TEST_EXISTS))
return FALSE;
file = taglib_file_new (song);
if (file == NULL)
return FALSE;
taglib_set_strings_unicode (FALSE);
tag = taglib_file_tag (file);
properties = taglib_file_audioproperties (file);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(tag_year_spin), taglib_tag_year(tag));
gtk_spin_button_set_value (GTK_SPIN_BUTTON(tag_track_spin), taglib_tag_track(tag));
gtk_label_set_text (GTK_LABEL(tag_file), song);
gtk_entry_set_text (GTK_ENTRY(tag_title), g_strstrip(taglib_tag_title(tag)));
gtk_entry_set_text (GTK_ENTRY(tag_artist), g_strstrip(taglib_tag_artist(tag)));
gtk_entry_set_text (GTK_ENTRY(tag_album), g_strstrip(taglib_tag_album(tag)));
gtk_entry_set_text (GTK_ENTRY(tag_comment), g_strstrip(taglib_tag_comment(tag)));
gtk_combo_box_append_text (GTK_COMBO_BOX(tag_genre), taglib_tag_genre(tag));
genre_model = gtk_combo_box_get_model (GTK_COMBO_BOX(tag_genre));
n = gtk_tree_model_iter_n_children (genre_model, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX(tag_genre), n-1);
/* Audio Information */
sec = taglib_audioproperties_length(properties) % 60;
min = (taglib_audioproperties_length(properties) - sec) / 60;
info = g_strdup_printf ("%02i:%02i", min, sec);
gtk_label_set_text (GTK_LABEL(tag_info_length), info);
g_free (info);
info = g_strdup_printf ("%i Kbps", taglib_audioproperties_bitrate(properties));
gtk_label_set_text (GTK_LABEL(tag_info_bitrate), info);
g_free (info);
info = g_strdup_printf ("%i", taglib_audioproperties_channels(properties));
gtk_label_set_text (GTK_LABEL(tag_info_channels), info);
g_free (info);
taglib_tag_free_strings ();
return TRUE;
}
int main()
{
int i;
int seconds;
int minutes;
TagLib_File *file;
TagLib_Tag *tag;
const TagLib_AudioProperties *properties;
//taglib_set_strings_unicode(FALSE);
//file = taglib_file_new("/home/milo/Downloads/State_Of_My_Head.mp3");
if(file == NULL)
{
printf("Err: Can't opne new tab file\n");
exit(1);
}
tag = taglib_file_tag(file);
if(tag != NULL) {
printf("-- TAG --\n");
printf("title - \"%s\"\n", taglib_tag_title(tag));
printf("artist - \"%s\"\n", taglib_tag_artist(tag));
printf("album - \"%s\"\n", taglib_tag_album(tag));
printf("year - \"%i\"\n", taglib_tag_year(tag));
printf("comment - \"%s\"\n", taglib_tag_comment(tag));
printf("track - \"%i\"\n", taglib_tag_track(tag));
printf("genre - \"%s\"\n", taglib_tag_genre(tag));
}
#if 0
if(properties != NULL) {
seconds = taglib_audioproperties_length(properties) % 60;
minutes = (taglib_audioproperties_length(properties) - seconds) / 60;
printf("-- AUDIO --\n");
printf("bitrate - %i\n", taglib_audioproperties_bitrate(properties));
printf("sample rate - %i\n", taglib_audioproperties_samplerate(properties));
printf("channels - %i\n", taglib_audioproperties_channels(properties));
printf("length - %i:%02i\n", minutes, seconds);
}
#endif
taglib_tag_free_strings();
taglib_file_free(file);
return 0;
}
int main(int argc, char *argv[])
{
int i;
int seconds;
int minutes;
TagLib_File *file;
TagLib_Tag *tag;
const TagLib_AudioProperties *properties;
taglib_set_strings_unicode(FALSE);
for(i = 1; i < argc; i++) {
printf("******************** \"%s\" ********************\n", argv[i]);
file = taglib_file_new(argv[i]);
if(file == NULL)
break;
tag = taglib_file_tag(file);
properties = taglib_file_audioproperties(file);
if(tag != NULL) {
printf("-- TAG --\n");
printf("title - \"%s\"\n", taglib_tag_title(tag));
printf("artist - \"%s\"\n", taglib_tag_artist(tag));
printf("album - \"%s\"\n", taglib_tag_album(tag));
printf("year - \"%i\"\n", taglib_tag_year(tag));
printf("comment - \"%s\"\n", taglib_tag_comment(tag));
printf("track - \"%i\"\n", taglib_tag_track(tag));
printf("genre - \"%s\"\n", taglib_tag_genre(tag));
}
if(properties != NULL) {
seconds = taglib_audioproperties_length(properties) % 60;
minutes = (taglib_audioproperties_length(properties) - seconds) / 60;
printf("-- AUDIO --\n");
printf("bitrate - %i\n", taglib_audioproperties_bitrate(properties));
printf("sample rate - %i\n", taglib_audioproperties_samplerate(properties));
printf("channels - %i\n", taglib_audioproperties_channels(properties));
printf("length - %i:%02i\n", minutes, seconds);
}
taglib_tag_free_strings();
taglib_file_free(file);
}
return 0;
}
int
main (int argc, char **argv)
{
TagLib_File *file;
TagLib_Tag *tag;
const TagLib_AudioProperties *properties;
if (argc != 2)
{
fprintf (stderr, "usage: emms-print-metadata file.{mp3,ogg,flac}\nother formats may work as well.\n");
exit (1);
}
file = taglib_file_new (argv[1]);
if (!file)
{
fprintf (stderr, "%s: File does not exist or is of an unknown type\n", argv[1]);
exit (1);
}
tag = taglib_file_tag (file);
/* Apparently, if the file is named foo.mp3 or similar, the library
still can open it, for whatever reason.
*/
if (!tag)
{
fprintf (stderr, "%s: File does not exist or is of an unknown type\n", argv[1]);
exit (1);
}
printf ("info-artist=%s\n", taglib_tag_artist (tag));
printf ("info-title=%s\n", taglib_tag_title (tag));
printf ("info-album=%s\n", taglib_tag_album (tag));
printf ("info-tracknumber=%d\n", taglib_tag_track (tag));
printf ("info-year=%d\n", taglib_tag_year (tag));
printf ("info-genre=%s\n", taglib_tag_genre (tag));
printf ("info-note=%s\n", taglib_tag_comment (tag));
properties = taglib_file_audioproperties (file);
printf ("info-playing-time=%d\n",
properties ? taglib_audioproperties_length (properties) : 0);
taglib_tag_free_strings ();
taglib_file_free (file);
return 0;
}
static gboolean get_info_taglib(gchar *file, struct tags *tags)
{
gboolean ret = FALSE;
TagLib_File *tfile;
TagLib_Tag *tag;
const TagLib_AudioProperties *audio_prop;
tfile = taglib_file_new(file);
if (!tfile) {
g_warning("Unable to open file using taglib : %s", file);
ret = FALSE;
goto exit;
}
tag = taglib_file_tag(tfile);
if (!tag) {
g_warning("Unable to locate tag");
ret = FALSE;
goto exit;
}
audio_prop = taglib_file_audioproperties(tfile);
if (!audio_prop) {
g_warning("Unable to locate audio properties");
ret = FALSE;
goto exit;
}
tags->title = g_strdup(taglib_tag_title(tag));
tags->artist = g_strdup(taglib_tag_artist(tag));
tags->album = g_strdup(taglib_tag_album(tag));
tags->genre = g_strdup(taglib_tag_genre(tag));
tags->comment = g_strdup(taglib_tag_comment(tag));
tags->track_no = taglib_tag_track(tag);
tags->year = taglib_tag_year(tag);
tags->bitrate = taglib_audioproperties_bitrate(audio_prop);
tags->length = taglib_audioproperties_length(audio_prop);
tags->channels = taglib_audioproperties_channels(audio_prop);
tags->samplerate = taglib_audioproperties_samplerate(audio_prop);
ret = TRUE;
exit:
taglib_tag_free_strings();
taglib_file_free(tfile);
return ret;
}
/* get an Itdb_Track from the given file */
Itdb_Track *track_parse(char *path, Itdb_iTunesDB *db) {
TagLib_File *file = NULL;
TagLib_Tag *tag = NULL;
const TagLib_AudioProperties *audio = NULL;
Itdb_Track *track = itdb_track_new();
FILE *track_file = fopen(path, "r");
fseek(track_file, 0, SEEK_END);
track->size = ftell(track_file);
fclose(track_file);
/* we are storing our filename in userdata */
track->userdata = g_strdup(path);
track->userdata_duplicate = (gpointer (*)(gpointer))g_strdup;
track->userdata_destroy = g_free;
track->transferred = FALSE;
itdb_track_add(db, track, -1);
file = taglib_file_new(path);
if (file == NULL) {
/* should this be an error? */
cpod_error("error reading metadata from \"%s\"\n", path);
return track;
}
tag = taglib_file_tag(file);
audio = taglib_file_audioproperties(file);
/* g_strdup() string fields so that taglib_tag_free_strings() works */
track->title = g_strdup(taglib_tag_title(tag));
track->album = g_strdup(taglib_tag_album(tag));
track->artist = g_strdup(taglib_tag_artist(tag));
track->genre = g_strdup(taglib_tag_genre(tag));
track->comment = g_strdup(taglib_tag_comment(tag));
track->track_nr = taglib_tag_track(tag);
track->year = taglib_tag_year(tag);
/* audioproperties_length is in seconds and track->tracklen is in ms */
track->tracklen = taglib_audioproperties_length(audio) * 1000;
track->samplerate = taglib_audioproperties_samplerate(audio);
taglib_tag_free_strings();
/* taglib_file_free() frees TagLib_{Tag,AudioProperties} too */
taglib_file_free(file);
return track;
}
//Read the meta tags of media_file and update eclair with the new data
void eclair_meta_tag_read(Eclair *eclair, Eclair_Media_File *media_file)
{
TagLib_File *tag_file;
TagLib_Tag *tag;
const TagLib_AudioProperties *tag_audio_props;
Evas_Bool need_to_update = 0;
if (!eclair || !media_file || !media_file->path)
return;
if (!eclair_database_get_meta_infos(&eclair->database, media_file, &need_to_update) || need_to_update)
{
if (!(tag_file = taglib_file_new(media_file->path)))
return;
if ((tag = taglib_file_tag(tag_file)))
{
eclair_media_file_set_field_string(&media_file->artist, taglib_tag_artist(tag));
eclair_media_file_set_field_string(&media_file->title, taglib_tag_title(tag));
eclair_media_file_set_field_string(&media_file->album, taglib_tag_album(tag));
eclair_media_file_set_field_string(&media_file->genre, taglib_tag_genre(tag));
eclair_media_file_set_field_string(&media_file->comment, taglib_tag_comment(tag));
media_file->year = taglib_tag_year(tag);
media_file->track = taglib_tag_track(tag);
}
if ((tag_audio_props = taglib_file_audioproperties(tag_file)))
{
media_file->length = taglib_audioproperties_length(tag_audio_props);
media_file->bitrate = taglib_audioproperties_bitrate(tag_audio_props);
media_file->samplerate = taglib_audioproperties_samplerate(tag_audio_props);
}
taglib_tag_free_strings();
taglib_file_free(tag_file);
//Insert the new tag infos in the database
eclair_database_insert_media_file(&eclair->database, media_file);
}
//Try to load the cover
if (!media_file->cover_path && !(media_file->cover_path = eclair_cover_file_get_from_local(&eclair->cover_manager, media_file->artist, media_file->album, media_file->path)))
eclair_cover_add_file_to_treat(&eclair->cover_manager, media_file);
}
/**
* scan a musepack file for metainfo.
*
* @param filename file to read metainfo for
* @param pmp3 MP3FILE structure to fill
* @returns TRUE if file should be added to DB, FALSE otherwise
*/
int scan_get_mpcinfo(char *filename, MP3FILE *pmp3) {
TagLib_File *file;
TagLib_Tag *tag;
const TagLib_AudioProperties *properties;
char *val;
int len;
unsigned int i;
/* open file with taglib */
if ((file = taglib_file_new_type(filename, TagLib_File_MPC)) == NULL) {
DPRINTF(E_WARN,L_SCAN,"Could not open %s with taglib\n", filename);
return FALSE;
}
/* retrieve all tags */
if ((tag = taglib_file_tag(file)) == NULL) {
DPRINTF(E_WARN,L_SCAN,"Could not retrieve tags of %s\n", filename);
taglib_file_free(file);
return FALSE;
}
/* fill the MP3FILE structure with the tags */
if ((val = taglib_tag_title(tag)) != NULL) {
len = strlen(val);
if ((pmp3->title = calloc(len + 1, 1)) != NULL)
strncpy(pmp3->title, val, len);
taglib_tag_free_strings();
}
if ((val = taglib_tag_artist(tag)) != NULL) {
len = strlen(val);
if ((pmp3->artist = calloc(len + 1, 1)) != NULL)
strncpy(pmp3->artist, val, len);
taglib_tag_free_strings();
}
if ((val = taglib_tag_album(tag)) != NULL) {
len = strlen(val);
if ((pmp3->album = calloc(len + 1, 1)) != NULL)
strncpy(pmp3->album, val, len);
taglib_tag_free_strings();
}
if ((val = taglib_tag_comment(tag)) != NULL) {
len = strlen(val);
if ((pmp3->comment = calloc(len + 1, 1)) != NULL)
strncpy(pmp3->comment, val, len);
taglib_tag_free_strings();
}
if ((val = taglib_tag_genre(tag)) != NULL) {
len = strlen(val);
if ((pmp3->genre = calloc(len + 1, 1)) != NULL)
strncpy(pmp3->genre, val, len);
taglib_tag_free_strings();
}
if ((i = taglib_tag_year(tag)) != 0)
pmp3->year = i;
if ((i = taglib_tag_track(tag)) != 0)
pmp3->track = i;
/* load the properties (like bitrate) from the file */
if ((properties = taglib_file_audioproperties(file)) == NULL) {
DPRINTF(E_WARN,L_SCAN,"Could not retrieve properties of %s\n", filename);
return FALSE;
}
/* fill the properties in the MP3FILE structure */
pmp3->song_length = taglib_audioproperties_length(properties) * 1000;
pmp3->bitrate = taglib_audioproperties_bitrate(properties);
pmp3->samplerate = taglib_audioproperties_samplerate(properties);
taglib_file_free(file);
return TRUE;
}
/* Load the tag editor */
gboolean
gimmix_tag_editor_populate (const void *song)
{
GtkTreeModel *genre_model;
gchar *info;
gint n;
guint year = 0;
guint track = 0;
gchar *title = NULL;
gchar *artist = NULL;
gchar *album = NULL;
gchar *genre = NULL;
gchar *comment = NULL;
if (!song)
return FALSE;
#ifdef HAVE_TAGEDITOR
const TagLib_AudioProperties *properties;
if (!g_file_test(song,G_FILE_TEST_EXISTS))
return FALSE;
file = taglib_file_new (song);
if (file == NULL)
return FALSE;
taglib_set_strings_unicode (FALSE);
tag = taglib_file_tag (file);
properties = taglib_file_audioproperties (file);
#else
mpd_Song *foo = (mpd_Song*) g_malloc0 (sizeof(mpd_Song));
memcpy (foo, song, sizeof(mpd_Song));
#endif
#ifdef HAVE_TAGEDITOR
year = taglib_tag_year (tag);
track = taglib_tag_track (tag);
title = g_strstrip (taglib_tag_title(tag));
artist = g_strstrip (taglib_tag_artist(tag));
album = g_strstrip (taglib_tag_album(tag));
comment = g_strstrip (taglib_tag_comment(tag));
genre = taglib_tag_genre (tag);
#else
if (foo->date)
{
year = atoi (foo->date);
}
if (foo->track)
{
track = atoi (foo->track);
}
title = foo->title;
artist = foo->artist;
album = foo->album;
comment = foo->comment;
genre = foo->genre;
#endif
gtk_spin_button_set_value (GTK_SPIN_BUTTON(tag_year_spin), year);
gtk_spin_button_set_value (GTK_SPIN_BUTTON(tag_track_spin), track);
gtk_entry_set_text (GTK_ENTRY(tag_file),
#ifdef HAVE_TAGEDITOR
song
#else
foo->file
#endif
);
if (title)
{
gtk_entry_set_text (GTK_ENTRY(tag_title), title);
}
if (artist)
{
gtk_entry_set_text (GTK_ENTRY(tag_artist), artist);
}
if (album)
{
gtk_entry_set_text (GTK_ENTRY(tag_album), album);
}
if (comment)
{
gtk_entry_set_text (GTK_ENTRY(tag_comment), comment);
}
if (genre)
{
gtk_combo_box_append_text (GTK_COMBO_BOX(tag_genre), genre);
}
genre_model = gtk_combo_box_get_model (GTK_COMBO_BOX(tag_genre));
n = gtk_tree_model_iter_n_children (genre_model, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX(tag_genre), n-1);
/* Audio Information */
#ifdef HAVE_TAGEDITOR
guint sec = taglib_audioproperties_length(properties) % 60;
guint min = (taglib_audioproperties_length(properties) - sec) / 60;
info = g_strdup_printf ("%02i:%02i", min, sec);
gtk_label_set_text (GTK_LABEL(tag_info_length), info);
#else
char *tok = NULL;
info = (char*) g_malloc0 (sizeof(char)*32);
gimmix_get_progress_status (gmo, NULL, info);
tok = strtok (info, "/");
tok = strtok (NULL, "/");
g_strstrip (tok);
gtk_label_set_text (GTK_LABEL(tag_info_length), tok);
#endif
g_free (info);
#ifdef HAVE_TAGEDITOR
info = g_strdup_printf ("%i Kbps", taglib_audioproperties_bitrate(properties));
#else
info = g_strdup_printf ("%i Kbps", mpd_status_get_bitrate(gmo));
#endif
gtk_label_set_text (GTK_LABEL(tag_info_bitrate), info);
g_free (info);
#ifdef HAVE_TAGEDITOR
info = g_strdup_printf ("%i", taglib_audioproperties_channels(properties));
#else
info = g_strdup_printf ("%i", mpd_status_get_channels(gmo));
#endif
gtk_label_set_text (GTK_LABEL(tag_info_channels), info);
g_free (info);
#ifdef HAVE_TAGEDITOR
taglib_tag_free_strings ();
#else
free (foo);
#endif
return TRUE;
}
/*
* Mp4_Tag_Read_File_Tag:
*
* Read tag data into an Mp4 file.
*
* Note:
* - for string fields, //if field is found but contains no info (strlen(str)==0), we don't read it
* - for track numbers, if they are zero, then we don't read it
*/
gboolean Mp4tag_Read_File_Tag (gchar *filename, File_Tag *FileTag)
{
FILE *file;
TagLib_File *mp4file;
TagLib_Tag *tag;
guint track;
if (!filename || !FileTag)
return FALSE;
if ( (file=fopen(filename,"r"))==NULL )
{
gchar *filename_utf8 = filename_to_display(filename);
Log_Print(LOG_ERROR,_("ERROR while opening file: '%s' (%s)."),filename_utf8,g_strerror(errno));
g_free(filename_utf8);
return FALSE;
}
fclose(file); // We close it cause mp4 opens/closes file itself
/* Get data from tag */
mp4file = taglib_file_new_type(filename,TagLib_File_MP4);
if (mp4file == NULL)
{
gchar *filename_utf8 = filename_to_display(filename);
Log_Print(LOG_ERROR,_("ERROR while opening file: '%s' (%s)."),filename_utf8,_("MP4 format invalid"));
g_free(filename_utf8);
return FALSE;
}
/* TODO Add error detection */
tag = taglib_file_tag(mp4file);
/*********
* Title *
*********/
FileTag->title = g_strdup(taglib_tag_title(tag));
/**********
* Artist *
**********/
FileTag->artist = g_strdup(taglib_tag_artist(tag));
/*********
* Album *
*********/
FileTag->album = g_strdup(taglib_tag_album(tag));
/****************
* Album Artist *
****************/
/* TODO: No album artist or disc number support in the TagLib C API! */
/********
* Year *
********/
FileTag->year = g_strdup_printf("%u", taglib_tag_year(tag));
/*************************
* Track and Total Track *
*************************/
track = taglib_tag_track(tag);
if (track != 0)
FileTag->track = NUMBER_TRACK_FORMATED ? g_strdup_printf("%.*d",NUMBER_TRACK_FORMATED_SPIN_BUTTON,(gint)track) : g_strdup_printf("%d",(gint)track);
/* TODO: No total track support in the TagLib C API! */
/*********
* Genre *
*********/
FileTag->genre = g_strdup(taglib_tag_genre(tag));
/***********
* Comment *
***********/
FileTag->comment = g_strdup(taglib_tag_comment(tag));
/**********************
* Composer or Writer *
**********************/
/* TODO: No composer support in the TagLib C API! */
/*****************
* Encoding Tool *
*****************/
/* TODO: No encode_by support in the TagLib C API! */
/***********
* Picture *
***********/
/* TODO: No encode_by support in the TagLib C API! */
/* Free allocated data */
taglib_tag_free_strings();
taglib_file_free(mp4file);
return TRUE;
}
