Minor cleanup on audio codecs

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

@@ -83,7 +83,7 @@ namespace lms::db
                     query.where("t.release_id = ?").bind(params.release);
 
                 if (params.filters.codec.has_value())
-                    query.where("t.codec = ?").bind(detail::getDbCodecType(*params.filters.codec));
+                    query.where("t.codec = ?").bind(detail::getDbCodec(*params.filters.codec));
 
                 if (params.filters.mediaLibrary.isValid())
                     query.where("t.media_library_id = ?").bind(params.filters.mediaLibrary);

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

@@ -57,7 +57,7 @@ namespace lms::db
                 query.join("track t ON t.id = t_a_l.track_id");
 
                 if (params.filters.codec.has_value())
-                    query.where("t.codec = ?").bind(detail::getDbCodecType(*params.filters.codec));
+                    query.where("t.codec = ?").bind(detail::getDbCodec(*params.filters.codec));
 
                 if (params.filters.mediaLibrary.isValid())
                     query.where("t.media_library_id = ?").bind(params.filters.mediaLibrary);

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

@@ -99,12 +99,12 @@ namespace lms::db
         utils::forEachQueryRangeResult(query, params.range, func);
     }
 
-    std::optional<core::media::ContainerType> PodcastEpisode::getContainer() const
+    std::optional<core::media::Container> PodcastEpisode::getContainer() const
     {
         return detail::getMediaContainerType(_container);
     }
 
-    std::optional<core::media::CodecType> PodcastEpisode::getCodec() const
+    std::optional<core::media::Codec> PodcastEpisode::getCodec() const
     {
         return detail::getMediaCodecType(_codec);
     }
@@ -119,14 +119,14 @@ namespace lms::db
         return _artwork.id();
     }
 
-    void PodcastEpisode::setContainer(core::media::ContainerType container)
+    void PodcastEpisode::setContainer(core::media::Container container)
     {
-        _container = detail::getDbContainerType(container);
+        _container = detail::getDbContainer(container);
     }
 
-    void PodcastEpisode::setCodec(core::media::CodecType codec)
+    void PodcastEpisode::setCodec(core::media::Codec codec)
     {
-        _codec = detail::getDbCodecType(codec);
+        _codec = detail::getDbCodec(codec);
     }
 
     void PodcastEpisode::setArtwork(ObjectPtr<Artwork> artwork)

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

@@ -220,7 +220,7 @@ namespace lms::db
             }
 
             if (params.filters.codec.has_value())
-                query.where("t.codec = ?").bind(detail::getDbCodecType(params.filters.codec.value()));
+                query.where("t.codec = ?").bind(detail::getDbCodec(params.filters.codec.value()));
 
             if (params.releaseGroupMBID)
                 query.where("group_mbid = ?").bind(params.releaseGroupMBID->getAsString());
@@ -684,15 +684,15 @@ 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<core::media::CodecType> Release::getCodecs() const
+    std::vector<core::media::Codec> Release::getCodecs() const
     {
         assert(session());
 
         // Get the codec ordered by frequency
-        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") };
+        auto query{ session()->query<detail::Codec>("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) {
+        std::vector<core::media::Codec> res;
+        utils::forEachQueryResult(query, [&](detail::Codec codec) {
             if (const auto mediaCodecType{ detail::getMediaCodecType(codec) })
                 res.push_back(*mediaCodecType);
         });

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

@@ -198,7 +198,7 @@ namespace lms::db
             }
 
             if (params.filters.codec.has_value())
-                query.where("t.codec = ?").bind(detail::getDbCodecType(*params.filters.codec));
+                query.where("t.codec = ?").bind(detail::getDbCodec(*params.filters.codec));
 
             switch (params.sortMethod)
             {
@@ -528,14 +528,14 @@ namespace lms::db
         _absoluteFilePath = filePath;
     }
 
-    void Track::setContainer(core::media::ContainerType container)
+    void Track::setContainer(core::media::Container container)
     {
-        _container = detail::getDbContainerType(container);
+        _container = detail::getDbContainer(container);
     }
 
-    void Track::setCodec(core::media::CodecType codec)
+    void Track::setCodec(core::media::Codec codec)
     {
-        _codec = detail::getDbCodecType(codec);
+        _codec = detail::getDbCodec(codec);
     }
 
     void Track::setName(std::string_view name)
@@ -618,12 +618,12 @@ namespace lms::db
         _preferredMediaArtwork = getDboPtr(artwork);
     }
 
-    std::optional<core::media::ContainerType> Track::getContainer() const
+    std::optional<core::media::Container> Track::getContainer() const
     {
         return detail::getMediaContainerType(_container);
     }
 
-    std::optional<core::media::CodecType> Track::getCodec() const
+    std::optional<core::media::Codec> Track::getCodec() const
     {
         return detail::getMediaCodecType(_codec);
     }

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

@@ -70,7 +70,7 @@ namespace lms::db
                 query.join("track t ON t.id = t_l_e.track_id");
 
                 if (params.filters.codec.has_value())
-                    query.where("t.codec = ?").bind(detail::getDbCodecType(*params.filters.codec));
+                    query.where("t.codec = ?").bind(detail::getDbCodec(*params.filters.codec));
 
                 if (params.filters.mediaLibrary.isValid())
                     query.where("t.media_library_id = ?").bind(params.filters.mediaLibrary);

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

@@ -21,182 +21,182 @@
 
 namespace lms::db::detail
 {
-    std::optional<core::media::ContainerType> getMediaContainerType(db::detail::ContainerType container)
+    std::optional<core::media::Container> getMediaContainerType(db::detail::Container 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 Container::AIFF:
+            return core::media::Container::AIFF;
+        case Container::APE:
+            return core::media::Container::APE;
+        case Container::ASF:
+            return core::media::Container::ASF;
+        case Container::DSF:
+            return core::media::Container::DSF;
+        case Container::FLAC:
+            return core::media::Container::FLAC;
+        case Container::MP4:
+            return core::media::Container::MP4;
+        case Container::MPC:
+            return core::media::Container::MPC;
+        case Container::MPEG:
+            return core::media::Container::MPEG;
+        case Container::Ogg:
+            return core::media::Container::Ogg;
+        case Container::Shorten:
+            return core::media::Container::Shorten;
+        case Container::TrueAudio:
+            return core::media::Container::TrueAudio;
+        case Container::WAV:
+            return core::media::Container::WAV;
+        case Container::WavPack:
+            return core::media::Container::WavPack;
 
-        case ContainerType::Unknown:
+        case Container::Unknown:
             break;
         }
 
         return std::nullopt;
     }
 
-    db::detail::ContainerType getDbContainerType(core::media::ContainerType container)
+    db::detail::Container getDbContainer(core::media::Container 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;
+        case core::media::Container::AIFF:
+            return Container::AIFF;
+        case core::media::Container::APE:
+            return Container::APE;
+        case core::media::Container::ASF:
+            return Container::ASF;
+        case core::media::Container::DSF:
+            return Container::DSF;
+        case core::media::Container::FLAC:
+            return Container::FLAC;
+        case core::media::Container::MP4:
+            return Container::MP4;
+        case core::media::Container::MPC:
+            return Container::MPC;
+        case core::media::Container::MPEG:
+            return Container::MPEG;
+        case core::media::Container::Ogg:
+            return Container::Ogg;
+        case core::media::Container::Shorten:
+            return Container::Shorten;
+        case core::media::Container::TrueAudio:
+            return Container::TrueAudio;
+        case core::media::Container::WAV:
+            return Container::WAV;
+        case core::media::Container::WavPack:
+            return Container::WavPack;
         }
 
-        return ContainerType::Unknown;
+        return Container::Unknown;
     }
 
-    std::optional<core::media::CodecType> getMediaCodecType(db::detail::CodecType codec)
+    std::optional<core::media::Codec> getMediaCodecType(db::detail::Codec 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 Codec::AAC:
+            return core::media::Codec::AAC;
+        case Codec::AC3:
+            return core::media::Codec::AC3;
+        case Codec::ALAC:
+            return core::media::Codec::ALAC;
+        case Codec::APE:
+            return core::media::Codec::APE;
+        case Codec::DSD:
+            return core::media::Codec::DSD;
+        case Codec::EAC3:
+            return core::media::Codec::EAC3;
+        case Codec::FLAC:
+            return core::media::Codec::FLAC;
+        case Codec::MP3:
+            return core::media::Codec::MP3;
+        case Codec::MP4ALS:
+            return core::media::Codec::MP4ALS;
+        case Codec::MPC7:
+            return core::media::Codec::MPC7;
+        case Codec::MPC8:
+            return core::media::Codec::MPC8;
+        case Codec::Opus:
+            return core::media::Codec::Opus;
+        case Codec::PCM:
+            return core::media::Codec::PCM;
+        case Codec::Shorten:
+            return core::media::Codec::Shorten;
+        case Codec::TrueAudio:
+            return core::media::Codec::TrueAudio;
+        case Codec::Vorbis:
+            return core::media::Codec::Vorbis;
+        case Codec::WavPack:
+            return core::media::Codec::WavPack;
+        case Codec::WMA1:
+            return core::media::Codec::WMA1;
+        case Codec::WMA2:
+            return core::media::Codec::WMA2;
+        case Codec::WMA9Pro:
+            return core::media::Codec::WMA9Pro;
+        case Codec::WMA9Lossless:
+            return core::media::Codec::WMA9Lossless;
 
-        case CodecType::Unknown:
+        case Codec::Unknown:
             break;
         }
 
         return std::nullopt;
     }
 
-    db::detail::CodecType getDbCodecType(core::media::CodecType codec)
+    db::detail::Codec getDbCodec(core::media::Codec 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;
+        case core::media::Codec::AAC:
+            return Codec::AAC;
+        case core::media::Codec::AC3:
+            return Codec::AC3;
+        case core::media::Codec::ALAC:
+            return Codec::ALAC;
+        case core::media::Codec::APE:
+            return Codec::APE;
+        case core::media::Codec::DSD:
+            return Codec::DSD;
+        case core::media::Codec::EAC3:
+            return Codec::EAC3;
+        case core::media::Codec::FLAC:
+            return Codec::FLAC;
+        case core::media::Codec::MP3:
+            return Codec::MP3;
+        case core::media::Codec::MP4ALS:
+            return Codec::MP4ALS;
+        case core::media::Codec::MPC7:
+            return Codec::MPC7;
+        case core::media::Codec::MPC8:
+            return Codec::MPC8;
+        case core::media::Codec::Opus:
+            return Codec::Opus;
+        case core::media::Codec::PCM:
+            return Codec::PCM;
+        case core::media::Codec::Shorten:
+            return Codec::Shorten;
+        case core::media::Codec::TrueAudio:
+            return Codec::TrueAudio;
+        case core::media::Codec::Vorbis:
+            return Codec::Vorbis;
+        case core::media::Codec::WavPack:
+            return Codec::WavPack;
+        case core::media::Codec::WMA1:
+            return Codec::WMA1;
+        case core::media::Codec::WMA2:
+            return Codec::WMA2;
+        case core::media::Codec::WMA9Pro:
+            return Codec::WMA9Pro;
+        case core::media::Codec::WMA9Lossless:
+            return Codec::WMA9Lossless;
         }
 
-        return CodecType::Unknown;
+        return Codec::Unknown;
     }
 
     core::media::ImageType getMediaImageType(db::detail::ImageType type)

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

@@ -21,19 +21,19 @@
 
 #include <optional>
 
-#include "core/media/CodecType.hpp"
-#include "core/media/ContainerType.hpp"
+#include "core/media/Codec.hpp"
+#include "core/media/Container.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::Container> getMediaContainerType(db::detail::Container container);
+    db::detail::Container getDbContainer(core::media::Container container);
 
-    std::optional<core::media::CodecType> getMediaCodecType(db::detail::CodecType codec);
-    db::detail::CodecType getDbCodecType(core::media::CodecType codec);
+    std::optional<core::media::Codec> getMediaCodecType(db::detail::Codec codec);
+    db::detail::Codec getDbCodec(core::media::Codec codec);
 
     core::media::ImageType getMediaImageType(db::detail::ImageType type);
     db::detail::ImageType getDbImageType(core::media::ImageType type);

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

@@ -23,7 +23,7 @@
 #include <span>
 #include <vector>
 
-#include "core/media/CodecType.hpp"
+#include "core/media/Codec.hpp"
 
 #include "database/objects/ClusterId.hpp"
 #include "database/objects/LabelId.hpp"
@@ -34,11 +34,11 @@ namespace lms::db
 {
     struct Filters
     {
-        MediaLibraryId mediaLibrary;                 // tracks that belongs to this library
-        std::vector<ClusterId> clusters;             // tracks that belong to *all* these clusters
-        LabelId label;                               // tracks which release has this label
-        ReleaseTypeId releaseType;                   // tracks which release has this type
-        std::optional<core::media::CodecType> codec; // tracks that match this codec
+        MediaLibraryId mediaLibrary;             // tracks that belongs to this library
+        std::vector<ClusterId> clusters;         // tracks that belong to *all* these clusters
+        LabelId label;                           // tracks which release has this label
+        ReleaseTypeId releaseType;               // tracks which release has this type
+        std::optional<core::media::Codec> codec; // tracks that match this codec
 
         Filters& setClusters(std::span<const ClusterId> _clusters)
         {
@@ -60,7 +60,7 @@ namespace lms::db
             releaseType = _releaseType;
             return *this;
         }
-        Filters& setCodec(std::optional<core::media::CodecType> _codec)
+        Filters& setCodec(std::optional<core::media::Codec> _codec)
         {
             codec = _codec;
             return *this;

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

@@ -29,8 +29,8 @@
 #include <Wt/Dbo/collection.h>
 #include <Wt/WDateTime.h>
 
-#include "core/media/CodecType.hpp"
-#include "core/media/ContainerType.hpp"
+#include "core/media/Codec.hpp"
+#include "core/media/Container.hpp"
 
 #include "database/Object.hpp"
 #include "database/Types.hpp"
@@ -97,8 +97,8 @@ namespace lms::db
 
         // Audio properties
         std::chrono::milliseconds getDuration() const { return _duration; }
-        std::optional<core::media::ContainerType> getContainer() const;
-        std::optional<core::media::CodecType> getCodec() const;
+        std::optional<core::media::Container> getContainer() const;
+        std::optional<core::media::Codec> getCodec() const;
         std::size_t getBitrate() const { return _bitrate; }
         std::size_t getChannelCount() const { return _channelCount; }
         std::size_t getSampleRate() const { return _sampleRate; }
@@ -128,8 +128,8 @@ namespace lms::db
 
         // Audio properties
         void setDuration(std::chrono::milliseconds duration) { _duration = duration; }
-        void setContainer(core::media::ContainerType container);
-        void setCodec(core::media::CodecType codec);
+        void setContainer(core::media::Container container);
+        void setCodec(core::media::Codec 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; }
@@ -193,8 +193,8 @@ namespace lms::db
 
         // Audio properties
         std::chrono::duration<int, std::milli> _duration{ 0 };
-        detail::ContainerType _container{ detail::ContainerType::Unknown };
-        detail::CodecType _codec{ detail::CodecType::Unknown };
+        detail::Container _container{ detail::Container::Unknown };
+        detail::Codec _codec{ detail::Codec::Unknown };
         int _bitrate{}; // in bps
         int _channelCount{};
         int _sampleRate{};

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

@@ -31,7 +31,7 @@
 #include "core/EnumSet.hpp"
 #include "core/PartialDateTime.hpp"
 #include "core/UUID.hpp"
-#include "core/media/CodecType.hpp"
+#include "core/media/Codec.hpp"
 
 #include "database/IdRange.hpp"
 #include "database/Object.hpp"
@@ -280,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<core::media::CodecType> getCodecs() const;
+        std::vector<core::media::Codec> getCodecs() const;
 
         // Accessors
         std::string_view getName() const { return _name; }

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

@@ -34,8 +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 "core/media/Codec.hpp"
+#include "core/media/Container.hpp"
 
 #include "database/IdRange.hpp"
 #include "database/Object.hpp"
@@ -232,8 +232,8 @@ namespace lms::db
 
         // Audio properties
         void setDuration(std::chrono::milliseconds duration) { _duration = duration; }
-        void setContainer(core::media::ContainerType container);
-        void setCodec(core::media::CodecType codec);
+        void setContainer(core::media::Container container);
+        void setCodec(core::media::Codec 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; }
@@ -278,8 +278,8 @@ namespace lms::db
 
         // Audio properties
         std::chrono::milliseconds getDuration() const { return _duration; }
-        std::optional<core::media::ContainerType> getContainer() const;
-        std::optional<core::media::CodecType> getCodec() const;
+        std::optional<core::media::Container> getContainer() const;
+        std::optional<core::media::Codec> getCodec() const;
         std::size_t getBitrate() const { return _bitrate; }
         std::size_t getChannelCount() const { return _channelCount; }
         std::size_t getSampleRate() const { return _sampleRate; }
@@ -383,8 +383,8 @@ namespace lms::db
 
         // Audio properties
         std::chrono::duration<int, std::milli> _duration{};
-        detail::ContainerType _container{ detail::ContainerType::Unknown };
-        detail::CodecType _codec{ detail::CodecType::Unknown };
+        detail::Container _container{ detail::Container::Unknown };
+        detail::Codec _codec{ detail::Codec::Unknown };
         int _bitrate{}; // in bps
         int _channelCount{};
         int _sampleRate{};

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

@@ -49,7 +49,7 @@ namespace lms::db::detail
         PublisherLogo = 21
     };
 
-    enum class ContainerType
+    enum class Container
     {
         Unknown = 0,
 
@@ -68,7 +68,7 @@ namespace lms::db::detail
         WavPack = 13,
     };
 
-    enum class CodecType
+    enum class Codec
     {
         Unknown = 0,
 

src/libs/database/test/Artist.cpp

@@ -530,15 +530,15 @@ namespace lms::db::tests
             TrackArtistLink::create(session, track1.get(), artist1.get(), TrackArtistLinkType::Artist);
             TrackArtistLink::create(session, track2.get(), artist2.get(), TrackArtistLinkType::Artist);
 
-            track1.get().modify()->setCodec(core::media::CodecType::MP3);
-            track2.get().modify()->setCodec(core::media::CodecType::FLAC);
+            track1.get().modify()->setCodec(core::media::Codec::MP3);
+            track2.get().modify()->setCodec(core::media::Codec::FLAC);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             Artist::FindParameters params;
-            params.setFilters(Filters{}.setCodec(core::media::CodecType::FLAC));
+            params.setFilters(Filters{}.setCodec(core::media::Codec::FLAC));
 
             const auto artists{ Artist::find(session, params) };
             ASSERT_EQ(artists.results.size(), 1);

src/libs/database/test/Release.cpp

@@ -1229,22 +1229,22 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createWriteTransaction() };
-            track1.get().modify()->setCodec(core::media::CodecType::FLAC);
+            track1.get().modify()->setCodec(core::media::Codec::FLAC);
             track1.get().modify()->setRelease(release1.get());
 
-            track2.get().modify()->setCodec(core::media::CodecType::MP3);
+            track2.get().modify()->setCodec(core::media::Codec::MP3);
             track2.get().modify()->setRelease(release1.get());
 
-            track3.get().modify()->setCodec(core::media::CodecType::MP3);
+            track3.get().modify()->setCodec(core::media::Codec::MP3);
             track3.get().modify()->setRelease(release1.get());
 
-            track4.get().modify()->setCodec(core::media::CodecType::AAC);
+            track4.get().modify()->setCodec(core::media::Codec::AAC);
             track4.get().modify()->setRelease(release1.get());
         }
 
         {
             auto transaction{ session.createReadTransaction() };
-            EXPECT_EQ(release1->getCodecs(), (std::vector<core::media::CodecType>{ core::media::CodecType::MP3, core::media::CodecType::FLAC, core::media::CodecType::AAC }));
+            EXPECT_EQ(release1->getCodecs(), (std::vector<core::media::Codec>{ core::media::Codec::MP3, core::media::Codec::FLAC, core::media::Codec::AAC }));
         }
     }
 
@@ -1263,10 +1263,10 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createWriteTransaction() };
-            track1.get().modify()->setCodec(core::media::CodecType::FLAC);
+            track1.get().modify()->setCodec(core::media::Codec::FLAC);
             track1.get().modify()->setRelease(release1.get());
 
-            track2.get().modify()->setCodec(core::media::CodecType::MP3);
+            track2.get().modify()->setCodec(core::media::Codec::MP3);
             track2.get().modify()->setRelease(release2.get());
         }
 
@@ -1274,7 +1274,7 @@ namespace lms::db::tests
             auto transaction{ session.createReadTransaction() };
 
             Release::FindParameters params;
-            params.setFilters(Filters{}.setCodec(core::media::CodecType::MP3));
+            params.setFilters(Filters{}.setCodec(core::media::Codec::MP3));
 
             auto releases{ Release::findIds(session, params) };
             ASSERT_EQ(releases.results.size(), 1);

src/libs/database/test/Track.cpp

@@ -245,15 +245,15 @@ namespace lms::db::tests
 
         {
             auto transaction{ session.createWriteTransaction() };
-            track1.get().modify()->setCodec(core::media::CodecType::MP3);
-            track2.get().modify()->setCodec(core::media::CodecType::FLAC);
+            track1.get().modify()->setCodec(core::media::Codec::MP3);
+            track2.get().modify()->setCodec(core::media::Codec::FLAC);
         }
 
         {
             auto transaction{ session.createReadTransaction() };
 
             Track::FindParameters params;
-            params.setFilters(Filters{}.setCodec(core::media::CodecType::FLAC));
+            params.setFilters(Filters{}.setCodec(core::media::Codec::FLAC));
 
             const auto tracks{ Track::find(session, params) };
             ASSERT_EQ(tracks.results.size(), 1);