mediaiofactory.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/error.h>
#include <promeki/list.h>
#include <promeki/mediaconfig.h>
#include <promeki/mediadesc.h>
#include <promeki/metadata.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/stringlist.h>
#include <promeki/url.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class IODevice;
class MediaIO;
class ObjectBase;
 
#define PROMEKI_REGISTER_MEDIAIO_FACTORY(FactoryClass)                                                                 \
        [[maybe_unused]] static int PROMEKI_CONCAT(__promeki_mediaio_factory_, PROMEKI_UNIQUE_ID) =                    \
                MediaIOFactory::registerFactory(new FactoryClass());
 
class MediaIOFactory {
        public:
                using Config = MediaConfig;
 
                virtual ~MediaIOFactory() = default;
 
                // ---- Identity ----
 
                virtual String name() const = 0;
 
                virtual String displayName() const { return name(); }
 
                virtual String description() const { return String(); }
 
                // ---- Discovery surfaces ----
 
                virtual StringList extensions() const { return StringList(); }
 
                virtual StringList schemes() const { return StringList(); }
 
                virtual bool canHandlePath(const String &path) const {
                        (void)path;
                        return false;
                }
 
                virtual bool canHandleDevice(IODevice *device) const {
                        (void)device;
                        return false;
                }
 
                virtual StringList enumerate() const { return StringList(); }
 
                // ---- Role flags ----
 
                virtual bool canBeSource() const { return false; }
 
                virtual bool canBeSink() const { return false; }
 
                virtual bool canBeTransform() const { return false; }
 
                virtual bool isFallback() const { return false; }
 
                // ---- Configuration ----
 
                virtual Config::SpecMap configSpecs() const { return Config::SpecMap(); }
 
                virtual Metadata defaultMetadata() const { return Metadata(); }
 
                virtual Error urlToConfig(const Url &url, Config *outConfig) const {
                        (void)url;
                        (void)outConfig;
                        return Error::NotSupported;
                }
 
                virtual bool bridge(const MediaDesc &from, const MediaDesc &to, Config *outConfig,
                                    int *outCost) const {
                        (void)from;
                        (void)to;
                        (void)outConfig;
                        (void)outCost;
                        return false;
                }
 
                // ---- Device introspection ----
 
                virtual List<MediaDesc> queryDevice(const Config &config) const {
                        (void)config;
                        return List<MediaDesc>();
                }
 
                virtual void printDeviceInfo(const Config &config) const { (void)config; }
 
                // ---- Construction ----
 
                virtual MediaIO *create(const Config &config, ObjectBase *parent = nullptr) const = 0;
 
                // ---- Static registry ----
 
                static int registerFactory(MediaIOFactory *factory);
 
                static const List<MediaIOFactory *> &registeredFactories();
 
                static const MediaIOFactory *findByName(const String &name);
 
                static const MediaIOFactory *findByExtension(const String &extension);
 
                static const MediaIOFactory *findByScheme(const String &scheme);
 
                static const MediaIOFactory *findForPath(const String &path);
 
                // ---- Registry-introspection convenience statics ----
                //
                // Each of the following is a thin wrapper around
                // findByName(typeName)->...; they exist so callers can
                // query backend metadata by string name without first
                // resolving the factory pointer themselves.  All return
                // an empty / default value when the named backend is
                // not registered.
 
                static Config defaultConfig(const String &typeName);
 
                static Config::SpecMap configSpecs(const String &typeName);
 
                static Metadata defaultMetadata(const String &typeName);
 
                static StringList enumerate(const String &typeName);
 
                static List<MediaDesc> queryDevice(const String &typeName, const Config &config);
 
                static void printDeviceInfo(const String &typeName, const Config &config);
 
                enum class ConfigValidation {
                        Lenient, 
                        Strict   
                };
 
                static StringList unknownConfigKeys(const String &typeName, const Config &cfg);
 
                static Error validateConfigKeys(const String &typeName, const Config &cfg, ConfigValidation mode,
                                                const String &contextLabel = String());
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV