mirx 0.43.0

MIRX binary image format — flat & chunk-based container for ahead-of-time UI assets
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

#![doc = include_str!("../README.md")]
#![no_std]

extern crate alloc;

mod alignment;
mod chunk;
pub mod coding;
mod crc32;
pub mod document;
mod error;
mod flat;
pub mod font;
mod format;
mod header;
pub mod image;
pub mod media;
mod model;
pub mod path;
pub mod payload;
pub mod reader;
pub mod scene;
pub mod types;
mod wire;

pub use alignment::{ByteAlignment, InvalidByteAlignment};
pub use chunk::{
    ChunkFile, ImageChunk, ImageChunkInput, encode_chunk_generic, encode_chunk_image,
    encode_chunks, parse_chunk,
};
pub use crc32::compute as crc32;
pub use document::{
    ChunkIter, ChunksOfType, CompatibilityPolicy, CriticalAssumption, Document, DocumentChunkMut,
    DocumentChunkRef, EncodeOptions, FileMetadata, LayoutPolicy, OpenOptions, PayloadInput,
    PayloadOrigin, RawChunkInput, RawChunkPolicy, RawTypePolicy, RelocationAssumption,
    RemovedChunkMetadata, ReservedBitsPolicy,
};
pub use error::{
    DocumentError, EditError, EncodeError, FontAccessError, FramesAccessError, ImageDecodeError,
    MetaAccessError, PaletteAccessError, ParseError, ReadError, TryEditError, VectorAccessError,
};
pub use flat::{FlatImage, FlatImageInput, encode_flat, parse_flat};
pub use font::{
    Font, FontAsset, FontCodepointError, FontCodepointIter, FontCodepoints, FontError,
    FontRepresentation, FontRepresentationError, FontRepresentationFallback,
    FontRepresentationKind, FontRepresentationMatch, FontRepresentationPreference,
    FontRepresentationRequest, FontRepresentations, FontSelectionError, FontView,
};
pub use format::ColorFormat;
pub use header::{
    CHUNK_FILE_HEADER_LEN, CHUNK_TABLE_ENTRY_LEN, ChunkEntry, ChunkFileHeader, FILE_HEADER_LEN,
    FLAT_HEADER_LEN, FileHeader, FlatHeader, Layout, MAGIC, VERSION_MAJOR, VERSION_MINOR,
    chunk_type,
};
pub use media::CodingId;
pub use model::{ChunkFlags, ChunkId, ChunkType, InvalidChunkType, PrimaryHints};
pub use path::{Path, PathCmd};
pub use payload::frames::{
    BlendMode, DisposalMode, EncodedFrames, FrameDecodeError, FrameEncoding, FrameEncodingSet,
    FramePolicy, FramePosition, FrameSequence, FrameSequenceError, FrameSession, FrameTimeline,
    FrameWriteError, FramesEncoder, FramesError, FramesPlaybackPlan, FramesView, PlaybackStorage,
};
pub use payload::image::{ImageAsset, ImageEncodeError, ImagePayloadError, ImageView};
pub use payload::meta::{
    Meta, MetaDecodeError, MetaEncodeError, MetaEntry, MetaEntryIter, MetaEntryRef,
    MetaMutationError, MetaValue, MetaValueRef, MetaView,
};
pub use payload::palette::{
    Palette, PaletteDecodeError, PaletteEncodeError, PaletteMutationError, PaletteView,
};
pub use payload::{ColorTableIter, ColorTableView};
pub use reader::{
    ChunkRef, ComplianceFinding, ContainerHeader, EntryIter, FindingIter, PayloadLimits,
    PayloadLocation, PayloadValidationError, PayloadValidationFailure, ReadOptions, Reader,
    TrailingBytesPolicy,
};
pub use scene::{
    CodecError, CompositeMode, FillRule, GradientStop, GradientUnits, LineCap, LineJoin,
    LinearGradient, Paint, RadialGradient, ResourceRef, Scene, SceneOp, SpreadMode,
    VectorChunkHeader, VectorEncodeError, VectorReadError,
};
pub use types::{Color, Fixed, Point, Rect, Transform};

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MirxFile<'a> {
    Flat(FlatImage<'a>),
    Chunk(ChunkFile<'a>),
}

pub fn parse(buf: &[u8]) -> Result<MirxFile<'_>, ParseError> {
    let header = FileHeader::parse(buf)?;
    match header.layout {
        Layout::Flat => parse_flat(buf).map(MirxFile::Flat),
        Layout::Chunk => parse_chunk(buf).map(MirxFile::Chunk),
    }
}

/// Only validates the common prefix; layout-specific bytes are untouched.
pub fn peek_header(buf: &[u8]) -> Result<FileHeader, ParseError> {
    FileHeader::parse(buf)
}