module_initial_settings.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2022 Intel Corporation. All rights reserved.
 */
 
#ifndef _ADSP_MODULE_INITIAL_SETTINGS_H_
#define _ADSP_MODULE_INITIAL_SETTINGS_H_
 
#include "adsp_stddef.h"
#include "fixed_array.h"
#include <ipc4/base-config.h>
 
/* Mapping of IPC4 definitions into IADK naming counterpart */
typedef struct ipc4_base_module_cfg BaseModuleCfg;
typedef struct ipc4_base_module_cfg LegacyModuleInitialSettings;
typedef struct ipc4_input_pin_format InputPinFormat;
typedef struct ipc4_output_pin_format OutputPinFormat;
typedef struct ipc4_audio_format AudioFormat;
 
#define INPUT_PIN_COUNT     (1 << 3)
#define OUTPUT_PIN_COUNT    (1 << 3)
 
namespace intel_adsp
{
    enum ModuleInitialSettingsKey {
        LEGACY_STRUCT = 0,
        IN_PINS_FORMAT,
        OUT_PINS_FORMAT
    };

    template < ModuleInitialSettingsKey KEY > struct ModuleInitialSettingsItem
    {
        typedef void ValueType;
    };

    struct ModuleInitialSettingsInterface {
        virtual void const *GetUntypedItem(ModuleInitialSettingsKey key,
                           size_t & length) = 0;
    };
 
    namespace system
    { class SystemAgent; }

    class ModuleInitialSettings
    {
        template < class DERIVED, class PROCESSING_MODULE >
                friend class ProcessingModuleFactory;
                friend class system::SystemAgent;
 
    public:
        template < class VALUE >
        struct Array : public FixedArray < VALUE >
        {
            friend class ModuleInitialSettings;
            typedef VALUE ValueType;

        explicit Array(ValueType *array, size_t length) :
                FixedArray < ValueType > (array, length)
        {}
 
        private:
            Array(Array < ValueType > const &);

            Array < ValueType > &operator = (Array < ValueType > const &);
        };

        typedef ModuleInitialSettingsKey Key;

        explicit ModuleInitialSettings(ModuleInitialSettingsInterface & performer) :
            performer_(performer)
        {}

        template < Key key >
        const Array < typename ModuleInitialSettingsItem < key >
                    :: ValueType const > GetItem()
        {
            size_t length;
 
            return Array < typename ModuleInitialSettingsItem < key >
                    :: ValueType const > (
            reinterpret_cast < typename ModuleInitialSettingsItem < key >
                    :: ValueType const *>
                    (performer_.GetUntypedItem(key, length)), length);
        }
 
    private:
        ModuleInitialSettings(ModuleInitialSettings const &src) :
                performer_(src.performer_) { }
        ModuleInitialSettings operator = (ModuleInitialSettings const &src);
 
        ModuleInitialSettingsInterface & performer_;
    };

    template < > struct ModuleInitialSettingsItem < LEGACY_STRUCT >
    {
        typedef LegacyModuleInitialSettings ValueType;
    };

    template < > struct ModuleInitialSettingsItem < IN_PINS_FORMAT >
    {
        typedef InputPinFormat ValueType;
    };

    template < > struct ModuleInitialSettingsItem < OUT_PINS_FORMAT >
    {
        typedef OutputPinFormat ValueType;
    };
 
} /*namespace intel_adsp */
 
#endif /* #ifndef _ADSP_MODULE_INITIAL_SETTINGS_H_ */