[Depends on #8344] Implement ApiHandler functions and add JsonWriter

filament/src/details/Engine.cpp

@@ -750,6 +750,25 @@ int FEngine::loop() {
     }
 #endif
 
+#if FILAMENT_ENABLE_FGVIEWER
+#ifdef __ANDROID__
+    const char* fgviewerPortString = "8085";
+#else
+    const char* fgviewerPortString = getenv("FILAMENT_FGVIEWER_PORT");
+#endif
+    if (fgviewerPortString != nullptr) {
+        const int fgviewerPort = atoi(fgviewerPortString);
+        debug.fgviewerServer = new fgviewer::DebugServer(fgviewerPort);
+
+        // Sometimes the server can fail to spin up (e.g. if the above port is already in use).
+        // When this occurs, carry onward, developers can look at civetweb.txt for details.
+        if (!debug.fgviewerServer->isReady()) {
+            delete debug.fgviewerServer;
+            debug.fgviewerServer = nullptr;
+        }
+    }
+#endif
+
     JobSystem::setThreadName("FEngine::loop");
     JobSystem::setThreadPriority(JobSystem::Priority::DISPLAY);
 

filament/src/details/Engine.h

@@ -88,6 +88,14 @@ using MaterialKey = uint32_t;
 } // namespace filament::matdbg
 #endif
 
+#if FILAMENT_ENABLE_FGVIEWER
+#include <fgviewer/DebugServer.h>
+#else
+namespace filament::fgviewer {
+    class DebugServer;
+} // namespace filament::fgviewer
+#endif
+
 namespace filament {
 
 class Renderer;
@@ -680,6 +688,7 @@ class FEngine : public Engine {
             bool combine_multiview_images = false;
         } stereo;
         matdbg::DebugServer* server = nullptr;
+        fgviewer::DebugServer* fgviewerServer = nullptr;
     } debug;
 
     struct {

filament/src/details/Renderer.cpp

@@ -1437,6 +1437,13 @@ void FRenderer::renderJob(RootArenaScope& rootArenaScope, FView& view) {
 
     fg.compile();
 
+#if FILAMENT_ENABLE_FGVIEWER
+    fgviewer::DebugServer* fgviewerServer = engine.debug.fgviewerServer;
+    if (UTILS_LIKELY(fgviewerServer)) {
+        fgviewerServer->update(view.getViewHandle(), fg.getFrameGraphInfo(view.getName()));
+    }
+#endif
+
     //fg.export_graphviz(slog.d, view.getName());
 
     fg.execute(driver);

filament/src/details/View.cpp

@@ -109,6 +109,14 @@ FView::FView(FEngine& engine)
     }
 #endif
 
+#if FILAMENT_ENABLE_FGVIEWER
+    fgviewer::DebugServer* fgviewerServer = engine.debug.fgviewerServer;
+    if (UTILS_LIKELY(fgviewerServer)) {
+        mFrameGraphViewerViewHandle =
+            fgviewerServer->createView(utils::CString(getName()));
+    }
+#endif
+
     // allocate UBOs
     mLightUbh = driver.createBufferObject(CONFIG_MAX_LIGHT_COUNT * sizeof(LightsUib),
             BufferObjectBinding::UNIFORM, BufferUsage::DYNAMIC);
@@ -153,6 +161,13 @@ void FView::terminate(FEngine& engine) {
         engine.getDebugRegistry().unregisterDataSource("d.view.frame_info");
     }
 #endif
+
+#if FILAMENT_ENABLE_FGVIEWER
+    fgviewer::DebugServer* fgviewerServer = engine.debug.fgviewerServer;
+    if (UTILS_LIKELY(fgviewerServer)) {
+        fgviewerServer->destroyView(mFrameGraphViewerViewHandle);
+    }
+#endif
 }
 
 void FView::setViewport(filament::Viewport const& viewport) noexcept {

filament/src/details/View.h

@@ -60,6 +60,14 @@
 #include <utils/Range.h>
 #include <utils/Slice.h>
 
+#if FILAMENT_ENABLE_FGVIEWER
+#include <fgviewer/DebugServer.h>
+#else
+namespace filament::fgviewer {
+    using ViewHandle = uint32_t;
+}
+#endif
+
 #include <math/scalar.h>
 #include <math/mat4.h>
 
@@ -467,6 +475,10 @@ class FView : public View {
         return mUniforms;
     }
 
+    fgviewer::ViewHandle getViewHandle() const noexcept {
+        return mFrameGraphViewerViewHandle;
+    }
+
 private:
     struct FPickingQuery : public PickingQuery {
     private:
@@ -600,6 +612,8 @@ class FView : public View {
                                                             { 0, 0, 0, 1 },
                                                     }};
 
+    fgviewer::ViewHandle mFrameGraphViewerViewHandle;
+
 #ifndef NDEBUG
     struct DebugState {
         std::unique_ptr<std::array<DebugRegistry::FrameHistory, 5*60>> debugFrameHistory{};

filament/src/fg/FrameGraph.cpp

@@ -479,6 +479,61 @@ void FrameGraph::export_graphviz(utils::io::ostream& out, char const* name) {
     mGraph.export_graphviz(out, name);
 }
 
+fgviewer::FrameGraphInfo FrameGraph::getFrameGraphInfo(const char *viewName) const {
+#if FILAMENT_ENABLE_FGVIEWER
+    fgviewer::FrameGraphInfo info{utils::CString(viewName)};
+    std::vector<fgviewer::FrameGraphInfo::Pass> passes;
+
+    auto first = mPassNodes.begin();
+    const auto activePassNodesEnd = mActivePassNodesEnd;
+    while (first != activePassNodesEnd) {
+        PassNode *const pass = *first;
+        first++;
+
+        assert_invariant(!pass->isCulled());
+        std::vector<fgviewer::ResourceId> reads;
+        auto const &readEdges = mGraph.getIncomingEdges(pass);
+        for (auto const &edge: readEdges) {
+            // all incoming edges should be valid by construction
+            assert_invariant(mGraph.isEdgeValid(edge));
+            reads.push_back(edge->from);
+        }
+
+        std::vector<fgviewer::ResourceId> writes;
+        auto const &writeEdges = mGraph.getOutgoingEdges(pass);
+        for (auto const &edge: writeEdges) {
+            // It is possible that the node we're writing to has been culled.
+            // In this case we'd like to ignore the edge.
+            if (!mGraph.isEdgeValid(edge)) {
+                continue;
+            }
+            writes.push_back(edge->to);
+        }
+        passes.emplace_back(utils::CString(pass->getName()),
+            std::move(reads), std::move(writes));
+    }
+
+    std::unordered_map<fgviewer::ResourceId, fgviewer::FrameGraphInfo::Resource> resources;
+    for (const auto &resource: mResourceNodes) {
+        std::vector<fgviewer::FrameGraphInfo::Resource::Property> resourceProps;
+        // TODO: Fill in resource properties
+        fgviewer::ResourceId id = resource->getId();
+        resources.emplace(id, fgviewer::FrameGraphInfo::Resource(
+                              id, utils::CString(resource->getName()),
+                              std::move(resourceProps))
+        );
+    }
+
+    info.setResources(std::move(resources));
+    info.setPasses(std::move(passes));
+
+    return info;
+#else
+    return fgviewer::FrameGraphInfo();
+#endif
+}
+
+
 // ------------------------------------------------------------------------------------------------
 
 /*

filament/src/fg/FrameGraph.h

@@ -36,6 +36,14 @@
 
 #include <functional>
 
+#if FILAMENT_ENABLE_FGVIEWER
+#include <fgviewer/FrameGraphInfo.h>
+#else
+namespace filament::fgviewer {
+    class FrameGraphInfo{};
+} // namespace filament::fgviewer
+#endif
+
 namespace filament {
 
 class ResourceAllocatorInterface;
@@ -434,6 +442,12 @@ class FrameGraph {
     //! export a graphviz view of the graph
     void export_graphviz(utils::io::ostream& out, const char* name = nullptr);
 
+    /**
+     * Export a fgviewer::FrameGraphInfo for current graph.
+     * Note that this function should be called after FrameGraph::compile().
+     */
+    fgviewer::FrameGraphInfo getFrameGraphInfo(const char *viewName) const;
+
 private:
     friend class FrameGraphResources;
     friend class PassNode;

libs/fgviewer/CMakeLists.txt

@@ -23,6 +23,7 @@ set(SRCS
     src/ApiHandler.h
     src/DebugServer.cpp
     src/FrameGraphInfo.cpp
+        src/JsonWriter.cpp
 )
 
 # ==================================================================================================

libs/fgviewer/include/fgviewer/DebugServer.h

@@ -31,8 +31,6 @@ namespace filament::fgviewer {
 
 using ViewHandle = uint32_t;
 
-
-
 /**
  * Server-side frame graph debugger.
  *

libs/fgviewer/include/fgviewer/FrameGraphInfo.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (C) 2024 The Android Open Source Project
+ * Copyright (C) 2024 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.
@@ -70,6 +70,12 @@ class FrameGraphInfo {
     // The incoming passes should be sorted by the execution order.
     void setPasses(std::vector<Pass> sortedPasses);
 
+    const char* getViewName() const;
+
+    const std::vector<Pass>& getPasses() const;
+
+    const std::unordered_map<ResourceId, Resource>& getResources() const;
+
 private:
     utils::CString viewName;
     // The order of the passes in the vector indicates the execution

libs/fgviewer/src/ApiHandler.cpp

@@ -18,6 +18,7 @@
 #include "ApiHandler.h"
 
 #include <fgviewer/DebugServer.h>
+#include <fgviewer/JsonWriter.h>
 
 #include <utils/FixedCapacityVector.h>
 #include <utils/Log.h>
@@ -40,29 +41,96 @@ auto const error = [](int line, std::string const& uri) {
 
 } // anonymous
 
-bool ApiHandler::handleGetApiFgInfo(struct mg_connection* conn,
-        struct mg_request_info const* request) {
-    auto const softError = [conn, request](char const* msg) {
-        utils::slog.e << "[fgviewer] DebugServer: " << msg << ": " << request->query_string << utils::io::endl;
-        mg_printf(conn, kErrorHeader.data(), "application/txt");
-        mg_write(conn, msg, strlen(msg));
+bool ApiHandler::handleGet(CivetServer* server, struct mg_connection* conn) {
+    struct mg_request_info const* request = mg_get_request_info(conn);
+    std::string const& uri = request->local_uri;
+
+    if (uri.find("/api/status") == 0) {
+        return handleGetStatus(conn, request);
+    }
+
+    if (uri == "/api/framegraphs") {
+        std::unique_lock const lock(mServer->mViewsMutex);
+        mg_printf(conn, kSuccessHeader.data(), "application/json");
+        mg_printf(conn, "[");
+        int index = 0;
+        for (auto const& view: mServer->mViews) {
+            bool const last = (++index) == mServer->mViews.size();
+
+            JsonWriter writer;
+            if (!writer.writeFrameGraphInfo(view.second)) {
+                return error(__LINE__, uri);
+            }
+
+            mg_printf(conn, "{ \"fgid\": \"%8.8x\", %s } %s", view.first, writer.getJsonString(),
+                    last ? "" : ",");
+        }
+        mg_printf(conn, "]");
+        return true;
+    }
+
+    if (uri == "/api/framegraph") {
+        const FrameGraphInfo* result = getFrameGraphInfo(conn, request);
+        if (!result) {
+            return error(__LINE__, uri);
+        }
+
+        JsonWriter writer;
+        if (!writer.writeFrameGraphInfo(*result)) {
+            return error(__LINE__, uri);
+        }
+        mg_printf(conn, kSuccessHeader.data(), "application/json");
+        mg_printf(conn, "{ %s }", writer.getJsonString());
         return true;
-    };
+    }
 
-    // TODO: Implement the method
-    return true;
+    return error(__LINE__, uri);
 }
 
-void ApiHandler::addFrameGraph(FrameGraphInfo const* framegraph) {
-    // TODO: Implement the method
+void ApiHandler::addFrameGraph(ViewHandle view_handle) {
+    std::unique_lock const lock(mStatusMutex);
+    snprintf(statusFrameGraphId, sizeof(statusFrameGraphId), "%8.8x", view_handle);
+    mStatusCondition.notify_all();
 }
 
+const FrameGraphInfo* ApiHandler::getFrameGraphInfo(struct mg_connection* conn,
+                                         struct mg_request_info const* request) {
+    size_t const qlength = strlen(request->query_string);
+    char fgid[9] = {};
+    if (mg_get_var(request->query_string, qlength, "fgid", fgid, sizeof(fgid)) < 0) {
+        return nullptr;
+    }
+    uint32_t const id = strtoul(fgid, nullptr, 16);
+    std::unique_lock const lock(mServer->mViewsMutex);
+    const auto it = mServer->mViews.find(id);
+    return it == mServer->mViews.end()
+        ? nullptr
+        : &(it->second);
+}
 
-bool ApiHandler::handleGet(CivetServer* server, struct mg_connection* conn) {
-    struct mg_request_info const* request = mg_get_request_info(conn);
-    std::string const& uri = request->local_uri;
-
-    // TODO: Implement the method
+bool ApiHandler::handleGetStatus(struct mg_connection* conn,
+                                 struct mg_request_info const* request) {
+    char const* qstr = request->query_string;
+    if (qstr && strcmp(qstr, "firstTime") == 0) {
+        mg_printf(conn, kSuccessHeader.data(), "application/txt");
+        mg_write(conn, "0", 1);
+        return true;
+    }
+
+    std::unique_lock<std::mutex> lock(mStatusMutex);
+    uint64_t const currentStatusCount = mCurrentStatus;
+    if (mStatusCondition.wait_for(lock, 10s,
+                                  [this, currentStatusCount] {
+                                      return currentStatusCount < mCurrentStatus;
+                                  })) {
+        mg_printf(conn, kSuccessHeader.data(), "application/txt");
+        mg_write(conn, statusFrameGraphId, 8);
+    } else {
+        mg_printf(conn, kSuccessHeader.data(), "application/txt");
+        // Use '1' to indicate a no-op.  This ensures that we don't block forever if the client is
+        // gone.
+        mg_write(conn, "1", 1);
+    }
     return true;
 }