You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
135 lines
4.6 KiB
135 lines
4.6 KiB
// Copyright (C) 2020 The Android Open Source Project
|
|
//
|
|
// 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 COMPUTEPIPE_RUNNER_GRAPH_INCLUDE_LOCALPREBUILTGRAPH_H
|
|
#define COMPUTEPIPE_RUNNER_GRAPH_INCLUDE_LOCALPREBUILTGRAPH_H
|
|
|
|
#include <condition_variable>
|
|
#include <functional>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <shared_mutex>
|
|
#include <string>
|
|
#include <thread>
|
|
|
|
#include "ClientConfig.pb.h"
|
|
#include "GrpcPrebuiltGraphService.grpc.pb.h"
|
|
#include "GrpcPrebuiltGraphService.pb.h"
|
|
#include "InputFrame.h"
|
|
#include "Options.pb.h"
|
|
#include "OutputConfig.pb.h"
|
|
#include "PrebuiltEngineInterface.h"
|
|
#include "PrebuiltGraph.h"
|
|
#include "RunnerComponent.h"
|
|
#include "StreamSetObserver.h"
|
|
#include "types/Status.h"
|
|
|
|
namespace android {
|
|
namespace automotive {
|
|
namespace computepipe {
|
|
namespace graph {
|
|
|
|
class GrpcGraph : public PrebuiltGraph, public StreamGraphInterface {
|
|
|
|
public:
|
|
GrpcGraph() {}
|
|
|
|
virtual ~GrpcGraph();
|
|
|
|
Status initialize(const std::string& address,
|
|
std::weak_ptr<PrebuiltEngineInterface> engineInterface);
|
|
|
|
// No copy or move constructors or operators are available.
|
|
GrpcGraph(const GrpcGraph&) = delete;
|
|
GrpcGraph& operator=(const GrpcGraph&) = delete;
|
|
|
|
// Override RunnerComponent interface functions for applying configs,
|
|
// starting the graph and stopping the graph.
|
|
Status handleConfigPhase(const runner::ClientConfig& e) override;
|
|
Status handleExecutionPhase(const runner::RunnerEvent& e) override;
|
|
Status handleStopWithFlushPhase(const runner::RunnerEvent& e) override;
|
|
Status handleStopImmediatePhase(const runner::RunnerEvent& e) override;
|
|
Status handleResetPhase(const runner::RunnerEvent& e) override;
|
|
|
|
PrebuiltGraphType GetGraphType() const override {
|
|
return PrebuiltGraphType::REMOTE;
|
|
}
|
|
|
|
PrebuiltGraphState GetGraphState() const override;
|
|
Status GetStatus() const override;
|
|
std::string GetErrorMessage() const override;
|
|
|
|
// Gets the supported graph config options.
|
|
const proto::Options& GetSupportedGraphConfigs() const override {
|
|
return mGraphConfig;
|
|
}
|
|
|
|
// Sets input stream data. The string is expected to be a serialized proto
|
|
// the definition of which is known to the graph.
|
|
Status SetInputStreamData(int streamIndex, int64_t timestamp,
|
|
const std::string& streamData) override;
|
|
|
|
// Sets pixel data to the specified input stream index.
|
|
Status SetInputStreamPixelData(int streamIndex, int64_t timestamp,
|
|
const runner::InputFrame& inputFrame) override;
|
|
|
|
// Starts graph profiling at some point after starting the graph with profiling enabled.
|
|
Status StartGraphProfiling() override;
|
|
|
|
// Stops graph profiling.
|
|
Status StopGraphProfiling() override;
|
|
|
|
// Collects debugging and profiling information for the graph. The graph
|
|
// needs to be started with debugging enabled in order to get valid info.
|
|
std::string GetDebugInfo() override;
|
|
|
|
// Stream Graph interface
|
|
proto::GrpcGraphService::Stub* getServiceStub() override {
|
|
return mGraphStub.get();
|
|
}
|
|
|
|
void dispatchPixelData(int streamId, int64_t timestamp_us,
|
|
const runner::InputFrame& frame) override;
|
|
|
|
void dispatchSerializedData(int streamId, int64_t timestamp_us,
|
|
std::string&& serialized_data) override;
|
|
|
|
void dispatchGraphTerminationMessage(Status, std::string&&) override;
|
|
private:
|
|
mutable std::mutex mLock;
|
|
|
|
PrebuiltGraphState mGraphState = PrebuiltGraphState::UNINITIALIZED;
|
|
|
|
Status mStatus = Status::SUCCESS;
|
|
|
|
std::string mErrorMessage = "";
|
|
|
|
// Cached callback interface that is passed in from the runner.
|
|
std::weak_ptr<PrebuiltEngineInterface> mEngineInterface;
|
|
|
|
// Cached graph config.
|
|
proto::Options mGraphConfig;
|
|
|
|
std::unique_ptr<proto::GrpcGraphService::Stub> mGraphStub;
|
|
|
|
std::unique_ptr<StreamSetObserver> mStreamSetObserver;
|
|
};
|
|
|
|
} // namespace graph
|
|
} // namespace computepipe
|
|
} // namespace automotive
|
|
} // namespace android
|
|
|
|
#endif // #define COMPUTEPIPE_RUNNER_GRAPH_INCLUDE_LOCALPREBUILTGRAPH_H
|