Factorized some container/codec handling code + removed the no longer needed transcode output formats mka and webm

src/libs/database/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_library(lmsdatabase STATIC
+	impl/objects/detail/Types.cpp
 	impl/objects/Artist.cpp
 	impl/objects/ArtistInfo.cpp
 	impl/objects/Artwork.cpp

src/libs/database/impl/objects/PodcastEpisode.cpp

@@ -27,6 +27,7 @@
 #include "database/objects/Podcast.hpp"
 
 #include "Utils.hpp"
+#include "detail/Types.hpp"
 #include "traits/IdTypeTraits.hpp"
 #include "traits/PathTraits.hpp"
 
@@ -98,6 +99,16 @@ namespace lms::db
         utils::forEachQueryRangeResult(query, params.range, func);
     }
 
+    std::optional<core::media::ContainerType> PodcastEpisode::getContainer() const
+    {
+        return detail::getMediaContainerType(_container);
+    }
+
+    std::optional<core::media::CodecType> PodcastEpisode::getCodec() const
+    {
+        return detail::getMediaCodecType(_codec);
+    }
+
     ObjectPtr<Artwork> PodcastEpisode::getArtwork() const
     {
         return _artwork;
@@ -108,6 +119,16 @@ namespace lms::db
         return _artwork.id();
     }
 
+    void PodcastEpisode::setContainer(core::media::ContainerType container)
+    {
+        _container = detail::getDbContainerType(container);
+    }
+
+    void PodcastEpisode::setCodec(core::media::CodecType codec)
+    {
+        _codec = detail::getDbCodecType(codec);
+    }
+
     void PodcastEpisode::setArtwork(ObjectPtr<Artwork> artwork)
     {
         _artwork = getDboPtr(artwork);

src/libs/database/impl/objects/Release.cpp

@@ -40,6 +40,7 @@
 
 #include "SqlQuery.hpp"
 #include "Utils.hpp"
+#include "detail/Types.hpp"
 #include "traits/EnumSetTraits.hpp"
 #include "traits/IdTypeTraits.hpp"
 #include "traits/PartialDateTimeTraits.hpp"
@@ -679,12 +680,20 @@ namespace lms::db
         return utils::fetchQuerySingleResult(session()->query<int>("SELECT COALESCE(AVG(t.bitrate), 0) FROM track t").where("release_id = ?").bind(getId()).where("bitrate > 0"));
     }
 
-    std::vector<CodecType> Release::getCodecs() const
+    std::vector<core::media::CodecType> Release::getCodecs() const
     {
         assert(session());
 
         // Get the codec ordered by frequency
-        return utils::fetchQueryResults(session()->query<CodecType>("SELECT t.codec FROM track t").where("release_id = ?").bind(getId()).groupBy("t.codec").orderBy("COUNT(t.id) DESC"));
+        auto query{ session()->query<detail::CodecType>("SELECT t.codec FROM track t").where("release_id = ?").bind(getId()).groupBy("t.codec").orderBy("COUNT(t.id) DESC") };
+
+        std::vector<core::media::CodecType> res;
+        utils::forEachQueryResult(query, [&](detail::CodecType codec) {
+            if (const auto mediaCodecType{ detail::getMediaCodecType(codec) })
+                res.push_back(*mediaCodecType);
+        });
+
+        return res;
     }
 
     std::vector<Artist::pointer> Release::getArtists(TrackArtistLinkType linkType) const

src/libs/database/impl/objects/Track.cpp

@@ -23,6 +23,7 @@
 #include <Wt/Dbo/WtSqlTraits.h>
 
 #include "core/ILogger.hpp"
+
 #include "database/Session.hpp"
 #include "database/Types.hpp"
 #include "database/objects/Artist.hpp"
@@ -41,6 +42,7 @@
 
 #include "SqlQuery.hpp"
 #include "Utils.hpp"
+#include "objects/detail/Types.hpp"
 #include "traits/IdTypeTraits.hpp"
 #include "traits/PartialDateTimeTraits.hpp"
 #include "traits/PathTraits.hpp"
@@ -523,6 +525,16 @@ namespace lms::db
         _absoluteFilePath = filePath;
     }
 
+    void Track::setContainer(core::media::ContainerType container)
+    {
+        _container = detail::getDbContainerType(container);
+    }
+
+    void Track::setCodec(core::media::CodecType codec)
+    {
+        _codec = detail::getDbCodecType(codec);
+    }
+
     void Track::setName(std::string_view name)
     {
         _name = std::string{ name, 0, _maxNameLength };
@@ -603,6 +615,16 @@ namespace lms::db
         _preferredMediaArtwork = getDboPtr(artwork);
     }
 
+    std::optional<core::media::ContainerType> Track::getContainer() const
+    {
+        return detail::getMediaContainerType(_container);
+    }
+
+    std::optional<core::media::CodecType> Track::getCodec() const
+    {
+        return detail::getMediaCodecType(_codec);
+    }
+
     std::optional<int> Track::getYear() const
     {
         return _date.getYear();

src/libs/database/impl/objects/TrackEmbeddedImage.cpp

@@ -28,6 +28,8 @@
 #include "database/objects/TrackEmbeddedImageLink.hpp"
 
 #include "Utils.hpp"
+#include "detail/Types.hpp"
+#include "objects/detail/Types.hpp"
 #include "traits/IdTypeTraits.hpp"
 #include "traits/ImageHashTypeTraits.hpp"
 
@@ -83,7 +85,7 @@ namespace lms::db
                 }
 
                 if (params.imageType.has_value())
-                    query.where("t_e_i_l.type = ?").bind(params.imageType.value());
+                    query.where("t_e_i_l.type = ?").bind(detail::getDbImageType(params.imageType.value()));
             }
 
             switch (params.sortMethod)

src/libs/database/impl/objects/TrackEmbeddedImageLink.cpp

@@ -23,11 +23,11 @@
 #include <Wt/Dbo/WtSqlTraits.h>
 
 #include "database/Session.hpp"
-#include "database/Types.hpp"
 #include "database/objects/Track.hpp"
 #include "database/objects/TrackEmbeddedImage.hpp"
 
 #include "Utils.hpp"
+#include "detail/Types.hpp"
 #include "traits/IdTypeTraits.hpp"
 #include "traits/ImageHashTypeTraits.hpp"
 
@@ -77,4 +77,14 @@ namespace lms::db
     {
         return _image;
     }
+
+    core::media::ImageType TrackEmbeddedImageLink::getType() const
+    {
+        return detail::getMediaImageType(_type);
+    }
+
+    void TrackEmbeddedImageLink::setType(core::media::ImageType type)
+    {
+        _type = detail::getDbImageType(type);
+    }
 } // namespace lms::db

src/libs/database/impl/objects/Types.cpp

@@ -72,96 +72,4 @@ namespace lms::db
     {
         return allowedAudioBitrates.find(bitrate) != std::cend(allowedAudioBitrates);
     }
-
-    core::LiteralString containerTypeToString(ContainerType type)
-    {
-        switch (type)
-        {
-        case ContainerType::Unknown:
-            break;
-
-        case ContainerType::AIFF:
-            return "AIFF";
-        case ContainerType::APE:
-            return "APE";
-        case ContainerType::ASF:
-            return "ASF";
-        case ContainerType::DSF:
-            return "DSF";
-        case ContainerType::FLAC:
-            return "FLAC";
-        case ContainerType::MP4:
-            return "MP4";
-        case ContainerType::MPC:
-            return "MPC";
-        case ContainerType::MPEG:
-            return "MPEG";
-        case ContainerType::Ogg:
-            return "Ogg";
-        case ContainerType::Shorten:
-            return "Shorten";
-        case ContainerType::TrueAudio:
-            return "TrueAudio";
-        case ContainerType::WAV:
-            return "WAV";
-        case ContainerType::WavPack:
-            return "WavPack";
-        }
-
-        return "Unknown";
-    }
-
-    core::LiteralString codecTypeToString(CodecType type)
-    {
-        switch (type)
-        {
-        case CodecType::Unknown:
-            break;
-
-        case CodecType::AAC:
-            return "AAC";
-        case CodecType::AC3:
-            return "AC3";
-        case CodecType::ALAC:
-            return "ALAC";
-        case CodecType::APE:
-            return "APE";
-        case CodecType::DSD:
-            return "DSD";
-        case CodecType::EAC3:
-            return "EAC3";
-        case CodecType::FLAC:
-            return "FLAC";
-        case CodecType::MP3:
-            return "MP3";
-        case CodecType::MP4ALS:
-            return "MP4ALS";
-        case CodecType::MPC7:
-            return "MPC7";
-        case CodecType::MPC8:
-            return "MPC8";
-        case CodecType::Opus:
-            return "Opus";
-        case CodecType::PCM:
-            return "PCM";
-        case CodecType::Shorten:
-            return "Shorten";
-        case CodecType::TrueAudio:
-            return "TrueAudio";
-        case CodecType::Vorbis:
-            return "Vorbis";
-        case CodecType::WavPack:
-            return "WavPack";
-        case CodecType::WMA1:
-            return "WMA1";
-        case CodecType::WMA2:
-            return "WMA2";
-        case CodecType::WMA9Pro:
-            return "WMA9Pro";
-        case CodecType::WMA9Lossless:
-            return "WMA9Lossless";
-        }
-
-        return "Unknown";
-    }
 } // namespace lms::db

src/libs/database/impl/objects/detail/Types.cpp

@@ -0,0 +1,307 @@
+/*
+ * Copyright (C) 2015 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 "Types.hpp"
+
+namespace lms::db::detail
+{
+    std::optional<core::media::ContainerType> getMediaContainerType(db::detail::ContainerType container)
+    {
+        switch (container)
+        {
+        case ContainerType::AIFF:
+            return core::media::ContainerType::AIFF;
+        case ContainerType::APE:
+            return core::media::ContainerType::APE;
+        case ContainerType::ASF:
+            return core::media::ContainerType::ASF;
+        case ContainerType::DSF:
+            return core::media::ContainerType::DSF;
+        case ContainerType::FLAC:
+            return core::media::ContainerType::FLAC;
+        case ContainerType::MP4:
+            return core::media::ContainerType::MP4;
+        case ContainerType::MPC:
+            return core::media::ContainerType::MPC;
+        case ContainerType::MPEG:
+            return core::media::ContainerType::MPEG;
+        case ContainerType::Ogg:
+            return core::media::ContainerType::Ogg;
+        case ContainerType::Shorten:
+            return core::media::ContainerType::Shorten;
+        case ContainerType::TrueAudio:
+            return core::media::ContainerType::TrueAudio;
+        case ContainerType::WAV:
+            return core::media::ContainerType::WAV;
+        case ContainerType::WavPack:
+            return core::media::ContainerType::WavPack;
+
+        case ContainerType::Unknown:
+            break;
+        }
+
+        return std::nullopt;
+    }
+
+    db::detail::ContainerType getDbContainerType(core::media::ContainerType container)
+    {
+        switch (container)
+        {
+        case core::media::ContainerType::AIFF:
+            return ContainerType::AIFF;
+        case core::media::ContainerType::APE:
+            return ContainerType::APE;
+        case core::media::ContainerType::ASF:
+            return ContainerType::ASF;
+        case core::media::ContainerType::DSF:
+            return ContainerType::DSF;
+        case core::media::ContainerType::FLAC:
+            return ContainerType::FLAC;
+        case core::media::ContainerType::MP4:
+            return ContainerType::MP4;
+        case core::media::ContainerType::MPC:
+            return ContainerType::MPC;
+        case core::media::ContainerType::MPEG:
+            return ContainerType::MPEG;
+        case core::media::ContainerType::Ogg:
+            return ContainerType::Ogg;
+        case core::media::ContainerType::Shorten:
+            return ContainerType::Shorten;
+        case core::media::ContainerType::TrueAudio:
+            return ContainerType::TrueAudio;
+        case core::media::ContainerType::WAV:
+            return ContainerType::WAV;
+        case core::media::ContainerType::WavPack:
+            return ContainerType::WavPack;
+        }
+
+        return ContainerType::Unknown;
+    }
+
+    std::optional<core::media::CodecType> getMediaCodecType(db::detail::CodecType codec)
+    {
+        switch (codec)
+        {
+        case CodecType::AAC:
+            return core::media::CodecType::AAC;
+        case CodecType::AC3:
+            return core::media::CodecType::AC3;
+        case CodecType::ALAC:
+            return core::media::CodecType::ALAC;
+        case CodecType::APE:
+            return core::media::CodecType::APE;
+        case CodecType::DSD:
+            return core::media::CodecType::DSD;
+        case CodecType::EAC3:
+            return core::media::CodecType::EAC3;
+        case CodecType::FLAC:
+            return core::media::CodecType::FLAC;
+        case CodecType::MP3:
+            return core::media::CodecType::MP3;
+        case CodecType::MP4ALS:
+            return core::media::CodecType::MP4ALS;
+        case CodecType::MPC7:
+            return core::media::CodecType::MPC7;
+        case CodecType::MPC8:
+            return core::media::CodecType::MPC8;
+        case CodecType::Opus:
+            return core::media::CodecType::Opus;
+        case CodecType::PCM:
+            return core::media::CodecType::PCM;
+        case CodecType::Shorten:
+            return core::media::CodecType::Shorten;
+        case CodecType::TrueAudio:
+            return core::media::CodecType::TrueAudio;
+        case CodecType::Vorbis:
+            return core::media::CodecType::Vorbis;
+        case CodecType::WavPack:
+            return core::media::CodecType::WavPack;
+        case CodecType::WMA1:
+            return core::media::CodecType::WMA1;
+        case CodecType::WMA2:
+            return core::media::CodecType::WMA2;
+        case CodecType::WMA9Pro:
+            return core::media::CodecType::WMA9Pro;
+        case CodecType::WMA9Lossless:
+            return core::media::CodecType::WMA9Lossless;
+
+        case CodecType::Unknown:
+            break;
+        }
+
+        return std::nullopt;
+    }
+
+    db::detail::CodecType getDbCodecType(core::media::CodecType codec)
+    {
+        switch (codec)
+        {
+        case core::media::CodecType::AAC:
+            return CodecType::AAC;
+        case core::media::CodecType::AC3:
+            return CodecType::AC3;
+        case core::media::CodecType::ALAC:
+            return CodecType::ALAC;
+        case core::media::CodecType::APE:
+            return CodecType::APE;
+        case core::media::CodecType::DSD:
+            return CodecType::DSD;
+        case core::media::CodecType::EAC3:
+            return CodecType::EAC3;
+        case core::media::CodecType::FLAC:
+            return CodecType::FLAC;
+        case core::media::CodecType::MP3:
+            return CodecType::MP3;
+        case core::media::CodecType::MP4ALS:
+            return CodecType::MP4ALS;
+        case core::media::CodecType::MPC7:
+            return CodecType::MPC7;
+        case core::media::CodecType::MPC8:
+            return CodecType::MPC8;
+        case core::media::CodecType::Opus:
+            return CodecType::Opus;
+        case core::media::CodecType::PCM:
+            return CodecType::PCM;
+        case core::media::CodecType::Shorten:
+            return CodecType::Shorten;
+        case core::media::CodecType::TrueAudio:
+            return CodecType::TrueAudio;
+        case core::media::CodecType::Vorbis:
+            return CodecType::Vorbis;
+        case core::media::CodecType::WavPack:
+            return CodecType::WavPack;
+        case core::media::CodecType::WMA1:
+            return CodecType::WMA1;
+        case core::media::CodecType::WMA2:
+            return CodecType::WMA2;
+        case core::media::CodecType::WMA9Pro:
+            return CodecType::WMA9Pro;
+        case core::media::CodecType::WMA9Lossless:
+            return CodecType::WMA9Lossless;
+        }
+
+        return CodecType::Unknown;
+    }
+
+    core::media::ImageType getMediaImageType(db::detail::ImageType type)
+    {
+        switch (type)
+        {
+        case db::detail::ImageType::Unknown:
+            return core::media::ImageType::Unknown;
+        case db::detail::ImageType::Other:
+            return core::media::ImageType::Other;
+        case db::detail::ImageType::FileIcon:
+            return core::media::ImageType::FileIcon;
+        case db::detail::ImageType::OtherFileIcon:
+            return core::media::ImageType::OtherFileIcon;
+        case db::detail::ImageType::FrontCover:
+            return core::media::ImageType::FrontCover;
+        case db::detail::ImageType::BackCover:
+            return core::media::ImageType::BackCover;
+        case db::detail::ImageType::LeafletPage:
+            return core::media::ImageType::LeafletPage;
+        case db::detail::ImageType::Media:
+            return core::media::ImageType::Media;
+        case db::detail::ImageType::LeadArtist:
+            return core::media::ImageType::LeadArtist;
+        case db::detail::ImageType::Artist:
+            return core::media::ImageType::Artist;
+        case db::detail::ImageType::Conductor:
+            return core::media::ImageType::Conductor;
+        case db::detail::ImageType::Band:
+            return core::media::ImageType::Band;
+        case db::detail::ImageType::Composer:
+            return core::media::ImageType::Composer;
+        case db::detail::ImageType::Lyricist:
+            return core::media::ImageType::Lyricist;
+        case db::detail::ImageType::RecordingLocation:
+            return core::media::ImageType::RecordingLocation;
+        case db::detail::ImageType::DuringRecording:
+            return core::media::ImageType::DuringRecording;
+        case db::detail::ImageType::DuringPerformance:
+            return core::media::ImageType::DuringPerformance;
+        case db::detail::ImageType::MovieScreenCapture:
+            return core::media::ImageType::MovieScreenCapture;
+        case db::detail::ImageType::ColouredFish:
+            return core::media::ImageType::ColouredFish;
+        case db::detail::ImageType::Illustration:
+            return core::media::ImageType::Illustration;
+        case db::detail::ImageType::BandLogo:
+            return core::media::ImageType::BandLogo;
+        case db::detail::ImageType::PublisherLogo:
+            return core::media::ImageType::PublisherLogo;
+        }
+
+        return core::media::ImageType::Unknown;
+    }
+
+    db::detail::ImageType getDbImageType(core::media::ImageType type)
+    {
+        switch (type)
+        {
+        case core::media::ImageType::Unknown:
+            return db::detail::ImageType::Unknown;
+        case core::media::ImageType::Other:
+            return db::detail::ImageType::Other;
+        case core::media::ImageType::FileIcon:
+            return db::detail::ImageType::FileIcon;
+        case core::media::ImageType::OtherFileIcon:
+            return db::detail::ImageType::OtherFileIcon;
+        case core::media::ImageType::FrontCover:
+            return db::detail::ImageType::FrontCover;
+        case core::media::ImageType::BackCover:
+            return db::detail::ImageType::BackCover;
+        case core::media::ImageType::LeafletPage:
+            return db::detail::ImageType::LeafletPage;
+        case core::media::ImageType::Media:
+            return db::detail::ImageType::Media;
+        case core::media::ImageType::LeadArtist:
+            return db::detail::ImageType::LeadArtist;
+        case core::media::ImageType::Artist:
+            return db::detail::ImageType::Artist;
+        case core::media::ImageType::Conductor:
+            return db::detail::ImageType::Conductor;
+        case core::media::ImageType::Band:
+            return db::detail::ImageType::Band;
+        case core::media::ImageType::Composer:
+            return db::detail::ImageType::Composer;
+        case core::media::ImageType::Lyricist:
+            return db::detail::ImageType::Lyricist;
+        case core::media::ImageType::RecordingLocation:
+            return db::detail::ImageType::RecordingLocation;
+        case core::media::ImageType::DuringRecording:
+            return db::detail::ImageType::DuringRecording;
+        case core::media::ImageType::DuringPerformance:
+            return db::detail::ImageType::DuringPerformance;
+        case core::media::ImageType::MovieScreenCapture:
+            return db::detail::ImageType::MovieScreenCapture;
+        case core::media::ImageType::ColouredFish:
+            return db::detail::ImageType::ColouredFish;
+        case core::media::ImageType::Illustration:
+            return db::detail::ImageType::Illustration;
+        case core::media::ImageType::BandLogo:
+            return db::detail::ImageType::BandLogo;
+        case core::media::ImageType::PublisherLogo:
+            return db::detail::ImageType::PublisherLogo;
+        }
+
+        return db::detail::ImageType::Unknown;
+    }
+} // namespace lms::db::detail

src/libs/database/impl/objects/detail/Types.hpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2015 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/>.
+ */
+
+#pragma once
+
+#include <optional>
+
+#include "core/media/CodecType.hpp"
+#include "core/media/ContainerType.hpp"
+#include "core/media/ImageType.hpp"
+
+#include "database/objects/detail/Types.hpp"
+
+namespace lms::db::detail
+{
+    std::optional<core::media::ContainerType> getMediaContainerType(db::detail::ContainerType container);
+    db::detail::ContainerType getDbContainerType(core::media::ContainerType container);
+
+    std::optional<core::media::CodecType> getMediaCodecType(db::detail::CodecType codec);
+    db::detail::CodecType getDbCodecType(core::media::CodecType codec);
+
+    core::media::ImageType getMediaImageType(db::detail::ImageType type);
+    db::detail::ImageType getDbImageType(core::media::ImageType type);
+} // namespace lms::db::detail

src/libs/database/include/database/objects/PodcastEpisode.hpp

@@ -29,12 +29,16 @@
 #include <Wt/Dbo/collection.h>
 #include <Wt/WDateTime.h>
 
+#include "core/media/CodecType.hpp"
+#include "core/media/ContainerType.hpp"
+
 #include "database/Object.hpp"
 #include "database/Types.hpp"
 #include "database/objects/ArtworkId.hpp"
 #include "database/objects/PodcastEpisodeId.hpp"
 #include "database/objects/PodcastId.hpp"
 #include "database/objects/Types.hpp"
+#include "database/objects/detail/Types.hpp"
 
 namespace lms::db
 {
@@ -93,8 +97,8 @@ namespace lms::db
 
         // Audio properties
         std::chrono::milliseconds getDuration() const { return _duration; }
-        ContainerType getContainer() const { return _container; }
-        CodecType getCodec() const { return _codec; }
+        std::optional<core::media::ContainerType> getContainer() const;
+        std::optional<core::media::CodecType> getCodec() const;
         std::size_t getBitrate() const { return _bitrate; }
         std::size_t getChannelCount() const { return _channelCount; }
         std::size_t getSampleRate() const { return _sampleRate; }
@@ -124,8 +128,8 @@ namespace lms::db
 
         // Audio properties
         void setDuration(std::chrono::milliseconds duration) { _duration = duration; }
-        void setContainer(ContainerType container) { _container = container; }
-        void setCodec(CodecType codec) { _codec = codec; }
+        void setContainer(core::media::ContainerType container);
+        void setCodec(core::media::CodecType codec);
         void setBitrate(std::size_t bitrate) { _bitrate = bitrate; }
         void setChannelCount(std::size_t channelCount) { _channelCount = channelCount; }
         void setSampleRate(std::size_t sampleRate) { _sampleRate = sampleRate; }
@@ -189,8 +193,8 @@ namespace lms::db
 
         // Audio properties
         std::chrono::duration<int, std::milli> _duration{ 0 };
-        ContainerType _container{ ContainerType::Unknown };
-        CodecType _codec{ CodecType::Unknown };
+        detail::ContainerType _container{ detail::ContainerType::Unknown };
+        detail::CodecType _codec{ detail::CodecType::Unknown };
         int _bitrate{}; // in bps
         int _channelCount{};
         int _sampleRate{};

src/libs/database/include/database/objects/Release.hpp

@@ -31,6 +31,7 @@
 #include "core/EnumSet.hpp"
 #include "core/PartialDateTime.hpp"
 #include "core/UUID.hpp"
+#include "core/media/CodecType.hpp"
 
 #include "database/IdRange.hpp"
 #include "database/Object.hpp"
@@ -279,7 +280,7 @@ namespace lms::db
         std::optional<std::string> getCopyright() const;
         std::optional<std::string> getCopyrightURL() const;
         std::size_t getMeanBitrate() const;
-        std::vector<CodecType> getCodecs() const;
+        std::vector<core::media::CodecType> getCodecs() const;
 
         // Accessors
         std::string_view getName() const { return _name; }

src/libs/database/include/database/objects/Track.hpp

@@ -34,6 +34,8 @@
 #include "core/EnumSet.hpp"
 #include "core/PartialDateTime.hpp"
 #include "core/UUID.hpp"
+#include "core/media/CodecType.hpp"
+#include "core/media/ContainerType.hpp"
 
 #include "database/IdRange.hpp"
 #include "database/Object.hpp"
@@ -51,6 +53,7 @@
 #include "database/objects/TrackListId.hpp"
 #include "database/objects/Types.hpp"
 #include "database/objects/UserId.hpp"
+#include "database/objects/detail/Types.hpp"
 
 namespace lms::db
 {
@@ -229,8 +232,8 @@ namespace lms::db
 
         // Audio properties
         void setDuration(std::chrono::milliseconds duration) { _duration = duration; }
-        void setContainer(ContainerType container) { _container = container; }
-        void setCodec(CodecType codec) { _codec = codec; }
+        void setContainer(core::media::ContainerType container);
+        void setCodec(core::media::CodecType codec);
         void setBitrate(std::size_t bitrate) { _bitrate = bitrate; }
         void setChannelCount(std::size_t channelCount) { _channelCount = channelCount; }
         void setSampleRate(std::size_t sampleRate) { _sampleRate = sampleRate; }
@@ -275,8 +278,8 @@ namespace lms::db
 
         // Audio properties
         std::chrono::milliseconds getDuration() const { return _duration; }
-        ContainerType getContainer() const { return _container; }
-        CodecType getCodec() const { return _codec; }
+        std::optional<core::media::ContainerType> getContainer() const;
+        std::optional<core::media::CodecType> getCodec() const;
         std::size_t getBitrate() const { return _bitrate; }
         std::size_t getChannelCount() const { return _channelCount; }
         std::size_t getSampleRate() const { return _sampleRate; }
@@ -380,8 +383,8 @@ namespace lms::db
 
         // Audio properties
         std::chrono::duration<int, std::milli> _duration{};
-        ContainerType _container{ ContainerType::Unknown };
-        CodecType _codec{ CodecType::Unknown };
+        detail::ContainerType _container{ detail::ContainerType::Unknown };
+        detail::CodecType _codec{ detail::CodecType::Unknown };
         int _bitrate{}; // in bps
         int _channelCount{};
         int _sampleRate{};

src/libs/database/include/database/objects/TrackEmbeddedImage.hpp

@@ -26,6 +26,8 @@
 #include <Wt/Dbo/Field.h>
 #include <Wt/Dbo/collection.h>
 
+#include "core/media/ImageType.hpp"
+
 #include "database/Object.hpp"
 #include "database/Types.hpp"
 #include "database/objects/MediumId.hpp"
@@ -53,7 +55,7 @@ namespace lms::db
             ReleaseId release;
             MediumId medium;
             TrackListId trackList;
-            std::optional<ImageType> imageType;
+            std::optional<core::media::ImageType> imageType;
             TrackEmbeddedImageSortMethod sortMethod{ TrackEmbeddedImageSortMethod::None };
 
             FindParameters& setRange(std::optional<Range> _range)
@@ -81,7 +83,7 @@ namespace lms::db
                 trackList = _trackList;
                 return *this;
             }
-            FindParameters& setImageType(std::optional<ImageType> _imageType)
+            FindParameters& setImageType(std::optional<core::media::ImageType> _imageType)
             {
                 imageType = _imageType;
                 return *this;

src/libs/database/include/database/objects/TrackEmbeddedImageLink.hpp

@@ -24,10 +24,13 @@
 
 #include <Wt/Dbo/Field.h>
 
+#include "core/media/ImageType.hpp"
+
 #include "database/Object.hpp"
 #include "database/objects/TrackEmbeddedImageId.hpp"
 #include "database/objects/TrackEmbeddedImageLinkId.hpp"
 #include "database/objects/Types.hpp"
+#include "database/objects/detail/Types.hpp"
 
 namespace lms::db
 {
@@ -49,12 +52,12 @@ namespace lms::db
         ObjectPtr<Track> getTrack() const;
         ObjectPtr<TrackEmbeddedImage> getImage() const;
         std::size_t getIndex() const { return _index; }
-        ImageType getType() const { return _type; }
+        core::media::ImageType getType() const;
         std::string_view getDescription() const { return _description; }
 
         // setters
         void setIndex(std::size_t index) { _index = static_cast<int>(index); }
-        void setType(ImageType type) { _type = type; }
+        void setType(core::media::ImageType type);
         void setDescription(std::string_view description) { _description = description; }
 
         template<class Action>
@@ -75,7 +78,7 @@ namespace lms::db
         static pointer create(Session& session, ObjectPtr<Track> track, ObjectPtr<TrackEmbeddedImage> image);
 
         int _index{}; // index within the track
-        ImageType _type{ ImageType::Unknown };
+        detail::ImageType _type{ detail::ImageType::Unknown };
         std::string _description;
 
         Wt::Dbo::ptr<Track> _track;

src/libs/database/include/database/objects/Types.hpp

@@ -155,32 +155,6 @@ namespace lms::db
         EmbeddedFirst,
     };
 
-    enum class ImageType
-    {
-        Unknown = 0,
-        Other = 1,
-        FileIcon = 2,
-        OtherFileIcon = 3,
-        FrontCover = 4,
-        BackCover = 5,
-        LeafletPage = 6,
-        Media = 7,
-        LeadArtist = 8,
-        Artist = 9,
-        Conductor = 10,
-        Band = 11,
-        Composer = 12,
-        Lyricist = 13,
-        RecordingLocation = 14,
-        DuringRecording = 15,
-        DuringPerformance = 16,
-        MovieScreenCapture = 17,
-        ColouredFish = 18,
-        Illustration = 19,
-        BandLogo = 20,
-        PublisherLogo = 21
-    };
-
     enum class TrackArtistLinkType
     {
         Artist = 0, // regular track artist
@@ -204,8 +178,8 @@ namespace lms::db
         MP3 = 1,
         OGG_OPUS = 2,
         OGG_VORBIS = 3,
-        WEBM_VORBIS = 4,
-        MATROSKA_OPUS = 5,
+        // WEBM_VORBIS = 4,
+        // MATROSKA_OPUS = 5,
     };
 
     using Bitrate = std::uint32_t;
@@ -266,54 +240,4 @@ namespace lms::db
         Clean = 2,
         Explicit = 3,
     };
-
-    enum class ContainerType
-    {
-        Unknown = 0,
-
-        AIFF = 1,
-        APE = 2,
-        ASF = 3,
-        DSF = 4,
-        FLAC = 5,
-        MP4 = 6,
-        MPC = 7,
-        MPEG = 8,
-        Ogg = 9,
-        Shorten = 10,
-        TrueAudio = 11,
-        WAV = 12,
-        WavPack = 13,
-    };
-
-    core::LiteralString containerTypeToString(ContainerType type);
-
-    enum class CodecType
-    {
-        Unknown = 0,
-
-        AAC = 1,
-        AC3 = 2,
-        ALAC = 3,
-        APE = 4,
-        DSD = 5,
-        EAC3 = 6,
-        FLAC = 7,
-        MP3 = 8,
-        MP4ALS = 9,
-        MPC7 = 10,
-        MPC8 = 11,
-        Opus = 12,
-        PCM = 13,
-        Shorten = 14,
-        TrueAudio = 15,
-        Vorbis = 16,
-        WavPack = 17,
-        WMA1 = 18,
-        WMA2 = 19,
-        WMA9Pro = 20,
-        WMA9Lossless = 21,
-    };
-
-    core::LiteralString codecTypeToString(CodecType type);
 } // namespace lms::db

src/libs/database/include/database/objects/detail/Types.hpp

@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2025 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/>.
+ */
+
+#pragma once
+
+namespace lms::db::detail
+{
+    // For enums that have explicit values, never change enum values as they are stored in database.
+    // => only add new values or remove unused values, do not recycle values.
+    enum class ImageType
+    {
+        Unknown = 0,
+        Other = 1,
+        FileIcon = 2,
+        OtherFileIcon = 3,
+        FrontCover = 4,
+        BackCover = 5,
+        LeafletPage = 6,
+        Media = 7,
+        LeadArtist = 8,
+        Artist = 9,
+        Conductor = 10,
+        Band = 11,
+        Composer = 12,
+        Lyricist = 13,
+        RecordingLocation = 14,
+        DuringRecording = 15,
+        DuringPerformance = 16,
+        MovieScreenCapture = 17,
+        ColouredFish = 18,
+        Illustration = 19,
+        BandLogo = 20,
+        PublisherLogo = 21
+    };
+
+    enum class ContainerType
+    {
+        Unknown = 0,
+
+        AIFF = 1,
+        APE = 2,
+        ASF = 3,
+        DSF = 4,
+        FLAC = 5,
+        MP4 = 6,
+        MPC = 7,
+        MPEG = 8,
+        Ogg = 9,
+        Shorten = 10,
+        TrueAudio = 11,
+        WAV = 12,
+        WavPack = 13,
+    };
+
+    enum class CodecType
+    {
+        Unknown = 0,
+
+        AAC = 1,
+        AC3 = 2,
+        ALAC = 3,
+        APE = 4,
+        DSD = 5,
+        EAC3 = 6,
+        FLAC = 7,
+        MP3 = 8,
+        MP4ALS = 9,
+        MPC7 = 10,
+        MPC8 = 11,
+        Opus = 12,
+        PCM = 13,
+        Shorten = 14,
+        TrueAudio = 15,
+        Vorbis = 16,
+        WavPack = 17,
+        WMA1 = 18,
+        WMA2 = 19,
+        WMA9Pro = 20,
+        WMA9Lossless = 21,
+    };
+} // namespace lms::db::detail

src/libs/database/test/Release.cpp

@@ -1229,22 +1229,22 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createWriteTransaction() };
-            track1.get().modify()->setCodec(CodecType::FLAC);
+            track1.get().modify()->setCodec(core::media::CodecType::FLAC);
             track1.get().modify()->setRelease(release1.get());
 
-            track2.get().modify()->setCodec(CodecType::MP3);
+            track2.get().modify()->setCodec(core::media::CodecType::MP3);
             track2.get().modify()->setRelease(release1.get());
 
-            track3.get().modify()->setCodec(CodecType::MP3);
+            track3.get().modify()->setCodec(core::media::CodecType::MP3);
             track3.get().modify()->setRelease(release1.get());
 
-            track4.get().modify()->setCodec(CodecType::AAC);
+            track4.get().modify()->setCodec(core::media::CodecType::AAC);
             track4.get().modify()->setRelease(release1.get());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(release1->getCodecs(), (std::vector<CodecType>{ CodecType::MP3, CodecType::FLAC, CodecType::AAC }));
+            EXPECT_EQ(release1->getCodecs(), (std::vector<core::media::CodecType>{ core::media::CodecType::MP3, core::media::CodecType::FLAC, core::media::CodecType::AAC }));
         }
     }
 

src/libs/database/test/TrackEmbeddedImage.cpp

@@ -130,7 +130,7 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createWriteTransaction() };
-            link.get().modify()->setType(ImageType::FrontCover);
+            link.get().modify()->setType(core::media::ImageType::FrontCover);
         }
 
         {
@@ -173,6 +173,30 @@ namespace lms::db::tests
             TrackEmbeddedImage::find(session, params, [&](const auto&) { visited = true; });
             EXPECT_TRUE(visited);
         }
+
+        {
+            auto transaction{ session.createReadTransaction() };
+
+            TrackEmbeddedImage::FindParameters params;
+            params.setTrack(track.getId());
+            params.setImageType(core::media::ImageType::FrontCover);
+
+            bool visited{};
+            TrackEmbeddedImage::find(session, params, [&](const auto&) { visited = true; });
+            EXPECT_TRUE(visited);
+        }
+
+        {
+            auto transaction{ session.createReadTransaction() };
+
+            TrackEmbeddedImage::FindParameters params;
+            params.setTrack(track.getId());
+            params.setImageType(core::media::ImageType::BackCover);
+
+            bool visited{};
+            TrackEmbeddedImage::find(session, params, [&](const auto&) { visited = true; });
+            EXPECT_FALSE(visited);
+        }
     }
 
     TEST_F(DatabaseFixture, TrackEmbeddedImage_findByParams_sorts)
@@ -200,18 +224,18 @@ namespace lms::db::tests
             track1.get().modify()->setMedium(medium1.get());
             track1.get().modify()->setTrackNumber(2);
 
-            link1.get().modify()->setType(ImageType::FrontCover);
+            link1.get().modify()->setType(core::media::ImageType::FrontCover);
             image1.get().modify()->setSize(750);
-            link2.get().modify()->setType(ImageType::Media);
+            link2.get().modify()->setType(core::media::ImageType::Media);
             image2.get().modify()->setSize(1000);
-            link3.get().modify()->setType(ImageType::Media);
+            link3.get().modify()->setType(core::media::ImageType::Media);
             image3.get().modify()->setSize(2000);
 
             track2.get().modify()->setRelease(release.get());
             track2.get().modify()->setMedium(medium2.get());
             track2.get().modify()->setTrackNumber(1);
 
-            link4.get().modify()->setType(ImageType::Media);
+            link4.get().modify()->setType(core::media::ImageType::Media);
             image4.get().modify()->setSize(1500);
         }
 
@@ -220,7 +244,7 @@ namespace lms::db::tests
 
             TrackEmbeddedImage::FindParameters params;
             params.setRelease(release.getId());
-            params.setImageType(ImageType::Media);
+            params.setImageType(core::media::ImageType::Media);
             params.setSortMethod(TrackEmbeddedImageSortMethod::SizeDesc);
 
             std::vector<TrackEmbeddedImageId> visitedIds;
@@ -236,7 +260,7 @@ namespace lms::db::tests
 
             TrackEmbeddedImage::FindParameters params;
             params.setMedium(medium1.getId());
-            params.setImageType(ImageType::Media);
+            params.setImageType(core::media::ImageType::Media);
             params.setSortMethod(TrackEmbeddedImageSortMethod::TrackNumberThenSizeDesc);
 
             std::vector<TrackEmbeddedImageId> visitedIds;
@@ -251,7 +275,7 @@ namespace lms::db::tests
 
             TrackEmbeddedImage::FindParameters params;
             params.setRelease(release.getId());
-            params.setImageType(ImageType::Media);
+            params.setImageType(core::media::ImageType::Media);
             params.setSortMethod(TrackEmbeddedImageSortMethod::DiscNumberThenTrackNumberThenSizeDesc);
 
             std::vector<TrackEmbeddedImageId> visitedIds;
@@ -267,7 +291,7 @@ namespace lms::db::tests
 
             TrackEmbeddedImage::FindParameters params;
             params.setRelease(release.getId());
-            params.setImageType(ImageType::BackCover);
+            params.setImageType(core::media::ImageType::BackCover);
             params.setSortMethod(TrackEmbeddedImageSortMethod::DiscNumberThenTrackNumberThenSizeDesc);
 
             std::vector<TrackEmbeddedImageId> visitedIds;
@@ -383,7 +407,7 @@ namespace lms::db::tests
             const TrackEmbeddedImageLink::pointer link{ TrackEmbeddedImageLink::find(session, imageLink.getId()) };
             ASSERT_NE(link, TrackEmbeddedImageLink::pointer{});
             EXPECT_EQ(link->getIndex(), 0);
-            EXPECT_EQ(link->getType(), ImageType::Unknown);
+            EXPECT_EQ(link->getType(), core::media::ImageType::Unknown);
             EXPECT_EQ(link->getDescription(), "");
             EXPECT_EQ(link->getTrack(), track.get());
             EXPECT_EQ(link->getImage(), image.get());
@@ -395,7 +419,7 @@ namespace lms::db::tests
             TrackEmbeddedImageLink::pointer link{ TrackEmbeddedImageLink::find(session, imageLink.getId()) };
             ASSERT_NE(link, TrackEmbeddedImage::pointer{});
             link.modify()->setIndex(2);
-            link.modify()->setType(ImageType::FrontCover);
+            link.modify()->setType(core::media::ImageType::FrontCover);
             link.modify()->setDescription("MyDesc");
         }
 
@@ -405,7 +429,7 @@ namespace lms::db::tests
             const TrackEmbeddedImageLink::pointer img{ TrackEmbeddedImageLink::find(session, imageLink.getId()) };
             ASSERT_NE(img, TrackEmbeddedImage::pointer{});
             EXPECT_EQ(img->getIndex(), 2);
-            EXPECT_EQ(img->getType(), ImageType::FrontCover);
+            EXPECT_EQ(img->getType(), core::media::ImageType::FrontCover);
             EXPECT_EQ(img->getDescription(), "MyDesc");
         }
 
@@ -415,7 +439,7 @@ namespace lms::db::tests
             bool visited{};
             TrackEmbeddedImageLink::find(session, image->getId(), [&](const TrackEmbeddedImageLink::pointer& link) {
                 EXPECT_EQ(link->getIndex(), 2);
-                EXPECT_EQ(link->getType(), ImageType::FrontCover);
+                EXPECT_EQ(link->getType(), core::media::ImageType::FrontCover);
                 EXPECT_EQ(link->getDescription(), "MyDesc");
                 EXPECT_EQ(link->getTrack(), track.get());