889 lines
37 KiB
C++
889 lines
37 KiB
C++
#include "assets/ppi_header.h"
|
|
|
|
#include "assets/image_metadata.h"
|
|
#include "foundation/binary_stream.h"
|
|
|
|
#include <array>
|
|
#include <bit>
|
|
#include <cmath>
|
|
#include <limits>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <utility>
|
|
|
|
namespace pp::assets {
|
|
|
|
namespace {
|
|
|
|
[[nodiscard]] pp::foundation::Result<std::uint32_t> read_u32(pp::foundation::ByteReader& reader) noexcept
|
|
{
|
|
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()));
|
|
}
|
|
|
|
void append_u32(std::vector<std::byte>& bytes, std::uint32_t value)
|
|
{
|
|
bytes.push_back(static_cast<std::byte>(value & 0xffU));
|
|
bytes.push_back(static_cast<std::byte>((value >> 8U) & 0xffU));
|
|
bytes.push_back(static_cast<std::byte>((value >> 16U) & 0xffU));
|
|
bytes.push_back(static_cast<std::byte>((value >> 24U) & 0xffU));
|
|
}
|
|
|
|
void append_f32(std::vector<std::byte>& bytes, float value)
|
|
{
|
|
append_u32(bytes, std::bit_cast<std::uint32_t>(value));
|
|
}
|
|
|
|
void append_ascii(std::vector<std::byte>& bytes, std::string_view value)
|
|
{
|
|
for (const auto ch : value) {
|
|
bytes.push_back(static_cast<std::byte>(ch));
|
|
}
|
|
}
|
|
|
|
[[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]] std::string generated_layer_name(std::string_view base_name, std::uint32_t layer_index, std::uint32_t layer_count)
|
|
{
|
|
if (layer_count == 1U) {
|
|
return std::string(base_name);
|
|
}
|
|
|
|
std::string name(base_name);
|
|
name.push_back(' ');
|
|
name += std::to_string(layer_index + 1U);
|
|
return name;
|
|
}
|
|
|
|
[[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();
|
|
}
|
|
|
|
[[nodiscard]] pp::foundation::Result<ImageMetadata> validate_face_png_payload(
|
|
std::span<const std::byte> payload,
|
|
std::uint32_t width,
|
|
std::uint32_t height) noexcept
|
|
{
|
|
const auto metadata = parse_png_metadata(payload);
|
|
if (!metadata) {
|
|
return pp::foundation::Result<ImageMetadata>::failure(metadata.status());
|
|
}
|
|
|
|
if (metadata.value().width != width || metadata.value().height != height) {
|
|
return pp::foundation::Result<ImageMetadata>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI face PNG dimensions do not match the dirty box"));
|
|
}
|
|
|
|
if (metadata.value().bit_depth != 8U || metadata.value().components != 4U
|
|
|| metadata.value().color_type != ImageColorType::rgba) {
|
|
return pp::foundation::Result<ImageMetadata>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI face PNG payload must be 8-bit RGBA"));
|
|
}
|
|
|
|
return pp::foundation::Result<ImageMetadata>::success(metadata.value());
|
|
}
|
|
|
|
}
|
|
|
|
pp::foundation::Result<PpiHeaderInfo> parse_ppi_header(std::span<const std::byte> bytes) noexcept
|
|
{
|
|
if (bytes.size() < ppi_header_size) {
|
|
return pp::foundation::Result<PpiHeaderInfo>::failure(
|
|
pp::foundation::Status::out_of_range("PPI header is truncated"));
|
|
}
|
|
|
|
pp::foundation::ByteReader reader(bytes.subspan(0, ppi_header_size));
|
|
const auto magic = reader.read_bytes(4);
|
|
if (!magic || magic.value()[0] != std::byte { 'P' } || magic.value()[1] != std::byte { 'P' }
|
|
|| magic.value()[2] != std::byte { 'I' } || magic.value()[3] != std::byte { 0 }) {
|
|
return pp::foundation::Result<PpiHeaderInfo>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI header magic is invalid"));
|
|
}
|
|
|
|
PpiHeaderInfo info;
|
|
const auto doc_major = read_u32(reader);
|
|
const auto doc_minor = read_u32(reader);
|
|
const auto soft_major = read_u32(reader);
|
|
const auto soft_minor = read_u32(reader);
|
|
const auto soft_fix = read_u32(reader);
|
|
const auto soft_build = read_u32(reader);
|
|
const auto thumb_width = read_u32(reader);
|
|
const auto thumb_height = read_u32(reader);
|
|
const auto thumb_components = read_u32(reader);
|
|
if (!doc_major || !doc_minor || !soft_major || !soft_minor || !soft_fix || !soft_build
|
|
|| !thumb_width || !thumb_height || !thumb_components) {
|
|
return pp::foundation::Result<PpiHeaderInfo>::failure(
|
|
pp::foundation::Status::out_of_range("PPI header is truncated"));
|
|
}
|
|
|
|
info.document_version = { doc_major.value(), doc_minor.value() };
|
|
info.software_version = {
|
|
soft_major.value(),
|
|
soft_minor.value(),
|
|
soft_fix.value(),
|
|
soft_build.value(),
|
|
};
|
|
info.thumbnail = {
|
|
thumb_width.value(),
|
|
thumb_height.value(),
|
|
thumb_components.value(),
|
|
};
|
|
|
|
if (info.document_version.major != 0 || info.document_version.minor < 1) {
|
|
return pp::foundation::Result<PpiHeaderInfo>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI document version is unsupported"));
|
|
}
|
|
|
|
if (info.thumbnail.width != 128 || info.thumbnail.height != 128 || info.thumbnail.components != 4) {
|
|
return pp::foundation::Result<PpiHeaderInfo>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI thumbnail descriptor is invalid"));
|
|
}
|
|
|
|
return pp::foundation::Result<PpiHeaderInfo>::success(info);
|
|
}
|
|
|
|
pp::foundation::Result<std::size_t> ppi_thumbnail_byte_size(PpiThumbnailInfo thumbnail) noexcept
|
|
{
|
|
if (thumbnail.width == 0 || thumbnail.height == 0 || thumbnail.components == 0) {
|
|
return pp::foundation::Result<std::size_t>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI thumbnail descriptor is invalid"));
|
|
}
|
|
|
|
const auto width = static_cast<std::uint64_t>(thumbnail.width);
|
|
const auto height = static_cast<std::uint64_t>(thumbnail.height);
|
|
const auto components = static_cast<std::uint64_t>(thumbnail.components);
|
|
if (width > std::numeric_limits<std::uint64_t>::max() / height) {
|
|
return pp::foundation::Result<std::size_t>::failure(
|
|
pp::foundation::Status::out_of_range("PPI thumbnail byte size overflows"));
|
|
}
|
|
|
|
const auto pixels = width * height;
|
|
if (pixels > std::numeric_limits<std::uint64_t>::max() / components) {
|
|
return pp::foundation::Result<std::size_t>::failure(
|
|
pp::foundation::Status::out_of_range("PPI thumbnail byte size overflows"));
|
|
}
|
|
|
|
const auto bytes = pixels * components;
|
|
if (bytes > static_cast<std::uint64_t>(std::numeric_limits<std::size_t>::max())) {
|
|
return pp::foundation::Result<std::size_t>::failure(
|
|
pp::foundation::Status::out_of_range("PPI thumbnail byte size exceeds addressable memory"));
|
|
}
|
|
|
|
return pp::foundation::Result<std::size_t>::success(static_cast<std::size_t>(bytes));
|
|
}
|
|
|
|
pp::foundation::Result<PpiProjectLayout> parse_ppi_project_layout(std::span<const std::byte> bytes) noexcept
|
|
{
|
|
const auto header = parse_ppi_header(bytes);
|
|
if (!header) {
|
|
return pp::foundation::Result<PpiProjectLayout>::failure(header.status());
|
|
}
|
|
|
|
const auto thumbnail_bytes = ppi_thumbnail_byte_size(header.value().thumbnail);
|
|
if (!thumbnail_bytes) {
|
|
return pp::foundation::Result<PpiProjectLayout>::failure(thumbnail_bytes.status());
|
|
}
|
|
|
|
if (thumbnail_bytes.value() > std::numeric_limits<std::size_t>::max() - ppi_header_size) {
|
|
return pp::foundation::Result<PpiProjectLayout>::failure(
|
|
pp::foundation::Status::out_of_range("PPI thumbnail byte size overflows"));
|
|
}
|
|
|
|
const auto body_offset = ppi_header_size + thumbnail_bytes.value();
|
|
if (bytes.size() < body_offset) {
|
|
return pp::foundation::Result<PpiProjectLayout>::failure(
|
|
pp::foundation::Status::out_of_range("PPI thumbnail payload is truncated"));
|
|
}
|
|
|
|
return pp::foundation::Result<PpiProjectLayout>::success(PpiProjectLayout {
|
|
.header = header.value(),
|
|
.thumbnail_offset = ppi_header_size,
|
|
.thumbnail_bytes = thumbnail_bytes.value(),
|
|
.body_offset = body_offset,
|
|
.body_bytes = bytes.size() - body_offset,
|
|
});
|
|
}
|
|
|
|
namespace {
|
|
|
|
pp::foundation::Result<PpiBodySummary> parse_ppi_body_impl(
|
|
PpiHeaderInfo header,
|
|
std::span<const std::byte> body,
|
|
PpiBodyIndex* index) noexcept
|
|
{
|
|
if (index != nullptr) {
|
|
index->summary = {};
|
|
index->layers.clear();
|
|
}
|
|
|
|
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,
|
|
};
|
|
|
|
std::vector<bool> seen_orders;
|
|
if (index != nullptr) {
|
|
index->layers.resize(summary.layer_count);
|
|
seen_orders.assign(summary.layer_count, false);
|
|
}
|
|
|
|
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 (index != nullptr) {
|
|
if (seen_orders[order.value()]) {
|
|
return pp::foundation::Result<PpiBodySummary>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI layer order is duplicated"));
|
|
}
|
|
seen_orders[order.value()] = true;
|
|
}
|
|
|
|
if (!std::isfinite(opacity.value())) {
|
|
return pp::foundation::Result<PpiBodySummary>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI layer opacity must be finite"));
|
|
}
|
|
|
|
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_bytes = reader.read_bytes(name_length.value());
|
|
if (!name_bytes) {
|
|
return pp::foundation::Result<PpiBodySummary>::failure(name_bytes.status());
|
|
}
|
|
|
|
PpiLayerSummary layer_summary;
|
|
if (index != nullptr) {
|
|
layer_summary.stored_order = order.value();
|
|
layer_summary.opacity = opacity.value();
|
|
layer_summary.name.reserve(name_bytes.value().size());
|
|
for (const auto byte : name_bytes.value()) {
|
|
layer_summary.name.push_back(static_cast<char>(std::to_integer<unsigned char>(byte)));
|
|
}
|
|
}
|
|
|
|
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"));
|
|
}
|
|
|
|
if (blend_mode.value() > 4U) {
|
|
return pp::foundation::Result<PpiBodySummary>::failure(
|
|
pp::foundation::Status::out_of_range("PPI layer blend mode is outside the supported range"));
|
|
}
|
|
|
|
if (index != nullptr) {
|
|
layer_summary.blend_mode = blend_mode.value();
|
|
layer_summary.alpha_locked = alpha_locked.value() != 0U;
|
|
layer_summary.visible = visible.value() != 0U;
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
if (index != nullptr) {
|
|
layer_summary.frames.resize(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"));
|
|
}
|
|
|
|
if (index != nullptr) {
|
|
layer_summary.frames[frame_index].duration_ms = duration.value();
|
|
}
|
|
}
|
|
|
|
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 byte_status = add_payload_bytes(summary, data_size.value());
|
|
if (!byte_status.ok()) {
|
|
return pp::foundation::Result<PpiBodySummary>::failure(byte_status);
|
|
}
|
|
|
|
const auto payload_offset = reader.position();
|
|
const auto payload = reader.read_bytes(data_size.value());
|
|
if (!payload) {
|
|
return pp::foundation::Result<PpiBodySummary>::failure(payload.status());
|
|
}
|
|
|
|
const auto png_metadata = validate_face_png_payload(
|
|
payload.value(),
|
|
x1.value() - x0.value(),
|
|
y1.value() - y0.value());
|
|
if (!png_metadata) {
|
|
return pp::foundation::Result<PpiBodySummary>::failure(png_metadata.status());
|
|
}
|
|
|
|
++summary.rgba_face_payload_count;
|
|
if (index != nullptr) {
|
|
layer_summary.frames[frame_index].faces[face] = PpiFacePayloadSummary {
|
|
.has_data = true,
|
|
.x0 = x0.value(),
|
|
.y0 = y0.value(),
|
|
.x1 = x1.value(),
|
|
.y1 = y1.value(),
|
|
.body_payload_offset = static_cast<std::uint32_t>(payload_offset),
|
|
.payload_bytes = data_size.value(),
|
|
.png_width = png_metadata.value().width,
|
|
.png_height = png_metadata.value().height,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
if (index != nullptr) {
|
|
index->layers[order.value()] = std::move(layer_summary);
|
|
}
|
|
}
|
|
|
|
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"));
|
|
}
|
|
|
|
if (index != nullptr) {
|
|
index->summary = summary;
|
|
}
|
|
|
|
return pp::foundation::Result<PpiBodySummary>::success(summary);
|
|
}
|
|
|
|
}
|
|
|
|
pp::foundation::Result<PpiBodySummary> parse_ppi_body_summary(
|
|
PpiHeaderInfo header,
|
|
std::span<const std::byte> body) noexcept
|
|
{
|
|
return parse_ppi_body_impl(header, body, nullptr);
|
|
}
|
|
|
|
pp::foundation::Result<PpiBodyIndex> parse_ppi_body_index(
|
|
PpiHeaderInfo header,
|
|
std::span<const std::byte> body)
|
|
{
|
|
PpiBodyIndex index;
|
|
const auto summary = parse_ppi_body_impl(header, body, &index);
|
|
if (!summary) {
|
|
return pp::foundation::Result<PpiBodyIndex>::failure(summary.status());
|
|
}
|
|
|
|
return pp::foundation::Result<PpiBodyIndex>::success(std::move(index));
|
|
}
|
|
|
|
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(),
|
|
});
|
|
}
|
|
|
|
pp::foundation::Result<PpiProjectIndex> parse_ppi_project_index(std::span<const std::byte> bytes)
|
|
{
|
|
const auto layout = parse_ppi_project_layout(bytes);
|
|
if (!layout) {
|
|
return pp::foundation::Result<PpiProjectIndex>::failure(layout.status());
|
|
}
|
|
|
|
const auto body = parse_ppi_body_index(
|
|
layout.value().header,
|
|
bytes.subspan(layout.value().body_offset, layout.value().body_bytes));
|
|
if (!body) {
|
|
return pp::foundation::Result<PpiProjectIndex>::failure(body.status());
|
|
}
|
|
|
|
return pp::foundation::Result<PpiProjectIndex>::success(PpiProjectIndex {
|
|
.layout = layout.value(),
|
|
.body = body.value(),
|
|
});
|
|
}
|
|
|
|
pp::foundation::Result<PpiDecodedProjectImages> decode_ppi_project_images(std::span<const std::byte> bytes)
|
|
{
|
|
auto project = parse_ppi_project_index(bytes);
|
|
if (!project) {
|
|
return pp::foundation::Result<PpiDecodedProjectImages>::failure(project.status());
|
|
}
|
|
|
|
PpiDecodedProjectImages decoded {
|
|
.project = project.value(),
|
|
.faces = {},
|
|
};
|
|
decoded.faces.reserve(decoded.project.body.summary.rgba_face_payload_count);
|
|
|
|
const auto body = bytes.subspan(decoded.project.layout.body_offset, decoded.project.layout.body_bytes);
|
|
for (std::size_t layer_index = 0; layer_index < decoded.project.body.layers.size(); ++layer_index) {
|
|
const auto& layer = decoded.project.body.layers[layer_index];
|
|
for (std::size_t frame_index = 0; frame_index < layer.frames.size(); ++frame_index) {
|
|
const auto& frame = layer.frames[frame_index];
|
|
for (std::size_t face_index = 0; face_index < frame.faces.size(); ++face_index) {
|
|
const auto& face = frame.faces[face_index];
|
|
if (!face.has_data) {
|
|
continue;
|
|
}
|
|
|
|
if (face.body_payload_offset > body.size()
|
|
|| face.payload_bytes > body.size() - face.body_payload_offset) {
|
|
return pp::foundation::Result<PpiDecodedProjectImages>::failure(
|
|
pp::foundation::Status::out_of_range("PPI face payload range is outside the body"));
|
|
}
|
|
|
|
const auto image = decode_png_rgba8(
|
|
body.subspan(face.body_payload_offset, face.payload_bytes));
|
|
if (!image) {
|
|
return pp::foundation::Result<PpiDecodedProjectImages>::failure(image.status());
|
|
}
|
|
|
|
if (image.value().width != face.png_width || image.value().height != face.png_height) {
|
|
return pp::foundation::Result<PpiDecodedProjectImages>::failure(
|
|
pp::foundation::Status::invalid_argument("decoded PPI face payload dimensions changed"));
|
|
}
|
|
|
|
decoded.faces.push_back(PpiDecodedFacePayload {
|
|
.layer_index = static_cast<std::uint32_t>(layer_index),
|
|
.frame_index = static_cast<std::uint32_t>(frame_index),
|
|
.face_index = static_cast<std::uint32_t>(face_index),
|
|
.descriptor = face,
|
|
.image = image.value(),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return pp::foundation::Result<PpiDecodedProjectImages>::success(std::move(decoded));
|
|
}
|
|
|
|
pp::foundation::Result<std::vector<std::byte>> create_ppi_project(PpiProjectConfig config)
|
|
{
|
|
const auto canvas_status = validate_canvas_size(config.width, config.height);
|
|
if (!canvas_status.ok()) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(canvas_status);
|
|
}
|
|
|
|
if (config.layers.empty() || config.layers.size() > max_ppi_layer_count) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI layer count is outside the configured range"));
|
|
}
|
|
|
|
std::uint32_t total_frame_count = 0;
|
|
std::vector<std::size_t> layer_frame_offsets;
|
|
layer_frame_offsets.reserve(config.layers.size());
|
|
for (const auto& layer : config.layers) {
|
|
if (layer.name.empty()) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI layer name must not be empty"));
|
|
}
|
|
|
|
if (layer.name.size() > max_ppi_layer_name_length) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI layer name exceeds the configured limit"));
|
|
}
|
|
|
|
if (!std::isfinite(layer.metadata.opacity)) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI layer opacity must be finite"));
|
|
}
|
|
|
|
if (layer.metadata.opacity < 0.0F || layer.metadata.opacity > 1.0F) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI layer opacity is outside the supported range"));
|
|
}
|
|
|
|
if (layer.metadata.blend_mode > 4U) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI layer blend mode is outside the supported range"));
|
|
}
|
|
|
|
if (layer.frames.empty() || layer.frames.size() > max_ppi_frame_count) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI layer frame count is outside the configured range"));
|
|
}
|
|
|
|
if (layer.frames.size() > max_ppi_frame_count - total_frame_count) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI total layer frame count exceeds the configured range"));
|
|
}
|
|
|
|
layer_frame_offsets.push_back(total_frame_count);
|
|
total_frame_count += static_cast<std::uint32_t>(layer.frames.size());
|
|
|
|
for (const auto& frame : layer.frames) {
|
|
if (frame.duration_ms == 0) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI frame duration must be greater than zero"));
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<std::array<bool, 6>> seen_faces(total_frame_count);
|
|
std::uint64_t total_payload_bytes = 0;
|
|
for (const auto& face : config.dirty_faces) {
|
|
if (face.layer_index >= config.layers.size()) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI dirty face layer index is outside the layer list"));
|
|
}
|
|
|
|
if (face.frame_index >= config.layers[face.layer_index].frames.size()) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI dirty face frame index is outside the frame list"));
|
|
}
|
|
|
|
if (face.face_index >= 6U) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI dirty face index is outside the cube face list"));
|
|
}
|
|
|
|
const auto slot_index = layer_frame_offsets[face.layer_index] + static_cast<std::size_t>(face.frame_index);
|
|
if (seen_faces[slot_index][face.face_index]) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI dirty face slot is duplicated"));
|
|
}
|
|
seen_faces[slot_index][face.face_index] = true;
|
|
|
|
if (face.width == 0 || face.height == 0) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI dirty face dimensions must be greater than zero"));
|
|
}
|
|
|
|
if (face.x > config.width || face.width > config.width - face.x
|
|
|| face.y > config.height || face.height > config.height - face.y) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI dirty face box is outside the canvas"));
|
|
}
|
|
|
|
if (face.png_rgba8.empty()) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::invalid_argument("PPI dirty face PNG payload must not be empty"));
|
|
}
|
|
|
|
if (face.png_rgba8.size() > static_cast<std::size_t>(std::numeric_limits<std::uint32_t>::max())) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI dirty face PNG payload is too large"));
|
|
}
|
|
|
|
const auto next_payload_bytes = total_payload_bytes + face.png_rgba8.size();
|
|
if (next_payload_bytes > max_ppi_face_payload_bytes) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI dirty face PNG payloads exceed the configured limit"));
|
|
}
|
|
total_payload_bytes = next_payload_bytes;
|
|
|
|
const auto metadata = validate_face_png_payload(face.png_rgba8, face.width, face.height);
|
|
if (!metadata) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(metadata.status());
|
|
}
|
|
}
|
|
|
|
std::vector<std::byte> bytes {
|
|
std::byte { 'P' },
|
|
std::byte { 'P' },
|
|
std::byte { 'I' },
|
|
std::byte { 0 },
|
|
};
|
|
append_u32(bytes, 0);
|
|
append_u32(bytes, 4);
|
|
append_u32(bytes, 0);
|
|
append_u32(bytes, 0);
|
|
append_u32(bytes, 0);
|
|
append_u32(bytes, 0);
|
|
append_u32(bytes, 128);
|
|
append_u32(bytes, 128);
|
|
append_u32(bytes, 4);
|
|
|
|
constexpr std::size_t thumbnail_bytes = 128U * 128U * 4U;
|
|
bytes.resize(ppi_header_size + thumbnail_bytes, std::byte { 0 });
|
|
|
|
append_u32(bytes, config.width);
|
|
append_u32(bytes, config.height);
|
|
append_u32(bytes, static_cast<std::uint32_t>(config.layers.size()));
|
|
append_u32(bytes, total_frame_count);
|
|
for (std::uint32_t layer = 0; layer < config.layers.size(); ++layer) {
|
|
const auto& layer_config = config.layers[layer];
|
|
append_u32(bytes, layer);
|
|
append_f32(bytes, layer_config.metadata.opacity);
|
|
append_u32(bytes, static_cast<std::uint32_t>(layer_config.name.size()));
|
|
append_ascii(bytes, layer_config.name);
|
|
append_u32(bytes, layer_config.metadata.blend_mode);
|
|
bytes.push_back(layer_config.metadata.alpha_locked ? std::byte { 1 } : std::byte { 0 });
|
|
bytes.push_back(layer_config.metadata.visible ? std::byte { 1 } : std::byte { 0 });
|
|
append_u32(bytes, static_cast<std::uint32_t>(layer_config.frames.size()));
|
|
for (std::uint32_t frame = 0; frame < layer_config.frames.size(); ++frame) {
|
|
append_u32(bytes, layer_config.frames[frame].duration_ms);
|
|
for (std::uint32_t face = 0; face < 6U; ++face) {
|
|
const PpiDirtyFacePayloadConfig* dirty_face = nullptr;
|
|
for (const auto& candidate : config.dirty_faces) {
|
|
if (candidate.layer_index == layer && candidate.frame_index == frame
|
|
&& candidate.face_index == face) {
|
|
dirty_face = &candidate;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (dirty_face == nullptr) {
|
|
append_u32(bytes, 0);
|
|
continue;
|
|
}
|
|
|
|
append_u32(bytes, 1);
|
|
append_u32(bytes, dirty_face->x);
|
|
append_u32(bytes, dirty_face->y);
|
|
append_u32(bytes, dirty_face->x + dirty_face->width);
|
|
append_u32(bytes, dirty_face->y + dirty_face->height);
|
|
append_u32(bytes, static_cast<std::uint32_t>(dirty_face->png_rgba8.size()));
|
|
bytes.insert(bytes.end(), dirty_face->png_rgba8.begin(), dirty_face->png_rgba8.end());
|
|
}
|
|
}
|
|
}
|
|
append_u32(bytes, 0);
|
|
|
|
return pp::foundation::Result<std::vector<std::byte>>::success(std::move(bytes));
|
|
}
|
|
|
|
pp::foundation::Result<std::vector<std::byte>> create_minimal_ppi_project(PpiMinimalProjectConfig config)
|
|
{
|
|
if (config.layer_count == 0 || config.layer_count > max_ppi_layer_count) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI layer count is outside the configured range"));
|
|
}
|
|
|
|
if (config.frame_count == 0 || config.frame_count > max_ppi_frame_count) {
|
|
return pp::foundation::Result<std::vector<std::byte>>::failure(
|
|
pp::foundation::Status::out_of_range("PPI frame count is outside the configured range"));
|
|
}
|
|
|
|
std::vector<std::string> names;
|
|
names.reserve(config.layer_count);
|
|
std::vector<std::vector<PpiFrameConfig>> frame_lists;
|
|
frame_lists.reserve(config.layer_count);
|
|
std::vector<PpiLayerConfig> layers;
|
|
layers.reserve(config.layer_count);
|
|
for (std::uint32_t layer = 0; layer < config.layer_count; ++layer) {
|
|
names.push_back(generated_layer_name(config.layer_name, layer, config.layer_count));
|
|
auto& frames = frame_lists.emplace_back();
|
|
frames.assign(config.frame_count, PpiFrameConfig { .duration_ms = config.frame_duration_ms });
|
|
layers.push_back(PpiLayerConfig {
|
|
.name = names.back(),
|
|
.metadata = config.layer_metadata,
|
|
.frames = std::span<const PpiFrameConfig>(frames.data(), frames.size()),
|
|
});
|
|
}
|
|
|
|
return create_ppi_project(PpiProjectConfig {
|
|
.width = config.width,
|
|
.height = config.height,
|
|
.layers = std::span<const PpiLayerConfig>(layers.data(), layers.size()),
|
|
.dirty_faces = config.dirty_faces,
|
|
});
|
|
}
|
|
|
|
}
|