Struct libheif_rs::HeifContext

pub struct HeifContext<'a> { /* private fields */ }

Implementations

impl HeifContext<'static>

pub fn new() -> Result<HeifContext<'static>>

Create a new empty context.

pub fn read_from_file(name: &str) -> Result<HeifContext<'static>>

Create a new context from file.

pub fn read_from_reader(reader: Box<dyn Reader>) -> Result<HeifContext<'static>>

Create a new context from reader.

impl<'a> HeifContext<'a>

pub fn read_from_bytes(bytes: &[u8]) -> Result<HeifContext<'_>>

Create a new context from bytes.

The provided memory buffer is not copied. That means, you will have to keep the memory buffer alive as long as you use the context.

pub fn write_to_bytes(&self) -> Result<Vec<u8>>

pub fn write_to_file(&self, name: &str) -> Result<()>

pub fn number_of_top_level_images(&self) -> usize

pub fn top_level_image_ids(&self, item_ids: &mut [ItemId]) -> usize

pub fn image_handle(&self, item_id: ItemId) -> Result<ImageHandle>

pub fn primary_image_handle(&self) -> Result<ImageHandle>

pub fn top_level_image_handles(&self) -> Vec<ImageHandle>

pub fn encode_image( &mut self, image: &Image, encoder: &mut Encoder<'_>, encoding_options: Option<EncodingOptions> ) -> Result<ImageHandle>

Compress the input image. The first image added to the context is also automatically set as the primary image, but you can change the primary image later with HeifContext::set_primary_image method.

pub fn encode_thumbnail( &mut self, image: &Image, master_image_handle: &ImageHandle, bbox_size: u32, encoder: &mut Encoder<'_>, encoding_options: Option<EncodingOptions> ) -> Result<Option<ImageHandle>>

Encode the image as a scaled down thumbnail image. The image is scaled down to fit into a square area of width bbox_size. If the input image is already so small that it fits into this bounding box, no thumbnail image is encoded and Ok(None) is returned. No error is returned in this case.

The encoded thumbnail is automatically assigned to the master_image_handle. Hence, you do not have to call HeifContext::assign_thumbnail() method.

pub fn assign_thumbnail( &mut self, master_image_handle: &ImageHandle, thumbnail_image_handle: &ImageHandle ) -> Result<()>

Assign master_image_handle as the thumbnail image of thumbnail_image_handle.

pub fn set_primary_image( &mut self, image_handle: &mut ImageHandle ) -> Result<()>

pub fn add_generic_metadata<T>( &mut self, image_handle: &ImageHandle, data: &[u8], item_type: T, content_type: Option<&str> ) -> Result<()>where T: Into<FourCC>,

Add generic, proprietary metadata to an image. You have to specify an item_type that will identify your metadata. content_type can be an additional type.

For example, this function can be used to add IPTC metadata (IIM stream, not XMP) to an image. Although not standard, we propose to store IPTC data with item_type=b"iptc" and content_type=None.

pub fn add_exif_metadata( &mut self, master_image: &ImageHandle, data: &[u8] ) -> Result<()>

Add EXIF metadata to an image.

pub fn add_xmp_metadata( &mut self, master_image: &ImageHandle, data: &[u8] ) -> Result<()>

Add XMP metadata to an image.

pub fn set_max_decoding_threads(&mut self, max_threads: u32)

If the maximum threads number is set to 0, the image tiles are decoded in the main thread. This is different from setting it to 1, which will generate a single background thread to decode the tiles.

Note that this setting only affects libheif itself. The codecs itself may still use multi-threaded decoding. You can use it, for example, in cases where you are decoding several images in parallel anyway you thus want to minimize parallelism in each decoder.

Trait Implementations

impl<'a> Drop for HeifContext<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> Send for HeifContext<'a>