computepipe/runner/graph/LocalPrebuiltGraph.cpp - platform/packages/services/Car - Git at Google

 // 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.

 #include "LocalPrebuiltGraph.h"

 #include <android-base/logging.h>
 #include <dlfcn.h>

 #include <functional>
 #include <iostream>
 #include <mutex>
 #include <shared_mutex>
 #include <string>
 #include <vector>

 #include "ClientConfig.pb.h"
 #include "InputFrame.h"
 #include "PrebuiltGraph.h"
 #include "RunnerComponent.h"
 #include "prebuilt_interface.h"
 #include "types/Status.h"

 namespace android {
 namespace automotive {
 namespace computepipe {
 namespace graph {

 #define LOAD_FUNCTION(name)                                                        \
     {                                                                              \
         std::string func_name = std::string("PrebuiltComputepipeRunner_") + #name; \
         mPrebuiltGraphInstance->mFn##name =                                        \
                 dlsym(mPrebuiltGraphInstance->mHandle, func_name.c_str());         \
         if (mPrebuiltGraphInstance->mFn##name == nullptr) {                        \
             initialized = false;                                                   \
             LOG(ERROR) << std::string(dlerror()) << std::endl;                     \
         }                                                                          \
     }

 std::mutex LocalPrebuiltGraph::mCreationMutex;
 LocalPrebuiltGraph* LocalPrebuiltGraph::mPrebuiltGraphInstance = nullptr;

 // Function to confirm that there would be no further changes to the graph configuration. This
 // needs to be called before starting the graph.
 Status LocalPrebuiltGraph::handleConfigPhase(const runner::ClientConfig& e) {
     if (mGraphState.load() == PrebuiltGraphState::UNINITIALIZED) {
         return Status::ILLEGAL_STATE;
     }

     // handleConfigPhase is a blocking call, so abort call is pointless for this RunnerEvent.
     if (e.isAborted()) {
         return Status::INVALID_ARGUMENT;
     } else if (e.isTransitionComplete()) {
         return Status::SUCCESS;
     }

     std::string config = e.getSerializedClientConfig();
     auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)(const unsigned char*,
                                                             size_t))mFnUpdateGraphConfig;
     PrebuiltComputepipeRunner_ErrorCode errorCode =
             mappedFn(reinterpret_cast<const unsigned char*>(config.c_str()), config.length());
     if (errorCode != PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
         return static_cast<Status>(static_cast<int>(errorCode));
     }

     // Set the pixel stream callback function. The same function will be called for all requested
     // pixel output streams.
     if (mEngineInterface.lock() != nullptr) {
         auto pixelCallbackFn = (PrebuiltComputepipeRunner_ErrorCode(*)(
                 void (*)(void* cookie, int, int64_t, const uint8_t* pixels, int width, int height,
                          int step, int format)))mFnSetOutputPixelStreamCallback;
         PrebuiltComputepipeRunner_ErrorCode errorCode =
                 pixelCallbackFn(LocalPrebuiltGraph::OutputPixelStreamCallbackFunction);
         if (errorCode != PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
             return static_cast<Status>(static_cast<int>(errorCode));
         }

         // Set the serialized stream callback function. The same callback function will be invoked
         // for all requested serialized output streams.
         auto streamCallbackFn = (PrebuiltComputepipeRunner_ErrorCode(*)(
                 void (*)(void* cookie, int, int64_t, const unsigned char*,
                          size_t)))mFnSetOutputStreamCallback;
         errorCode = streamCallbackFn(LocalPrebuiltGraph::OutputStreamCallbackFunction);
         if (errorCode != PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
             return static_cast<Status>(static_cast<int>(errorCode));
         }

         // Set the callback function for when the graph terminates.
         auto terminationCallback = (PrebuiltComputepipeRunner_ErrorCode(*)(
                 void (*)(void* cookie, const unsigned char*,
                          size_t)))mFnSetGraphTerminationCallback;
         errorCode = terminationCallback(LocalPrebuiltGraph::GraphTerminationCallbackFunction);
         if (errorCode != PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
             return static_cast<Status>(static_cast<int>(errorCode));
         }
     }

     return Status::SUCCESS;
 }

 // Starts the graph.
 Status LocalPrebuiltGraph::handleExecutionPhase(const runner::RunnerEvent& e) {
     if (mGraphState.load() != PrebuiltGraphState::STOPPED) {
         return Status::ILLEGAL_STATE;
     }

     if (e.isAborted()) {
         // Starting the graph is a blocking call and cannot be aborted in between.
         return Status::INVALID_ARGUMENT;
     } else if (e.isTransitionComplete()) {
         return Status::SUCCESS;
     }

     auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)(void*))mFnStartGraphExecution;
     PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn(reinterpret_cast<void*>(this));
     if (errorCode == PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
         mGraphState.store(PrebuiltGraphState::RUNNING);
     }
     return static_cast<Status>(static_cast<int>(errorCode));
 }

 // Stops the graph while letting the graph flush output packets in flight.
 Status LocalPrebuiltGraph::handleStopWithFlushPhase(const runner::RunnerEvent& e) {
     if (mGraphState.load() != PrebuiltGraphState::RUNNING) {
         return Status::ILLEGAL_STATE;
     }

     if (e.isAborted()) {
         return Status::INVALID_ARGUMENT;
     } else if (e.isTransitionComplete()) {
         return Status::SUCCESS;
     }

     return StopGraphExecution(/* flushOutputFrames = */ true);
 }

 // Stops the graph and cancels all the output packets.
 Status LocalPrebuiltGraph::handleStopImmediatePhase(const runner::RunnerEvent& e) {
     if (mGraphState.load() != PrebuiltGraphState::RUNNING) {
         return Status::ILLEGAL_STATE;
     }

     if (e.isAborted()) {
         return Status::INVALID_ARGUMENT;
     } else if (e.isTransitionComplete()) {
         return Status::SUCCESS;
     }

     return StopGraphExecution(/* flushOutputFrames = */ false);
 }

 Status LocalPrebuiltGraph::handleResetPhase(const runner::RunnerEvent& e) {
     if (mGraphState.load() != PrebuiltGraphState::STOPPED) {
         return Status::ILLEGAL_STATE;
     }

     if (e.isAborted()) {
         return Status::INVALID_ARGUMENT;
     } else if (e.isTransitionComplete()) {
         return Status::SUCCESS;
     }

     auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)())mFnResetGraph;
     mappedFn();
     return Status::SUCCESS;
 }

 LocalPrebuiltGraph* LocalPrebuiltGraph::GetPrebuiltGraphFromLibrary(
         const std::string& prebuilt_library,
         std::weak_ptr<PrebuiltEngineInterface> engineInterface) {
     std::unique_lock<std::mutex> lock(LocalPrebuiltGraph::mCreationMutex);
     if (mPrebuiltGraphInstance != nullptr) {
         mPrebuiltGraphInstance = new LocalPrebuiltGraph();
     }
     if (mPrebuiltGraphInstance->mGraphState.load() != PrebuiltGraphState::UNINITIALIZED) {
         return mPrebuiltGraphInstance;
     }
     mPrebuiltGraphInstance->mHandle = dlopen(prebuilt_library.c_str(), RTLD_NOW);

     if (mPrebuiltGraphInstance->mHandle) {
         bool initialized = true;

         // Load config and version number first.
         const unsigned char* (*getVersionFn)() =
                 (const unsigned char* (*)())dlsym(mPrebuiltGraphInstance->mHandle,
                                                   "PrebuiltComputepipeRunner_GetVersion");
         if (getVersionFn != nullptr) {
             mPrebuiltGraphInstance->mGraphVersion =
                     std::string(reinterpret_cast<const char*>(getVersionFn()));
         } else {
             LOG(ERROR) << std::string(dlerror());
             initialized = false;
         }

         void (*getSupportedGraphConfigsFn)(const void**, size_t*) =
                 (void (*)(const void**,
                           size_t*))dlsym(mPrebuiltGraphInstance->mHandle,
                                          "PrebuiltComputepipeRunner_GetSupportedGraphConfigs");
         if (getSupportedGraphConfigsFn != nullptr) {
             size_t graphConfigSize;
             const void* graphConfig;

             getSupportedGraphConfigsFn(&graphConfig, &graphConfigSize);

             if (graphConfigSize > 0) {
                 initialized &= mPrebuiltGraphInstance->mGraphConfig.ParseFromString(
                         std::string(reinterpret_cast<const char*>(graphConfig), graphConfigSize));
             }
         } else {
             LOG(ERROR) << std::string(dlerror());
             initialized = false;
         }

         // Null callback interface is not acceptable.
         if (initialized && engineInterface.lock() == nullptr) {
             initialized = false;
         }

         LOAD_FUNCTION(GetErrorCode);
         LOAD_FUNCTION(GetErrorMessage);
         LOAD_FUNCTION(ResetGraph);
         LOAD_FUNCTION(UpdateGraphConfig);
         LOAD_FUNCTION(SetInputStreamData);
         LOAD_FUNCTION(SetInputStreamPixelData);
         LOAD_FUNCTION(SetOutputStreamCallback);
         LOAD_FUNCTION(SetOutputPixelStreamCallback);
         LOAD_FUNCTION(SetGraphTerminationCallback);
         LOAD_FUNCTION(StartGraphExecution);
         LOAD_FUNCTION(StopGraphExecution);
         LOAD_FUNCTION(StartGraphProfiling);
         LOAD_FUNCTION(StopGraphProfiling);
         LOAD_FUNCTION(GetDebugInfo);

         // This is the only way to create this object and there is already a
         // lock around object creation, so no need to hold the graphState lock
         // here.
         if (initialized) {
             mPrebuiltGraphInstance->mGraphState.store(PrebuiltGraphState::STOPPED);
             mPrebuiltGraphInstance->mEngineInterface = engineInterface;
         }
     }

     return mPrebuiltGraphInstance;
 }

 LocalPrebuiltGraph::~LocalPrebuiltGraph() {
     if (mHandle) {
         dlclose(mHandle);
     }
 }

 Status LocalPrebuiltGraph::GetStatus() const {
     if (mGraphState.load() == PrebuiltGraphState::UNINITIALIZED) {
         return Status::ILLEGAL_STATE;
     }

     auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)())mFnGetErrorCode;
     PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn();
     return static_cast<Status>(static_cast<int>(errorCode));
 }

 std::string LocalPrebuiltGraph::GetErrorMessage() const {
     if (mGraphState.load() == PrebuiltGraphState::UNINITIALIZED) {
         return "Graph has not been initialized";
     }
     auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)(unsigned char*, size_t,
                                                             size_t*))mFnGetErrorMessage;
     size_t errorMessageSize = 0;

     PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn(nullptr, 0, &errorMessageSize);
     std::vector<unsigned char> errorMessage(errorMessageSize);

     errorCode = mappedFn(&errorMessage[0], errorMessage.size(), &errorMessageSize);
     if (errorCode != PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
         return "Unable to get error message from the graph.";
     }

     return std::string(reinterpret_cast<char*>(&errorMessage[0]),
                        reinterpret_cast<char*>(&errorMessage[0]) + errorMessage.size());
 }

 Status LocalPrebuiltGraph::SetInputStreamData(int streamIndex, int64_t timestamp,
                                               const std::string& streamData) {
     if (mGraphState.load() == PrebuiltGraphState::UNINITIALIZED) {
         return Status::ILLEGAL_STATE;
     }
     auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)(int, int64_t, const unsigned char*,
                                                             size_t))mFnSetInputStreamData;
     PrebuiltComputepipeRunner_ErrorCode errorCode =
             mappedFn(streamIndex, timestamp,
                      reinterpret_cast<const unsigned char*>(streamData.c_str()),
                      streamData.length());
     return static_cast<Status>(static_cast<int>(errorCode));
 }

 Status LocalPrebuiltGraph::SetInputStreamPixelData(int streamIndex, int64_t timestamp,
                                                    const runner::InputFrame& inputFrame) {
     if (mGraphState.load() == PrebuiltGraphState::UNINITIALIZED) {
         return Status::ILLEGAL_STATE;
     }

     auto mappedFn =
             (PrebuiltComputepipeRunner_ErrorCode(*)(int, int64_t, const uint8_t*, int, int, int,
                                                     PrebuiltComputepipeRunner_PixelDataFormat))
                     mFnSetInputStreamPixelData;
     PrebuiltComputepipeRunner_ErrorCode errorCode =
             mappedFn(streamIndex, timestamp, inputFrame.getFramePtr(),
                      inputFrame.getFrameInfo().width, inputFrame.getFrameInfo().height,
                      inputFrame.getFrameInfo().stride,
                      static_cast<PrebuiltComputepipeRunner_PixelDataFormat>(
                              static_cast<int>(inputFrame.getFrameInfo().format)));
     return static_cast<Status>(static_cast<int>(errorCode));
 }

 Status LocalPrebuiltGraph::StopGraphExecution(bool flushOutputFrames) {
     auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)(bool))mFnStopGraphExecution;
     PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn(flushOutputFrames);
     if (errorCode == PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
         mGraphState.store(flushOutputFrames ? PrebuiltGraphState::FLUSHING
                                             : PrebuiltGraphState::STOPPED);
     }
     return static_cast<Status>(static_cast<int>(errorCode));
 }

 Status LocalPrebuiltGraph::StartGraphProfiling() {
     auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)())mFnStartGraphProfiling;
     PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn();
     return static_cast<Status>(static_cast<int>(errorCode));
 }

 Status LocalPrebuiltGraph::StopGraphProfiling() {
     auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)())mFnStopGraphProfiling;
     PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn();
     return static_cast<Status>(static_cast<int>(errorCode));
 }

 std::string LocalPrebuiltGraph::GetDebugInfo() {
     if (mGraphState.load() == PrebuiltGraphState::UNINITIALIZED) {
         return "";
     }
     auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)(unsigned char*, size_t,
                                                             size_t*))mFnGetDebugInfo;

     size_t debugInfoSize = 0;
     PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn(nullptr, 0, &debugInfoSize);
     std::vector<unsigned char> debugInfo(debugInfoSize);

     errorCode = mappedFn(&debugInfo[0], debugInfo.size(), &debugInfoSize);
     if (errorCode != PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
         return "";
     }

     return std::string(reinterpret_cast<char*>(&debugInfo[0]),
                        reinterpret_cast<char*>(&debugInfo[0]) + debugInfo.size());
 }

 void LocalPrebuiltGraph::OutputStreamCallbackFunction(void* cookie, int streamIndex,
                                                       int64_t timestamp, const unsigned char* data,
                                                       size_t data_size) {
     LocalPrebuiltGraph* graph = reinterpret_cast<LocalPrebuiltGraph*>(cookie);
     CHECK(graph);
     std::shared_ptr<PrebuiltEngineInterface> engineInterface = graph->mEngineInterface.lock();
     if (engineInterface != nullptr) {
         engineInterface->DispatchSerializedData(streamIndex, timestamp,
                                                 std::string(data, data + data_size));
     }
 }

 void LocalPrebuiltGraph::OutputPixelStreamCallbackFunction(void* cookie, int streamIndex,
                                                            int64_t timestamp, const uint8_t* pixels,
                                                            int width, int height, int step,
                                                            int format) {
     LocalPrebuiltGraph* graph = reinterpret_cast<LocalPrebuiltGraph*>(cookie);
     CHECK(graph);
     std::shared_ptr<PrebuiltEngineInterface> engineInterface = graph->mEngineInterface.lock();

     if (engineInterface) {
         runner::InputFrame frame(height, width, static_cast<PixelFormat>(format), step, pixels);
         engineInterface->DispatchPixelData(streamIndex, timestamp, frame);
     }
 }

 void LocalPrebuiltGraph::GraphTerminationCallbackFunction(void* cookie,
                                                           const unsigned char* termination_message,
                                                           size_t termination_message_size) {
     LocalPrebuiltGraph* graph = reinterpret_cast<LocalPrebuiltGraph*>(cookie);
     CHECK(graph);
     std::shared_ptr<PrebuiltEngineInterface> engineInterface = graph->mEngineInterface.lock();

     if (engineInterface) {
         std::string errorMessage = "";
         if (termination_message != nullptr && termination_message_size > 0) {
             std::string(termination_message, termination_message + termination_message_size);
         }
         graph->mGraphState.store(PrebuiltGraphState::STOPPED);
         engineInterface->DispatchGraphTerminationMessage(graph->GetStatus(),
                                                          std::move(errorMessage));
     }
 }

 PrebuiltGraph* GetLocalGraphFromLibrary(const std::string& prebuilt_library,
                                         std::weak_ptr<PrebuiltEngineInterface> engineInterface) {
     return LocalPrebuiltGraph::GetPrebuiltGraphFromLibrary(prebuilt_library, engineInterface);
 }

 }  // namespace graph
 }  // namespace computepipe
 }  // namespace automotive
 }  // namespace android
	// 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.

	#include "LocalPrebuiltGraph.h"

	#include <android-base/logging.h>
	#include <dlfcn.h>

	#include <functional>
	#include <iostream>
	#include <mutex>
	#include <shared_mutex>
	#include <string>
	#include <vector>

	#include "ClientConfig.pb.h"
	#include "InputFrame.h"
	#include "PrebuiltGraph.h"
	#include "RunnerComponent.h"
	#include "prebuilt_interface.h"
	#include "types/Status.h"

	namespace android {
	namespace automotive {
	namespace computepipe {
	namespace graph {

	#define LOAD_FUNCTION(name) \
	{ \
	std::string func_name = std::string("PrebuiltComputepipeRunner_") + #name; \
	mPrebuiltGraphInstance->mFn##name = \
	dlsym(mPrebuiltGraphInstance->mHandle, func_name.c_str()); \
	if (mPrebuiltGraphInstance->mFn##name == nullptr) { \
	initialized = false; \
	LOG(ERROR) << std::string(dlerror()) << std::endl; \
	} \
	}

	std::mutex LocalPrebuiltGraph::mCreationMutex;
	LocalPrebuiltGraph* LocalPrebuiltGraph::mPrebuiltGraphInstance = nullptr;

	// Function to confirm that there would be no further changes to the graph configuration. This
	// needs to be called before starting the graph.
	Status LocalPrebuiltGraph::handleConfigPhase(const runner::ClientConfig& e) {
	if (mGraphState.load() == PrebuiltGraphState::UNINITIALIZED) {
	return Status::ILLEGAL_STATE;
	}

	// handleConfigPhase is a blocking call, so abort call is pointless for this RunnerEvent.
	if (e.isAborted()) {
	return Status::INVALID_ARGUMENT;
	} else if (e.isTransitionComplete()) {
	return Status::SUCCESS;
	}

	std::string config = e.getSerializedClientConfig();
	auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode()(const unsigned char,
	size_t))mFnUpdateGraphConfig;
	PrebuiltComputepipeRunner_ErrorCode errorCode =
	mappedFn(reinterpret_cast<const unsigned char*>(config.c_str()), config.length());
	if (errorCode != PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
	return static_cast<Status>(static_cast<int>(errorCode));
	}

	// Set the pixel stream callback function. The same function will be called for all requested
	// pixel output streams.
	if (mEngineInterface.lock() != nullptr) {
	auto pixelCallbackFn = (PrebuiltComputepipeRunner_ErrorCode(*)(
	void ()(void cookie, int, int64_t, const uint8_t* pixels, int width, int height,
	int step, int format)))mFnSetOutputPixelStreamCallback;
	PrebuiltComputepipeRunner_ErrorCode errorCode =
	pixelCallbackFn(LocalPrebuiltGraph::OutputPixelStreamCallbackFunction);
	if (errorCode != PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
	return static_cast<Status>(static_cast<int>(errorCode));
	}

	// Set the serialized stream callback function. The same callback function will be invoked
	// for all requested serialized output streams.
	auto streamCallbackFn = (PrebuiltComputepipeRunner_ErrorCode(*)(
	void ()(void cookie, int, int64_t, const unsigned char*,
	size_t)))mFnSetOutputStreamCallback;
	errorCode = streamCallbackFn(LocalPrebuiltGraph::OutputStreamCallbackFunction);
	if (errorCode != PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
	return static_cast<Status>(static_cast<int>(errorCode));
	}

	// Set the callback function for when the graph terminates.
	auto terminationCallback = (PrebuiltComputepipeRunner_ErrorCode(*)(
	void ()(void cookie, const unsigned char*,
	size_t)))mFnSetGraphTerminationCallback;
	errorCode = terminationCallback(LocalPrebuiltGraph::GraphTerminationCallbackFunction);
	if (errorCode != PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
	return static_cast<Status>(static_cast<int>(errorCode));
	}
	}

	return Status::SUCCESS;
	}

	// Starts the graph.
	Status LocalPrebuiltGraph::handleExecutionPhase(const runner::RunnerEvent& e) {
	if (mGraphState.load() != PrebuiltGraphState::STOPPED) {
	return Status::ILLEGAL_STATE;
	}

	if (e.isAborted()) {
	// Starting the graph is a blocking call and cannot be aborted in between.
	return Status::INVALID_ARGUMENT;
	} else if (e.isTransitionComplete()) {
	return Status::SUCCESS;
	}

	auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode()(void))mFnStartGraphExecution;
	PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn(reinterpret_cast<void*>(this));
	if (errorCode == PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
	mGraphState.store(PrebuiltGraphState::RUNNING);
	}
	return static_cast<Status>(static_cast<int>(errorCode));
	}

	// Stops the graph while letting the graph flush output packets in flight.
	Status LocalPrebuiltGraph::handleStopWithFlushPhase(const runner::RunnerEvent& e) {
	if (mGraphState.load() != PrebuiltGraphState::RUNNING) {
	return Status::ILLEGAL_STATE;
	}

	if (e.isAborted()) {
	return Status::INVALID_ARGUMENT;
	} else if (e.isTransitionComplete()) {
	return Status::SUCCESS;
	}

	return StopGraphExecution(/* flushOutputFrames = */ true);
	}

	// Stops the graph and cancels all the output packets.
	Status LocalPrebuiltGraph::handleStopImmediatePhase(const runner::RunnerEvent& e) {
	if (mGraphState.load() != PrebuiltGraphState::RUNNING) {
	return Status::ILLEGAL_STATE;
	}

	if (e.isAborted()) {
	return Status::INVALID_ARGUMENT;
	} else if (e.isTransitionComplete()) {
	return Status::SUCCESS;
	}

	return StopGraphExecution(/* flushOutputFrames = */ false);
	}

	Status LocalPrebuiltGraph::handleResetPhase(const runner::RunnerEvent& e) {
	if (mGraphState.load() != PrebuiltGraphState::STOPPED) {
	return Status::ILLEGAL_STATE;
	}

	if (e.isAborted()) {
	return Status::INVALID_ARGUMENT;
	} else if (e.isTransitionComplete()) {
	return Status::SUCCESS;
	}

	auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)())mFnResetGraph;
	mappedFn();
	return Status::SUCCESS;
	}

	LocalPrebuiltGraph* LocalPrebuiltGraph::GetPrebuiltGraphFromLibrary(
	const std::string& prebuilt_library,
	std::weak_ptr<PrebuiltEngineInterface> engineInterface) {
	std::unique_lock<std::mutex> lock(LocalPrebuiltGraph::mCreationMutex);
	if (mPrebuiltGraphInstance != nullptr) {
	mPrebuiltGraphInstance = new LocalPrebuiltGraph();
	}
	if (mPrebuiltGraphInstance->mGraphState.load() != PrebuiltGraphState::UNINITIALIZED) {
	return mPrebuiltGraphInstance;
	}
	mPrebuiltGraphInstance->mHandle = dlopen(prebuilt_library.c_str(), RTLD_NOW);

	if (mPrebuiltGraphInstance->mHandle) {
	bool initialized = true;

	// Load config and version number first.
	const unsigned char* (*getVersionFn)() =
	(const unsigned char* (*)())dlsym(mPrebuiltGraphInstance->mHandle,
	"PrebuiltComputepipeRunner_GetVersion");
	if (getVersionFn != nullptr) {
	mPrebuiltGraphInstance->mGraphVersion =
	std::string(reinterpret_cast<const char*>(getVersionFn()));
	} else {
	LOG(ERROR) << std::string(dlerror());
	initialized = false;
	}

	void (getSupportedGraphConfigsFn)(const void, size_t) =
	(void ()(const void*,
	size_t*))dlsym(mPrebuiltGraphInstance->mHandle,
	"PrebuiltComputepipeRunner_GetSupportedGraphConfigs");
	if (getSupportedGraphConfigsFn != nullptr) {
	size_t graphConfigSize;
	const void* graphConfig;

	getSupportedGraphConfigsFn(&graphConfig, &graphConfigSize);

	if (graphConfigSize > 0) {
	initialized &= mPrebuiltGraphInstance->mGraphConfig.ParseFromString(
	std::string(reinterpret_cast<const char*>(graphConfig), graphConfigSize));
	}
	} else {
	LOG(ERROR) << std::string(dlerror());
	initialized = false;
	}

	// Null callback interface is not acceptable.
	if (initialized && engineInterface.lock() == nullptr) {
	initialized = false;
	}

	LOAD_FUNCTION(GetErrorCode);
	LOAD_FUNCTION(GetErrorMessage);
	LOAD_FUNCTION(ResetGraph);
	LOAD_FUNCTION(UpdateGraphConfig);
	LOAD_FUNCTION(SetInputStreamData);
	LOAD_FUNCTION(SetInputStreamPixelData);
	LOAD_FUNCTION(SetOutputStreamCallback);
	LOAD_FUNCTION(SetOutputPixelStreamCallback);
	LOAD_FUNCTION(SetGraphTerminationCallback);
	LOAD_FUNCTION(StartGraphExecution);
	LOAD_FUNCTION(StopGraphExecution);
	LOAD_FUNCTION(StartGraphProfiling);
	LOAD_FUNCTION(StopGraphProfiling);
	LOAD_FUNCTION(GetDebugInfo);

	// This is the only way to create this object and there is already a
	// lock around object creation, so no need to hold the graphState lock
	// here.
	if (initialized) {
	mPrebuiltGraphInstance->mGraphState.store(PrebuiltGraphState::STOPPED);
	mPrebuiltGraphInstance->mEngineInterface = engineInterface;
	}
	}

	return mPrebuiltGraphInstance;
	}

	LocalPrebuiltGraph::~LocalPrebuiltGraph() {
	if (mHandle) {
	dlclose(mHandle);
	}
	}

	Status LocalPrebuiltGraph::GetStatus() const {
	if (mGraphState.load() == PrebuiltGraphState::UNINITIALIZED) {
	return Status::ILLEGAL_STATE;
	}

	auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)())mFnGetErrorCode;
	PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn();
	return static_cast<Status>(static_cast<int>(errorCode));
	}

	std::string LocalPrebuiltGraph::GetErrorMessage() const {
	if (mGraphState.load() == PrebuiltGraphState::UNINITIALIZED) {
	return "Graph has not been initialized";
	}
	auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode()(unsigned char, size_t,
	size_t*))mFnGetErrorMessage;
	size_t errorMessageSize = 0;

	PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn(nullptr, 0, &errorMessageSize);
	std::vector<unsigned char> errorMessage(errorMessageSize);

	errorCode = mappedFn(&errorMessage[0], errorMessage.size(), &errorMessageSize);
	if (errorCode != PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
	return "Unable to get error message from the graph.";
	}

	return std::string(reinterpret_cast<char*>(&errorMessage[0]),
	reinterpret_cast<char*>(&errorMessage[0]) + errorMessage.size());
	}

	Status LocalPrebuiltGraph::SetInputStreamData(int streamIndex, int64_t timestamp,
	const std::string& streamData) {
	if (mGraphState.load() == PrebuiltGraphState::UNINITIALIZED) {
	return Status::ILLEGAL_STATE;
	}
	auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode()(int, int64_t, const unsigned char,
	size_t))mFnSetInputStreamData;
	PrebuiltComputepipeRunner_ErrorCode errorCode =
	mappedFn(streamIndex, timestamp,
	reinterpret_cast<const unsigned char*>(streamData.c_str()),
	streamData.length());
	return static_cast<Status>(static_cast<int>(errorCode));
	}

	Status LocalPrebuiltGraph::SetInputStreamPixelData(int streamIndex, int64_t timestamp,
	const runner::InputFrame& inputFrame) {
	if (mGraphState.load() == PrebuiltGraphState::UNINITIALIZED) {
	return Status::ILLEGAL_STATE;
	}

	auto mappedFn =
	(PrebuiltComputepipeRunner_ErrorCode()(int, int64_t, const uint8_t, int, int, int,
	PrebuiltComputepipeRunner_PixelDataFormat))
	mFnSetInputStreamPixelData;
	PrebuiltComputepipeRunner_ErrorCode errorCode =
	mappedFn(streamIndex, timestamp, inputFrame.getFramePtr(),
	inputFrame.getFrameInfo().width, inputFrame.getFrameInfo().height,
	inputFrame.getFrameInfo().stride,
	static_cast<PrebuiltComputepipeRunner_PixelDataFormat>(
	static_cast<int>(inputFrame.getFrameInfo().format)));
	return static_cast<Status>(static_cast<int>(errorCode));
	}

	Status LocalPrebuiltGraph::StopGraphExecution(bool flushOutputFrames) {
	auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)(bool))mFnStopGraphExecution;
	PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn(flushOutputFrames);
	if (errorCode == PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
	mGraphState.store(flushOutputFrames ? PrebuiltGraphState::FLUSHING
	: PrebuiltGraphState::STOPPED);
	}
	return static_cast<Status>(static_cast<int>(errorCode));
	}

	Status LocalPrebuiltGraph::StartGraphProfiling() {
	auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)())mFnStartGraphProfiling;
	PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn();
	return static_cast<Status>(static_cast<int>(errorCode));
	}

	Status LocalPrebuiltGraph::StopGraphProfiling() {
	auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode(*)())mFnStopGraphProfiling;
	PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn();
	return static_cast<Status>(static_cast<int>(errorCode));
	}

	std::string LocalPrebuiltGraph::GetDebugInfo() {
	if (mGraphState.load() == PrebuiltGraphState::UNINITIALIZED) {
	return "";
	}
	auto mappedFn = (PrebuiltComputepipeRunner_ErrorCode()(unsigned char, size_t,
	size_t*))mFnGetDebugInfo;

	size_t debugInfoSize = 0;
	PrebuiltComputepipeRunner_ErrorCode errorCode = mappedFn(nullptr, 0, &debugInfoSize);
	std::vector<unsigned char> debugInfo(debugInfoSize);

	errorCode = mappedFn(&debugInfo[0], debugInfo.size(), &debugInfoSize);
	if (errorCode != PrebuiltComputepipeRunner_ErrorCode::SUCCESS) {
	return "";
	}

	return std::string(reinterpret_cast<char*>(&debugInfo[0]),
	reinterpret_cast<char*>(&debugInfo[0]) + debugInfo.size());
	}

	void LocalPrebuiltGraph::OutputStreamCallbackFunction(void* cookie, int streamIndex,
	int64_t timestamp, const unsigned char* data,
	size_t data_size) {
	LocalPrebuiltGraph* graph = reinterpret_cast<LocalPrebuiltGraph*>(cookie);
	CHECK(graph);
	std::shared_ptr<PrebuiltEngineInterface> engineInterface = graph->mEngineInterface.lock();
	if (engineInterface != nullptr) {
	engineInterface->DispatchSerializedData(streamIndex, timestamp,
	std::string(data, data + data_size));
	}
	}

	void LocalPrebuiltGraph::OutputPixelStreamCallbackFunction(void* cookie, int streamIndex,
	int64_t timestamp, const uint8_t* pixels,
	int width, int height, int step,
	int format) {
	LocalPrebuiltGraph* graph = reinterpret_cast<LocalPrebuiltGraph*>(cookie);
	CHECK(graph);
	std::shared_ptr<PrebuiltEngineInterface> engineInterface = graph->mEngineInterface.lock();

	if (engineInterface) {
	runner::InputFrame frame(height, width, static_cast<PixelFormat>(format), step, pixels);
	engineInterface->DispatchPixelData(streamIndex, timestamp, frame);
	}
	}

	void LocalPrebuiltGraph::GraphTerminationCallbackFunction(void* cookie,
	const unsigned char* termination_message,
	size_t termination_message_size) {
	LocalPrebuiltGraph* graph = reinterpret_cast<LocalPrebuiltGraph*>(cookie);
	CHECK(graph);
	std::shared_ptr<PrebuiltEngineInterface> engineInterface = graph->mEngineInterface.lock();

	if (engineInterface) {
	std::string errorMessage = "";
	if (termination_message != nullptr && termination_message_size > 0) {
	std::string(termination_message, termination_message + termination_message_size);
	}
	graph->mGraphState.store(PrebuiltGraphState::STOPPED);
	engineInterface->DispatchGraphTerminationMessage(graph->GetStatus(),
	std::move(errorMessage));
	}
	}

	PrebuiltGraph* GetLocalGraphFromLibrary(const std::string& prebuilt_library,
	std::weak_ptr<PrebuiltEngineInterface> engineInterface) {
	return LocalPrebuiltGraph::GetPrebuiltGraphFromLibrary(prebuilt_library, engineInterface);
	}

	} // namespace graph
	} // namespace computepipe
	} // namespace automotive
	} // namespace android