253 lines
7.5 KiB
C++
253 lines
7.5 KiB
C++
/*
|
|
* Copyright (C) 2016 Emeric Poupon
|
|
*
|
|
* This file is part of LMS.
|
|
*
|
|
* LMS is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* LMS is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with LMS. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "TagLibParser.hpp"
|
|
|
|
#include <taglib/fileref.h>
|
|
#include <taglib/tag.h>
|
|
#include <taglib/tpropertymap.h>
|
|
#include <taglib/mpegfile.h>
|
|
#include <taglib/id3v2tag.h>
|
|
|
|
#include "utils/Logger.hpp"
|
|
#include "utils/Utils.hpp"
|
|
|
|
namespace MetaData
|
|
{
|
|
|
|
boost::optional<Items>
|
|
TagLibParser::parse(const boost::filesystem::path& p, bool debug)
|
|
{
|
|
TagLib::FileRef f {p.string().c_str(),
|
|
true, // read audio properties
|
|
TagLib::AudioProperties::Average};
|
|
|
|
if (f.isNull())
|
|
return boost::none;
|
|
|
|
if (!f.audioProperties())
|
|
return boost::none;
|
|
|
|
Items items;
|
|
|
|
{
|
|
const TagLib::AudioProperties *properties {f.audioProperties() };
|
|
|
|
items[MetaData::Type::Duration] = std::chrono::milliseconds {properties->length() * 1000};
|
|
|
|
MetaData::AudioStream audioStream {.bitRate = static_cast<std::size_t>(properties->bitrate() * 1000)};
|
|
items[MetaData::Type::AudioStreams] = std::vector<MetaData::AudioStream> {audioStream};
|
|
}
|
|
|
|
// Not that good embedded pictures handling
|
|
|
|
// MP3
|
|
if (TagLib::MPEG::File *mp3File = dynamic_cast<TagLib::MPEG::File*>(f.file()))
|
|
{
|
|
if (mp3File->ID3v2Tag())
|
|
{
|
|
if (!mp3File->ID3v2Tag()->frameListMap()["APIC"].isEmpty())
|
|
items.insert( std::make_pair(MetaData::Type::HasCover, true));
|
|
}
|
|
}
|
|
|
|
if (f.tag())
|
|
{
|
|
MetaData::Clusters clusters;
|
|
const TagLib::PropertyMap& properties {f.file()->properties()};
|
|
|
|
for(auto property : properties)
|
|
{
|
|
const std::string tag = property.first.upper().to8Bit(true);
|
|
const TagLib::StringList& values = property.second;
|
|
|
|
if (tag.empty() || values.isEmpty() || values.front().isEmpty())
|
|
continue;
|
|
|
|
// TODO validate MBID format
|
|
|
|
if (debug)
|
|
{
|
|
std::vector<std::string> strs;
|
|
for (auto value : values)
|
|
strs.push_back(values.front().to8Bit(true));
|
|
|
|
std::cout << "[" << tag << "] = " << joinStrings(strs, ",") << std::endl;
|
|
}
|
|
|
|
if (tag == "ARTIST")
|
|
{
|
|
// Lower priority than ARTISTS
|
|
if (items.find(MetaData::Type::Artists) == items.end())
|
|
items[MetaData::Type::Artists] = std::vector<std::string>{ stringTrim( values.front().to8Bit(true)) };
|
|
}
|
|
else if (tag == "ARTISTS")
|
|
{
|
|
// Higher priority than ARTISTS
|
|
std::vector<std::string> strings {splitString(values.front().to8Bit(), "/;")}; // Picard separator is '/'
|
|
|
|
std::vector<std::string> artists;
|
|
for (const std::string& string : strings)
|
|
artists.emplace_back(stringTrim(string));
|
|
|
|
items[MetaData::Type::Artists] = std::move(artists);
|
|
}
|
|
|
|
else if (tag == "ALBUM")
|
|
items.insert( std::make_pair(MetaData::Type::Album, stringTrim( values.front().to8Bit(true))));
|
|
else if (tag == "TITLE")
|
|
items.insert( std::make_pair(MetaData::Type::Title, stringTrim( values.front().to8Bit(true))));
|
|
else if (tag == "MUSICBRAINZ_RELEASETRACKID"
|
|
|| tag == "MUSICBRAINZ RELEASE TRACK ID")
|
|
{
|
|
items.insert( std::make_pair(MetaData::Type::MusicBrainzTrackID, stringTrim( values.front().to8Bit(true))));
|
|
}
|
|
else if (tag == "MUSICBRAINZ_ARTISTID")
|
|
{
|
|
std::vector<std::string> strings {splitString(values.front().to8Bit(), "/")}; // Picard separator is '/'
|
|
|
|
std::vector<std::string> mbids;
|
|
for (const std::string& string : strings)
|
|
mbids.emplace_back(stringTrim(string));
|
|
|
|
items[MetaData::Type::MusicBrainzArtistID] = std::move(mbids);
|
|
}
|
|
else if (tag == "MUSICBRAINZ_ALBUMID")
|
|
items.insert( std::make_pair(MetaData::Type::MusicBrainzAlbumID, stringTrim( values.front().to8Bit(true))));
|
|
else if (tag == "MUSICBRAINZ_TRACKID")
|
|
items.insert( std::make_pair(MetaData::Type::MusicBrainzRecordingID, stringTrim( values.front().to8Bit(true))));
|
|
else if (tag == "ACOUSTID_ID")
|
|
items.insert( std::make_pair(MetaData::Type::AcoustID, stringTrim( values.front().to8Bit(true))));
|
|
else if (tag == "TRACKTOTAL")
|
|
{
|
|
auto totalTrack {readAs<std::size_t>(values.front().to8Bit(true)) };
|
|
if (totalTrack)
|
|
items[MetaData::Type::TotalTrack] = *totalTrack;
|
|
}
|
|
else if (tag == "TRACKNUMBER")
|
|
{
|
|
// Expecting 'Number/Total'
|
|
std::vector<std::string> strings {splitString(values.front().to8Bit(), "/")};
|
|
|
|
if (!strings.empty())
|
|
{
|
|
auto number {readAs<std::size_t>(strings[0])};
|
|
if (number)
|
|
items.insert( std::make_pair(MetaData::Type::TrackNumber, *number ));
|
|
|
|
// Lower priority than TRACKTOTAL
|
|
if (strings.size() > 1 && items.find(MetaData::Type::TotalTrack) == items.end())
|
|
{
|
|
auto totalTrack {readAs<std::size_t>(strings[1])};
|
|
if (totalTrack)
|
|
items[MetaData::Type::TotalTrack] = *totalTrack;
|
|
}
|
|
}
|
|
}
|
|
else if (tag == "DISCTOTAL")
|
|
{
|
|
auto totalDisc = readAs<std::size_t>(values.front().to8Bit(true));
|
|
if (totalDisc)
|
|
items[MetaData::Type::TotalDisc] = *totalDisc;
|
|
}
|
|
else if (tag == "DISCNUMBER")
|
|
{
|
|
// Expecting 'Number/Total'
|
|
auto strings = splitString(values.front().to8Bit(), "/");
|
|
|
|
if (!strings.empty())
|
|
{
|
|
auto number = readAs<std::size_t>(strings[0]);
|
|
if (number)
|
|
items.insert( std::make_pair(MetaData::Type::DiscNumber, *number));
|
|
|
|
// Lower priority than DISCTOTAL
|
|
if (strings.size() > 1 && items.find(MetaData::Type::TotalDisc) == items.end())
|
|
{
|
|
auto totalDisc = readAs<std::size_t>(strings[1]);
|
|
if (totalDisc)
|
|
items[MetaData::Type::TotalDisc] = *totalDisc;
|
|
}
|
|
}
|
|
}
|
|
else if (tag == "DATE")
|
|
{
|
|
auto timePoint = readAs<int>(values.front().to8Bit());
|
|
if (timePoint)
|
|
items.insert( std::make_pair(MetaData::Type::Year, *timePoint));
|
|
}
|
|
else if (tag == "ORIGINALDATE")
|
|
{
|
|
// Lower priority than original year
|
|
if (items.find(MetaData::Type::OriginalYear) == items.end())
|
|
{
|
|
auto timePoint = readAs<int>(values.front().to8Bit());
|
|
if (timePoint)
|
|
items[MetaData::Type::OriginalYear] = *timePoint;
|
|
}
|
|
}
|
|
else if (tag == "ORIGINALYEAR")
|
|
{
|
|
auto timePoint = readAs<int>(values.front().to8Bit());
|
|
if (timePoint)
|
|
{
|
|
// Take priority on original year
|
|
items[MetaData::Type::OriginalYear] = *timePoint;
|
|
}
|
|
}
|
|
else if (tag == "METADATA_BLOCK_PICTURE")
|
|
{
|
|
// Only add once
|
|
if (items.find(MetaData::Type::HasCover) == items.end())
|
|
items.insert( std::make_pair(MetaData::Type::HasCover, true));
|
|
}
|
|
else if (tag == "COPYRIGHT")
|
|
{
|
|
items.insert(std::make_pair(MetaData::Type::Copyright, values.front().to8Bit()));
|
|
}
|
|
else if (tag == "COPYRIGHTURL")
|
|
{
|
|
items.insert(std::make_pair(MetaData::Type::CopyrightURL, values.front().to8Bit()));
|
|
}
|
|
else if (_clusterTypeNames.find(tag) != _clusterTypeNames.end())
|
|
{
|
|
std::set<std::string> clusterNames;
|
|
for (const auto& valueList : values)
|
|
{
|
|
auto values = splitString(valueList.to8Bit(), "/,;");
|
|
|
|
for (auto value : values)
|
|
clusterNames.insert(value);
|
|
}
|
|
|
|
if (!clusterNames.empty())
|
|
clusters[tag] = clusterNames;
|
|
}
|
|
}
|
|
|
|
if (!clusters.empty())
|
|
items.insert( std::make_pair(MetaData::Type::Clusters, clusters) );
|
|
}
|
|
|
|
return items;
|
|
}
|
|
|
|
} // namespace MetaData
|
|
|