owen/lms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Subsonic API: added bitrate support, ref #363

Browse Source
This commit is contained in:
emeric
2023-11-11 15:13:46 +01:00
parent afcb4d96ca
commit 1d21ba41b7
16 changed files with 1063 additions and 1053 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/av/impl/AudioFile.cpp
+34 -40
View File
@@ -32,9 +32,11 @@ extern "C"
#include "utils/Logger.hpp"
#include "utils/String.hpp"
namespace Av {
static std::string averror_to_string(int error)
namespace Av
{
namespace
{
std::string averror_to_string(int error)
{
std::array<char, 128> buf = { 0 };
@@ -52,8 +54,20 @@ class AudioFileException : public Av::Exception
{}
};
std::unique_ptr<IAudioFile>
parseAudioFile(const std::filesystem::path& p)
void getMetaDataFromDictionnary(AVDictionary* dictionnary, AudioFile::MetadataMap& res)
{
if (!dictionnary)
return;
AVDictionaryEntry* tag = NULL;
while ((tag = ::av_dict_get(dictionnary, "", tag, AV_DICT_IGNORE_SUFFIX)))
{
res[StringUtils::stringToUpper(tag->key)] = tag->value;
}
}
}
std::unique_ptr<IAudioFile> parseAudioFile(const std::filesystem::path& p)
{
return std::make_unique<AudioFile>(p);
}
@@ -82,14 +96,12 @@ AudioFile::~AudioFile()
avformat_close_input(&_context);
}
const std::filesystem::path&
AudioFile::getPath() const
const std::filesystem::path& AudioFile::getPath() const
{
return _p;
}
std::chrono::milliseconds
AudioFile::getDuration() const
std::chrono::milliseconds AudioFile::getDuration() const
{
if (_context->duration == AV_NOPTS_VALUE)
return std::chrono::milliseconds{ 0 }; // TODO estimate
@@ -97,21 +109,7 @@ AudioFile::getDuration() const
return std::chrono::milliseconds{ _context->duration / AV_TIME_BASE * 1000 };
}
void
getMetaDataFromDictionnary(AVDictionary* dictionnary, AudioFile::MetadataMap& res)
{
if (!dictionnary)
return;
AVDictionaryEntry *tag = NULL;
while ((tag = ::av_dict_get(dictionnary, "", tag, AV_DICT_IGNORE_SUFFIX)))
{
res[StringUtils::stringToUpper(tag->key)] = tag->value;
}
}
AudioFile::MetadataMap
AudioFile::getMetaData() const
AudioFile::MetadataMap AudioFile::getMetaData() const
{
MetadataMap res;
@@ -133,8 +131,7 @@ AudioFile::getMetaData() const
return res;
}
std::vector<StreamInfo>
AudioFile::getStreamInfo() const
std::vector<StreamInfo> AudioFile::getStreamInfo() const
{
std::vector<StreamInfo> res;
@@ -148,8 +145,7 @@ AudioFile::getStreamInfo() const
return res;
}
std::optional<std::size_t>
AudioFile::getBestStreamIndex() const
std::optional<std::size_t> AudioFile::getBestStreamIndex() const
{
int res = ::av_find_best_stream(_context,
AVMEDIA_TYPE_AUDIO,
@@ -164,8 +160,7 @@ AudioFile::getBestStreamIndex() const
return res;
}
std::optional<StreamInfo>
AudioFile::getBestStreamInfo() const
std::optional<StreamInfo> AudioFile::getBestStreamInfo() const
{
std::optional<StreamInfo> res;
@@ -176,8 +171,7 @@ AudioFile::getBestStreamInfo() const
return res;
}
bool
AudioFile::hasAttachedPictures() const
bool AudioFile::hasAttachedPictures() const
{
for (std::size_t i = 0; i < _context->nb_streams; ++i)
{
@@ -188,8 +182,7 @@ AudioFile::hasAttachedPictures() const
return false;
}
void
AudioFile::visitAttachedPictures(std::function<void(const Picture&)> func) const
void AudioFile::visitAttachedPictures(std::function<void(const Picture&)> func) const
{
static const std::unordered_map<int, std::string> codecMimeMap =
{
@@ -237,8 +230,7 @@ AudioFile::visitAttachedPictures(std::function<void(const Picture&)> func) const
}
}
std::optional<StreamInfo>
AudioFile::getStreamInfo(std::size_t streamIndex) const
std::optional<StreamInfo> AudioFile::getStreamInfo(std::size_t streamIndex) const
{
std::optional<StreamInfo> res;
@@ -266,16 +258,18 @@ AudioFile::getStreamInfo(std::size_t streamIndex) const
return res;
}
std::optional<AudioFileFormat>
guessAudioFileFormat(const std::filesystem::path& file)
std::optional<AudioFileFormat> guessAudioFileFormat(const std::filesystem::path& file)
{
const AVOutputFormat* format{ ::av_guess_format(NULL, file.string().c_str(), NULL) };
if (!format || !format->name)
return {};
{
LMS_LOG(AV, INFO) << "File '" << file.string() << "': cannot guess file format!";
return std::nullopt;
}
LMS_LOG(AV, DEBUG) << "File '" << file.string() << "', formats = '" << format->name << "'";
auto formats {StringUtils::splitString(format->name, ",")};
const auto formats{ StringUtils::splitString(format->name, ",") };
if (formats.size() > 1)
LMS_LOG(AV, INFO) << "File '" << file.string() << "' reported several formats: '" << format->name << "'";
src/libs/av/impl/AudioFile.hpp
+3 -5
View File
@@ -34,11 +34,6 @@ namespace Av
AudioFile(const std::filesystem::path& p);
~AudioFile();
AudioFile(const AudioFile&) = delete;
AudioFile(AudioFile&&) = delete;
AudioFile& operator=(const AudioFile&) = delete;
AudioFile& operator=(AudioFile&&) = delete;
const std::filesystem::path& getPath() const override;
std::chrono::milliseconds getDuration() const override;
MetadataMap getMetaData() const override;
@@ -49,6 +44,9 @@ namespace Av
void visitAttachedPictures(std::function<void(const Picture&)> func) const override;
private:
AudioFile(const AudioFile&) = delete;
AudioFile& operator=(const AudioFile&) = delete;
std::optional<StreamInfo> getStreamInfo(std::size_t streamIndex) const;
const std::filesystem::path _p;
src/libs/metadata/impl/AvFormatParser.cpp
+6 -6
View File
@@ -187,14 +187,14 @@ AvFormatParser::parse(const std::filesystem::path& p, bool debug)
const auto mediaFile {Av::parseAudioFile(p)};
// Stream info
if (const auto stream{ mediaFile->getBestStreamInfo() })
{
std::vector<AudioStream> audioStreams;
for (auto stream : mediaFile->getStreamInfo())
{
MetaData::AudioStream audioStream {static_cast<unsigned>(stream.bitrate)};
track.audioStreams.emplace_back(audioStream);
track.bitrate = stream->bitrate;
}
else
{
LMS_LOG(METADATA, INFO) << "File '" << p.string() << "': cannot get best audio stream";
return std::nullopt;
}
track.duration = mediaFile->getDuration();
src/libs/metadata/impl/TagLibParser.cpp
+51 -75
View File
@@ -44,13 +44,13 @@
namespace MetaData
{
namespace
{
// TODO use string_views here for values
using TagMap = std::map<std::string, std::vector<std::string>>;
template<typename T>
std::vector<T>
getPropertyValuesFirstMatchAs(const TagMap& tags, std::initializer_list<std::string_view> keys)
std::vector<T> getPropertyValuesFirstMatchAs(const TagMap& tags, std::initializer_list<std::string_view> keys)
{
std::vector<T> res;
@@ -82,8 +82,7 @@ getPropertyValuesFirstMatchAs(const TagMap& tags, std::initializer_list<std::str
}
template <typename T>
std::optional<T>
getPropertyValueFirstMatchAs(const TagMap& tags, std::initializer_list<std::string_view> keys)
std::optional<T> getPropertyValueFirstMatchAs(const TagMap& tags, std::initializer_list<std::string_view> keys)
{
std::optional<T> res;
std::vector<T> values{ getPropertyValuesFirstMatchAs<T>(tags, keys) };
@@ -94,22 +93,18 @@ getPropertyValueFirstMatchAs(const TagMap& tags, std::initializer_list<std::stri
}
template <typename T>
std::vector<T>
getPropertyValuesAs(const TagMap& tags, std::string_view key)
std::vector<T> getPropertyValuesAs(const TagMap& tags, std::string_view key)
{
return getPropertyValuesFirstMatchAs<T>(tags, { key });
}
template <typename T>
std::optional<T>
getPropertyValueAs(const TagMap& tags, std::string_view key)
std::optional<T> getPropertyValueAs(const TagMap& tags, std::string_view key)
{
return getPropertyValueFirstMatchAs<T>(tags, { key });
}
static
std::vector<std::string_view>
splitAndTrimString(std::string_view str, std::string_view delimiters)
std::vector<std::string_view> splitAndTrimString(std::string_view str, std::string_view delimiters)
{
std::vector<std::string_view> strings{ StringUtils::splitString(str, delimiters) };
for (std::string_view& s : strings)
@@ -118,9 +113,7 @@ splitAndTrimString(std::string_view str, std::string_view delimiters)
return strings;
}
static
std::vector<Artist>
getArtists(const TagMap& tags,
std::vector<Artist> getArtists(const TagMap& tags,
std::initializer_list<std::string_view> artistTagNames,
std::initializer_list<std::string_view> artistSortTagNames,
std::initializer_list<std::string_view> artistMBIDTagNames
@@ -158,10 +151,7 @@ getArtists(const TagMap& tags,
return artists;
}
static
PerformerContainer
getPerformerArtists(const TagMap& tags,
std::initializer_list<std::string_view> artistTagNames)
PerformerContainer getPerformerArtists(const TagMap& tags, std::initializer_list<std::string_view> artistTagNames)
{
PerformerContainer performers;
@@ -198,9 +188,7 @@ getPerformerArtists(const TagMap& tags,
return performers;
}
static
std::optional<Release>
getRelease(const TagMap& tags)
std::optional<Release> getRelease(const TagMap& tags)
{
std::optional<Release> release;
@@ -236,9 +224,7 @@ getRelease(const TagMap& tags)
return release;
}
static
std::optional<Medium>
getMedium(const TagMap& tags)
std::optional<Medium> getMedium(const TagMap& tags)
{
std::optional<Medium> medium;
medium.emplace();
@@ -275,9 +261,7 @@ getMedium(const TagMap& tags)
return medium;
}
static
TagLib::AudioProperties::ReadStyle
readStyleToTagLibReadStyle(ParserReadStyle readStyle)
TagLib::AudioProperties::ReadStyle readStyleToTagLibReadStyle(ParserReadStyle readStyle)
{
switch (readStyle)
{
@@ -289,13 +273,41 @@ readStyleToTagLibReadStyle(ParserReadStyle readStyle)
throw LmsException{ "Cannot convert read style" };
}
TagMap constructTagMap(const TagLib::PropertyMap& properties)
{
TagMap tagMap;
for (const auto& [propertyName, propertyValues] : properties)
{
std::vector<std::string>& values{ tagMap[propertyName.upper().to8Bit(true)] };
for (const TagLib::String& propertyValue : propertyValues)
{
std::string trimedValue{ StringUtils::stringTrim(propertyValue.to8Bit(true)) };
if (!trimedValue.empty())
values.emplace_back(std::move(trimedValue));
}
}
return tagMap;
}
void mergeTagMaps(TagMap& dst, TagMap&& src)
{
for (auto&& [tag, values] : src)
{
if (dst.find(tag) == std::cend(dst))
dst[tag] = std::move(values);
}
}
}
TagLibParser::TagLibParser(ParserReadStyle readStyle)
: _readStyle{ readStyleToTagLibReadStyle(readStyle) }
{
}
void
TagLibParser::processTag(Track& track, const std::string& tag, const std::vector<std::string>& values, bool debug)
void TagLibParser::processTag(Track& track, const std::string& tag, const std::vector<std::string>& values, bool debug)
{
if (debug)
std::cout << "[" << tag << "] = " << StringUtils::joinStrings(values, "*SEP*") << std::endl;
@@ -371,39 +383,7 @@ TagLibParser::processTag(Track& track, const std::string& tag, const std::vector
}
}
static
TagMap
constructTagMap(const TagLib::PropertyMap& properties)
{
TagMap tagMap;
for (const auto& [propertyName, propertyValues] : properties)
{
std::vector<std::string>& values {tagMap[propertyName.upper().to8Bit(true)]};
for (const TagLib::String& propertyValue : propertyValues)
{
std::string trimedValue {StringUtils::stringTrim(propertyValue.to8Bit(true))};
if (!trimedValue.empty())
values.emplace_back(std::move(trimedValue));
}
}
return tagMap;
}
static
void
mergeTagMaps(TagMap& dst, TagMap&& src)
{
for (auto&& [tag, values] : src)
{
if (dst.find(tag) == std::cend(dst))
dst[tag] = std::move(values);
}
}
std::optional<Track>
TagLibParser::parse(const std::filesystem::path& p, bool debug)
std::optional<Track> TagLibParser::parse(const std::filesystem::path& p, bool debug)
{
TagLib::FileRef f{ p.string().c_str(),
true, // read audio properties
@@ -415,23 +395,19 @@ TagLibParser::parse(const std::filesystem::path& p, bool debug)
return std::nullopt;
}
if (!f.audioProperties())
Track track;
if (const TagLib::AudioProperties* properties{ f.audioProperties() })
{
track.duration = std::chrono::milliseconds{ properties->lengthInMilliseconds() };
track.bitrate = static_cast<std::size_t>(properties->bitrate() * 1000);
}
else
{
LMS_LOG(METADATA, INFO) << "File '" << p.string() << "': no audio properties";
return std::nullopt;
}
Track track;
{
const TagLib::AudioProperties *properties {f.audioProperties() };
track.duration = std::chrono::milliseconds {properties->lengthInMilliseconds()};
MetaData::AudioStream audioStream {static_cast<unsigned>(properties->bitrate() * 1000)};
track.audioStreams = {audioStream};
}
TagMap tags{ constructTagMap(f.file()->properties()) };
auto getAPETags = [&](const TagLib::APE::Tag* apeTag)
src/libs/metadata/include/metadata/IParser.hpp
+2 -7
View File
@@ -96,11 +96,6 @@ namespace MetaData
std::optional<float> replayGain;
};
struct AudioStream
{
unsigned bitRate;
};
struct Track
{
std::optional<UUID> mbid;
@@ -109,11 +104,11 @@ namespace MetaData
std::optional<Medium> medium;
std::optional<std::size_t> position; // in medium
Tags tags;
std::chrono::milliseconds duration;
std::chrono::milliseconds duration{};
std::size_t bitrate{};
Wt::WDate date;
Wt::WDate originalDate;
bool hasCover{};
std::vector<AudioStream> audioStreams;
std::optional<UUID> acoustID;
std::string copyright;
std::string copyrightURL;
src/libs/services/database/impl/Migration.cpp
+10
View File
@@ -234,6 +234,15 @@ CREATE TABLE IF NOT EXISTS "track_backup" (
ScanSettings::get(session).modify()->incScanVersion();
}
static void migrateFromV44(Session& session)
{
// add bitrate
session.getDboSession().execute("ALTER TABLE track ADD bitrate INTEGER");
// Just increment the scan version of the settings to make the next scheduled scan rescan everything
ScanSettings::get(session).modify()->incScanVersion();
}
void doDbMigration(Session& session)
{
static const std::string outdatedMsg{ "Outdated database, please rebuild it (delete the .db file and restart)" };
@@ -256,6 +265,7 @@ CREATE TABLE IF NOT EXISTS "track_backup" (
{41, migrateFromV41},
{42, migrateFromV42},
{43, migrateFromV43},
{44, migrateFromV44},
};
{
src/libs/services/database/impl/Migration.hpp
+1 -1
View File
@@ -26,7 +26,7 @@ namespace Database
class Session;
using Version = std::size_t;
static constexpr Version LMS_DATABASE_VERSION{ 44 };
static constexpr Version LMS_DATABASE_VERSION{ 45 };
class VersionInfo
{
public:
src/libs/services/database/impl/Release.cpp
+12 -3
View File
@@ -387,9 +387,8 @@ namespace Database
Wt::Dbo::collection<std::string> copyrights = session()->query<std::string>
("SELECT copyright_url FROM track t INNER JOIN release r ON r.id = t.release_id")
.where("r.id = ?")
.groupBy("copyright_url")
.bind(getId());
.where("r.id = ?").bind(getId())
.groupBy("copyright_url");
std::vector<std::string> values(copyrights.begin(), copyrights.end());
@@ -400,6 +399,16 @@ namespace Database
return values.front();
}
std::size_t Release::getMeanBitrate() const
{
assert(session());
return session()->query<int>("SELECT COALESCE(AVG(t.bitrate), 0) FROM track t")
.where("release_id = ?").bind(getId())
.where("bitrate > 0")
.resultValue();
}
std::vector<Artist::pointer> Release::getArtists(TrackArtistLinkType linkType) const
{
assert(session());
src/libs/services/database/include/services/database/Release.hpp
+1
View File
@@ -104,6 +104,7 @@ namespace Database
Wt::WDate getOriginalReleaseDate() const;
std::optional<std::string> getCopyright() const;
std::optional<std::string> getCopyrightURL() const;
std::size_t getMeanBitrate() const;
// Accessors
const std::string& getName() const { return _name; }
src/libs/services/database/include/services/database/Track.hpp
+4
View File
@@ -128,6 +128,7 @@ namespace Database {
void setName(const std::string& name) { _name = std::string(name, 0, _maxNameLength); }
void setPath(const std::filesystem::path& filePath) { _filePath = filePath; }
void setDuration(std::chrono::milliseconds duration) { _duration = duration; }
void setBitrate(std::size_t bitrate) { _bitrate = bitrate; }
void setLastWriteTime(Wt::WDateTime time) { _fileLastWrite = time; }
void setAddedTime(Wt::WDateTime time) { _fileAdded = time; }
void setDate(const Wt::WDate& date) { _date = date; }
@@ -153,6 +154,7 @@ namespace Database {
std::string getName() const { return _name; }
std::filesystem::path getPath() const { return _filePath; }
std::chrono::milliseconds getDuration() const { return _duration; }
std::size_t getBitrate() const { return _bitrate; }
const Wt::WDateTime& getLastWritten() const { return _fileLastWrite; }
std::optional<int> getYear() const;
std::optional<int> getOriginalYear() const;
@@ -186,6 +188,7 @@ namespace Database {
Wt::Dbo::field(a, _discSubtitle, "disc_subtitle"); // here in Track since Release does not have concept of "disc" (yet?)
Wt::Dbo::field(a, _name, "name");
Wt::Dbo::field(a, _duration, "duration");
Wt::Dbo::field(a, _bitrate, "bitrate");
Wt::Dbo::field(a, _date, "date");
Wt::Dbo::field(a, _originalDate, "original_date");
Wt::Dbo::field(a, _filePath, "file_path");
@@ -220,6 +223,7 @@ namespace Database {
std::string _discSubtitle;
std::string _name;
std::chrono::duration<int, std::milli> _duration{};
int _bitrate; // in bps
Wt::WDate _date;
Wt::WDate _originalDate;
std::string _filePath;
src/libs/services/database/test/Release.cpp
+40 -1
View File
@@ -547,7 +547,7 @@ TEST_F(DatabaseFixture, Release_releaseType)
}
}
TEST_F(DatabaseFixture, ReleaseSortOrder)
TEST_F(DatabaseFixture, Release_sortMethod)
{
ScopedRelease release1{ session, "MyRelease1" };
const Wt::WDate release1Date{ Wt::WDate {2000, 2, 3} };
@@ -616,3 +616,42 @@ TEST_F(DatabaseFixture, ReleaseSortOrder)
}
}
TEST_F(DatabaseFixture, Release_meanBitrate)
{
ScopedRelease release1{ session, "MyRelease1" };
ScopedTrack track1{ session, "MyTrack1" };
ScopedTrack track2{ session, "MyTrack2" };
ScopedTrack track3{ session, "MyTrack3" };
auto checkExpectedBitrate = [&](std::size_t bitrate)
{
auto transaction{ session.createSharedTransaction() };
EXPECT_EQ(release1->getMeanBitrate(), bitrate);
};
checkExpectedBitrate(0);
{
auto transaction{ session.createUniqueTransaction() };
track1.get().modify()->setBitrate(128);
track1.get().modify()->setRelease(release1.get());
}
checkExpectedBitrate(128);
{
auto transaction{ session.createUniqueTransaction() };
track2.get().modify()->setBitrate(256);
track2.get().modify()->setRelease(release1.get());
}
checkExpectedBitrate(192);
{
auto transaction{ session.createUniqueTransaction() };
track3.get().modify()->setBitrate(0);
track3.get().modify()->setRelease(release1.get());
}
checkExpectedBitrate(192); // 0 should not be taken into account
}
src/libs/services/scanner/impl/ScanStepScanFiles.cpp
+2 -16
View File
@@ -405,22 +405,7 @@ namespace Scanner
}
}
// We estimate this is an audio file if:
// - we found a least one audio stream
// - the duration is not null
if (trackInfo->audioStreams.empty())
{
LMS_LOG(DBUPDATER, DEBUG) << "Skipped '" << file.string() << "' (no audio stream found)";
// If Track exists here, delete it!
if (track)
{
track.remove();
stats.deletions++;
}
stats.errors.emplace_back(ScanError{ file, ScanErrorType::NoAudioTrack });
return;
}
// We estimate this is an audio file if the duration is not null
if (trackInfo->duration == std::chrono::milliseconds::zero())
{
LMS_LOG(DBUPDATER, DEBUG) << "Skipped '" << file.string() << "' (duration is 0)";
@@ -513,6 +498,7 @@ namespace Scanner
track.modify()->setLastWriteTime(lastWriteTime);
track.modify()->setName(title);
track.modify()->setDuration(trackInfo->duration);
track.modify()->setBitrate(trackInfo->bitrate);
track.modify()->setAddedTime(Wt::WDateTime::currentDateTime());
track.modify()->setTrackNumber(trackInfo->position);
track.modify()->setDiscNumber(trackInfo->medium ? trackInfo->medium->position : std::nullopt);
src/libs/subsonic/impl/responses/Song.cpp
+1
View File
@@ -148,6 +148,7 @@ namespace API::Subsonic
}
trackResponse.setAttribute("duration", std::chrono::duration_cast<std::chrono::seconds>(track->getDuration()).count());
trackResponse.setAttribute("bitRate", (track->getBitrate() / 1000));
trackResponse.setAttribute("type", "music");
trackResponse.setAttribute("created", StringUtils::toISO8601String(track->getLastWritten()));
src/lms/ui/explore/ReleaseView.cpp
+6 -5
View File
@@ -137,7 +137,7 @@ namespace UserInterface
}
}
// TODO: save in DB and mean all this
// TODO: save in DB and aggregate all this
for (const Track::pointer& track : Track::find(LmsApp->getDbSession(), Track::FindParameters{}.setRelease(releaseId).setRange(Range{ 0, 1 })).results)
{
if (const auto audioFile{ Av::parseAudioFile(track->getPath()) })
@@ -147,14 +147,15 @@ namespace UserInterface
{
releaseInfo->setCondition("if-has-codec", true);
releaseInfo->bindString("codec", audioStream->codec);
if (audioStream->bitrate)
{
releaseInfo->setCondition("if-has-bitrate", true);
releaseInfo->bindString("bitrate", std::to_string(audioStream->bitrate / 1000) + " kbps");
break;
}
}
}
if (std::size_t meanBitrate{ release->getMeanBitrate() })
{
releaseInfo->setCondition("if-has-bitrate", true);
releaseInfo->bindString("bitrate", std::to_string(release->getMeanBitrate() / 1000) + " kbps");
}
Wt::WPushButton* okBtn{ releaseInfo->bindNew<Wt::WPushButton>("ok-btn", Wt::WString::tr("Lms.ok")) };
src/lms/ui/explore/TrackListHelpers.cpp
+9 -11
View File
@@ -43,12 +43,11 @@
#include "ModalManager.hpp"
#include "Utils.hpp"
using namespace Database;
namespace UserInterface::TrackListHelpers
{
void
showTrackInfoModal(Database::TrackId trackId, Filters& filters)
using namespace Database;
void showTrackInfoModal(Database::TrackId trackId, Filters& filters)
{
auto transaction{ LmsApp->getDbSession().createSharedTransaction() };
@@ -132,15 +131,15 @@ namespace UserInterface::TrackListHelpers
{
trackInfo->setCondition("if-has-codec", true);
trackInfo->bindString("codec", audioStream->codec);
if (audioStream->bitrate)
{
trackInfo->setCondition("if-has-bitrate", true);
trackInfo->bindString("bitrate", std::to_string(audioStream->bitrate / 1000) + " kbps");
}
}
}
trackInfo->bindString("duration", Utils::durationToString(track->getDuration()));
if (track->getBitrate())
{
trackInfo->setCondition("if-has-bitrate", true);
trackInfo->bindString("bitrate", std::to_string(track->getBitrate() / 1000) + " kbps");
}
Wt::WContainerWidget* clusterContainer{ trackInfo->bindWidget("clusters", Utils::createClustersForTrack(track, filters)) };
if (clusterContainer->count() > 0)
@@ -155,8 +154,7 @@ namespace UserInterface::TrackListHelpers
LmsApp->getModalManager().show(std::move(trackInfo));
}
std::unique_ptr<Wt::WWidget>
createEntry(const Database::ObjectPtr<Database::Track>& track, PlayQueueController& playQueueController, Filters& filters)
std::unique_ptr<Wt::WWidget> createEntry(const Database::ObjectPtr<Database::Track>& track, PlayQueueController& playQueueController, Filters& filters)
{
auto entry{ std::make_unique<Template>(Wt::WString::tr("Lms.Explore.Tracks.template.entry")) };
auto* entryPtr{ entry.get() };
src/tools/metadata/LmsMetadata.cpp
+1 -3
View File
@@ -212,6 +212,7 @@ void parse(MetaData::IParser& parser, const std::filesystem::path& file)
}
std::cout << "Duration: " << std::fixed << std::setprecision(2) << track->duration.count() / 1000. << "s" << std::endl;
std::cout << "Bitrate: " << track->bitrate << " bps" << std::endl;
if (track->position)
std::cout << "Position: " << *track->position << std::endl;
@@ -224,9 +225,6 @@ void parse(MetaData::IParser& parser, const std::filesystem::path& file)
std::cout << "HasCover = " << std::boolalpha << track->hasCover << std::endl;
for (const auto& audioStream : track->audioStreams)
std::cout << "Audio stream: " << audioStream.bitRate << " bps" << std::endl;
if (track->replayGain)
std::cout << "Track replay gain: " << *track->replayGain << std::endl;