processing_module_interface.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2022 Intel Corporation. All rights reserved.
 */
 
#ifndef _ADSP_PROCESSING_MODULE_INTERFACE_H_
#define _ADSP_PROCESSING_MODULE_INTERFACE_H_
 
#include "system_error.h"
 
#include <stdint.h>
#include <stddef.h>
 
namespace intel_adsp
{
    struct ProcessingMode {
        enum Enum {
            NORMAL = 0,
            BYPASS  
        };

        typedef int Type;

        ProcessingMode(void)
            :   value_(NORMAL)
        {}

        ProcessingMode(Enum mode_value)
            :   value_(mode_value)
        {}

        operator Enum(void)
        {
            return (Enum) value_;
        }
 
    private:
        Type value_;
    };

    struct InputStreamFlags {
        bool end_of_stream : 1;
    };

    struct InputStreamBuffer {
        InputStreamBuffer() : data(), size(), flags() {}
        InputStreamBuffer(uint8_t *_data, size_t _size,
        InputStreamFlags _flags) : data(_data), size(_size), flags(_flags) {}
        uint8_t *const data; 
        size_t size;
        const InputStreamFlags flags; 
    };

    struct OutputStreamBuffer {
        OutputStreamBuffer() : data(), size() {}
        OutputStreamBuffer(uint8_t *_data, size_t _size) : data(_data), size(_size) {}
        uint8_t *const data; 
        size_t size;
    };

    struct ConfigurationFragmentPosition {
        enum Enum {
            MIDDLE = 0,
            FIRST = 1,
            LAST = 2,
            SINGLE = 3
        };

        typedef int Type;

        ConfigurationFragmentPosition(Enum mode_value)
            :   value_(mode_value)
        {}

        operator Enum(void)
        {
            return (Enum) value_;
        }
 
    private:
        Type value_;
    };

    class ProcessingModuleInterface
    {
    public:
        struct ErrorCode : intel_adsp::ErrorCode {
            enum Enum {
                INVALID_CONFIGURATION = intel_adsp::ErrorCode::MaxValue + 1,
                NO_CONFIGURATION
            };

            static Enum const MinValue = INVALID_CONFIGURATION;
            static Enum const MaxValue = NO_CONFIGURATION;

            explicit ErrorCode(Type value)
                :   intel_adsp::ErrorCode(value)
            {}
        };

        virtual ErrorCode::Type Init(void) = 0;
        virtual ErrorCode::Type Delete(void) = 0;

        virtual uint32_t Process(
            InputStreamBuffer * input_stream_buffers,
            OutputStreamBuffer * output_stream_buffers
        ) = 0;
        virtual void Reset(void) = 0;

        virtual void SetProcessingMode(ProcessingMode mode) = 0;
        virtual ProcessingMode GetProcessingMode(void) = 0;
        virtual ErrorCode::Type SetConfiguration(
                uint32_t config_id,
                ConfigurationFragmentPosition fragment_position,
                uint32_t data_offset_size,
                const uint8_t *fragment_buffer,
                size_t fragment_size,
                uint8_t *response,
                size_t & response_size
 
            ) = 0;
        virtual ErrorCode::Type GetConfiguration(
                uint32_t config_id,
                ConfigurationFragmentPosition fragment_position,
                uint32_t & data_offset_size,
                uint8_t *fragment_buffer,
                size_t & fragment_size
            ) = 0;
    };

 
    class DetectorModuleInterface : public ProcessingModuleInterface
    {
    public:

        typedef enum {
            PROCESSING = 0,
            IDLE = 1,
        } State;

        virtual State GetState(void) = 0;

        virtual uint64_t GetIdlePeriod(void) = 0;

        virtual void OnStreamState(uint64_t counter,
                    uint32_t stream_index,
                    State state) = 0;
    };
} /*namespace intel_adsp */
 
#endif /* #ifndef _ADSP_PROCESSING_MODULE_INTERFACE_H_ */