gint sort(FmFileInfo *fi1, FmFileInfo *fi2){
char *filename1, *filename2;
int year1 = 0, year2 = 0;
TagLib_File *TL_file1, *TL_file2;
filename1 = fm_path_to_str( fm_file_info_get_path(fi1) );
filename2 = fm_path_to_str( fm_file_info_get_path(fi2) );
TL_file1 = taglib_file_new( filename1 );
TL_file2 = taglib_file_new( filename2 );
free( filename1 );
free( filename2 );
if (TL_file1 != NULL) {
if(taglib_file_is_valid(TL_file1)){
TagLib_Tag *TL_tag = taglib_file_tag( TL_file1 );
year1 = taglib_tag_year( TL_tag );
taglib_tag_free_strings();
taglib_file_free( TL_file1 );
}
}
if (TL_file2 != NULL) {
if(taglib_file_is_valid(TL_file2)){
TagLib_Tag *TL_tag = taglib_file_tag( TL_file2 );
year2 = taglib_tag_year( TL_tag );
taglib_tag_free_strings();
taglib_file_free( TL_file2 );
}
}
return year1 - year2;
}
void get_value(FmFileInfo *fi, GValue *value){
char* filename;
int year;
char year_string[10];
TagLib_File *TL_file;
TagLib_Tag *TL_tag;
filename = fm_path_to_str( fm_file_info_get_path(fi) );
TL_file = taglib_file_new( filename );
free( filename );
if (TL_file != NULL) {
if(taglib_file_is_valid(TL_file)){
TL_tag = taglib_file_tag( TL_file );
year = taglib_tag_year( TL_tag );
if( year !=0 ){
sprintf( year_string, "%d", year );
g_value_set_string( value, year_string );
}
taglib_tag_free_strings();
taglib_file_free( TL_file );
}
}
};
/**
* Open a file via taglib and add file type information
*
* Open files, that taglib supports but taggit doesn't have specific support
* for using TagLibs generic interface only. That will stop us from working
* with multi-artist files for those types, but it's better than nothing.
*
* @param file file name to open
*
* @return copy of the generated struct taggit_file; *NOT* a pointer
* to it! Destroy using taggit_file_destroy().
* @sideeffects none
*/
struct taggit_file
taggit_file_open(const char *file)
{
struct taggit_file rc;
char *ext;
ext = (char *)strrchr(file, (int)'.');
if (ext == NULL || *(ext + 1) == '\0')
goto err;
ext++;
if (strcaseeq(ext, (char *)"mp3")) {
rc.data = reinterpret_cast<TagLib_File *>
(new TagLib::MPEG::File(file));
rc.type = FT_MPEG;
} else if (strcaseeq(ext, (char *)"ogg")) {
rc.data = reinterpret_cast<TagLib_File *>
(new TagLib::Ogg::Vorbis::File(file));
rc.type = FT_OGGVORBIS;
} else if (strcaseeq(ext, (char *)"oga")) {
TagLib::File *f;
f = new TagLib::Ogg::FLAC::File(file);
if (f->isValid()) {
rc.data = reinterpret_cast<TagLib_File *>(f);
rc.type = FT_OGGFLAC;
} else {
delete f;
rc.data = reinterpret_cast<TagLib_File *>
(new TagLib::Ogg::Vorbis::File(file));
rc.type = FT_OGGVORBIS;
}
} else if (strcaseeq(ext, (char *)"flac")) {
rc.data = reinterpret_cast<TagLib_File *>
(new TagLib::FLAC::File(file));
rc.type = FT_FLAC;
} else {
TagLib_File *f;
f = taglib_file_new(file);
if (!taglib_file_is_valid(f)) {
taglib_file_free(f);
goto err;
} else {
rc.data = f;
rc.type = FT_UNKNOWN;
}
}
return rc;
err:
fprintf(stderr, "Cannot handle file: \"%s\" - skipping.\n", file);
rc.data = NULL;
rc.type = FT_INVALID;
return rc;
}
gint sort(FmFileInfo *fi1, FmFileInfo *fi2){
int result;
char *filename1, *filename2;
char *genre1=NULL, *genre2=NULL;
TagLib_File *TL_file1, *TL_file2;
filename1 = fm_path_to_str( fm_file_info_get_path(fi1) );
filename2 = fm_path_to_str( fm_file_info_get_path(fi2) );
TL_file1 = taglib_file_new( filename1 );
TL_file2 = taglib_file_new( filename2 );
free( filename1 );
free( filename2 );
if (TL_file1 != NULL) {
if(taglib_file_is_valid(TL_file1)){
TagLib_Tag *TL_tag = taglib_file_tag( TL_file1 );
genre1 = taglib_tag_genre( TL_tag );
taglib_file_free( TL_file1 );
}
}
if (TL_file2 != NULL) {
if(taglib_file_is_valid(TL_file2)){
TagLib_Tag *TL_tag = taglib_file_tag( TL_file2 );
genre2 = taglib_tag_genre( TL_tag );
taglib_file_free( TL_file2 );
}
}
result = strcasecmp(genre1, genre2);
if (TL_file1 != NULL || TL_file2 != NULL) {
taglib_tag_free_strings();
}
return result;
}
void get_value(FmFileInfo *fi, GValue *value){
char* filename;
char* genre;
TagLib_File *TL_file;
TagLib_Tag *TL_tag;
filename = fm_path_to_str( fm_file_info_get_path(fi) );
TL_file = taglib_file_new( filename );
free( filename );
if( TL_file != NULL ) {
if(taglib_file_is_valid(TL_file)){
TL_tag = taglib_file_tag( TL_file );
genre = taglib_tag_genre( TL_tag );
g_value_set_string( value, genre );
taglib_tag_free_strings();
taglib_file_free( TL_file );
}
}
};
static int
build_path_from_tag(const char *filepath, struct filename *fn)
{
TagLib_File *file;
TagLib_Tag *tag;
int ret = -1;
char *p = FMT;
file = taglib_file_new(filepath);
if (!file) {
fprintf(stderr, "'%s' type cannot be determined"
" or file cannot be opened.\n", filepath);
goto free_taglib;
}
if (!taglib_file_is_valid(file)) {
fprintf(stderr, "The file %s is not valid\n", filepath);
goto free_taglib;
}
tag = taglib_file_tag(file);
if (!tag) {
fprintf(stderr, "The file %s is not valid.\n", filepath);
goto free_taglib;
}
while (*p) {
if (*p != '%') {
ret = append(fn, "%c", *p++);
} else {
switch (*++p) {
case 'a':
ret = append_esc(fn, "%s",
taglib_tag_artist(tag));
break;
case 'A':
ret = append_esc(fn, "%s",
taglib_tag_album(tag));
break;
case 't':
ret = append_esc(fn, "%02d",
taglib_tag_track(tag));
break;
case 'T':
ret = append_esc(fn, "%s",
taglib_tag_title(tag));
break;
case 'y':
ret = append_esc(fn, "%d",
taglib_tag_year(tag));
break;
default:
break;
}
++p;
}
if (ret)
goto free_taglib;
}
free_taglib:
taglib_tag_free_strings();
taglib_file_free(file);
return ret;
}
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);
}
