/*
|
* 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.
|
*
|
*/
|
#ifndef SRC_RT_TASK_TASK_GRAPH_RTTASKNODEBASE_H_
|
#define SRC_RT_TASK_TASK_GRAPH_RTTASKNODEBASE_H_
|
|
#include "string.h"
|
#include <map>
|
#include <functional>
|
|
#include "rt_header.h"
|
|
#include "RTTaskNodeContext.h"
|
#include "RTTaskNodeContextManager.h"
|
#include "RTTaskNodeOptions.h"
|
#include "RTTaskNodeFactory.h"
|
#include "RTNodeCommon.h"
|
#include "RTStreamInfo.h"
|
|
typedef struct _RTTaskNodeInfo {
|
INT32 nodeId;
|
std::string nodeName;
|
} RTTaskNodeInfo;
|
|
class RTBufferListener;
|
class RTInputStreamHandler;
|
class RTInputStreamManager;
|
class RTOutputStreamHandler;
|
class RTOutputStreamManager;
|
class RTSchedulerQueue;
|
class RTMediaBufferPool;
|
class RTTaskNodeStat;
|
class RTTaskNodeBase {
|
public:
|
RTTaskNodeBase();
|
virtual ~RTTaskNodeBase();
|
|
RT_RET prepareForRun(RtMetaData* options,
|
std::function<void()> sourceNodeOpenedCallback,
|
std::function<void(RTTaskNodeContext *)> scheduleCallback);
|
|
RT_RET cleanupAfterRun();
|
INT32 getID() { return mNodeId; }
|
RtMetaData* getOptions() { return mOptions; }
|
RT_BOOL isSource() const;
|
RT_BOOL isSink() const;
|
RT_BOOL hasMirror(RT_BOOL nodeOnly = RT_FALSE) const;
|
INT32 numInputStreams() const;
|
INT32 numOutputStreams() const;
|
|
RT_RET processNode(RTTaskNodeContext *packet);
|
void nodeOpened();
|
bool closed();
|
RT_RET flush();
|
RT_RET reset();
|
RT_BOOL isDone();
|
RT_RET closeNode();
|
RT_RET closeInputStreams();
|
RT_RET closeOutputStreams();
|
|
void setMaxInputStreamQueueSize(INT32 maxQueueSize);
|
void setMaxBatchPrcoessSize(INT32 maxBatchSize);
|
void setQueueSizeCallbacks(
|
std::function<void(RTInputStreamManager*, bool*)> becomesFullCallback,
|
std::function<void(RTInputStreamManager*, bool*)> becomesNotFullCallback,
|
std::function<void(RTInputStreamManager*, bool*)> becomesEmptyCallback);
|
|
RT_RET initialize(INT32 node_id, RTTaskNodeInfo *nodeInfo) { return RT_OK; }
|
RT_RET initialize(
|
INT32 nodeId,
|
RTTaskNodeInfo *nodeInfo,
|
RTInputStreamManager *inputManager,
|
RTOutputStreamManager *outputManager);
|
RT_RET initialize(INT32 nodeId,
|
RTTaskNodeInfo *nodeInfo,
|
const std::vector<RTInputStreamManager *> &inputManagers,
|
const std::vector<RTOutputStreamManager *> &outputManagers);
|
|
RT_RET addStreamSource(
|
INT32 streamId, RTOutputStreamManager *lastOutputManager);
|
RT_RET addStreamSource(RTOutputStreamManager *lastOutputManager);
|
RT_RET removeStreamSource(RTOutputStreamManager *outputManager);
|
const std::vector<INT32> &getStreamSource() { return mSourceNodes; }
|
|
void checkIfBecameReady();
|
|
RT_BOOL tryToBeginScheduling();
|
void schedulingLoop();
|
void endScheduling();
|
|
// Returns a pointer to the default calculator context that is used for
|
// sequential execution. A source node should always reuse its default
|
// calculator context.
|
RTTaskNodeContext* getDefaultNodeContext() const {
|
return mNodeContextManager.getDefaultNodeContext();
|
}
|
|
RTSchedulerQueue* getSchedulerQueue() const {
|
return mSchedulerQueue;
|
}
|
|
// Sets the scheduler queue the node is assigned to.
|
void setSchedulerQueue(RTSchedulerQueue* queue) {
|
mSchedulerQueue = queue;
|
}
|
|
RT_RET sendInterrupt(std::string reason);
|
RT_RET cancelInterrupt(std::string reason);
|
RT_RET dump();
|
|
RT_RET attachOutStreamPool(RTMediaBufferPool *pool, std::string streamType = RT_NONE);
|
RT_RET detachOutStreamPool(std::string streamType = RT_NONE);
|
|
void setComponentUid(INT32 componentUid);
|
INT32 getComponentUid();
|
|
public:
|
virtual RT_RET open(RTTaskNodeContext *context) = 0;
|
virtual RT_RET process(RTTaskNodeContext *context) = 0;
|
virtual RT_RET close(RTTaskNodeContext *context) = 0;
|
virtual RT_RET invoke(RtMetaData *meta);
|
virtual RT_RET queryStat(RTTaskNodeStat *stat);
|
virtual RT_RET queryStatInternal(RTTaskNodeStat *nodeStat) { return RT_ERR_UNSUPPORT; }
|
|
protected:
|
virtual RT_RET initSupportOptions() { return RT_OK; }
|
virtual RT_RET invokeInternal(RtMetaData *meta) { return RT_ERR_UNSUPPORT; }
|
|
private:
|
RT_RET addInputStreams(RTInputStreamManager *inputManager);
|
RT_RET addOutputStreams(RTOutputStreamManager *outputManager);
|
RT_RET prepareOptionsForRun();
|
RT_RET processPassThrough(RTTaskNodeContext *nodeContext);
|
|
protected:
|
INT32 mNodeId;
|
RTInputStreamHandler *mInputHandler;
|
RTOutputStreamHandler *mOutputHandler;
|
|
RtMutex mMutex;
|
|
INT32 mCurrentInScheduling = 0;
|
INT32 mMaxInScheduling = 1;
|
// SchedulingState incidates the current state of the node scheduling process.
|
// There are four possible transitions:
|
// (a) From kIdle to kScheduling.
|
// Any thread that makes this transition becomes the scheduling thread and
|
// will be responsible for preparing and scheduling all possible invocations.
|
// (b) From kScheduling to kSchedulingPending.
|
// Any thread, except the scheduling thread, can make this transition.
|
// kSchedulingPending indicates that some recent changes require the
|
// scheduling thread to recheck the node readiness after current scheduling
|
// iteration.
|
// (c) From kSchedulingPending to kScheduling.
|
// Made by the scheduling thread to indicate that it has already caught up
|
// with all the recent changes that can affect node readiness.
|
// (d) From kScheduling to kIdle. Made by the scheduling thread when there is
|
// no more scheduling work to be done.
|
enum RTSchedulingState {
|
kIdle = 0, //
|
kScheduling = 1, //
|
kSchedulingPending = 2
|
};
|
RTSchedulingState mSchedulingState = kIdle;
|
RTTaskNodeContextManager mNodeContextManager;
|
RtMetaData *mOptions;
|
std::function<void()> mSourceNodeOpenedCallback;
|
// The status of the current Calculator that this CalculatorNode
|
// is wrapping. kStateActive is currently used only for source nodes.
|
enum RTNodeStatus {
|
kStateUninitialized = 0,
|
kStatePrepared = 1,
|
kStateOpened = 2,
|
kStateActive = 3,
|
kStateClosed = 4
|
};
|
RTNodeStatus mStatus = kStateUninitialized;
|
RTSchedulerQueue *mSchedulerQueue = NULL;
|
std::map<std::string/* name */, RTTaskNodeOption> mSupportOptions;
|
std::vector<INT32> mSourceNodes;
|
std::vector<RTStreamInfo *> mInputStreamInfos;
|
std::vector<RTStreamInfo *> mOutputStreamInfos;
|
RT_BOOL mIsPassThrough;
|
RtReference *mProcRef;
|
INT32 mComponentUid;
|
};
|
|
#endif // SRC_RT_TASK_TASK_GRAPH_RTTASKNODEBASE_H_
|
