ffmpeg.hxx

#pragma once
 
#include <Alchemy/exception.hxx>
#include <Alchemy/media/alias.hxx>
#include <StormByte/expected.hxx>
#include <StormByte/multimedia/media/property/tags.hxx>
 
#include <filesystem>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
// Forward declarations
namespace Json { class Value; }
 
namespace Alchemy {
    class ALCHEMY_PUBLIC FFMpeg {
        friend class FFProbe;
        public:
            FFMpeg(const FFMpeg& other)                                                         = default;
 
            FFMpeg(FFMpeg&& other) noexcept                                                     = default;
 
            FFMpeg& operator=(const FFMpeg& other)                                              = default;
 
            FFMpeg& operator=(FFMpeg&& other) noexcept                                          = default;
 
            virtual ~FFMpeg() noexcept                                                          = default;
 
            static StormByte::Expected<FFMpeg, StreamError>                                     FromFile(const std::filesystem::path& path);
 
            Media::Streams&                                                                     Streams() noexcept;
 
            const Media::Streams&                                                               Streams() const noexcept;
 
            const std::filesystem::path&                                                        Path() const noexcept;
 
            static const std::string                                                            Version();
 
            void test(const std::filesystem::path& path) const;
 
        protected:
            std::filesystem::path                                                               m_path;                     
            Media::Streams                                                                      m_streams;                  
 
            FFMpeg(const std::filesystem::path& path) noexcept;
    };
}