ClientReceiverFb.h

Go to the documentation of this file.

// Copyright 2023 DreamWorks Animation LLC
// SPDX-License-Identifier: Apache-2.0

#pragma once

#include <mcrt_messages/ProgressiveFrame.h>
#include <scene_rdl2/common/grid_util/Fb.h>
#include <scene_rdl2/common/grid_util/LatencyLog.h>
#include <scene_rdl2/common/grid_util/Parser.h>
#include <scene_rdl2/common/math/Viewport.h>
#include <scene_rdl2/common/rec_time/RecTime.h>

namespace mcrt_dataio {

class ClientReceiverConsoleDriver;
class TimingRecorderHydra;

class ClientReceiverFb
{
public:
    using CallBackStartedCondition = std::function<void()>;
    using CallBackGenericComment = std::function<void(const std::string &comment)>;
    using CallBackSendMessage = std::function<bool(const arras4::api::MessageContentConstPtr msg)>;
    using Parser = scene_rdl2::grid_util::Parser;

    enum class DenoiseEngine : int {
        OPTIX,
        OPEN_IMAGE_DENOISE    
    };

    enum class DenoiseMode : int {
        DISABLE, // disable denoise
        ENABLE, // enable denoise but does not use any additional input
        ENABLE_W_ALBEDO, // enable denoise with ALBEDO input if available
        ENABLE_W_NORMAL, // enable denoise with NORMAL input if available
        ENABLE_W_ALBEDO_NORMAL // enable denoise with ALBEDO and NORMAL input if available
    };

    enum class BackendStat : int {
        IDLE, // idle mode
        RENDER_PREP_RUN, // executing renderPrep phase
        RENDER_PREP_CANCEL, // middle of canceling renderPrep
        MCRT, // executing MCRT phase
        UNKNOWN
    };

    enum class SenderMachineId : int {
        DISPATCH = -1,
        MERGE = -2,
        UNKNOWN = -3
    };

    ClientReceiverFb();
    ~ClientReceiverFb();

    ClientReceiverFb& operator = (const ClientReceiverFb&) = delete;
    ClientReceiverFb(const ClientReceiverFb&) = delete;

    //------------------------------

    bool decodeProgressiveFrame(const mcrt::ProgressiveFrame& message,
                                const bool doParallel,
                                const CallBackStartedCondition& callBackFuncAtStartedCondition,
                                const CallBackGenericComment& callBackForGenericComment = nullptr);

    //------------------------------

    size_t getViewId() const;

    uint32_t getFrameId() const;

    mcrt::BaseFrame::Status getStatus() const;

    BackendStat getBackendStat() const;

    float getRenderPrepProgress() const;

    float getProgress() const;

    bool isCoarsePass() const;

    uint64_t getSnapshotStartTime() const;

    float getElapsedSecFromStart(); // return sec

    uint64_t getRecvMsgSize() const; // return last message size as byte

    unsigned getWidth() const;

    unsigned getHeight() const;

    const scene_rdl2::math::Viewport& getRezedViewport() const; // closed viewport

    bool getRoiViewportStatus() const;

    const scene_rdl2::math::Viewport& getRoiViewport() const; // closed viewport

    bool getPixelInfoStatus() const;

    const std::string& getPixelInfoName() const;

    int getPixelInfoNumChan() const;

    bool getHeatMapStatus() const;

    const std::string& getHeatMapName() const;

    int getHeatMapNumChan() const;

    bool getWeightBufferStatus() const;

    const std::string& getWeightBufferName() const;

    int getWeightBufferNumChan() const;

    bool getRenderBufferOddStatus() const;

    int getRenderBufferOddNumChan() const;

    unsigned getTotalRenderOutput() const;

    const std::string& getRenderOutputName(const unsigned id) const;

    int getRenderOutputNumChan(const unsigned id) const;

    int getRenderOutputNumChan(const std::string& aovName) const;

    bool getRenderOutputClosestFilter(const unsigned id) const;

    bool getRenderOutputClosestFilter(const std::string& aovName) const;

    //------------------------------

    void setDenoiseEngine(DenoiseEngine engine);

    DenoiseEngine getDenoiseEngine() const;

    void setBeautyDenoiseMode(DenoiseMode mode);

    DenoiseMode getBeautyDenoiseMode() const;

    const std::string& getErrorMsg() const;

    //------------------------------

    bool getBeautyRgb888(std::vector<unsigned char>& rgbFrame,
                         const bool top2bottom = false,
                         const bool isSrgb = false);

    bool getPixelInfoRgb888(std::vector<unsigned char>& rgbFrame,
                            const bool top2bottom = false,
                            const bool isSrgb = false);

    bool getHeatMapRgb888(std::vector<unsigned char>& rgbFrame,
                          const bool top2bottom = false,
                          const bool isSrgb = false);

    bool getWeightBufferRgb888(std::vector<unsigned char>& rgbFrame,
                               const bool top2bottom = false,
                               const bool isSrgb = false);

    bool getBeautyAuxRgb888(std::vector<unsigned char>& rgbFrame,
                            const bool top2bottom = false,
                            const bool isSrgb = false);

    bool getRenderOutputRgb888(const unsigned id,
                               std::vector<unsigned char>& rgbFrame,
                               const bool top2bottom = false,
                               const bool isSrgb = false,
                               const bool closestFilterDepthOutput = false);

    bool getRenderOutputRgb888(const std::string& aovName,
                               std::vector<unsigned char>& rgbFrame,
                               const bool top2bottom = false,
                               const bool isSrgb = false,
                               const bool closestFilterDepthOutput = false);

    //------------------------------

    bool getBeauty(std::vector<float>& rgba,
                   const bool top2bottom = false); // 4 channels per pixel

    bool getPixelInfo(std::vector<float>& data, const bool top2bottom = false); // 1 channel per pixel

    bool getHeatMap(std::vector<float>& data, const bool top2bottom = false);   // 1 channel per pixel

    bool getWeightBuffer(std::vector<float>& data, const bool top2bottom = false); // 1 channel per pixel

    bool getBeautyOdd(std::vector<float>& rgba, const bool top2bottom = false); // 4 channels per pixel

    int  getRenderOutput(const unsigned id,
                         std::vector<float>& data,
                         const bool top2bottom = false,
                         const bool closestFilterDepthOutput = false);

    int  getRenderOutput(const std::string& aovName,
                         std::vector<float>& data,
                         const bool top2bottom = false,
                         const bool closestFilterDepthOutput = false);

    //------------------------------

    // Return value is Vec4f and [0]=R, [1]=G, [2]=B and [3]=A
    scene_rdl2::math::Vec4f getPixBeauty(const int sx, const int sy) const;

    float getPixPixelInfo(const int sx, const int sy) const;

    float getPixHeatMap(const int sx, const int sy) const;

    float getPixWeightBuffer(const int sx, const int sy) const;

    // Return value is Vec4f and [0]=R, [1]=G, [2]=B and [3]=A
    scene_rdl2::math::Vec4f getPixBeautyOdd(const int sx, const int sy) const;

    int getPixRenderOutput(const unsigned id, const int sx, const int sy,
                           std::vector<float>& out) const; // return numChan

    int getPixRenderOutput(const std::string& aovName, const int sx, const int sy,
                           std::vector<float>& out) const; // return numChan

    std::string showPix(const int sx, const int sy, const std::string& aovName) const;

    //------------------------------

    const scene_rdl2::grid_util::LatencyLog &getLatencyLog() const;

    const scene_rdl2::grid_util::LatencyLogUpstream& getLatencyLogUpstream() const;

    //------------------------------

    void setInfoRecInterval(const float sec); // 0.0 = disable infoRec logic

    void setInfoRecDisplayInterval(const float sec);

    void setInfoRecFileName(const std::string& fileName);

    void updateStatsMsgInterval(); // update message interval info

    void updateStatsProgressiveFrame(); // update progressiveFrame message info

    bool getStats(const float intervalSec, std::string& outMsg);

    float getRecvImageDataFps();

    unsigned getFbActivityCounter();

    //------------------------------

    void consoleAutoSetup(const CallBackSendMessage& sendMessage);

    void consoleEnable(const unsigned short port,
                       const CallBackSendMessage& sendMessage);

    ClientReceiverConsoleDriver& consoleDriver();

    Parser& getParser();

    static std::string showDenoiseEngine(const DenoiseEngine& engine);

    static std::string showDenoiseMode(const DenoiseMode& mode);

    static std::string showBackendStat(const BackendStat& stat);

    //------------------------------

    void setTimingRecorderHydra(std::shared_ptr<TimingRecorderHydra> ptr);

    int getReceivedImageSenderMachineId() const;

    static std::string showSenderMachineId(int machineId);

    //------------------------------

    void setTelemetryOverlayReso(unsigned width, unsigned height);

    void setTelemetryOverlayActive(bool sw);

    bool getTelemetryOverlayActive() const;

    void switchTelemetryLayoutNext();

protected:
    class Impl;
    std::unique_ptr<Impl> mImpl;
}; // ClientReceiverFb

} // namespace mcrt_dataio