Embedded_AI/include/AsyncProcessor.h

#pragma once

#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <map>
#include <atomic>

#include "Common.h"
#include "Request.h"
// #include "ResourceKit.h"


struct PreProcessedCache
{
    // unsigned char *preProcessedImg;
    // unsigned char *preProcessedMaxImg;
    std::shared_ptr<unsigned char> preProcessedMaxImg;
    int preProcessedImgSize;
    float scaleInfo;         ///< 缩放因子
    int srcWidth, srcHeight; ///< 媒体流的宽高
};

struct InferedCache
{
    // int8_t *inferedMaxTotalensor;
    #ifdef EEASY_CHIP
    std::shared_ptr<int8_t> inferedMaxTotalensor;
    std::vector<signed char *> inferedTensor;
    #elif AXERA_CHIP
    std::shared_ptr<float_t> inferedMaxTotalensor;
    std::vector<float *> inferedTensor;
    #endif

    // std::vector<std::shared_ptr<signed char> > inferedTensor;

    // std::vector<vx_size[4]> outputDataDims;     ///< 输出数据的维度
    std::vector<std::array<size_t, 4>> outputDataDims; ///< 输出数据的维度

    int32_t dataType[5];     ///< 数据类型数组
    int floatingPoint[5];    ///< 浮点数位数数组
    unsigned int strides[5]; ///< 步长数组

    std::vector<std::string> classNames; ///< 类别名称数组

    PreProcessedCache preProcessedCache;
};

class AsyncProcessor
{
public:
    // AsynProcessor();
    // ~AsynProcessor()
    // {
    //     // cleanup(); // 在对象销毁时执行清理操作
    // }

    int initialize(const ResourceKit resourceKit);
    int setCache(unsigned long  maxPreprocessDstImageSize,unsigned long  maxInferedTensorTotalSize);
    void cleanup();
    int createRequest(const frame_t data, const ResourceKit resourceKit, std::vector<std::tuple<int, std::vector<int>>> inferResource);
    void wait(int requestId);
    Result getResult(int requestId);

private:
    int nextRequestId = 0; 
    void processUnit(int unit);
    void process(Request &request, int unit);
    void distribution(Request &request);

    // 预处理后结果缓存
    PreProcessedCache preProcessedCache;
    std::mutex mutex_preProcessedImg;

    // 推理后结果缓存
    InferedCache inferedCache;
    std::mutex mutex_infered;

    // 后处理需要用到的变量
    // PostProcessedCache postProcessedCache;

    // ai处理的三个线程
    std::vector<std::thread> aiThreads;

    // 未处理队列
    std::vector<std::queue<Request>> unprocessedQueues;
    // 未处理队列锁
    std::mutex mutex_unprocessedQueues;
    // 已经有结果的队列
    std::mutex mutex_processedRequests;
    // 未有结果的队列
    std::map<int, Result> processedRequests;

    std::condition_variable condition;
    std::condition_variable conditionProcessed;

    std::atomic<bool> stopProcessing;
};