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/plan.hxx>
#include <StormByte/multimedia/pipeline/typedefs.hxx>
#include <StormByte/multimedia/type.hxx>
#include <StormByte/multimedia/visibility.h>
 
#include <atomic>
#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 ProcessTwoPasses;

    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;
        friend class ProcessTwoPasses;
 
        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;

            bool MeasuringTwoPass() const 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;                                 
            std::shared_ptr<const Pipeline::Plan> m_plan;           
            int m_origin;                                           
    };

    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 ProcessTwoPasses: public Process {
        friend class StormByte::Multimedia::Pipeline::Filters;
        friend class FFmpeg;
 
        public:
            ProcessTwoPasses(const ProcessTwoPasses& other) = delete;

            ProcessTwoPasses(ProcessTwoPasses&& other) noexcept = delete;

            ~ProcessTwoPasses() noexcept override = default;

            ProcessTwoPasses& operator=(const ProcessTwoPasses& other) = delete;

            ProcessTwoPasses& operator=(ProcessTwoPasses&& other) noexcept = delete;
 
        protected:
            ProcessTwoPasses(std::shared_ptr<StormByte::Logger::Log> log, std::string name) noexcept;

            ProcessTwoPasses(std::shared_ptr<StormByte::Logger::Log> log, std::string name,
                Pipeline::Kinds receives, Pipeline::Kinds produces) noexcept;

            bool Measuring() const noexcept;

            virtual void Measure(const Pipeline::Frame& frame) noexcept = 0;

            virtual void Measured() noexcept;
 
        private:
            void EnterMeasure() noexcept;

            void LeaveMeasure() noexcept;

            void BindMeasure(StormByte::Multimedia::Pipeline::Filters* owner) noexcept;

            void MeasureSourceClosed() noexcept;

            void DrainMeasure() noexcept;
 
            bool m_measuring = false;   
            std::atomic<bool> m_measureClosed{false};   
            std::atomic<bool> m_measureDrained{false};  
            StormByte::Multimedia::Pipeline::Filters* m_measureOwner = nullptr; 
    };

    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;
            }
    };
}