stegano_f5_jpeg_decoder/

parser.rs

use crate::error::{Error, Result, UnsupportedFeature};
use crate::huffman::{HuffmanTable, HuffmanTableClass};
use crate::marker::Marker;
use crate::marker::Marker::*;
use crate::{read_u8, read_u16_from_be};
use alloc::borrow::ToOwned;
use alloc::vec::Vec;
use alloc::{format, vec};
use core::ops::{self, Range};
use std::io::{self, Read};

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Dimensions {
    pub width: u16,
    pub height: u16,
}

/// The entropy coding method used in the JPEG image.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EntropyCoding {
    /// Huffman coding (most common)
    Huffman,
    /// Arithmetic coding
    Arithmetic,
}

/// Represents the coding process of an image.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CodingProcess {
    /// Sequential Discrete Cosine Transform
    DctSequential,
    /// Progressive Discrete Cosine Transform
    DctProgressive,
    /// Lossless
    Lossless,
}

// Table H.1
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Predictor {
    NoPrediction,
    Ra,
    Rb,
    Rc,
    RaRbRc1, // Ra + Rb - Rc
    RaRbRc2, // Ra + ((Rb - Rc) >> 1)
    RaRbRc3, // Rb + ((Ra - Rb) >> 1)
    RaRb,    // (Ra + Rb)/2
}

/// Information from the JPEG frame header (SOF marker).
#[derive(Clone)]
pub struct FrameInfo {
    /// Whether this is a baseline DCT frame (SOF0).
    pub is_baseline: bool,
    /// Whether this is a differential frame.
    pub is_differential: bool,
    /// The coding process (sequential, progressive, or lossless).
    pub coding_process: CodingProcess,
    /// The entropy coding method (Huffman or arithmetic).
    pub entropy_coding: EntropyCoding,
    /// Sample precision in bits (typically 8 or 12).
    pub precision: u8,
    /// The original image dimensions.
    pub image_size: Dimensions,
    /// The output dimensions (may differ due to scaling).
    pub output_size: Dimensions,
    /// The MCU (Minimum Coded Unit) grid dimensions.
    pub mcu_size: Dimensions,
    /// The image components (Y, Cb, Cr, etc.).
    pub components: Vec<Component>,
}

#[derive(Debug)]
pub struct ScanInfo {
    pub component_indices: Vec<usize>,
    pub dc_table_indices: Vec<usize>,
    pub ac_table_indices: Vec<usize>,

    pub spectral_selection: Range<u8>,
    pub predictor_selection: Predictor, // for lossless
    pub successive_approximation_high: u8,
    pub successive_approximation_low: u8,
    pub point_transform: u8, // for lossless
}

/// A JPEG image component (e.g., Y, Cb, Cr).
#[derive(Clone, Debug)]
pub struct Component {
    /// Component identifier (1=Y, 2=Cb, 3=Cr in JFIF).
    pub identifier: u8,
    /// Horizontal sampling factor (1-4).
    pub horizontal_sampling_factor: u8,
    /// Vertical sampling factor (1-4).
    pub vertical_sampling_factor: u8,
    /// Index of the quantization table used by this component.
    pub quantization_table_index: usize,
    /// DCT scaling factor.
    pub dct_scale: usize,
    /// Component dimensions in pixels.
    pub size: Dimensions,
    /// Component dimensions in 8x8 blocks.
    pub block_size: Dimensions,
}

#[derive(Debug)]
pub enum AppData {
    Adobe(AdobeColorTransform),
    Jfif,
    Avi1,
    Icc(IccChunk),
    Exif(Vec<u8>),
    Xmp(Vec<u8>),
    Psir(Vec<u8>),
}

// http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/JPEG.html#Adobe
#[allow(clippy::upper_case_acronyms)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum AdobeColorTransform {
    // RGB or CMYK
    Unknown,
    YCbCr,
    // YCbCrK
    YCCK,
}
#[derive(Debug)]
pub struct IccChunk {
    pub num_markers: u8,
    pub seq_no: u8,
    pub data: Vec<u8>,
}

impl FrameInfo {
    pub(crate) fn update_idct_size(&mut self, idct_size: usize) -> Result<()> {
        for component in &mut self.components {
            component.dct_scale = idct_size;
        }

        update_component_sizes(self.image_size, &mut self.components)?;

        self.output_size = Dimensions {
            width: (self.image_size.width as f32 * idct_size as f32 / 8.0).ceil() as u16,
            height: (self.image_size.height as f32 * idct_size as f32 / 8.0).ceil() as u16,
        };

        Ok(())
    }
}

fn read_length<R: Read>(reader: &mut R, marker: Marker) -> Result<usize> {
    assert!(marker.has_length());

    // length is including itself.
    let length = usize::from(read_u16_from_be(reader)?);

    if length < 2 {
        return Err(Error::Format(format!(
            "encountered {:?} with invalid length {}",
            marker, length
        )));
    }

    Ok(length - 2)
}

fn skip_bytes<R: Read>(reader: &mut R, length: usize) -> Result<()> {
    let length = length as u64;
    let to_skip = &mut reader.by_ref().take(length);
    let copied = io::copy(to_skip, &mut io::sink())?;
    if copied < length {
        Err(Error::Io(io::ErrorKind::UnexpectedEof.into()))
    } else {
        Ok(())
    }
}

// Section B.2.2
pub fn parse_sof<R: Read>(reader: &mut R, marker: Marker) -> Result<FrameInfo> {
    let length = read_length(reader, marker)?;

    if length <= 6 {
        return Err(Error::Format("invalid length in SOF".to_owned()));
    }

    let is_baseline = marker == SOF(0);
    let is_differential = match marker {
        SOF(0..=3) | SOF(9..=11) => false,
        SOF(5..=7) | SOF(13..=15) => true,
        _ => panic!(),
    };
    let coding_process = match marker {
        SOF(0) | SOF(1) | SOF(5) | SOF(9) | SOF(13) => CodingProcess::DctSequential,
        SOF(2) | SOF(6) | SOF(10) | SOF(14) => CodingProcess::DctProgressive,
        SOF(3) | SOF(7) | SOF(11) | SOF(15) => CodingProcess::Lossless,
        _ => panic!(),
    };
    let entropy_coding = match marker {
        SOF(0..=3) | SOF(5..=7) => EntropyCoding::Huffman,
        SOF(9..=11) | SOF(13..=15) => EntropyCoding::Arithmetic,
        _ => panic!(),
    };

    let precision = read_u8(reader)?;

    match precision {
        8 => {}
        12 => {
            if is_baseline {
                return Err(Error::Format(
                    "12 bit sample precision is not allowed in baseline".to_owned(),
                ));
            }
        }
        _ => {
            if coding_process != CodingProcess::Lossless || precision > 16 {
                return Err(Error::Format(format!(
                    "invalid precision {} in frame header",
                    precision
                )));
            }
        }
    }

    let height = read_u16_from_be(reader)?;
    let width = read_u16_from_be(reader)?;

    // height:
    // "Value 0 indicates that the number of lines shall be defined by the DNL marker and
    //     parameters at the end of the first scan (see B.2.5)."
    if height == 0 {
        return Err(Error::Unsupported(UnsupportedFeature::DNL));
    }

    if width == 0 {
        return Err(Error::Format("zero width in frame header".to_owned()));
    }

    let component_count = read_u8(reader)?;

    if component_count == 0 {
        return Err(Error::Format(
            "zero component count in frame header".to_owned(),
        ));
    }
    if coding_process == CodingProcess::DctProgressive && component_count > 4 {
        return Err(Error::Format(
            "progressive frame with more than 4 components".to_owned(),
        ));
    }

    if length != 6 + 3 * component_count as usize {
        return Err(Error::Format("invalid length in SOF".to_owned()));
    }

    let mut components: Vec<Component> = Vec::with_capacity(component_count as usize);

    for _ in 0..component_count {
        let identifier = read_u8(reader)?;

        // Each component's identifier must be unique.
        if components.iter().any(|c| c.identifier == identifier) {
            return Err(Error::Format(format!(
                "duplicate frame component identifier {}",
                identifier
            )));
        }

        let byte = read_u8(reader)?;
        let horizontal_sampling_factor = byte >> 4;
        let vertical_sampling_factor = byte & 0x0f;

        if horizontal_sampling_factor == 0 || horizontal_sampling_factor > 4 {
            return Err(Error::Format(format!(
                "invalid horizontal sampling factor {}",
                horizontal_sampling_factor
            )));
        }
        if vertical_sampling_factor == 0 || vertical_sampling_factor > 4 {
            return Err(Error::Format(format!(
                "invalid vertical sampling factor {}",
                vertical_sampling_factor
            )));
        }

        let quantization_table_index = read_u8(reader)?;

        if quantization_table_index > 3
            || (coding_process == CodingProcess::Lossless && quantization_table_index != 0)
        {
            return Err(Error::Format(format!(
                "invalid quantization table index {}",
                quantization_table_index
            )));
        }

        components.push(Component {
            identifier,
            horizontal_sampling_factor,
            vertical_sampling_factor,
            quantization_table_index: quantization_table_index as usize,
            dct_scale: 8,
            size: Dimensions {
                width: 0,
                height: 0,
            },
            block_size: Dimensions {
                width: 0,
                height: 0,
            },
        });
    }

    let mcu_size = update_component_sizes(Dimensions { width, height }, &mut components)?;

    Ok(FrameInfo {
        is_baseline,
        is_differential,
        coding_process,
        entropy_coding,
        precision,
        image_size: Dimensions { width, height },
        output_size: Dimensions { width, height },
        mcu_size,
        components,
    })
}

/// Returns ceil(x/y), requires x>0
fn ceil_div(x: u32, y: u32) -> Result<u16> {
    if x == 0 || y == 0 {
        // TODO Determine how this error is reached. Can we validate input
        // earlier and error out then?
        return Err(Error::Format("invalid dimensions".to_owned()));
    }
    Ok((1 + ((x - 1) / y)) as u16)
}

fn update_component_sizes(size: Dimensions, components: &mut [Component]) -> Result<Dimensions> {
    let h_max = components
        .iter()
        .map(|c| c.horizontal_sampling_factor)
        .max()
        .unwrap() as u32;
    let v_max = components
        .iter()
        .map(|c| c.vertical_sampling_factor)
        .max()
        .unwrap() as u32;

    let mcu_size = Dimensions {
        width: ceil_div(size.width as u32, h_max * 8)?,
        height: ceil_div(size.height as u32, v_max * 8)?,
    };

    for component in components {
        component.size.width = ceil_div(
            size.width as u32
                * component.horizontal_sampling_factor as u32
                * component.dct_scale as u32,
            h_max * 8,
        )?;
        component.size.height = ceil_div(
            size.height as u32
                * component.vertical_sampling_factor as u32
                * component.dct_scale as u32,
            v_max * 8,
        )?;

        component.block_size.width = mcu_size.width * component.horizontal_sampling_factor as u16;
        component.block_size.height = mcu_size.height * component.vertical_sampling_factor as u16;
    }

    Ok(mcu_size)
}

#[test]
fn test_update_component_sizes() {
    let mut components = [Component {
        identifier: 1,
        horizontal_sampling_factor: 2,
        vertical_sampling_factor: 2,
        quantization_table_index: 0,
        dct_scale: 8,
        size: Dimensions {
            width: 0,
            height: 0,
        },
        block_size: Dimensions {
            width: 0,
            height: 0,
        },
    }];
    let mcu = update_component_sizes(
        Dimensions {
            width: 800,
            height: 280,
        },
        &mut components,
    )
    .unwrap();
    assert_eq!(
        mcu,
        Dimensions {
            width: 50,
            height: 18
        }
    );
    assert_eq!(
        components[0].block_size,
        Dimensions {
            width: 100,
            height: 36
        }
    );
    assert_eq!(
        components[0].size,
        Dimensions {
            width: 800,
            height: 280
        }
    );
}

// Section B.2.3
pub fn parse_sos<R: Read>(reader: &mut R, frame: &FrameInfo) -> Result<ScanInfo> {
    let length = read_length(reader, SOS)?;
    if 0 == length {
        return Err(Error::Format("zero length in SOS".to_owned()));
    }

    let component_count = read_u8(reader)?;

    if component_count == 0 || component_count > 4 {
        return Err(Error::Format(format!(
            "invalid component count {} in scan header",
            component_count
        )));
    }

    if length != 4 + 2 * component_count as usize {
        return Err(Error::Format("invalid length in SOS".to_owned()));
    }

    let mut component_indices = Vec::with_capacity(component_count as usize);
    let mut dc_table_indices = Vec::with_capacity(component_count as usize);
    let mut ac_table_indices = Vec::with_capacity(component_count as usize);

    for _ in 0..component_count {
        let identifier = read_u8(reader)?;

        let component_index = match frame
            .components
            .iter()
            .position(|c| c.identifier == identifier)
        {
            Some(value) => value,
            None => {
                return Err(Error::Format(format!(
                    "scan component identifier {} does not match any of the component identifiers defined in the frame",
                    identifier
                )));
            }
        };

        // Each of the scan's components must be unique.
        if component_indices.contains(&component_index) {
            return Err(Error::Format(format!(
                "duplicate scan component identifier {}",
                identifier
            )));
        }

        // "... the ordering in the scan header shall follow the ordering in the frame header."
        if component_index < *component_indices.iter().max().unwrap_or(&0) {
            return Err(Error::Format(
                "the scan component order does not follow the order in the frame header".to_owned(),
            ));
        }

        let byte = read_u8(reader)?;
        let dc_table_index = byte >> 4;
        let ac_table_index = byte & 0x0f;

        if dc_table_index > 3 || (frame.is_baseline && dc_table_index > 1) {
            return Err(Error::Format(format!(
                "invalid dc table index {}",
                dc_table_index
            )));
        }
        if ac_table_index > 3 || (frame.is_baseline && ac_table_index > 1) {
            return Err(Error::Format(format!(
                "invalid ac table index {}",
                ac_table_index
            )));
        }

        component_indices.push(component_index);
        dc_table_indices.push(dc_table_index as usize);
        ac_table_indices.push(ac_table_index as usize);
    }

    let blocks_per_mcu = component_indices
        .iter()
        .map(|&i| {
            frame.components[i].horizontal_sampling_factor as u32
                * frame.components[i].vertical_sampling_factor as u32
        })
        .fold(0, ops::Add::add);

    if component_count > 1 && blocks_per_mcu > 10 {
        return Err(Error::Format(
            "scan with more than one component and more than 10 blocks per MCU".to_owned(),
        ));
    }

    // Also utilized as 'Predictor' in lossless coding, as MEAN in JPEG-LS etc.
    let spectral_selection_start = read_u8(reader)?;
    // Also utilized as ILV parameter in JPEG-LS.
    let mut spectral_selection_end = read_u8(reader)?;

    let byte = read_u8(reader)?;
    let successive_approximation_high = byte >> 4;
    let successive_approximation_low = byte & 0x0f;

    // The Differential Pulse-Mode prediction used (similar to png). Only utilized in Lossless
    // coding. Don't confuse with the JPEG-LS parameter coded using the same scan info portion.
    let predictor_selection;
    let point_transform = successive_approximation_low;

    if point_transform >= frame.precision {
        return Err(Error::Format(
            "invalid point transform, must be less than the frame precision".to_owned(),
        ));
    }

    if frame.coding_process == CodingProcess::DctProgressive {
        predictor_selection = Predictor::NoPrediction;
        if spectral_selection_end > 63
            || spectral_selection_start > spectral_selection_end
            || (spectral_selection_start == 0 && spectral_selection_end != 0)
        {
            return Err(Error::Format(format!(
                "invalid spectral selection parameters: ss={}, se={}",
                spectral_selection_start, spectral_selection_end
            )));
        }
        if spectral_selection_start != 0 && component_count != 1 {
            return Err(Error::Format(
                "spectral selection scan with AC coefficients can't have more than one component"
                    .to_owned(),
            ));
        }

        if successive_approximation_high > 13 || successive_approximation_low > 13 {
            return Err(Error::Format(format!(
                "invalid successive approximation parameters: ah={}, al={}",
                successive_approximation_high, successive_approximation_low
            )));
        }

        // Section G.1.1.1.2
        // "Each scan which follows the first scan for a given band progressively improves
        //     the precision of the coefficients by one bit, until full precision is reached."
        if successive_approximation_high != 0
            && successive_approximation_high != successive_approximation_low + 1
        {
            return Err(Error::Format(
                "successive approximation scan with more than one bit of improvement".to_owned(),
            ));
        }
    } else if frame.coding_process == CodingProcess::Lossless {
        if spectral_selection_end != 0 {
            return Err(Error::Format(
                "spectral selection end shall be zero in lossless scan".to_owned(),
            ));
        }
        if successive_approximation_high != 0 {
            return Err(Error::Format(
                "successive approximation high shall be zero in lossless scan".to_owned(),
            ));
        }
        predictor_selection = match spectral_selection_start {
            0 => Predictor::NoPrediction,
            1 => Predictor::Ra,
            2 => Predictor::Rb,
            3 => Predictor::Rc,
            4 => Predictor::RaRbRc1,
            5 => Predictor::RaRbRc2,
            6 => Predictor::RaRbRc3,
            7 => Predictor::RaRb,
            _ => {
                return Err(Error::Format(format!(
                    "invalid predictor selection value: {}",
                    spectral_selection_start
                )));
            }
        };
    } else {
        predictor_selection = Predictor::NoPrediction;
        if spectral_selection_end == 0 {
            spectral_selection_end = 63;
        }
        if spectral_selection_start != 0 || spectral_selection_end != 63 {
            return Err(Error::Format(
                "spectral selection is not allowed in non-progressive scan".to_owned(),
            ));
        }
        if successive_approximation_high != 0 || successive_approximation_low != 0 {
            return Err(Error::Format(
                "successive approximation is not allowed in non-progressive scan".to_owned(),
            ));
        }
    }

    Ok(ScanInfo {
        component_indices,
        dc_table_indices,
        ac_table_indices,
        spectral_selection: Range {
            start: spectral_selection_start,
            end: spectral_selection_end + 1,
        },
        predictor_selection,
        successive_approximation_high,
        successive_approximation_low,
        point_transform,
    })
}

// Section B.2.4.1
pub fn parse_dqt<R: Read>(reader: &mut R) -> Result<[Option<[u16; 64]>; 4]> {
    let mut length = read_length(reader, DQT)?;
    let mut tables = [None; 4];

    // Each DQT segment may contain multiple quantization tables.
    while length > 0 {
        let byte = read_u8(reader)?;
        let precision = (byte >> 4) as usize;
        let index = (byte & 0x0f) as usize;

        // The combination of 8-bit sample precision and 16-bit quantization tables is explicitly
        // disallowed by the JPEG spec:
        //     "An 8-bit DCT-based process shall not use a 16-bit precision quantization table."
        //     "Pq: Quantization table element precision – Specifies the precision of the Qk
        //      values. Value 0 indicates 8-bit Qk values; value 1 indicates 16-bit Qk values. Pq
        //      shall be zero for 8 bit sample precision P (see B.2.2)."
        // libjpeg allows this behavior though, and there are images in the wild using it. So to
        // match libjpeg's behavior we are deviating from the JPEG spec here.
        if precision > 1 {
            return Err(Error::Format(format!(
                "invalid precision {} in DQT",
                precision
            )));
        }
        if index > 3 {
            return Err(Error::Format(format!(
                "invalid destination identifier {} in DQT",
                index
            )));
        }
        if length < 65 + 64 * precision {
            return Err(Error::Format("invalid length in DQT".to_owned()));
        }

        let mut table = [0u16; 64];

        for item in table.iter_mut() {
            *item = match precision {
                0 => u16::from(read_u8(reader)?),
                1 => read_u16_from_be(reader)?,
                _ => unreachable!(),
            };
        }

        if table.contains(&0) {
            return Err(Error::Format(
                "quantization table contains element with a zero value".to_owned(),
            ));
        }

        tables[index] = Some(table);
        length -= 65 + 64 * precision;
    }

    Ok(tables)
}

// Section B.2.4.2
#[allow(clippy::type_complexity)]
pub fn parse_dht<R: Read>(
    reader: &mut R,
    is_baseline: Option<bool>,
) -> Result<(Vec<Option<HuffmanTable>>, Vec<Option<HuffmanTable>>)> {
    let mut length = read_length(reader, DHT)?;
    let mut dc_tables = vec![None, None, None, None];
    let mut ac_tables = vec![None, None, None, None];

    // Each DHT segment may contain multiple huffman tables.
    while length > 17 {
        let byte = read_u8(reader)?;
        let class = byte >> 4;
        let index = (byte & 0x0f) as usize;

        if class != 0 && class != 1 {
            return Err(Error::Format(format!("invalid class {} in DHT", class)));
        }
        if is_baseline == Some(true) && index > 1 {
            return Err(Error::Format(
                "a maximum of two huffman tables per class are allowed in baseline".to_owned(),
            ));
        }
        if index > 3 {
            return Err(Error::Format(format!(
                "invalid destination identifier {} in DHT",
                index
            )));
        }

        let mut counts = [0u8; 16];
        reader.read_exact(&mut counts)?;

        let size = counts
            .iter()
            .map(|&val| val as usize)
            .fold(0, ops::Add::add);

        if size == 0 {
            return Err(Error::Format(
                "encountered table with zero length in DHT".to_owned(),
            ));
        } else if size > 256 {
            return Err(Error::Format(
                "encountered table with excessive length in DHT".to_owned(),
            ));
        } else if size > length - 17 {
            return Err(Error::Format("invalid length in DHT".to_owned()));
        }

        let mut values = vec![0u8; size];
        reader.read_exact(&mut values)?;

        match class {
            0 => {
                dc_tables[index] = Some(HuffmanTable::new(&counts, &values, HuffmanTableClass::DC)?)
            }
            1 => {
                ac_tables[index] = Some(HuffmanTable::new(&counts, &values, HuffmanTableClass::AC)?)
            }
            _ => unreachable!(),
        }

        length -= 17 + size;
    }

    if length != 0 {
        return Err(Error::Format("invalid length in DHT".to_owned()));
    }

    Ok((dc_tables, ac_tables))
}

// Section B.2.4.4
pub fn parse_dri<R: Read>(reader: &mut R) -> Result<u16> {
    let length = read_length(reader, DRI)?;

    if length != 2 {
        return Err(Error::Format("DRI with invalid length".to_owned()));
    }

    Ok(read_u16_from_be(reader)?)
}

// Section B.2.4.5
pub fn parse_com<R: Read>(reader: &mut R) -> Result<Vec<u8>> {
    let length = read_length(reader, COM)?;
    let mut buffer = vec![0u8; length];

    reader.read_exact(&mut buffer)?;

    Ok(buffer)
}

// Section B.2.4.6
pub fn parse_app<R: Read>(reader: &mut R, marker: Marker) -> Result<Option<AppData>> {
    let length = read_length(reader, marker)?;
    let mut bytes_read = 0;
    let mut result = None;

    match marker {
        APP(0) => {
            if length >= 5 {
                let mut buffer = [0u8; 5];
                reader.read_exact(&mut buffer)?;
                bytes_read = buffer.len();

                // http://www.w3.org/Graphics/JPEG/jfif3.pdf
                if buffer[0..5] == *b"JFIF\0" {
                    result = Some(AppData::Jfif);
                // https://sno.phy.queensu.ca/~phil/exiftool/TagNames/JPEG.html#AVI1
                } else if buffer[0..5] == *b"AVI1\0" {
                    result = Some(AppData::Avi1);
                }
            }
        }
        APP(1) => {
            let mut buffer = vec![0u8; length];
            reader.read_exact(&mut buffer)?;
            bytes_read = buffer.len();

            // https://web.archive.org/web/20190624045241if_/http://www.cipa.jp:80/std/documents/e/DC-008-Translation-2019-E.pdf
            // 4.5.4 Basic Structure of JPEG Compressed Data
            if length >= 6 && buffer[0..6] == *b"Exif\x00\x00" {
                result = Some(AppData::Exif(buffer[6..].to_vec()));
            }
            // XMP packet
            // https://github.com/adobe/XMP-Toolkit-SDK/blob/main/docs/XMPSpecificationPart3.pdf
            else if length >= 29 && buffer[0..29] == *b"http://ns.adobe.com/xap/1.0/\0" {
                result = Some(AppData::Xmp(buffer[29..].to_vec()));
            }
        }
        APP(2) => {
            if length > 14 {
                let mut buffer = [0u8; 14];
                reader.read_exact(&mut buffer)?;
                bytes_read = buffer.len();

                // http://www.color.org/ICC_Minor_Revision_for_Web.pdf
                // B.4 Embedding ICC profiles in JFIF files
                if buffer[0..12] == *b"ICC_PROFILE\0" {
                    let mut data = vec![0; length - bytes_read];
                    reader.read_exact(&mut data)?;
                    bytes_read += data.len();
                    result = Some(AppData::Icc(IccChunk {
                        seq_no: buffer[12],
                        num_markers: buffer[13],
                        data,
                    }));
                }
            }
        }
        APP(13) => {
            if length >= 14 {
                let mut buffer = [0u8; 14];
                reader.read_exact(&mut buffer)?;
                bytes_read = buffer.len();

                // PSIR (Photoshop)
                // https://github.com/adobe/XMP-Toolkit-SDK/blob/main/docs/XMPSpecificationPart3.pdf
                if buffer[0..14] == *b"Photoshop 3.0\0" {
                    let mut data = vec![0; length - bytes_read];
                    reader.read_exact(&mut data)?;
                    bytes_read += data.len();
                    result = Some(AppData::Psir(data));
                }
            }
        }
        APP(14) => {
            if length >= 12 {
                let mut buffer = [0u8; 12];
                reader.read_exact(&mut buffer)?;
                bytes_read = buffer.len();

                // http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/JPEG.html#Adobe
                if buffer[0..6] == *b"Adobe\0" {
                    let color_transform = match buffer[11] {
                        0 => AdobeColorTransform::Unknown,
                        1 => AdobeColorTransform::YCbCr,
                        2 => AdobeColorTransform::YCCK,
                        _ => {
                            return Err(Error::Format(
                                "invalid color transform in adobe app segment".to_owned(),
                            ));
                        }
                    };

                    result = Some(AppData::Adobe(color_transform));
                }
            }
        }
        _ => {}
    }

    skip_bytes(reader, length - bytes_read)?;
    Ok(result)
}