Using track id for the transcoding service

src/libs/services/auth/CMakeLists.txt

@@ -18,14 +18,11 @@ target_include_directories(lmsauth PRIVATE
 	impl
 	)
 
-target_link_libraries(lmsauth PRIVATE
-	lmscore
-	lmsdatabase
-	)
-
 target_link_libraries(lmsauth PUBLIC
 	Boost::system
 	Wt::Wt
+	lmscore
+	lmsdatabase
 	)
 	
 # PAM

src/libs/services/recommendation/CMakeLists.txt

@@ -21,7 +21,11 @@ target_include_directories(lmsrecommendation PRIVATE
 	)
 
 target_link_libraries(lmsrecommendation PRIVATE
-	lmsdatabase
+
 	lmssom
 	std::filesystem
 	)
+
+target_link_libraries(lmsrecommendation PUBLIC
+	lmsdatabase
+	)

src/libs/services/recommendation/include/services/recommendation/IRecommendationService.hpp

@@ -23,6 +23,8 @@
 #include <vector>
 
 #include "core/EnumSet.hpp"
+#include "database/ArtistId.hpp"
+#include "database/ReleaseId.hpp"
 #include "database/TrackListId.hpp"
 #include "database/Types.hpp"
 #include "services/recommendation/Types.hpp"

src/libs/services/transcoding/CMakeLists.txt

@@ -15,3 +15,8 @@ target_include_directories(lmstranscoding PRIVATE
 target_link_libraries(lmstranscoding PRIVATE
 	lmsav
 	)
+
+target_link_libraries(lmstranscoding PUBLIC
+	lmsdatabase
+	)
+

src/libs/services/transcoding/impl/TranscodingResourceHandler.cpp

@@ -25,39 +25,19 @@
 
 namespace lms::transcoding
 {
-    namespace
+    std::unique_ptr<core::IResourceHandler> createResourceHandler(const av::InputParameters& inputParameters, const av::OutputParameters& outputParameters, bool estimateContentLength)
-    {
-        std::size_t doEstimateContentLength(const InputParameters& inputParameters, const OutputParameters& outputParameters)
-        {
-            const std::size_t estimatedContentLength{ outputParameters.bitrate / 8 * static_cast<std::size_t>(std::chrono::duration_cast<std::chrono::milliseconds>(inputParameters.duration).count()) / 1000 };
-            return estimatedContentLength;
-        }
-
-        av::InputParameters toAv(const InputParameters& in)
-        {
-            return { .file = in.file, .offset = in.offset, .streamIndex = in.streamIndex };
-        }
-
-        av::OutputParameters toAv(const OutputParameters& out)
-        {
-            return { .format = static_cast<lms::av::OutputFormat>(out.format), .bitrate = out.bitrate, .stripMetadata = out.stripMetadata };
-        }
-
-    } // namespace
-
-    std::unique_ptr<core::IResourceHandler> createResourceHandler(const InputParameters& inputParameters, const OutputParameters& outputParameters, bool estimateContentLength)
     {
         return std::make_unique<TranscodingResourceHandler>(inputParameters, outputParameters, estimateContentLength);
     }
 
     // TODO set some nice HTTP return code
 
-    TranscodingResourceHandler::TranscodingResourceHandler(const InputParameters& inputParameters, const OutputParameters& outputParameters, bool estimateContentLength)
+    TranscodingResourceHandler::TranscodingResourceHandler(const av::InputParameters& inputParameters, const av::OutputParameters& outputParameters, std::optional<std::size_t> estimatedContentLength)
-        : _estimatedContentLength{ estimateContentLength ? std::make_optional(doEstimateContentLength(inputParameters, outputParameters)) : std::nullopt }
+        : _estimatedContentLength{ estimatedContentLength }
     {
         try
         {
-            _transcoder = av::createTranscoder(toAv(inputParameters), toAv(outputParameters));
+            _transcoder = av::createTranscoder(inputParameters, outputParameters);
 
             if (_estimatedContentLength)
                 LMS_LOG(TRANSCODING, DEBUG, "Estimated content length = " << *_estimatedContentLength);

src/libs/services/transcoding/impl/TranscodingResourceHandler.hpp

@@ -23,20 +23,15 @@
 #include <memory>
 #include <optional>
 
+#include "av/ITranscoder.hpp"
 #include "core/IResourceHandler.hpp"
-#include "services/transcoding/ITranscodingService.hpp"
-
-namespace lms::av
-{
-    class ITranscoder;
-}
 
 namespace lms::transcoding
 {
     class TranscodingResourceHandler final : public core::IResourceHandler
     {
     public:
-        TranscodingResourceHandler(const InputParameters& inputParameters, const OutputParameters& outputParameters, bool estimateContentLength);
+        TranscodingResourceHandler(const av::InputParameters& inputParameters, const av::OutputParameters& outputParameters, std::optional<std::size_t> estimatedContentLength);
         ~TranscodingResourceHandler() override;
 
         TranscodingResourceHandler(const TranscodingResourceHandler&) = delete;

src/libs/services/transcoding/impl/TranscodingService.cpp

@@ -19,19 +19,38 @@
 
 #include "TranscodingService.hpp"
 
+#include "av/ITranscoder.hpp"
 #include "core/ILogger.hpp"
+#include "database/Db.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
 
 #include "TranscodingResourceHandler.hpp"
 
 namespace lms::transcoding
 {
-    std::unique_ptr<ITranscodingService> createTranscodingService(core::IChildProcessManager& childProcessManager)
+    namespace
     {
-        return std::make_unique<TranscodingService>(childProcessManager);
+        av::OutputParameters toAv(const OutputParameters& out)
+        {
+            return { .format = static_cast<lms::av::OutputFormat>(out.format), .bitrate = out.bitrate, .stripMetadata = out.stripMetadata };
+        }
+
+        std::size_t doEstimateContentLength(std::size_t bitrate, std::chrono::milliseconds duration)
+        {
+            const std::size_t estimatedContentLength{ (bitrate / 8 * duration.count()) / 1000 };
+            return estimatedContentLength;
+        }
+    } // namespace
+
+    std::unique_ptr<ITranscodingService> createTranscodingService(db::Db& db, core::IChildProcessManager& childProcessManager)
+    {
+        return std::make_unique<TranscodingService>(db, childProcessManager);
     }
 
-    TranscodingService::TranscodingService(core::IChildProcessManager& childProcessManager)
+    TranscodingService::TranscodingService(db::Db& db, core::IChildProcessManager& childProcessManager)
-        : _childProcessManager(childProcessManager)
+        : _db{ db }
+        , _childProcessManager(childProcessManager)
     {
         LMS_LOG(TRANSCODING, INFO, "Service started!");
     }
@@ -43,6 +62,24 @@ namespace lms::transcoding
 
     std::unique_ptr<core::IResourceHandler> TranscodingService::createResourceHandler(const InputParameters& inputParameters, const OutputParameters& outputParameters, bool estimateContentLength)
     {
-        return std::make_unique<TranscodingResourceHandler>(inputParameters, outputParameters, estimateContentLength);
+        av::InputParameters avInputParams;
+        std::optional<std::size_t> estimatedContentLength;
+        {
+            auto& session{ _db.getTLSSession() };
+            auto transaction{ session.createReadTransaction() };
+
+            db::Track::pointer track{ db::Track::find(session, inputParameters.trackId) };
+            if (!track)
+                return nullptr;
+
+            avInputParams.file = track->getAbsoluteFilePath();
+            avInputParams.offset = inputParameters.offset;
+            avInputParams.streamIndex = inputParameters.streamIndex;
+
+            if (estimateContentLength)
+                estimatedContentLength = doEstimateContentLength(outputParameters.bitrate, track->getDuration());
+        }
+
+        return std::make_unique<TranscodingResourceHandler>(avInputParams, toAv(outputParameters), estimatedContentLength);
     }
 } // namespace lms::transcoding

src/libs/services/transcoding/impl/TranscodingService.hpp

@@ -26,7 +26,7 @@ namespace lms::transcoding
     class TranscodingService : public ITranscodingService
     {
     public:
-        explicit TranscodingService(core::IChildProcessManager& childProcessManager);
+        explicit TranscodingService(db::Db& db, core::IChildProcessManager& childProcessManager);
         ~TranscodingService() override;
 
         TranscodingService(const TranscodingService&) = delete;
@@ -35,6 +35,7 @@ namespace lms::transcoding
     private:
         std::unique_ptr<core::IResourceHandler> createResourceHandler(const InputParameters& inputParameters, const OutputParameters& outputParameters, bool estimateContentLength) override;
 
+        db::Db& _db;
         core::IChildProcessManager& _childProcessManager;
     };
 } // namespace lms::transcoding

src/libs/services/transcoding/include/services/transcoding/ITranscodingService.hpp

@@ -23,19 +23,28 @@
 #include <memory>
 #include <optional>
 
-namespace lms::core
+#include "database/TrackId.hpp"
+
+namespace lms
 {
-    class IChildProcessManager;
+    namespace core
-    class IResourceHandler;
+    {
-} // namespace lms::core
+        class IChildProcessManager;
+        class IResourceHandler;
+    } // namespace core
+
+    namespace db
+    {
+        class Db;
+    }
+} // namespace lms
 
 namespace lms::transcoding
 {
     struct InputParameters
     {
-        std::filesystem::path file;             // Path to the input file
+        db::TrackId trackId;
-        std::chrono::milliseconds duration;     // Offset in the input file to start transcoding from
+        std::chrono::milliseconds offset{};     // Offset in the track file to start transcoding from
-        std::chrono::milliseconds offset{};     // Offset in the input file to start transcoding from
         std::optional<std::size_t> streamIndex; // Index of the stream to be transcoded (select "best" audio stream if not set)
     };
 
@@ -63,5 +72,5 @@ namespace lms::transcoding
         virtual std::unique_ptr<core::IResourceHandler> createResourceHandler(const InputParameters& inputParameters, const OutputParameters& outputParameters, bool estimateContentLength) = 0;
     };
 
-    std::unique_ptr<ITranscodingService> createTranscodingService(core::IChildProcessManager& childProcessManager);
+    std::unique_ptr<ITranscodingService> createTranscodingService(db::Db& db, core::IChildProcessManager& childProcessManager);
 } // namespace lms::transcoding

src/libs/subsonic/impl/endpoints/MediaRetrieval.cpp

@@ -101,6 +101,7 @@ namespace lms::api::subsonic
         {
             transcoding::InputParameters inputParameters;
             std::optional<transcoding::OutputParameters> outputParameters;
+            std::filesystem::path trackPath;
             bool estimateContentLength{};
         };
 
@@ -143,10 +144,10 @@ namespace lms::api::subsonic
             if (!track)
                 throw RequestedDataNotFoundError{};
 
-            parameters.inputParameters.file = track->getAbsoluteFilePath();
+            parameters.inputParameters.trackId = id;
-            parameters.inputParameters.duration = track->getDuration();
             parameters.inputParameters.offset = std::chrono::seconds{ timeOffset };
             parameters.estimateContentLength = estimateContentLength;
+            parameters.trackPath = track->getAbsoluteFilePath();
 
             if (format == "raw") // raw => no transcoding
                 return parameters;
@@ -309,7 +310,7 @@ namespace lms::api::subsonic
                 if (streamParameters.outputParameters)
                     resourceHandler = core::Service<transcoding::ITranscodingService>::get()->createResourceHandler(streamParameters.inputParameters, *streamParameters.outputParameters, streamParameters.estimateContentLength);
                 else
-                    resourceHandler = core::createFileResourceHandler(streamParameters.inputParameters.file);
+                    resourceHandler = core::createFileResourceHandler(streamParameters.trackPath);
             }
             else
             {

src/lms/main.cpp

@@ -374,7 +374,7 @@ namespace lms
             core::Service<recommendation::IRecommendationService> recommendationService{ recommendation::createRecommendationService(database) };
             core::Service<recommendation::IPlaylistGeneratorService> playlistGeneratorService{ recommendation::createPlaylistGeneratorService(database, *recommendationService.get()) };
             core::Service<scanner::IScannerService> scannerService{ scanner::createScannerService(database) };
-            core::Service<transcoding::ITranscodingService> transcodingService{ transcoding::createTranscodingService(*childProcessManagerService.get()) };
+            core::Service<transcoding::ITranscodingService> transcodingService{ transcoding::createTranscodingService(database, *childProcessManagerService.get()) };
 
             scannerService->getEvents().scanComplete.connect([&] {
                 // Flush cover cache even if no changes:

src/lms/ui/resource/AudioTranscodingResource.cpp

@@ -141,22 +141,8 @@ namespace lms::ui
             // optional parameter
             std::size_t offset{ readParameterAs<std::size_t>(request, "offset").value_or(0) };
 
-            std::filesystem::path trackPath;
+            parameters.inputParameters.trackId = *trackId;
-            {
+            parameters.inputParameters.offset = std::chrono::seconds{ offset };
-                auto transaction{ LmsApp->getDbSession().createReadTransaction() };
-
-                const db::Track::pointer track{ db::Track::find(LmsApp->getDbSession(), *trackId) };
-                if (!track)
-                {
-                    TRANSCODE_LOG(ERROR, "Missing track");
-                    return std::nullopt;
-                }
-
-                parameters.inputParameters.file = track->getAbsoluteFilePath();
-                parameters.inputParameters.duration = track->getDuration();
-                parameters.inputParameters.offset = std::chrono::seconds{ offset };
-            }
-
             parameters.outputParameters.stripMetadata = true;
             parameters.outputParameters.format = *avFormat;
             parameters.outputParameters.bitrate = *bitrate;