Struct image::codecs::tga::decoder::TgaDecoder

pub struct TgaDecoder<R> {
    r: R,
    width: usize,
    height: usize,
    bytes_per_pixel: usize,
    has_loaded_metadata: bool,
    image_type: ImageType,
    color_type: ColorType,
    original_color_type: Option<ExtendedColorType>,
    header: Header,
    color_map: Option<ColorMap>,
    line_read: Option<usize>,
    line_remain_buff: Vec<u8>,
}

The representation of a TGA decoder

Fields

r: R

width: usize

height: usize

bytes_per_pixel: usize

has_loaded_metadata: bool

image_type: ImageType

color_type: ColorType

original_color_type: Option<ExtendedColorType>

header: Header

color_map: Option<ColorMap>

line_read: Option<usize>

line_remain_buff: Vec<u8>

Implementations

impl<R: Read + Seek> TgaDecoder<R>

pub fn new(r: R) -> ImageResult<TgaDecoder<R>>

Create a new decoder that decodes from the stream r

fn read_header(&mut self) -> ImageResult<()>

fn read_metadata(&mut self) -> ImageResult<()>

fn read_color_information(&mut self) -> ImageResult<()>

Loads the color information for the decoder

To keep things simple, we won’t handle bit depths that aren’t divisible by 8 and are larger than 32.

fn read_image_id(&mut self) -> ImageResult<()>

Read the image id field

We’re not interested in this field, so this function skips it if it is present

fn read_color_map(&mut self) -> ImageResult<()>

fn expand_color_map(&self, pixel_data: &[u8]) -> Result<Vec<u8>>

Expands indices into its mapped color

fn read_encoded_data(&mut self, num_bytes: usize) -> Result<Vec<u8>>

Reads a run length encoded data for given number of bytes

fn read_all_encoded_data(&mut self) -> ImageResult<Vec<u8>>

Reads a run length encoded packet

fn read_encoded_line(&mut self) -> Result<Vec<u8>>

Reads a run length encoded line

fn reverse_encoding_in_output(&mut self, pixels: &mut [u8])

Reverse from BGR encoding to RGB encoding

TGA files are stored in the BGRA encoding. This function swaps the blue and red bytes in the pixels array.

fn flip_vertically(&mut self, pixels: &mut [u8])

Flip the image vertically depending on the screen origin bit

The bit in position 5 of the image descriptor byte is the screen origin bit. If it’s 1, the origin is in the top left corner. If it’s 0, the origin is in the bottom left corner. This function checks the bit, and if it’s 0, flips the image vertically.

fn is_flipped_vertically(&self) -> bool

Check whether the image is vertically flipped

The bit in position 5 of the image descriptor byte is the screen origin bit. If it’s 1, the origin is in the top left corner. If it’s 0, the origin is in the bottom left corner. This function checks the bit, and if it’s 0, flips the image vertically.

fn read_scanline(&mut self, buf: &mut [u8]) -> Result<usize>

Trait Implementations

impl<'a, R: 'a + Read + Seek> ImageDecoder<'a> for TgaDecoder<R>

type Reader = TGAReader<R>

The type of reader produced by into_reader.

fn dimensions(&self) -> (u32, u32)

Returns a tuple containing the width and height of the image

fn color_type(&self) -> ColorType

Returns the color type of the image data produced by this decoder

fn original_color_type(&self) -> ExtendedColorType

Returns the color type of the image file before decoding

fn scanline_bytes(&self) -> u64

👎Deprecated: Planned for removal. See https://github.com/image-rs/image/issues/1989

Returns the minimum number of bytes that can be efficiently read from this decoder. This may be as few as 1 or as many as total_bytes().

fn into_reader(self) -> ImageResult<Self::Reader>

👎Deprecated: Planned for removal. See https://github.com/image-rs/image/issues/1989

Returns a reader that can be used to obtain the bytes of the image. For the best performance, always try to read at least scanline_bytes from the reader at a time. Reading fewer bytes will cause the reader to perform internal buffering.

fn read_image(self, buf: &mut [u8]) -> ImageResult<()>

Returns all the bytes in the image.

fn icc_profile(&mut self) -> Option<Vec<u8>>

Returns the ICC color profile embedded in the image

fn total_bytes(&self) -> u64

Returns the total number of bytes in the decoded image.

fn read_image_with_progress<F: Fn(Progress)>( self, buf: &mut [u8], progress_callback: F ) -> ImageResult<()>

👎Deprecated: Use read_image instead. See https://github.com/image-rs/image/issues/1989

Same as read_image but periodically calls the provided callback to give updates on loading progress.

fn set_limits(&mut self, limits: Limits) -> ImageResult<()>

Set decoding limits for this decoder. See Limits for the different kinds of limits that is possible to set.