bool CMusicInfoTagLoaderSPC::Load(const CStdString& strFileName, CMusicInfoTag& tag)
{
tag.SetLoaded(false);
CFile file;
if (!file.Open(strFileName))
{
CLog::Log(LOGERROR,"MusicInfoTagLoaderSPC: failed to open SPC %s",strFileName.c_str());
return false;
}
tag.SetURL(strFileName);
tag.SetLoaded(false);
SPC_ID666* spc = SPC_get_id666FP(file);
if (!spc)
return false;
if( strcmp(spc->songname,"") )
{
tag.SetTitle(spc->songname);
tag.SetLoaded(true);
}
if( strcmp(spc->author,"") && tag.Loaded() )
tag.SetArtist(spc->author);
if (spc->playtime)
tag.SetDuration(spc->playtime);
else
tag.SetDuration(4*60); // 4 mins
free(spc);
return tag.Loaded();
}
void CTagLoaderTagLib::SetGenre(CMusicInfoTag &tag, const vector<string> &values)
{
if (values.size() == 1)
tag.SetGenre(values[0]);
else
tag.SetGenre(values);
}
void CTagLoaderTagLib::AddArtistRole(CMusicInfoTag &tag, const std::string& strRole, const std::vector<std::string> &values)
{
if (values.size() == 1)
tag.AddArtistRole(strRole, values[0]);
else
tag.AddArtistRole(strRole, values);
}
bool CMusicInfoLoader::LoadAdditionalTagInfo(CFileItem* pItem)
{
if (!pItem || pItem->m_bIsFolder || pItem->IsPlayList() || pItem->IsNFO() || pItem->IsInternetStream())
return false;
if (pItem->GetPropertyBOOL("hasfullmusictag"))
return false; // already have the information
CStdString path(pItem->m_strPath);
if (pItem->IsMusicDb())
path = pItem->GetMusicInfoTag()->GetURL();
CLog::Log(LOGDEBUG, "Loading additional tag info for file %s", path.c_str());
// we load up the actual tag for this file
CMusicInfoTag tag;
auto_ptr<IMusicInfoTagLoader> pLoader (CMusicInfoTagLoaderFactory::CreateLoader(path));
if (NULL != pLoader.get())
{
pLoader->Load(path, tag);
// then we set the fields from the file tags to the item
pItem->SetProperty("lyrics", tag.GetLyrics());
pItem->SetProperty("hasfullmusictag", true);
return true;
}
return false;
}
bool CTagLoaderTagLib::ParseTag(Tag *generic, EmbeddedArt *art, CMusicInfoTag& tag)
{
if (!generic)
return false;
PropertyMap properties = generic->properties();
for (PropertyMap::ConstIterator it = properties.begin(); it != properties.end(); ++it)
{
if (it->first == "ARTIST")
SetArtist(tag, StringListToVectorString(it->second));
else if (it->first == "ALBUM")
tag.SetAlbum(it->second.front().to8Bit(true));
else if (it->first == "TITLE")
tag.SetTitle(it->second.front().to8Bit(true));
else if (it->first == "TRACKNUMBER")
tag.SetTrackNumber(it->second.front().toInt());
else if (it->first == "YEAR")
tag.SetYear(it->second.front().toInt());
else if (it->first == "GENRE")
SetGenre(tag, StringListToVectorString(it->second));
else if (it->first == "COMMENT")
tag.SetComment(it->second.front().to8Bit(true));
}
return true;
}
void CTagLoaderTagLib::SetAlbumArtistHints(CMusicInfoTag &tag, const std::vector<std::string> &values)
{
if (values.size() == 1)
tag.SetMusicBrainzAlbumArtistHints(StringUtils::Split(values[0], g_advancedSettings.m_musicItemSeparator));
else
tag.SetMusicBrainzAlbumArtistHints(values);
}
bool CLastFmManager::Unban(const CMusicInfoTag& musicinfotag, bool askConfirmation /*= true*/)
{
if (!IsLastFmEnabled())
{
CLog::Log(LOGERROR, "LastFmManager Unban, lasfm is not enabled");
return false;
}
CStdString strTitle = musicinfotag.GetTitle();
CStdString strArtist = musicinfotag.GetArtist();
if (strArtist.IsEmpty())
{
CLog::Log(LOGERROR, "Last.fm Unban no artistname provided.");
return false;
}
if (strTitle.IsEmpty())
{
CLog::Log(LOGERROR, "Last.fm Unban no tracktitle provided.");
return false;
}
CStdString strInfo;
strInfo.Format("%s - %s", strArtist, strTitle);
if (!askConfirmation || CGUIDialogYesNo::ShowAndGetInput(g_localizeStrings.Get(15200), g_localizeStrings.Get(15298), strInfo, ""))
{
return CallXmlRpc("unBanTrack", strArtist, strTitle);
}
return false;
}
bool CMusicInfoTagLoaderSHN::Load(const CStdString& strFileName, CMusicInfoTag& tag)
{
try
{
// SHN has no tag information other than the duration.
// Load our codec class
SHNCodec codec;
if (codec.Init(strFileName, 4096))
{
tag.SetURL(strFileName);
tag.SetDuration((int)((codec.m_TotalTime + 500)/ 1000));
tag.SetLoaded(false);
codec.DeInit();
return true;
}
}
catch (...)
{
CLog::Log(LOGERROR, "Tag loader ape: exception in file %s", strFileName.c_str());
}
tag.SetLoaded(false);
return false;
}
void CMusicInfoTagLoaderWMA::SetTagValueUnsigned(const CStdString& strFrameName, uint32_t value, CMusicInfoTag& tag)
{
if (strFrameName == "WM/TrackNumber")
{
if (tag.GetTrackNumber() <= 0)
tag.SetTrackNumber(value);
}
}
int CMusicInfoScanner::GetSongDuration(const CStdString& strFullFileName) {
CMusicInfoTag tag;
auto_ptr<IMusicInfoTagLoader> pLoader (CMusicInfoTagLoaderFactory::CreateLoader(strFullFileName));
if (pLoader.get() == NULL) return 0;
pLoader->Load(strFullFileName, tag);
return tag.GetDuration();
}
void CTagLoaderTagLib::SetAlbumArtist(CMusicInfoTag &tag, const std::vector<std::string> &values)
{
if (values.size() == 1)
tag.SetAlbumArtist(values[0]);
else
// Fill both artist vector and artist desc from tag value.
// Note desc may not be empty as it could have been set by previous parsing of ID3v2 before APE
tag.SetAlbumArtist(values, true);
}
bool CLastFmManager::Unlove(const CMusicInfoTag& musicinfotag, bool askConfirmation /*= true*/)
{
if (!IsLastFmEnabled())
{
CLog::Log(LOGERROR, "LastFmManager Unlove, lasfm is not enabled");
return false;
}
CStdString strTitle = musicinfotag.GetTitle();
CStdString strArtist = StringUtils::Join(musicinfotag.GetArtist(), g_advancedSettings.m_musicItemSeparator);
if (strArtist.IsEmpty())
{
CLog::Log(LOGERROR, "Last.fm Unlove no artistname provided.");
return false;
}
if (strTitle.IsEmpty())
{
CLog::Log(LOGERROR, "Last.fm Unlove no tracktitle provided.");
return false;
}
CStdString strInfo;
strInfo.Format("%s - %s", strArtist, strTitle);
if (!askConfirmation || CGUIDialogYesNo::ShowAndGetInput(g_localizeStrings.Get(15200), g_localizeStrings.Get(15297), strInfo, ""))
{
if (CallXmlRpc("unLoveTrack", strArtist, strTitle))
{
//update our local rating, now this is tricky because we only have an artist and title
//and don't know if it was a local or radio song.
//So we're going to try to get it from the database and check if the rating is 5,
//if it is we can assume this was the song we loved before.
CMusicDatabase musicdatabase;
if (musicdatabase.Open())
{
long songid = musicdatabase.GetSongByArtistAndAlbumAndTitle(strArtist, "%", strTitle);
if (songid > 0)
{
CSong song;
musicdatabase.GetSongById(songid, song);
if (song.rating == '5')
{
//reset the rating
musicdatabase.SetSongRating(song.strFileName, '0');
}
}
musicdatabase.Close();
}
return true;
}
}
return false;
}
bool CMusicInfoTagLoaderNSF::Load(const CStdString& strFileName, CMusicInfoTag& tag)
{
tag.SetLoaded(false);
if (!m_dll.Load())
return false;
m_nsf = m_dll.LoadNSF(strFileName.c_str());
if (!m_nsf)
{
CLog::Log(LOGERROR,"MusicInfoTagLoaderNSF: failed to open NSF %s",strFileName.c_str());
return false;
}
tag.SetURL(strFileName);
tag.SetLoaded(false);
char* szTitle = (char*)m_dll.GetTitle(m_nsf); // no alloc
if( szTitle && strcmp(szTitle,"<?>") )
{
tag.SetTitle(szTitle);
tag.SetLoaded(true);
}
char* szArtist = (char*)m_dll.GetArtist(m_nsf); // no alloc
if( szArtist && strcmp(szArtist,"<?>") && tag.Loaded() )
tag.SetArtist(szArtist);
m_dll.FreeNSF(m_nsf);
m_nsf = 0;
return tag.Loaded();
}
bool CGUIDialogBoxeeShare::GetDefaultMusicShareText(CStdString& defaultMusicShareText)
{
CMusicInfoTag* musicInfoTag = m_item.GetMusicInfoTag();
if (!musicInfoTag || musicInfoTag->GetAlbum().IsEmpty() || musicInfoTag->GetArtist().IsEmpty())
{
return false;
}
defaultMusicShareText += musicInfoTag->GetAlbum();
defaultMusicShareText += " by ";
defaultMusicShareText += musicInfoTag->GetArtist();
return true;
}
bool CMusicInfoTagLoaderMod::Load(const CStdString& strFileName, CMusicInfoTag& tag, EmbeddedArt *art)
{
tag.SetURL(strFileName);
// first, does the module have a .mdz?
CStdString strMDZ(URIUtils::ReplaceExtension(strFileName,".mdz"));
if (CFile::Exists(strMDZ))
{
if (!getFile(strMDZ,strMDZ))
{
tag.SetLoaded(false);
return( false );
}
ifstream inMDZ(CSpecialProtocol::TranslatePath(strMDZ.c_str()));
char temp[8192];
char temp2[8192];
while (!inMDZ.eof())
{
inMDZ.getline(temp,8191);
if (strstr(temp,"COMPOSER"))
{
strcpy(temp2,temp+strlen("COMPOSER "));
tag.SetArtist(temp2);
}
else if (strstr(temp,"TITLE"))
{
strcpy(temp2,temp+strlen("TITLE "));
tag.SetTitle(temp2);
tag.SetLoaded(true);
}
else if (strstr(temp,"PLAYTIME"))
{
char* temp3 = strtok(temp+strlen("PLAYTIME "),":");
int iSecs = atoi(temp3)*60;
temp3 = strtok(NULL,":");
iSecs += atoi(temp3);
tag.SetDuration(iSecs);
}
else if (strstr(temp,"STYLE"))
{
strcpy(temp2,temp+strlen("STYLE "));
tag.SetGenre(temp2);
}
}
return( tag.Loaded() );
}
else
{
// TODO: no, then try to atleast fetch the title
}
return tag.Loaded();
}
bool CMusicInfoTagLoaderDatabase::Load(const CStdString& strFileName, CMusicInfoTag& tag, EmbeddedArt *art)
{
tag.SetLoaded(false);
CMusicDatabase database;
database.Open();
XFILE::MUSICDATABASEDIRECTORY::CQueryParams param;
XFILE::MUSICDATABASEDIRECTORY::CDirectoryNode::GetDatabaseInfo(strFileName,param);
CSong song;
if (database.GetSong(param.GetSongId(),song))
tag.SetSong(song);
database.Close();
return tag.Loaded();
}
bool CLastFmManager::Ban(const CMusicInfoTag& musicinfotag)
{
if (!IsRadioEnabled())
{
CLog::Log(LOGERROR, "LastFmManager Ban, radio is not active");
return false;
}
if (CallXmlRpc("banTrack", musicinfotag.GetArtist(), musicinfotag.GetTitle()))
{
//we banned this track so skip to the next track
g_application.getApplicationMessenger().ExecBuiltIn("playercontrol(next)");
m_CurrentSong.IsBanned = true;
return true;
}
return false;
}
bool CMusicInfoLoader::LoadAdditionalTagInfo(CFileItem* pItem)
{
if (!pItem || pItem->m_bIsFolder || pItem->IsPlayList() || pItem->IsNFO() || pItem->IsInternetStream())
return false;
if (pItem->GetProperty("hasfullmusictag") == "true")
return false; // already have the information
std::string path(pItem->GetPath());
if (pItem->IsMusicDb())
{
// set the artist / album properties
XFILE::MUSICDATABASEDIRECTORY::CQueryParams param;
XFILE::MUSICDATABASEDIRECTORY::CDirectoryNode::GetDatabaseInfo(pItem->GetPath(),param);
CArtist artist;
CMusicDatabase database;
database.Open();
if (database.GetArtist(param.GetArtistId(), artist, false))
CMusicDatabase::SetPropertiesFromArtist(*pItem,artist);
CAlbum album;
if (database.GetAlbum(param.GetAlbumId(), album, false))
CMusicDatabase::SetPropertiesFromAlbum(*pItem,album);
path = pItem->GetMusicInfoTag()->GetURL();
}
CLog::Log(LOGDEBUG, "Loading additional tag info for file %s", path.c_str());
// we load up the actual tag for this file in order to
// fetch the lyrics and add it to the current music info tag
CFileItem tempItem(path, false);
std::unique_ptr<IMusicInfoTagLoader> pLoader (CMusicInfoTagLoaderFactory::CreateLoader(tempItem));
if (NULL != pLoader.get())
{
CMusicInfoTag tag;
pLoader->Load(path, tag);
pItem->GetMusicInfoTag()->SetLyrics(tag.GetLyrics());
pItem->SetProperty("hasfullmusictag", "true");
return true;
}
return false;
}
bool CMusicInfoTagLoaderSHN::Load(const std::string& strFileName, CMusicInfoTag& tag, EmbeddedArt *art)
{
try
{
tag.SetURL(strFileName);
tag.SetDuration((long)0); //! @todo Use libavformat to calculate duration.
tag.SetLoaded(false);
return true;
}
catch (...)
{
CLog::Log(LOGERROR, "Tag loader shn: exception in file %s", strFileName.c_str());
}
tag.SetLoaded(false);
return false;
}
bool CMusicInfoTagLoaderMP4::Load(const CStdString& strFileName, CMusicInfoTag& tag, EmbeddedArt *art)
{
try
{
// Initially we say that we've not loaded any tag information
tag.SetLoaded(false);
// Attempt to open the file..
if ( !m_file.Open( strFileName ) )
{
CLog::Log(LOGDEBUG, "Tag loader mp4: failed to open file %s", strFileName.c_str() );
return false;
}
// We've opened it, so associate the tag with the filename.
tag.SetURL(strFileName);
// Now go parse our atom data
m_isCompilation = false;
ParseAtom( 0, m_file.GetLength(), tag, art );
if (m_isCompilation)
{ // iTunes compilation flag is set - this could be a various artists file
if (tag.GetAlbumArtist().empty())
tag.SetAlbumArtist(g_localizeStrings.Get(340)); // Various Artists
}
// Close the file..
m_file.Close();
// Return to caller
return true;
}
catch (...)
{
CLog::Log(LOGERROR, "Tag loader mp4: exception in file %s", strFileName.c_str());
}
// Something must have gone wrong for us to get here, so let's report our failure to the boss..
tag.SetLoaded(false);
return false;
}
bool CMusicGUIInfo::InitCurrentItem(CFileItem *item)
{
if (item && (item->IsAudio() || (item->IsInternetStream() && g_application.GetAppPlayer().IsPlayingAudio())))
{
CLog::Log(LOGDEBUG,"CMusicGUIInfo::InitCurrentItem(%s)", item->GetPath().c_str());
item->LoadMusicTag();
CMusicInfoTag* tag = item->GetMusicInfoTag(); // creates item if not yet set, so no nullptr checks needed
if (tag->GetTitle().empty())
{
// No title in tag, show filename only
tag->SetTitle(CUtil::GetTitleFromPath(item->GetPath()));
}
tag->SetLoaded(true);
// find a thumb for this file.
if (item->IsInternetStream())
{
if (!g_application.m_strPlayListFile.empty())
{
CLog::Log(LOGDEBUG,"Streaming media detected... using %s to find a thumb", g_application.m_strPlayListFile.c_str());
CFileItem streamingItem(g_application.m_strPlayListFile,false);
CMusicThumbLoader loader;
loader.FillThumb(streamingItem);
if (streamingItem.HasArt("thumb"))
item->SetArt("thumb", streamingItem.GetArt("thumb"));
}
}
else
{
CMusicThumbLoader loader;
loader.LoadItem(item);
}
CMusicInfoLoader::LoadAdditionalTagInfo(item);
return true;
}
return false;
}
int CPVRChannels::GetChannels(CFileItemList* results, int iGroupID /* = -1 */, bool bHidden /* = false */)
{
int iAmount = 0;
SortByChannelNumber();
for (unsigned int ptr = 0; ptr < size(); ptr++)
{
CPVRChannel *channel = at(ptr);
if (channel->IsHidden() != bHidden)
continue;
if (iGroupID != -1 && channel->GroupID() != iGroupID)
continue;
CFileItemPtr channelFile(new CFileItem(*channel));
if (channel->IsRadio())
{
CMusicInfoTag* musictag = channelFile->GetMusicInfoTag();
if (musictag)
{
const CPVREpgInfoTag *epgNow = channel->GetEPGNow();
musictag->SetURL(channel->Path());
musictag->SetTitle(epgNow->Title());
musictag->SetArtist(channel->ChannelName());
musictag->SetAlbumArtist(channel->ChannelName());
musictag->SetGenre(epgNow->Genre());
musictag->SetDuration(epgNow->GetDuration());
musictag->SetLoaded(true);
musictag->SetComment("");
musictag->SetLyrics("");
}
}
results->Add(channelFile);
iAmount++;
}
return iAmount;
}
void CTagLoaderTagLib::AddArtistRole(CMusicInfoTag &tag, const std::vector<std::string> &values)
{
// Values contains role, name pairs (as in ID3 standard for TIPL or TMCL tags)
// Every odd entry is a function (e.g. Producer, Arranger etc.) or instrument (e.g. Orchestra, Vocal, Piano)
// and every even is an artist or a comma delimited list of artists.
if (values.size() % 2 != 0) // Must contain an even number of entries
return;
for (size_t i = 0; i + 1 < values.size(); i += 2)
tag.AddArtistRole(values[i], StringUtils::Split(values[i + 1], ","));
}
bool CMusicInfoTagLoaderOgg::Load(const CStdString& strFileName, CMusicInfoTag& tag)
{
try
{
// retrieve the OGG Tag info from strFileName
// and put it in tag
COggTag myTag;
if (myTag.Read(strFileName))
{
myTag.GetMusicInfoTag(tag);
}
return tag.Loaded();
}
catch (...)
{
CLog::Log(LOGERROR, "Tag loader ogg: exception in file %s", strFileName.c_str());
}
tag.SetLoaded(false);
return false;
}
bool CLastFmManager::Love(const CMusicInfoTag& musicinfotag)
{
if (!IsLastFmEnabled())
{
CLog::Log(LOGERROR, "LastFmManager Love, lastfm is not enabled.");
return false;
}
CStdString strTitle = musicinfotag.GetTitle();
CStdString strArtist = StringUtils::Join(musicinfotag.GetArtist(), g_advancedSettings.m_musicItemSeparator);
CStdString strFilePath;
if (m_CurrentSong.CurrentSong && !m_CurrentSong.CurrentSong->IsLastFM())
{
//path to update the rating for
strFilePath = m_CurrentSong.CurrentSong->GetPath();
}
if (CallXmlRpc("loveTrack",strArtist, strTitle))
{
m_CurrentSong.IsLoved = true;
//update the rating to 5, we loved it.
CMusicInfoTag newTag(musicinfotag);
newTag.SetRating('5');
CApplicationMessenger::Get().SetCurrentSongTag(newTag);
//try updating the rating in the database if it's a local file.
CMusicDatabase musicdatabase;
if (musicdatabase.Open())
{
CSong song;
//update if the song exists in our database and there is no rating yet.
if (musicdatabase.GetSongByFileName(strFilePath, song) && song.rating == '0')
{
musicdatabase.SetSongRating(strFilePath, '5');
}
musicdatabase.Close();
}
return true;
}
return false;
}
bool CMusicInfoTagLoaderFlac::Load(const CStdString& strFileName, CMusicInfoTag& tag, EmbeddedArt *art)
{
try
{
// retrieve the Flac Tag info from strFileName
// and put it in tag
CFlacTag myTag;
myTag.SetArt(art);
if (myTag.Read(strFileName))
{
myTag.GetMusicInfoTag(tag);
}
return tag.Loaded();
}
catch (...)
{
CLog::Log(LOGERROR, "Tag loader flac: exception in file %s", strFileName.c_str());
}
tag.SetLoaded(false);
return false;
}
// There is no reliable tag information in MIDI files. There is a 'title' field (@T), but it looks
// like everyone puts there song title, artist name, the name of the person who created the lyrics and
// greetings to their friends and family. Therefore we return the song title as file name, and the
// song artist as parent directory.
// A good intention of creating a pattern-based artist/song recognition engine failed greatly. Simple formats
// like %A-%T fail greatly with artists like A-HA and songs like "Ob-la-Di ob-la-Da.mid". So if anyone has
// a good idea which would include cases from above, I'd be happy to hear about it.
bool CMusicInfoTagLoaderMidi::Load(const CStdString & strFileName, CMusicInfoTag & tag, EmbeddedArt *art)
{
tag.SetURL(strFileName);
CStdString path, title;
URIUtils::Split( strFileName, path, title);
URIUtils::RemoveExtension( title );
tag.SetTitle( title );
URIUtils::RemoveSlashAtEnd(path );
if ( !path.IsEmpty() )
{
CStdString artist = URIUtils::GetFileName( path );
if ( !artist.IsEmpty() )
tag.SetArtist( artist );
}
tag.SetLoaded(true);
return true;
}
bool CTagLoaderTagLib::ParseTag(ID3v1::Tag *id3v1, EmbeddedArt *art, CMusicInfoTag& tag)
{
if (!id3v1) return false;
tag.SetTitle(id3v1->title().to8Bit(true));
tag.SetArtist(id3v1->artist().to8Bit(true));
tag.SetAlbum(id3v1->album().to8Bit(true));
tag.SetComment(id3v1->comment().to8Bit(true));
tag.SetGenre(id3v1->genre().to8Bit(true));
tag.SetYear(id3v1->year());
tag.SetTrackNumber(id3v1->track());
return true;
}
bool CEncoderLame::Close()
{
// may return one more mp3 frames
int iBytes = m_dll.lame_encode_flush(m_pGlobalFlags, m_buffer, sizeof(m_buffer));
if (iBytes < 0)
{
CLog::Log(LOGERROR, "Internal Lame error: %i", iBytes);
return false;
}
WriteStream(m_buffer, iBytes);
FlushStream();
FileClose();
// open again, but now the old way, lame only accepts FILE pointers
FILE* file = fopen_utf8(m_strFile.c_str(), "rb+");
if (!file)
{
CLog::Log(LOGERROR, "Error: Cannot open file for writing tags: %s", m_strFile.c_str());
return false;
}
m_dll.lame_mp3_tags_fid(m_pGlobalFlags, file); /* add VBR tags to mp3 file */
fclose(file);
m_dll.lame_close(m_pGlobalFlags);
// unload the lame dll
m_dll.Unload();
// Store a id3 tag in the ripped file
CID3Tag id3tag;
CMusicInfoTag tag;
tag.SetAlbum(m_strAlbum);
tag.SetAlbumArtist(m_strAlbumArtist);
tag.SetArtist(m_strArtist);
tag.SetGenre(m_strGenre);
tag.SetTitle(m_strTitle);
tag.SetTrackNumber(atoi(m_strTrack.c_str()));
SYSTEMTIME time;
time.wYear=atoi(m_strYear.c_str());
tag.SetReleaseDate(time);
id3tag.SetMusicInfoTag(tag);
id3tag.Write(m_strFile);
return true;
}
void CTagLoaderTagLib::SetGenre(CMusicInfoTag &tag, const std::vector<std::string> &values)
{
/*
TagLib doesn't resolve ID3v1 genre numbers in the case were only
a number is specified, thus this workaround.
*/
std::vector<std::string> genres;
for (std::vector<std::string>::const_iterator i = values.begin(); i != values.end(); ++i)
{
std::string genre = *i;
if (StringUtils::IsNaturalNumber(genre))
{
int number = strtol(i->c_str(), NULL, 10);
if (number >= 0 && number < 256)
genre = ID3v1::genre(number).to8Bit(true);
}
genres.push_back(genre);
}
if (genres.size() == 1)
tag.SetGenre(genres[0]);
else
tag.SetGenre(genres);
}