computepipe/runner/graph/include/PrebuiltGraph.h

// 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_PREBUILTGRAPH_H_
#define COMPUTEPIPE_RUNNER_GRAPH_INCLUDE_PREBUILTGRAPH_H_

#include <functional>
#include <shared_mutex>
#include <string>

#include "ClientConfig.pb.h"
#include "Options.pb.h"
#include "PrebuiltEngineInterface.h"
#include "RunnerComponent.h"
#include "types/Status.h"

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

enum PrebuiltGraphState {
    RUNNING = 0,
    UNINITIALIZED,
    FLUSHING,
    STOPPED,
};

// PrebuiltGraph is a singleton class. This is because the underlying functions that it implements
// are C functions that carry around state.
class PrebuiltGraph : public runner::RunnerComponentInterface {
  private:
    // Private constructor
    PrebuiltGraph() {
    }

  public:
    ~PrebuiltGraph();

    // No copy or move constructors or operators are available.
    PrebuiltGraph(const PrebuiltGraph&) = delete;
    PrebuiltGraph& operator=(const PrebuiltGraph&) = delete;
    PrebuiltGraph(PrebuiltGraph&&) = delete;
    PrebuiltGraph& operator=(PrebuiltGraph&&) = 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;

    static PrebuiltGraph* GetPrebuiltGraphFromLibrary(
        const std::string& prebuiltLib, std::shared_ptr<PrebuiltEngineInterface> engineInterface);

    PrebuiltGraphState GetGraphState() const {
        return mGraphState;
    }

    Status GetStatus() const;

    std::string GetErrorMessage() const;

    // Gets the supported graph config options.
    const proto::Options& GetSupportedGraphConfigs() const {
        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);

    // Sets pixel data to the specified input stream index.
    Status SetInputStreamPixelData(int streamIndex, int64_t timestamp, const uint8_t* pixels,
                                   int width, int height, int step, PixelFormat format);

    // 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();

  private:
    // Starts the graph execution.
    Status StartGraphExecution(bool debuggingEnabled);

    // Stops the graph execution.
    Status StopGraphExecution(bool flushOutputFrames);

    // Callback functions. The class has a C++ function callback interface while it deals with pure
    // C functions underneath that do not have object context. We need to have these static
    // functions that need to be passed to the C interface.
    static void OutputPixelStreamCallbackFunction(void* cookie, int streamIndex, int64_t timestamp,
                                                  const uint8_t* pixels, int width, int height,
                                                  int step, int format);
    static void OutputStreamCallbackFunction(void* cookie, int streamIndex, int64_t timestamp,
                                             const unsigned char* data, size_t dataSize);
    static void GraphTerminationCallbackFunction(void* cookie,
                                                 const unsigned char* terminationMessage,
                                                 size_t terminationMessageSize);

    // Cached callback interface that is passed in from the runner.
    std::shared_ptr<PrebuiltEngineInterface> mEngineInterface;

    static std::mutex mCreationMutex;
    static PrebuiltGraph* mPrebuiltGraphInstance;

    // Even though mutexes are generally preferred over atomics, the only varialble in this class
    // that changes after initialization is graph state and that is the only vairable that needs
    // to be guarded. The prebuilt is internally assumed to be thread safe, so that concurrent
    // calls into the library will automatically be handled in a thread safe manner by the it.
    std::atomic<PrebuiltGraphState> mGraphState = PrebuiltGraphState::UNINITIALIZED;

    // Dynamic library handle
    void* mHandle;

    // Repeated function calls need not be made to get the graph version and the config is this is
    // constant through the operation of the graph. These values are just cached as strings.
    std::string mGraphVersion;
    proto::Options mGraphConfig;

    // Cached functions from the dynamic library.
    void* mFnGetErrorCode;
    void* mFnGetErrorMessage;
    void* mFnUpdateGraphConfig;
    void* mFnResetGraph;
    void* mFnSetInputStreamData;
    void* mFnSetInputStreamPixelData;
    void* mFnSetOutputStreamCallback;
    void* mFnSetOutputPixelStreamCallback;
    void* mFnSetGraphTerminationCallback;
    void* mFnStartGraphExecution;
    void* mFnStopGraphExecution;
    void* mFnGetDebugInfo;
};

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

#endif  // COMPUTEPIPE_RUNNER_GRAPH_INCLUDE_PREBUILTGRAPH_H_