transcoder.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte-Multimedia.
 *
 * StormByte-Multimedia original source is dual-licensed:
 *
 * 1. GNU Lesser General Public License v3.0 (or later)
 *    You may redistribute and/or modify this file under the terms of the
 *    GNU Lesser General Public License as published by the Free Software
 *    Foundation, either version 3 of the License, or (at your option)
 *    any later version.
 *
 * 2. Commercial license
 *    Alternatively, this file may be used under the terms of a commercial
 *    license agreement with the copyright holder
 *    (David C. Manuelda <StormByte@gmail.com>).
 *
 * Both licenses apply only to original StormByte-Multimedia source in this
 * file. Third-party components — including FFmpeg and embedded trained data —
 * remain under their own licenses and are not covered by the commercial grant.
 *
 * Neither license grants any patent rights. Any patent licenses required
 * to use this software or third-party components must be obtained separately
 * from the patent holders.
 *
 * StormByte-Multimedia 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with StormByte-Multimedia. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
 */
 
#pragma once
 
#include <StormByte/buffer/consumer.hxx>
#include <StormByte/clonable.hxx>
#include <StormByte/logger/log.hxx>
#include <StormByte/multimedia/codec.hxx>
#include <StormByte/multimedia/container.hxx>
#include <StormByte/multimedia/file.hxx>
#include <StormByte/multimedia/pipeline/filters/ffmpeg.hxx>
#include <StormByte/multimedia/pipeline/filters/report.hxx>
#include <StormByte/multimedia/pipeline/plan.hxx>
#include <StormByte/multimedia/type.hxx>
#include <StormByte/multimedia/typedefs.hxx>
#include <StormByte/multimedia/visibility.h>
 
#include <chrono>
#include <cstdint>
#include <filesystem>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace StormByte::Multimedia::Backend::Pipeline {
    class Transcoder;   
}
 
namespace StormByte::Multimedia::Pipeline {
    class Encoder;
    class Transcoder;
 
    enum class Status {
        Stopped,    
        Running,    
        Paused,     
        Done,       
        Error,      
        Aborted     
    };
 
    class STORMBYTE_MULTIMEDIA_PUBLIC TrackSettled:
        public StormByte::Clonable<TrackSettled, std::unique_ptr<TrackSettled>> {
        public:
            TrackSettled() noexcept = default;
 
            TrackSettled(const TrackSettled& other) = default;
 
            TrackSettled(TrackSettled&& other) noexcept = default;
 
            virtual ~TrackSettled() noexcept override = default;
 
            TrackSettled& operator=(const TrackSettled& other) = default;
 
            TrackSettled& operator=(TrackSettled&& other) noexcept = default;
 
            inline PointerType Clone() const override {
                return MakePointer<TrackSettled>(*this);
            }
 
            inline PointerType Move() override {
                return MakePointer<TrackSettled>(std::move(*this));
            }
 
            virtual std::string ToString() const;
 
            int In = -1;                                                
            int Out = -1;                                               
            Type Kind = Type::Unknown;                                  
            const Codec* Source = nullptr;                              
            const Codec* Destination = nullptr;                         
            std::optional<std::string> Implementation;                  
            std::optional<int> Crf;                                     
            std::optional<std::int64_t> BitRate;                        
            std::optional<std::int64_t> MaxBitRate;                     
            std::optional<std::string> Preset;                          
            std::optional<std::string> Tune;                            
            std::map<std::string, std::string> FineTune;                
            std::optional<int> SampleFormat;                            
            std::optional<int> SourceChannels;                          
            std::optional<int> EncoderChannels;                         
            std::optional<int> FrameSize;                               
            std::optional<int> SampleRate;                              
    };
 
    class STORMBYTE_MULTIMEDIA_PUBLIC Transcoder {
        public:
            class STORMBYTE_MULTIMEDIA_PUBLIC Track {
                public:
                    Track(const Track& other) noexcept = default;
 
                    Track(Track&& other) noexcept = default;
 
                    ~Track() noexcept = default;
 
                    Track& operator=(const Track& other) noexcept = default;
 
                    Track& operator=(Track&& other) noexcept = default;
 
                    Track& Remux() noexcept;
 
                    Track& Codec(const Codec& codec) noexcept;
 
                    Track& Implementation(std::string name) noexcept;
 
                    Track& CRF(int value) noexcept;
 
                    Track& BitRate(std::int64_t bits_per_second) noexcept;
 
                    Track& MaxBitRate(std::int64_t bits_per_second) noexcept;
 
                    Track& Preset(std::string name) noexcept;
 
                    Track& Tune(std::string name) noexcept;
 
                    Track& FineTune(std::map<std::string, std::string> options) noexcept;
 
                    Track& Language(std::string language) noexcept;
 
                    Track& Title(std::string title) noexcept;
 
                    template<typename FilterType, typename... Args>
                    Track& Filter(Args&&... args) noexcept {
                        m_owner->AttachFilter(m_slot,
                            std::make_shared<FilterType>(std::forward<Args>(args)...));
                        return *this;
                    }
 
                private:
                    friend class Transcoder;
 
                    Track(Transcoder& owner, std::size_t slot) noexcept;
 
                    Transcoder* m_owner;                                
                    std::size_t m_slot;                                 
            };
 
            Transcoder(std::shared_ptr<StormByte::Logger::Log> logger, File&& file) noexcept;
 
            Transcoder(const Transcoder& other) = delete;
 
            Transcoder(Transcoder&& other) noexcept = delete;
 
            virtual ~Transcoder() noexcept;
 
            Transcoder& operator=(const Transcoder& other) = delete;
 
            Transcoder& operator=(Transcoder&& other) noexcept = delete;
 
            static ExpectedTranscoder Open(std::shared_ptr<StormByte::Logger::Log> logger,
                const std::filesystem::path& source,
                const std::filesystem::path& destination,
                std::optional<std::chrono::nanoseconds> duration = std::nullopt) noexcept;
 
            const File& Source() const noexcept;
 
            const std::shared_ptr<StormByte::Logger::Log>& Logger() const noexcept;
 
            inline const std::shared_ptr<class Plan>& Plan() const noexcept {
                return m_plan;
            }
 
            Track Video(int in) noexcept;
 
            Track Audio(int in) noexcept;
 
            Track Subtitle(int in) noexcept;
 
            Transcoder& Attachments() noexcept;
 
            Transcoder& Attachments(std::string_view mime) noexcept;
 
            Transcoder& Ignore(int in) noexcept;
 
            template<typename FilterType, typename... Args>
            Transcoder& Filter(Args&&... args) noexcept {
                static_assert(std::is_base_of_v<Filter::Analytics, FilterType>,
                    "Track filters attach on Track::Filter");
                AttachAnalytics(std::make_shared<FilterType>(std::forward<Args>(args)...));
                return *this;
            }
 
            Transcoder& Destination(const Container& container, std::filesystem::path path) noexcept;
 
            void Run() noexcept;
 
            void Cancel() noexcept;
 
            void Pause() noexcept;
 
            void Resume() noexcept;
 
            enum Status Status() const noexcept;
 
            bool Failed() const noexcept;
 
            std::optional<std::string> Error() const noexcept;
 
            std::optional<unsigned> Progress() const noexcept;
 
            std::vector<std::pair<std::string, Filter::Report>> Reports() const noexcept;
 
            explicit operator bool() const noexcept;
 
        protected:
            virtual void InstallLog() noexcept;
 
            inline const std::shared_ptr<StormByte::Logger::Log>& ApplicationLog() const noexcept {
                return m_app_log;
            }
 
            virtual std::unique_ptr<class Plan> EmptyPlan(File&& source,
                const Container& container,
                std::filesystem::path destination) const noexcept;
 
            virtual std::unique_ptr<TrackSettled> EmptySettled() const noexcept;
 
            virtual void OnConfigure() noexcept;
 
            virtual enum Status OnStart() noexcept;
 
            virtual void OnPlan(const class Plan& plan) noexcept;
 
            virtual void OnSettled(const TrackSettled& track) noexcept;
 
            virtual void OnProgress(unsigned percent) noexcept;
 
            virtual void OnDone() noexcept;
 
            virtual void OnError(const std::string& message) noexcept;
 
            virtual void OnAborted() noexcept;
 
        private:
            friend class Backend::Pipeline::Transcoder;
            friend class Track;
 
            void Fail(std::string reason) noexcept;
 
            static ExpectedTranscoder BindLoggerAndFile(std::shared_ptr<StormByte::Logger::Log> logger,
                ExpectedFile opened) noexcept;
 
            Track AddTrack(int in, Type kind) noexcept;
 
            void MarkSettled(int in, Encoder& encoder) noexcept;
 
            void SetProgress(unsigned percent) noexcept;
 
            bool ValidSlot(std::size_t slot) const noexcept;
 
            void AttachFilter(std::size_t slot, std::shared_ptr<Filter::FFmpeg> filter) noexcept;
 
            void AttachAnalytics(std::shared_ptr<Filter::FFmpeg> filter) noexcept;
 
            std::shared_ptr<StormByte::Logger::Log> m_app_log;          
            std::shared_ptr<StormByte::Logger::Log> m_logger;           
            std::unique_ptr<File> m_file;                               
            std::shared_ptr<class Plan> m_plan;                         
            std::unique_ptr<Backend::Pipeline::Transcoder> m_backend;   
    };
}