Summarize PPI project bodies

src/assets/ppi_header.cpp

@@ -2,6 +2,7 @@
 
 #include "foundation/binary_stream.h"
 
+#include <bit>
 #include <limits>
 
 namespace pp::assets {
@@ -13,6 +14,69 @@ namespace {
     return reader.read_u32_le();
 }
 
+[[nodiscard]] pp::foundation::Result<std::uint32_t> read_positive_i32(
+    pp::foundation::ByteReader& reader,
+    const char* message) noexcept
+{
+    const auto value = reader.read_u32_le();
+    if (!value) {
+        return value;
+    }
+
+    if (value.value() > static_cast<std::uint32_t>(std::numeric_limits<std::int32_t>::max())) {
+        return pp::foundation::Result<std::uint32_t>::failure(
+            pp::foundation::Status::out_of_range(message));
+    }
+
+    return value;
+}
+
+[[nodiscard]] pp::foundation::Result<float> read_f32(pp::foundation::ByteReader& reader) noexcept
+{
+    const auto bits = reader.read_u32_le();
+    if (!bits) {
+        return pp::foundation::Result<float>::failure(bits.status());
+    }
+
+    return pp::foundation::Result<float>::success(std::bit_cast<float>(bits.value()));
+}
+
+[[nodiscard]] pp::foundation::Status skip_bytes(
+    pp::foundation::ByteReader& reader,
+    std::size_t bytes) noexcept
+{
+    const auto skipped = reader.read_bytes(bytes);
+    if (!skipped) {
+        return skipped.status();
+    }
+
+    return pp::foundation::Status::success();
+}
+
+[[nodiscard]] pp::foundation::Status validate_canvas_size(std::uint32_t width, std::uint32_t height) noexcept
+{
+    if (width == 0 || height == 0) {
+        return pp::foundation::Status::invalid_argument("PPI canvas dimensions must be greater than zero");
+    }
+
+    if (width > max_ppi_canvas_dimension || height > max_ppi_canvas_dimension) {
+        return pp::foundation::Status::out_of_range("PPI canvas dimensions exceed the configured limit");
+    }
+
+    return pp::foundation::Status::success();
+}
+
+[[nodiscard]] pp::foundation::Status add_payload_bytes(PpiBodySummary& summary, std::uint32_t bytes) noexcept
+{
+    const auto next = summary.compressed_face_bytes + static_cast<std::uint64_t>(bytes);
+    if (next > max_ppi_face_payload_bytes) {
+        return pp::foundation::Status::out_of_range("PPI compressed face payload exceeds the configured limit");
+    }
+
+    summary.compressed_face_bytes = next;
+    return pp::foundation::Status::success();
+}
+
 }
 
 pp::foundation::Result<PpiHeaderInfo> parse_ppi_header(std::span<const std::byte> bytes) noexcept
@@ -134,4 +198,221 @@ pp::foundation::Result<PpiProjectLayout> parse_ppi_project_layout(std::span<cons
     });
 }
 
+pp::foundation::Result<PpiBodySummary> parse_ppi_body_summary(
+    PpiHeaderInfo header,
+    std::span<const std::byte> body) noexcept
+{
+    pp::foundation::ByteReader reader(body);
+    const auto width = read_positive_i32(reader, "PPI canvas width is outside the supported range");
+    const auto height = read_positive_i32(reader, "PPI canvas height is outside the supported range");
+    const auto layer_count = read_positive_i32(reader, "PPI layer count is outside the supported range");
+    if (!width || !height || !layer_count) {
+        return pp::foundation::Result<PpiBodySummary>::failure(
+            !width ? width.status() : (!height ? height.status() : layer_count.status()));
+    }
+
+    const auto canvas_status = validate_canvas_size(width.value(), height.value());
+    if (!canvas_status.ok()) {
+        return pp::foundation::Result<PpiBodySummary>::failure(canvas_status);
+    }
+
+    if (layer_count.value() == 0 || layer_count.value() > max_ppi_layer_count) {
+        return pp::foundation::Result<PpiBodySummary>::failure(
+            pp::foundation::Status::out_of_range("PPI layer count is outside the configured range"));
+    }
+
+    PpiBodySummary summary {
+        .width = width.value(),
+        .height = height.value(),
+        .layer_count = layer_count.value(),
+        .declared_frame_count = 1,
+    };
+
+    if (header.document_version.minor >= 3U) {
+        const auto declared_frames = read_positive_i32(reader, "PPI declared frame count is outside the supported range");
+        if (!declared_frames) {
+            return pp::foundation::Result<PpiBodySummary>::failure(declared_frames.status());
+        }
+
+        if (declared_frames.value() == 0 || declared_frames.value() > max_ppi_frame_count) {
+            return pp::foundation::Result<PpiBodySummary>::failure(
+                pp::foundation::Status::out_of_range("PPI declared frame count is outside the configured range"));
+        }
+        summary.declared_frame_count = declared_frames.value();
+    }
+
+    for (std::uint32_t layer_index = 0; layer_index < summary.layer_count; ++layer_index) {
+        const auto order = read_positive_i32(reader, "PPI layer order is outside the supported range");
+        const auto opacity = read_f32(reader);
+        const auto name_length = read_positive_i32(reader, "PPI layer name length is outside the supported range");
+        if (!order || !opacity || !name_length) {
+            return pp::foundation::Result<PpiBodySummary>::failure(
+                !order ? order.status() : (!opacity ? opacity.status() : name_length.status()));
+        }
+
+        if (order.value() >= summary.layer_count) {
+            return pp::foundation::Result<PpiBodySummary>::failure(
+                pp::foundation::Status::out_of_range("PPI layer order is outside the layer list"));
+        }
+
+        if (opacity.value() < 0.0F || opacity.value() > 1.0F) {
+            return pp::foundation::Result<PpiBodySummary>::failure(
+                pp::foundation::Status::out_of_range("PPI layer opacity is outside the supported range"));
+        }
+
+        if (name_length.value() > max_ppi_layer_name_length) {
+            return pp::foundation::Result<PpiBodySummary>::failure(
+                pp::foundation::Status::out_of_range("PPI layer name exceeds the configured limit"));
+        }
+
+        const auto name_status = skip_bytes(reader, name_length.value());
+        if (!name_status.ok()) {
+            return pp::foundation::Result<PpiBodySummary>::failure(name_status);
+        }
+
+        if (header.document_version.minor >= 2U) {
+            const auto blend_mode = read_positive_i32(reader, "PPI layer blend mode is outside the supported range");
+            const auto alpha_locked = reader.read_u8();
+            const auto visible = reader.read_u8();
+            if (!blend_mode || !alpha_locked || !visible) {
+                return pp::foundation::Result<PpiBodySummary>::failure(
+                    !blend_mode ? blend_mode.status() : (!alpha_locked ? alpha_locked.status() : visible.status()));
+            }
+
+            if (alpha_locked.value() > 1U || visible.value() > 1U) {
+                return pp::foundation::Result<PpiBodySummary>::failure(
+                    pp::foundation::Status::invalid_argument("PPI layer boolean field is invalid"));
+            }
+        }
+
+        std::uint32_t layer_frames = 1;
+        if (header.document_version.minor >= 3U) {
+            const auto frame_count = read_positive_i32(reader, "PPI layer frame count is outside the supported range");
+            if (!frame_count) {
+                return pp::foundation::Result<PpiBodySummary>::failure(frame_count.status());
+            }
+
+            if (frame_count.value() == 0 || frame_count.value() > max_ppi_frame_count) {
+                return pp::foundation::Result<PpiBodySummary>::failure(
+                    pp::foundation::Status::out_of_range("PPI layer frame count is outside the configured range"));
+            }
+            layer_frames = frame_count.value();
+        }
+
+        if (summary.total_layer_frames > max_ppi_frame_count - layer_frames) {
+            return pp::foundation::Result<PpiBodySummary>::failure(
+                pp::foundation::Status::out_of_range("PPI total frame count exceeds the configured limit"));
+        }
+        summary.total_layer_frames += layer_frames;
+
+        for (std::uint32_t frame_index = 0; frame_index < layer_frames; ++frame_index) {
+            if (header.document_version.minor >= 3U) {
+                const auto duration = read_positive_i32(reader, "PPI frame duration is outside the supported range");
+                if (!duration) {
+                    return pp::foundation::Result<PpiBodySummary>::failure(duration.status());
+                }
+
+                if (duration.value() == 0) {
+                    return pp::foundation::Result<PpiBodySummary>::failure(
+                        pp::foundation::Status::invalid_argument("PPI frame duration must be greater than zero"));
+                }
+            }
+
+            for (std::uint32_t face = 0; face < 6U; ++face) {
+                const auto has_data = read_positive_i32(reader, "PPI face data flag is outside the supported range");
+                if (!has_data) {
+                    return pp::foundation::Result<PpiBodySummary>::failure(has_data.status());
+                }
+
+                if (has_data.value() > 1U) {
+                    return pp::foundation::Result<PpiBodySummary>::failure(
+                        pp::foundation::Status::invalid_argument("PPI face data flag is invalid"));
+                }
+
+                if (has_data.value() == 0U) {
+                    continue;
+                }
+
+                ++summary.dirty_face_count;
+                const auto x0 = read_positive_i32(reader, "PPI dirty box coordinate is outside the supported range");
+                const auto y0 = read_positive_i32(reader, "PPI dirty box coordinate is outside the supported range");
+                const auto x1 = read_positive_i32(reader, "PPI dirty box coordinate is outside the supported range");
+                const auto y1 = read_positive_i32(reader, "PPI dirty box coordinate is outside the supported range");
+                const auto data_size = read_positive_i32(reader, "PPI compressed face data size is outside the supported range");
+                if (!x0 || !y0 || !x1 || !y1 || !data_size) {
+                    return pp::foundation::Result<PpiBodySummary>::failure(
+                        !x0 ? x0.status()
+                            : (!y0 ? y0.status() : (!x1 ? x1.status() : (!y1 ? y1.status() : data_size.status()))));
+                }
+
+                if (x0.value() >= x1.value() || y0.value() >= y1.value() || x1.value() > summary.width
+                    || y1.value() > summary.height) {
+                    return pp::foundation::Result<PpiBodySummary>::failure(
+                        pp::foundation::Status::out_of_range("PPI dirty box is outside the canvas"));
+                }
+
+                if (data_size.value() == 0U) {
+                    return pp::foundation::Result<PpiBodySummary>::failure(
+                        pp::foundation::Status::invalid_argument("PPI compressed face payload must not be empty"));
+                }
+
+                const auto payload_status = add_payload_bytes(summary, data_size.value());
+                if (!payload_status.ok()) {
+                    return pp::foundation::Result<PpiBodySummary>::failure(payload_status);
+                }
+
+                const auto skip_status = skip_bytes(reader, data_size.value());
+                if (!skip_status.ok()) {
+                    return pp::foundation::Result<PpiBodySummary>::failure(skip_status);
+                }
+            }
+        }
+    }
+
+    if (header.document_version.minor >= 3U && summary.total_layer_frames != summary.declared_frame_count) {
+        return pp::foundation::Result<PpiBodySummary>::failure(
+            pp::foundation::Status::invalid_argument("PPI declared frame count does not match layer frames"));
+    }
+
+    if (header.document_version.minor >= 4U) {
+        const auto info_bytes = read_positive_i32(reader, "PPI info block size is outside the supported range");
+        if (!info_bytes) {
+            return pp::foundation::Result<PpiBodySummary>::failure(info_bytes.status());
+        }
+
+        summary.info_bytes = info_bytes.value();
+        const auto info_status = skip_bytes(reader, summary.info_bytes);
+        if (!info_status.ok()) {
+            return pp::foundation::Result<PpiBodySummary>::failure(info_status);
+        }
+    }
+
+    if (!reader.empty()) {
+        return pp::foundation::Result<PpiBodySummary>::failure(
+            pp::foundation::Status::invalid_argument("PPI body has trailing bytes"));
+    }
+
+    return pp::foundation::Result<PpiBodySummary>::success(summary);
+}
+
+pp::foundation::Result<PpiProjectSummary> parse_ppi_project_summary(std::span<const std::byte> bytes) noexcept
+{
+    const auto layout = parse_ppi_project_layout(bytes);
+    if (!layout) {
+        return pp::foundation::Result<PpiProjectSummary>::failure(layout.status());
+    }
+
+    const auto body = parse_ppi_body_summary(
+        layout.value().header,
+        bytes.subspan(layout.value().body_offset, layout.value().body_bytes));
+    if (!body) {
+        return pp::foundation::Result<PpiProjectSummary>::failure(body.status());
+    }
+
+    return pp::foundation::Result<PpiProjectSummary>::success(PpiProjectSummary {
+        .layout = layout.value(),
+        .body = body.value(),
+    });
+}
+
 }