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;
}
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);
}
static int get_track_info(char *fullPath,
mps_library_track_info_t *track_info)
{
int rv = MPS_LIBRARYDBD_SUCCESS;
TagLib_File *tagLibFile;
TagLib_Tag *tagLibTag;
TagLib_File_Type tagLibType;
mps_library_element_type_t mpsFileType;
const TagLib_AudioProperties *tagLibProp;
char *tmpString;
MPS_DBG_PRINT("Entering %s(0x%08x)\n", __func__, (unsigned int) track_info);
taglib_set_strings_unicode(true);
mpsFileType = track_info->file_type;
tagLibType = (mpsFileType==MPS_LIBRARY_MP3_FILE?TagLib_File_MPEG:
mpsFileType==MPS_LIBRARY_FLAC_FILE?TagLib_File_FLAC:
mpsFileType==MPS_LIBRARY_OGG_FILE?TagLib_File_OggVorbis:
mpsFileType==MPS_LIBRARY_AAC_FILE?TagLib_File_MP4:
mpsFileType==MPS_LIBRARY_APPLE_LOSSLESS_FILE?TagLib_File_MP4:
mpsFileType==MPS_LIBRARY_WMA_FILE?TagLib_File_ASF:
mpsFileType==MPS_LIBRARY_AIF_FILE?TagLib_File_AIFF:
mpsFileType==MPS_LIBRARY_WAV_FILE?TagLib_File_WAV:
0);
tagLibFile = taglib_file_new_type(fullPath, tagLibType);
if(tagLibFile == NULL) {
MPS_DBG_PRINT("Call to taglib_file_new(%s) failed.\n", fullPath);
rv = MPS_LIBRARYDBD_FAILURE;
goto ERR_OUT;
}
tagLibTag = taglib_file_tag(tagLibFile);
tagLibProp = taglib_file_audioproperties(tagLibFile);
/* TODO: need to go one step further to determine whether a file with
an "m4a", etc. header is actually an apple lossless */
track_info->file_type = mpsFileType;
tmpString = taglib_tag_title(tagLibTag);
if (tmpString != NULL) {
copy_string_without_edge_whitespace(track_info->title,
tmpString,
MPS_MAX_TRACK_INFO_FIELD_LENGTH);
MPS_DBG_PRINT("Copied \"%s\" into track_title->title\n", track_info->title);
}
tmpString = taglib_tag_album(tagLibTag);
if (tmpString != NULL) {
copy_string_without_edge_whitespace(track_info->album,
tmpString,
MPS_MAX_TRACK_INFO_FIELD_LENGTH);
MPS_DBG_PRINT("Copied \"%s\" into track_title->album\n", track_info->album);
}
tmpString = taglib_tag_artist(tagLibTag);
if (tmpString != NULL) {
copy_string_without_edge_whitespace(track_info->artist,
tmpString,
MPS_MAX_TRACK_INFO_FIELD_LENGTH);
MPS_DBG_PRINT("Copied \"%s\" into track_title->artist\n", track_info->artist);
}
track_info->year = taglib_tag_year(tagLibTag);
MPS_DBG_PRINT("Copied \"%d\" into track_title->year\n", track_info->year);
tmpString = taglib_tag_genre(tagLibTag);
if (tmpString != NULL) {
copy_string_without_edge_whitespace(track_info->genre,
tmpString,
MPS_MAX_TRACK_INFO_FIELD_LENGTH);
MPS_DBG_PRINT("Copied \"%s\" into track_title->genre\n", track_info->genre);
}
track_info->ordinal_track_number = taglib_tag_track(tagLibTag);
MPS_DBG_PRINT("Copied \"%d\" into track_title->ordinal_track_number\n",
track_info->ordinal_track_number);
if (tagLibProp != NULL) {
MPS_DBG_PRINT("Setting bitrate, etc.\n");
track_info->bitrate =
taglib_audioproperties_bitrate(tagLibProp);
track_info->sampling_rate =
taglib_audioproperties_samplerate(tagLibProp);
track_info->channel_mode =
(taglib_audioproperties_channels(tagLibProp) < 2 ?
MPS_CHANNEL_MODE_MONO:
MPS_CHANNEL_MODE_STEREO);
track_info->vbr_mode = MPS_VBR_MODE_UNKNOWN;
track_info->time_length =
taglib_audioproperties_length(tagLibProp);
#if 0
track_info->channel_mode =
((finfo.mode==MPG123_M_STEREO)?MPS_CHANNEL_MODE_STEREO:
((finfo.mode==MPG123_M_JOINT)?MPS_CHANNEL_MODE_JOINT_STEREO:
((finfo.mode==MPG123_M_DUAL)?MPS_CHANNEL_MODE_DUAL_CHANNEL:
((finfo.mode==MPG123_M_MONO)?MPS_CHANNEL_MODE_MONO:
MPS_CHANNEL_MODE_UNKNOWN))));
track_info->vbr_mode =
((finfo.vbr==MPG123_CBR)?MPS_VBR_MODE_CONSTANT:
((finfo.vbr==MPG123_VBR)?MPS_VBR_MODE_VARIABLE:
((finfo.vbr==MPG123_ABR)?MPS_VBR_MODE_AVERAGE:
MPS_VBR_MODE_UNKNOWN)));
if (track_info->sampling_rate > 0) {
total_samples = mpg123_length_64(m);
track_info->time_length = total_samples/track_info->sampling_rate;
}
#endif
}
else {
MPS_LOG("taglib_file_audioproperties() returned NULL");
}
ERR_OUT:
taglib_tag_free_strings();
taglib_file_free(tagLibFile);
MPS_DBG_PRINT("Leaving %s() - return value %d\n", __func__, rv);
return rv;
}
/**
* 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;
}
int main(int argc, char *argv[])
{
float *data;
float *out;
char *mp3_file;
unsigned int srate;
unsigned int len = 0;
unsigned int num_octaves;
unsigned int out_len;
char *cmd;
TagLib_File *f;
if(argc <= 1) {
printf("USAGE: %s <MP3 File>\n", argv[0]);
return 0;
}
mp3_file = argv[1];
f = taglib_file_new(mp3_file);
if(f == NULL) {
printf("Cannot open %s\n",mp3_file);
exit(-1);
}
srate = taglib_audioproperties_samplerate(taglib_file_audioproperties(f));
taglib_file_free(f);
if(srate == 0) {
printf("Sample rate in tag == 0, cannot proceed\n");
exit(-1);
}
printf("Sampling rate = %d\n",srate);
cmd = calloc(512, sizeof(char));
sprintf(cmd, "spectgen -r -o ./tmp.raw \"%s\"",mp3_file);
if(system(cmd) != 0) {
printf("spectgen failed!\n");
printf("Cmd = %s\n",cmd);
exit(-1);
}
free(cmd);
cmd = NULL;
if(get_file(&data, &len, "./tmp.raw")) {
printf("Getting file failed!\n");
printf("Len = %d\n",len);
exit(-1);
}
if(len < srate) {
printf("File too short!\n");
exit(-1);
}
printf("Number of samples = %d\n", len);
printf("Doing gabor!\n");
if(cwt_gabor(&num_octaves, &out_len, &out, data, len, srate, 1.0/16.0)) {
printf("Cwt failed!\n");
exit(-1);
}
free(data);
unlink("./tmp.raw");
#if 0
{
int i,j;
for(i = 0; i < out_len; i++) {
for(j = 0; j < 12 * (num_octaves - 1); j++) {
printf("%.3f ", out[(j * (num_octaves - 1)) + i]);
}
printf("\n");
}
}
exit(-1);
#endif
pgm("test.pgm", out, out_len, 12 * (num_octaves - 2),
BACKGROUND_WHITE, GREYSCALE, COL_NORMALIZATION);
free(out);
return 0;
}
int
hgd_get_tag_metadata(char *filename, struct hgd_media_tag *meta)
{
#ifdef HAVE_TAGLIB
TagLib_File *file;
TagLib_Tag *tag;
const TagLib_AudioProperties *ap;
#endif
DPRINTF(HGD_D_DEBUG, "Attempting to read tags for '%s'", filename);
meta->artist = xstrdup("");
meta->title = xstrdup("");
meta->album = xstrdup("");
meta->genre = xstrdup("");
meta->year = 0;
meta->duration = 0;
meta->samplerate = 0;
meta->channels = 0;
meta->bitrate = 0;
#ifdef HAVE_TAGLIB
file = taglib_file_new(filename);
if (file == NULL) {
DPRINTF(HGD_D_DEBUG, "taglib could not open '%s'", filename);
return (HGD_FAIL);
}
if (!taglib_file_is_valid(file)) {
DPRINTF(HGD_D_WARN, "invalid tag in '%s'", filename);
return (HGD_FAIL);
}
tag = taglib_file_tag(file);
if (tag == NULL) {
DPRINTF(HGD_D_WARN, "failed to get tag of '%s'", filename);
return (HGD_FAIL);
}
free(meta->artist);
free(meta->title);
free(meta->album);
free(meta->genre);
meta->artist = xstrdup(taglib_tag_artist(tag));
meta->title = xstrdup(taglib_tag_title(tag));
meta->album = xstrdup(taglib_tag_album(tag));
meta->genre = xstrdup(taglib_tag_genre(tag));
meta->year = taglib_tag_year(tag);
/* now audio properties: i dont consider this failing fatal */
ap = taglib_file_audioproperties(file);
if (ap != NULL) {
meta->duration = taglib_audioproperties_length(ap);
meta->samplerate = taglib_audioproperties_samplerate(ap);
meta->channels = taglib_audioproperties_channels(ap);
meta->bitrate = taglib_audioproperties_bitrate(ap);
} else {
DPRINTF(HGD_D_WARN,
"failed to get audio properties: %s", filename);
}
DPRINTF(HGD_D_INFO,
"Got tag from '%s': '%s' by '%s' from the album '%s' from the year"
"'%u' of genre '%s' [%d secs, %d chans, %d Hz, %d bps]\n",
filename, meta->title, meta->artist, meta->album, meta->year,
meta->genre, meta->duration, meta->channels, meta->samplerate,
meta->bitrate);
taglib_tag_free_strings();
#else
DPRINTF(HGD_D_DEBUG, "No taglib support, skipping tag retrieval");
#endif
return (HGD_OK);
}
