Attach captured canvas payloads to document snapshots

src/app_core/document_canvas.h

@@ -26,6 +26,16 @@ struct DocumentCanvasClearPlan {
     bool no_op = true;
 };
 
+struct DocumentCanvasFacePayloadInput {
+    std::uint32_t frame_index = 0;
+    std::uint32_t face_index = 0;
+    std::uint32_t x = 0;
+    std::uint32_t y = 0;
+    std::uint32_t width = 0;
+    std::uint32_t height = 0;
+    std::span<const std::uint8_t> rgba8;
+};
+
 struct DocumentCanvasLayerSnapshotInput {
     std::string_view name;
     bool visible = true;
@@ -34,6 +44,7 @@ struct DocumentCanvasLayerSnapshotInput {
     int blend_mode = 0;
     std::span<const std::uint32_t> frame_durations_ms;
     std::size_t pending_face_payloads = 0;
+    std::span<const DocumentCanvasFacePayloadInput> captured_face_payloads;
 };
 
 struct DocumentCanvasSnapshotInput {
@@ -50,7 +61,8 @@ struct DocumentCanvasSnapshotResult {
     std::size_t layer_count = 0;
     std::size_t frame_count = 0;
     std::size_t pending_face_payloads = 0;
-    bool metadata_only = true;
+    std::size_t captured_face_payloads = 0;
+    bool metadata_only = false;
     bool requires_renderer_payload_readback = false;
 };
 
@@ -87,9 +99,11 @@ public:
 
     std::size_t frame_count = 1U;
     std::size_t pending_face_payloads = 0U;
+    std::size_t captured_face_payloads = 0U;
     for (const auto& layer : input.layers) {
         frame_count = std::max(frame_count, layer.frame_durations_ms.size());
         pending_face_payloads += layer.pending_face_payloads;
+        captured_face_payloads += layer.captured_face_payloads.size();
     }
 
     if (input.active_layer_index >= input.layers.size()) {
@@ -161,6 +175,26 @@ public:
         return pp::foundation::Result<DocumentCanvasSnapshotResult>::failure(document.status());
     }
 
+    for (std::size_t layer_index = 0; layer_index < input.layers.size(); ++layer_index) {
+        for (const auto& payload : input.layers[layer_index].captured_face_payloads) {
+            pp::document::LayerFacePixels pixels {
+                .face_index = payload.face_index,
+                .x = payload.x,
+                .y = payload.y,
+                .width = payload.width,
+                .height = payload.height,
+                .rgba8 = std::vector<std::uint8_t>(payload.rgba8.begin(), payload.rgba8.end()),
+            };
+            const auto payload_status = document.value().set_layer_frame_face_pixels(
+                layer_index,
+                payload.frame_index,
+                std::move(pixels));
+            if (!payload_status.ok()) {
+                return pp::foundation::Result<DocumentCanvasSnapshotResult>::failure(payload_status);
+            }
+        }
+    }
+
     auto active_status = document.value().set_active_layer(input.active_layer_index);
     if (!active_status.ok()) {
         return pp::foundation::Result<DocumentCanvasSnapshotResult>::failure(active_status);
@@ -176,8 +210,9 @@ public:
         .layer_count = input.layers.size(),
         .frame_count = frame_count,
         .pending_face_payloads = pending_face_payloads,
-        .metadata_only = true,
-        .requires_renderer_payload_readback = pending_face_payloads > 0U,
+        .captured_face_payloads = captured_face_payloads,
+        .metadata_only = captured_face_payloads == 0U,
+        .requires_renderer_payload_readback = pending_face_payloads > captured_face_payloads,
     });
 }