xref: /OK3568_Linux_fs/external/rockit/tgi/sdk/include/RTTaskGraph.h (revision 4882a59341e53eb6f0b4789bf948001014eff981)

/*
 * Copyright 2020 Rockchip Electronics Co. LTD
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *     author: <rimon.xu@rock-chips.com> and <martin.cheng@rock-chips.com>
 *       date: 2020-04-03
 *     module: RTTaskGraph
 */

#ifndef SRC_RT_TASK_APP_GRAPH_RTTASKGRAPH_H_
#define SRC_RT_TASK_APP_GRAPH_RTTASKGRAPH_H_

#include <vector>
#include <memory>
#include <map>
#include <functional>
#include <stdarg.h>

#include "rt_header.h"
#include "rt_metadata.h"
#include "RTGraphCommon.h"

typedef enum ExecutorMode {
    EXECUTOR_THREAD_POOL,
    EXECUTOR_THREAD_LOCAL,
} RTExecutorMode;

typedef enum GraphCmd {
    GRAPH_CMD_PREPARE = 100,
    GRAPH_CMD_START,
    GRAPH_CMD_STOP,
    GRAPH_CMD_RESUME,
    GRAPH_CMD_PAUSE,
    GRAPH_CMD_FLUSH,
    // for graph private command
    GRAPH_CMD_PRIVATE_CMD,
    // for task node command
    GRAPH_CMD_TASK_NODE_PRIVATE_CMD,
    GRAPH_CMD_MAX,
} RTGraphCmd;

class RTInputStreamManager;
class RTOutputStreamManager;
class RTTaskNode;
class RTGraphInputStream;
class RTGraphOutputStream;
class RTExecutor;
class RTScheduler;
class RTMediaBuffer;
class RTGraphParser;
class RTTaskGraphConfig;
class RTTaskGraphStat;
class RTTaskGraph {
 public:
    explicit RTTaskGraph(const char* tagName);
    explicit RTTaskGraph(UINT64 uid, const char* tagName);
    virtual ~RTTaskGraph();

 public:
    // external common api
    UINT64      getUid();
    std::string getName();
    RT_RET      autoBuild(const char* config, RT_BOOL isFileType = RT_TRUE);
    RT_RET      prepare(RtMetaData *params = RT_NULL);
    RT_RET      start();
    RT_RET      stop(RT_BOOL block = RT_TRUE);
    RT_RET      resume();
    RT_RET      pause(RT_BOOL block = RT_FALSE);
    RT_RET      flush();
    RT_RET      reset();
    RT_RET      release();
    RT_RET      invoke(INT32 cmd, RtMetaData *params);
    RT_RET      waitForObservedOutput(INT64 timeoutUs = -1);
    RT_RET      waitUntilDone(INT64 timeoutUs = -1);
    RT_RET      waitUntilEos(INT64 timeoutUs = -1);
    RT_RET      queryStat(RTTaskGraphStat *stat);
    RT_RET      dump();

    RTCBHandle  observeOutputStream(
                    const std::string streamName,
                    std::function<RT_RET(RTMediaBuffer *)> streamCallback);
    RT_RET      cancelObserveOutputStream(RTCBHandle handle);

 public:
    // deprecated api
    RT_RET      observeOutputStream(const std::string& streamName,
                    INT32 streamId,
                    std::function<RT_RET(RTMediaBuffer *)> streamCallback);
    RT_RET      cancelObserveOutputStream(INT32 streamId);
    RT_RET      addSubGraph(const char *graphConfigFile);
    RT_RET      removeSubGraph(const char *graphConfigFile);
    RT_BOOL     hasMirror(INT32 nodeId, RT_BOOL nodeOnly = RT_FALSE);
    RT_RET      setExternalExecutor(RTExecutor *executor);

 public:
    // external link graph api
    RTLinkHandle addDownGraph(RTTaskGraph *graph, std::string srcName, std::string dstName);
    RT_RET       removeDownGraph(RTLinkHandle handle);
    RT_RET       setGraphOutputStreamAddMode(RTGraphIOStreamMode mode);

 public:
    // external link node api
    RTTaskNode* createNode(std::string nodeConfig, std::string streamConfig);
    RT_RET      linkNode(RTTaskNode *srcNode, RTTaskNode *dstNode);
    template <class T, class... Args>
    RT_RET      linkNode(T src, T dst, Args... rest) {
        return linkMultiNode(src, dst, rest...);
    }
    RT_RET      unlinkNode(RTTaskNode *srcNode, RTTaskNode *dstNode);

    RT_BOOL     hasLinkMode(std::string mode);
    RT_RET      selectLinkMode(std::string mode);
    template <class T, class... Args>
    RT_RET      selectLinkMode(T arg1, T arg2, Args... rest) {
        return selectMultiMode(arg1, arg2, rest...);
    }
    RT_RET      clearLinkShips();

 public:
    // internal api
    void        sendInterrupt(std::string reason);
    RT_BOOL     unthrottleSources();

 protected:
    RT_RET      addPacketToInputStream(std::string streamName, INT64 timeoutUs, RTMediaBuffer *packet);
    RTCBHandle  addOutputStreamPoller(const std::string streamName);
    RT_RET      removeOutputStreamPoller(RTCBHandle handle);
    RT_RET      checkInputStreamFull(std::string streamName);
    virtual RT_RET onReceiveOutputStreams(RTGraphOutputStream *graphOutputStream) { return RT_OK; }

 private:
    template <class T, class... Args>
    RT_RET      linkMultiNode(T src, T dst, Args... rest) {
        RT_RET ret = linkNode(src, dst);
        if (ret != RT_OK) {
            RT_LOGE("src node %d dst node %d link failed", src->getID(), dst->getID());
        } else {
            linkMultiNode(dst, rest...);
        }
        return ret;
    }

    template <class T>
    RT_RET      linkMultiNode(T end) {
        return RT_OK;
    }

    template <class T, class... Args>
    RT_RET      selectMultiMode(T arg1, T arg2, Args... rest) {
        RT_RET ret = selectLinkMode(arg1);
        if (ret != RT_OK) {
            RT_LOGE("select mode %s failed", arg1);
        } else {
            selectMultiMode(arg2, rest...);
        }
        return ret;
    }

    template <class T>
    RT_RET      selectMultiMode(T end) {
        RT_RET ret = selectLinkMode(end);
        if (ret != RT_OK) {
            RT_LOGE("select mode %s failed", end);
        }
        return ret;
    }

 private:
    RT_RET      autoLinkSource();
    RT_RET      autoUnlinkSource(INT32 nodeId);
    RT_RET      prepareForRun(RtMetaData *options);
    RT_RET      prepareNodeForRun(RTTaskNode *node, RtMetaData *options);
    RT_RET      cleanupAfterRun();
    void        updateThrottledNodes(RTInputStreamManager* stream, bool *streamWasFull);
    void        updateThrottledNodesNoLock(RTInputStreamManager* stream, bool *streamWasFull);
    RT_RET      buildTaskNode(INT32 pipeId, INT32 nodeId, RTGraphParser* nodeParser);
    RT_RET      buildExecutors(RTGraphParser *parser);
    RT_RET      buildNodes(RTGraphParser *parser);
    RT_RET      buildLinkModes(RTGraphParser *parser);
    RT_RET      buildSubGraph(RTGraphParser *graphParser);
    RT_RET      notifyOutputStreams(RTGraphOutputStream *graphOutputStream);
    RTTaskNode *createNodeByText(const char *graphConfig);
    std::vector<std::vector<INT32>> parseLinkShip(std::string linkShip);
    RT_RET      linkNode(INT32 srcNodeId, INT32 dstNodeId);
    RT_RET      unlinkNode(INT32 srcNodeId, INT32 dstNodeId);

    RT_RET      setupGraphInputStream(std::string streamName);

 protected:
    UINT64               mGraphUid;
    std::string          mTagName;
    RT_BOOL              mHasError;
    RtMutex              mFullInputStreamsMutex;
    RtMutex              mErrorMutex;
    RTScheduler         *mScheduler;
    RtMutex             *mLock;
    RTTaskGraphConfig   *mGraphConfig;
    RTGraphIOStreamMode  mIoStreamMode;
    INT32                mThreadNum;
    std::map<INT32, RTExecutor *>                         mExecutors;
    RTExecutor                                           *mExtExecutor;
    std::map<INT32/* node id */, RTTaskNode *>            mNodes;
    std::map<INT32, std::vector<RTInputStreamManager *>>  mFullInputStreams;
    std::map<INT32/* node id */, RTInputStreamManager *>  mInputManagers;
    std::map<INT32/* node id */, RTOutputStreamManager *> mOutputManagers;
    // The graph output streams.
    std::map<INT32, RTGraphOutputStream *>                mGraphOutputStreams;
    std::map<INT32, RTGraphInputStream *>                 mGraphInputStreams;
    // Maps graph input streams to their virtual node ids.
    std::map<std::string, INT32>                          mGraphInputStreamIds;
    std::map<std::string, std::string>                    mLinkShips;
    std::vector<std::string>                              mLinkModes;
    // Compatible with old interfaces
    std::map<INT32/* old stream id */, std::string>       mOutputStreamCompMaps;
    std::map<INT32/* old stream id */, RTCBHandle>        mGraphOutCompMaps;
};

#endif  // SRC_RT_TASK_APP_GRAPH_RTTASKGRAPH_H_