mod edit;
mod image;
mod part;
#[cfg(test)]
mod tests;
pub use image::{ImageEntry, ValueKind, is_animated_png, png_dimensions};
use crate::{
Compression, Limits, Movie, container,
error::{Error, Result},
movie::decode,
wire::{self, Field, LENGTH_DELIMITED},
};
use part::{Buffer, Part};
use std::sync::Arc;
pub(crate) const VERSION: u32 = 1;
pub(crate) const PARAMS: u32 = 2;
pub(crate) const IMAGES: u32 = 3;
pub(crate) const SPRITES: u32 = 4;
pub(crate) const AUDIOS: u32 = 5;
#[derive(Debug, Clone)]
pub struct Document {
parts: Vec<Part>,
}
impl Document {
pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
Self::from_bytes_with(bytes, &Limits::default())
}
pub fn from_bytes_with(bytes: &[u8], limits: &Limits) -> Result<Self> {
let inflated = container::inflate(bytes, limits)?;
Self::from_buffer(Buffer::Vec(Arc::new(inflated)), limits)
}
pub fn from_proto(proto: impl Into<Arc<[u8]>>) -> Result<Self> {
Self::from_proto_with(proto, &Limits::default())
}
pub fn from_proto_with(proto: impl Into<Arc<[u8]>>, limits: &Limits) -> Result<Self> {
Self::from_buffer(Buffer::Slice(proto.into()), limits)
}
fn from_buffer(buffer: Buffer, limits: &Limits) -> Result<Self> {
if buffer.len() > limits.max_inflated_bytes {
return Err(Error::limit("svga_inflated_size_exceeds_limit"));
}
let mut parts = Vec::new();
for field in wire::fields(&buffer) {
if parts.len() >= limits.max_fields {
return Err(Error::limit("svga_too_many_fields"));
}
parts.push(Part::from_source(&buffer, &field?)?);
}
Ok(Self { parts })
}
pub fn from_movie(movie: &Movie, images: &[(&str, &[u8])]) -> Result<Self> {
Self::from_proto(crate::movie::encode::movie(movie, images))
}
pub fn fields(&self) -> impl Iterator<Item = Field<'_>> {
self.parts.iter().map(Part::field)
}
pub fn has_unknown_fields(&self) -> bool {
self.parts
.iter()
.any(|part| !(VERSION..=AUDIOS).contains(&part.number))
}
pub fn version(&self) -> Option<&str> {
let part = self.parts.iter().rfind(|part| part.number == VERSION)?;
std::str::from_utf8(part.field().payload).ok()
}
pub fn images(&self) -> impl DoubleEndedIterator<Item = ImageEntry<'_>> {
self.parts.iter().filter_map(Part::image)
}
pub fn image(&self, key: &str) -> Option<&[u8]> {
let mut entries = self
.images()
.filter(|image| image.key_bytes() == key.as_bytes());
entries.next_back().map(|image| image.value())
}
pub fn movie(&self) -> Result<Movie> {
self.movie_with(&Limits::default())
}
pub fn movie_with(&self, limits: &Limits) -> Result<Movie> {
decode::movie(self, limits)
}
pub fn proto_len(&self) -> usize {
self.parts.iter().map(|part| part.raw().len()).sum()
}
pub fn to_proto(&self) -> Vec<u8> {
let mut proto = Vec::with_capacity(self.proto_len());
for part in &self.parts {
proto.extend_from_slice(part.raw());
}
proto
}
pub fn to_bytes(&self, compression: Compression) -> Result<Vec<u8>> {
container::deflate(&self.to_proto(), compression)
}
}
fn expect_length_delimited(field: &Field<'_>) -> Result<()> {
if field.wire_type == LENGTH_DELIMITED {
Ok(())
} else {
Err(Error::malformed("svga_unexpected_wire_type"))
}
}