ffmpeg.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/logger/log.hxx>
#include <StormByte/multimedia/ffmpeg/AVFrame.hxx>
#include <StormByte/multimedia/ffmpeg/AVPacket.hxx>
#include <StormByte/multimedia/pipeline/filters/report.hxx>
#include <StormByte/multimedia/pipeline/frame.hxx>
#include <StormByte/multimedia/pipeline/packet.hxx>
#include <StormByte/multimedia/pipeline/typedefs.hxx>
#include <StormByte/multimedia/type.hxx>
#include <StormByte/multimedia/visibility.h>
 
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <deque>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
 
namespace StormByte::Multimedia::Backend::Pipeline {
    class Host;
    class Pipe;
    class Pumper;
    class Worker;
}
 
namespace StormByte::Multimedia::Backend::Pipeline::Detail::Worker {
    class Filter;
}
 
namespace StormByte::Multimedia::Pipeline {
    class Filters;
    class Route;
}
 
namespace StormByte::Multimedia::Pipeline::Filter {
    class STORMBYTE_MULTIMEDIA_PUBLIC FFmpeg {
        friend class StormByte::Multimedia::Pipeline::Filters;
        friend class StormByte::Multimedia::Pipeline::Route;
        friend class StormByte::Multimedia::Backend::Pipeline::Detail::Worker::Filter;
 
        public:
            FFmpeg(const FFmpeg& other) = delete;
 
            FFmpeg(FFmpeg&& other) noexcept = delete;
 
            virtual ~FFmpeg() noexcept;
 
            FFmpeg& operator=(const FFmpeg& other) = delete;
 
            FFmpeg& operator=(FFmpeg&& other) noexcept = delete;
 
            virtual enum StormByte::Multimedia::Type Media() const noexcept = 0;
 
            std::string Name() const noexcept;
 
            inline const std::string& Leaf() const noexcept {
                return m_name;
            }
 
            inline const Pipeline::Kinds& Receives() const noexcept {
                return m_receives;
            }
 
            inline const Pipeline::Kinds& Produces() const noexcept {
                return m_produces;
            }
 
            virtual void Clean() noexcept = 0;
 
            virtual void Setup() noexcept = 0;
 
            virtual void Process(const Pipeline::Frame& frame) noexcept;
 
            virtual void Process(const Pipeline::Packet& packet) noexcept;
 
            virtual class Report Report() const noexcept;
 
            Pipeline::State Status() const noexcept;
 
            bool Failed() const noexcept;
 
            const std::optional<std::string>& Error() const noexcept;
 
            virtual std::size_t InputCeiling() const noexcept;
 
        protected:
            FFmpeg(std::shared_ptr<StormByte::Logger::Log> log,
                std::string name, Pipeline::Kinds receives, Pipeline::Kinds produces) noexcept;
 
            void Log(StormByte::Logger::Level level, std::string_view message) noexcept;
 
            void Fail(std::string reason) noexcept;
 
            void Hold(std::uint8_t n) noexcept;
 
            void Release() noexcept;
 
            bool Held() const noexcept;
 
            std::uint8_t HeldFor() const noexcept;
 
            virtual void Eof() noexcept;
 
            virtual void LastChance(const Pipeline::Frame& frame) noexcept;
 
            virtual void LastChance(const Pipeline::Packet& packet) noexcept;
 
            const StormByte::Multimedia::FFmpeg::AVFrame& AVFrame() const noexcept;
 
            const StormByte::Multimedia::FFmpeg::AVPacket& AVPacket() const noexcept;
 
            void Save(StormByte::Multimedia::FFmpeg::AVFrame&& incoming) noexcept;
 
            void Save(StormByte::Multimedia::FFmpeg::AVPacket&& incoming) noexcept;
 
        private:
            class Surface;
 
            void Open() noexcept;
 
            void Work(Pipeline::Item::PointerType item) noexcept;
 
            void Finish() noexcept;
 
            void Park() noexcept;
 
            void CallLastChance() noexcept;
 
            void Emit(Pipeline::Item::PointerType item) noexcept;
 
            void Wait() noexcept;
 
            void Launch() noexcept;
 
            void Halt() noexcept;
 
            void Stop() noexcept;
 
            bool Stopping() const noexcept;
 
            Backend::Pipeline::Host& Face() noexcept;
 
            std::condition_variable& Wake() noexcept;
 
            void CloseHoppers() noexcept;
 
            void RecordWork(std::int64_t microseconds) noexcept;
 
            void DumpWork() noexcept;
 
            std::shared_ptr<StormByte::Logger::Log> m_log;      
            std::string m_name;                                 
            Pipeline::Kinds m_receives;                         
            Pipeline::Kinds m_produces;                         
 
        private:
            std::condition_variable m_wake;                     
            std::unique_ptr<Backend::Pipeline::Pipe> m_pipe;    
 
        protected:
            Backend::Pipeline::Pipe& pipe() noexcept;
 
            const Backend::Pipeline::Pipe& pipe() const noexcept;
 
            std::unique_ptr<Surface> m_surface;                     
            std::unique_ptr<Backend::Pipeline::Pumper> m_pumper;    
            std::mutex m_wait;                                      
            std::optional<std::string> m_error;                     
            bool m_exhausted;                                       
            std::uint64_t m_workN;                                  
            std::int64_t m_workMin;                                 
            std::int64_t m_workMax;                                 
            std::int64_t m_lastWork;                                
            Pipeline::Item::PointerType m_current;                  
            std::deque<Pipeline::Item::PointerType> m_queue;        
            std::uint8_t m_hold;                                    
            std::uint8_t m_heldFor;                                 
    };
 
    class STORMBYTE_MULTIMEDIA_PUBLIC Process: public FFmpeg {
        public:
            Process(const Process& other) = delete;
 
            Process(Process&& other) noexcept = delete;
 
            ~Process() noexcept override = default;
 
            Process& operator=(const Process& other) = delete;
 
            Process& operator=(Process&& other) noexcept = delete;
 
        protected:
            Process(std::shared_ptr<StormByte::Logger::Log> log, std::string name) noexcept;
 
            Process(std::shared_ptr<StormByte::Logger::Log> log, std::string name,
                Pipeline::Kinds receives, Pipeline::Kinds produces) noexcept;
    };
 
    class STORMBYTE_MULTIMEDIA_PUBLIC Packet: public FFmpeg {
        public:
            Packet(const Packet& other) = delete;
 
            Packet(Packet&& other) noexcept = delete;
 
            ~Packet() noexcept override = default;
 
            Packet& operator=(const Packet& other) = delete;
 
            Packet& operator=(Packet&& other) noexcept = delete;
 
        protected:
            Packet(std::shared_ptr<StormByte::Logger::Log> log, std::string name) noexcept;
 
            Packet(std::shared_ptr<StormByte::Logger::Log> log, std::string name,
                Pipeline::Kinds receives, Pipeline::Kinds produces) noexcept;
    };
 
    class STORMBYTE_MULTIMEDIA_PUBLIC Analytics: public FFmpeg {
        public:
            Analytics(const Analytics& other) = delete;
 
            Analytics(Analytics&& other) noexcept = delete;
 
            ~Analytics() noexcept override = default;
 
            Analytics& operator=(const Analytics& other) = delete;
 
            Analytics& operator=(Analytics&& other) noexcept = delete;
 
        protected:
            Analytics(std::shared_ptr<StormByte::Logger::Log> log, std::string name) noexcept;
 
            Analytics(std::shared_ptr<StormByte::Logger::Log> log, std::string name,
                Pipeline::Kinds receives, Pipeline::Kinds produces) noexcept;
 
            void Save(StormByte::Multimedia::FFmpeg::AVFrame&& incoming) noexcept = delete;
 
            void Save(StormByte::Multimedia::FFmpeg::AVPacket&& incoming) noexcept = delete;
 
            void Hold(std::uint8_t n) noexcept = delete;
 
            void Release() noexcept = delete;
 
            bool Held() const noexcept = delete;
 
            std::uint8_t HeldFor() const noexcept = delete;
 
            void LastChance(const Pipeline::Frame& frame) noexcept override {
                (void)frame;
            }
 
            void LastChance(const Pipeline::Packet& packet) noexcept override {
                (void)packet;
            }
    };
}