1494 lines
55 KiB
Rust
1494 lines
55 KiB
Rust
use crate::error::{Error, Result, UnsupportedFeature};
|
||
use crate::huffman::{fill_default_mjpeg_tables, HuffmanDecoder, HuffmanTable};
|
||
use crate::marker::Marker;
|
||
use crate::parser::{
|
||
parse_app, parse_com, parse_dht, parse_dqt, parse_dri, parse_sof, parse_sos,
|
||
AdobeColorTransform, AppData, CodingProcess, Component, Dimensions, EntropyCoding, FrameInfo,
|
||
IccChunk, ScanInfo,
|
||
};
|
||
use crate::read_u8;
|
||
use crate::upsampler::Upsampler;
|
||
use crate::worker::{compute_image_parallel, PreferWorkerKind, RowData, Worker, WorkerScope};
|
||
use alloc::borrow::ToOwned;
|
||
use alloc::sync::Arc;
|
||
use alloc::vec::Vec;
|
||
use alloc::{format, vec};
|
||
use core::cmp;
|
||
use core::mem;
|
||
use core::ops::Range;
|
||
use std::convert::TryInto;
|
||
use std::io::Read;
|
||
|
||
pub const MAX_COMPONENTS: usize = 4;
|
||
|
||
mod lossless;
|
||
use self::lossless::compute_image_lossless;
|
||
|
||
#[cfg_attr(rustfmt, rustfmt_skip)]
|
||
static UNZIGZAG: [u8; 64] = [
|
||
0, 1, 8, 16, 9, 2, 3, 10,
|
||
17, 24, 32, 25, 18, 11, 4, 5,
|
||
12, 19, 26, 33, 40, 48, 41, 34,
|
||
27, 20, 13, 6, 7, 14, 21, 28,
|
||
35, 42, 49, 56, 57, 50, 43, 36,
|
||
29, 22, 15, 23, 30, 37, 44, 51,
|
||
58, 59, 52, 45, 38, 31, 39, 46,
|
||
53, 60, 61, 54, 47, 55, 62, 63,
|
||
];
|
||
|
||
/// An enumeration over combinations of color spaces and bit depths a pixel can have.
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
pub enum PixelFormat {
|
||
/// Luminance (grayscale), 8 bits
|
||
L8,
|
||
/// Luminance (grayscale), 16 bits
|
||
L16,
|
||
/// RGB, 8 bits per channel
|
||
RGB24,
|
||
/// CMYK, 8 bits per channel
|
||
CMYK32,
|
||
}
|
||
|
||
impl PixelFormat {
|
||
/// Determine the size in bytes of each pixel in this format
|
||
pub fn pixel_bytes(&self) -> usize {
|
||
match self {
|
||
PixelFormat::L8 => 1,
|
||
PixelFormat::L16 => 2,
|
||
PixelFormat::RGB24 => 3,
|
||
PixelFormat::CMYK32 => 4,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Represents metadata of an image.
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
pub struct ImageInfo {
|
||
/// The width of the image, in pixels.
|
||
pub width: u16,
|
||
/// The height of the image, in pixels.
|
||
pub height: u16,
|
||
/// The pixel format of the image.
|
||
pub pixel_format: PixelFormat,
|
||
/// The coding process of the image.
|
||
pub coding_process: CodingProcess,
|
||
}
|
||
|
||
/// Describes the colour transform to apply before binary data is returned
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
||
#[non_exhaustive]
|
||
pub enum ColorTransform {
|
||
/// No transform should be applied and the data is returned as-is.
|
||
None,
|
||
/// Unknown colour transformation
|
||
Unknown,
|
||
/// Grayscale transform should be applied (expects 1 channel)
|
||
Grayscale,
|
||
/// RGB transform should be applied.
|
||
RGB,
|
||
/// YCbCr transform should be applied.
|
||
YCbCr,
|
||
/// CMYK transform should be applied.
|
||
CMYK,
|
||
/// YCCK transform should be applied.
|
||
YCCK,
|
||
/// big gamut Y/Cb/Cr, bg-sYCC
|
||
JcsBgYcc,
|
||
/// big gamut red/green/blue, bg-sRGB
|
||
JcsBgRgb,
|
||
}
|
||
|
||
/// JPEG decoder
|
||
pub struct Decoder<R> {
|
||
reader: R,
|
||
|
||
frame: Option<FrameInfo>,
|
||
dc_huffman_tables: Vec<Option<HuffmanTable>>,
|
||
ac_huffman_tables: Vec<Option<HuffmanTable>>,
|
||
quantization_tables: [Option<Arc<[u16; 64]>>; 4],
|
||
|
||
restart_interval: u16,
|
||
|
||
adobe_color_transform: Option<AdobeColorTransform>,
|
||
color_transform: Option<ColorTransform>,
|
||
|
||
is_jfif: bool,
|
||
is_mjpeg: bool,
|
||
|
||
icc_markers: Vec<IccChunk>,
|
||
|
||
exif_data: Option<Vec<u8>>,
|
||
|
||
// Used for progressive JPEGs.
|
||
coefficients: Vec<Vec<i16>>,
|
||
// Bitmask of which coefficients has been completely decoded.
|
||
coefficients_finished: [u64; MAX_COMPONENTS],
|
||
|
||
// Maximum allowed size of decoded image buffer
|
||
decoding_buffer_size_limit: usize,
|
||
}
|
||
|
||
impl<R: Read> Decoder<R> {
|
||
/// Creates a new `Decoder` using the reader `reader`.
|
||
pub fn new(reader: R) -> Decoder<R> {
|
||
Decoder {
|
||
reader,
|
||
frame: None,
|
||
dc_huffman_tables: vec![None, None, None, None],
|
||
ac_huffman_tables: vec![None, None, None, None],
|
||
quantization_tables: [None, None, None, None],
|
||
restart_interval: 0,
|
||
adobe_color_transform: None,
|
||
color_transform: None,
|
||
is_jfif: false,
|
||
is_mjpeg: false,
|
||
icc_markers: Vec::new(),
|
||
exif_data: None,
|
||
coefficients: Vec::new(),
|
||
coefficients_finished: [0; MAX_COMPONENTS],
|
||
decoding_buffer_size_limit: usize::MAX,
|
||
}
|
||
}
|
||
|
||
/// Colour transform to use when decoding the image. App segments relating to colour transforms
|
||
/// will be ignored.
|
||
pub fn set_color_transform(&mut self, transform: ColorTransform) {
|
||
self.color_transform = Some(transform);
|
||
}
|
||
|
||
/// Set maximum buffer size allowed for decoded images
|
||
pub fn set_max_decoding_buffer_size(&mut self, max: usize) {
|
||
self.decoding_buffer_size_limit = max;
|
||
}
|
||
|
||
/// Returns metadata about the image.
|
||
///
|
||
/// The returned value will be `None` until a call to either `read_info` or `decode` has
|
||
/// returned `Ok`.
|
||
pub fn info(&self) -> Option<ImageInfo> {
|
||
match self.frame {
|
||
Some(ref frame) => {
|
||
let pixel_format = match frame.components.len() {
|
||
1 => match frame.precision {
|
||
8 => PixelFormat::L8,
|
||
16 => PixelFormat::L16,
|
||
_ => panic!(),
|
||
},
|
||
3 => PixelFormat::RGB24,
|
||
4 => PixelFormat::CMYK32,
|
||
_ => panic!(),
|
||
};
|
||
|
||
Some(ImageInfo {
|
||
width: frame.output_size.width,
|
||
height: frame.output_size.height,
|
||
pixel_format,
|
||
coding_process: frame.coding_process,
|
||
})
|
||
}
|
||
None => None,
|
||
}
|
||
}
|
||
|
||
/// Returns raw exif data, starting at the TIFF header, if the image contains any.
|
||
///
|
||
/// The returned value will be `None` until a call to `decode` has returned `Ok`.
|
||
pub fn exif_data(&self) -> Option<&[u8]> {
|
||
self.exif_data.as_deref()
|
||
}
|
||
|
||
/// Returns the embeded icc profile if the image contains one.
|
||
pub fn icc_profile(&self) -> Option<Vec<u8>> {
|
||
let mut marker_present: [Option<&IccChunk>; 256] = [None; 256];
|
||
let num_markers = self.icc_markers.len();
|
||
if num_markers == 0 || num_markers >= 255 {
|
||
return None;
|
||
}
|
||
// check the validity of the markers
|
||
for chunk in &self.icc_markers {
|
||
if usize::from(chunk.num_markers) != num_markers {
|
||
// all the lengths must match
|
||
return None;
|
||
}
|
||
if chunk.seq_no == 0 {
|
||
return None;
|
||
}
|
||
if marker_present[usize::from(chunk.seq_no)].is_some() {
|
||
// duplicate seq_no
|
||
return None;
|
||
} else {
|
||
marker_present[usize::from(chunk.seq_no)] = Some(chunk);
|
||
}
|
||
}
|
||
|
||
// assemble them together by seq_no failing if any are missing
|
||
let mut data = Vec::new();
|
||
// seq_no's start at 1
|
||
for &chunk in marker_present.get(1..=num_markers)? {
|
||
data.extend_from_slice(&chunk?.data);
|
||
}
|
||
Some(data)
|
||
}
|
||
|
||
/// Heuristic to avoid starting thread, synchronization if we expect a small amount of
|
||
/// parallelism to be utilized.
|
||
fn select_worker(frame: &FrameInfo, worker_preference: PreferWorkerKind) -> PreferWorkerKind {
|
||
const PARALLELISM_THRESHOLD: u64 = 128 * 128;
|
||
|
||
match worker_preference {
|
||
PreferWorkerKind::Immediate => PreferWorkerKind::Immediate,
|
||
PreferWorkerKind::Multithreaded => {
|
||
let width: u64 = frame.output_size.width.into();
|
||
let height: u64 = frame.output_size.width.into();
|
||
if width * height > PARALLELISM_THRESHOLD {
|
||
PreferWorkerKind::Multithreaded
|
||
} else {
|
||
PreferWorkerKind::Immediate
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Tries to read metadata from the image without decoding it.
|
||
///
|
||
/// If successful, the metadata can be obtained using the `info` method.
|
||
pub fn read_info(&mut self) -> Result<()> {
|
||
WorkerScope::with(|worker| self.decode_internal(true, worker)).map(|_| ())
|
||
}
|
||
|
||
/// Configure the decoder to scale the image during decoding.
|
||
///
|
||
/// This efficiently scales the image by the smallest supported scale
|
||
/// factor that produces an image larger than or equal to the requested
|
||
/// size in at least one axis. The currently implemented scale factors
|
||
/// are 1/8, 1/4, 1/2 and 1.
|
||
///
|
||
/// To generate a thumbnail of an exact size, pass the desired size and
|
||
/// then scale to the final size using a traditional resampling algorithm.
|
||
pub fn scale(&mut self, requested_width: u16, requested_height: u16) -> Result<(u16, u16)> {
|
||
self.read_info()?;
|
||
let frame = self.frame.as_mut().unwrap();
|
||
let idct_size = crate::idct::choose_idct_size(
|
||
frame.image_size,
|
||
Dimensions {
|
||
width: requested_width,
|
||
height: requested_height,
|
||
},
|
||
);
|
||
frame.update_idct_size(idct_size)?;
|
||
Ok((frame.output_size.width, frame.output_size.height))
|
||
}
|
||
|
||
/// Decodes the image and returns the decoded pixels if successful.
|
||
pub fn decode(&mut self) -> Result<Vec<u8>> {
|
||
WorkerScope::with(|worker| self.decode_internal(false, worker))
|
||
}
|
||
|
||
fn decode_internal(
|
||
&mut self,
|
||
stop_after_metadata: bool,
|
||
worker_scope: &WorkerScope,
|
||
) -> Result<Vec<u8>> {
|
||
if stop_after_metadata && self.frame.is_some() {
|
||
// The metadata has already been read.
|
||
return Ok(Vec::new());
|
||
} else if self.frame.is_none()
|
||
&& (read_u8(&mut self.reader)? != 0xFF
|
||
|| Marker::from_u8(read_u8(&mut self.reader)?) != Some(Marker::SOI))
|
||
{
|
||
return Err(Error::Format(
|
||
"first two bytes are not an SOI marker".to_owned(),
|
||
));
|
||
}
|
||
|
||
let mut previous_marker = Marker::SOI;
|
||
let mut pending_marker = None;
|
||
let mut scans_processed = 0;
|
||
let mut planes = vec![
|
||
Vec::<u8>::new();
|
||
self.frame
|
||
.as_ref()
|
||
.map_or(0, |frame| frame.components.len())
|
||
];
|
||
let mut planes_u16 = vec![
|
||
Vec::<u16>::new();
|
||
self.frame
|
||
.as_ref()
|
||
.map_or(0, |frame| frame.components.len())
|
||
];
|
||
|
||
loop {
|
||
let marker = match pending_marker.take() {
|
||
Some(m) => m,
|
||
None => self.read_marker()?,
|
||
};
|
||
|
||
match marker {
|
||
// Frame header
|
||
Marker::SOF(..) => {
|
||
// Section 4.10
|
||
// "An image contains only one frame in the cases of sequential and
|
||
// progressive coding processes; an image contains multiple frames for the
|
||
// hierarchical mode."
|
||
if self.frame.is_some() {
|
||
return Err(Error::Unsupported(UnsupportedFeature::Hierarchical));
|
||
}
|
||
|
||
let frame = parse_sof(&mut self.reader, marker)?;
|
||
let component_count = frame.components.len();
|
||
|
||
if frame.is_differential {
|
||
return Err(Error::Unsupported(UnsupportedFeature::Hierarchical));
|
||
}
|
||
if frame.entropy_coding == EntropyCoding::Arithmetic {
|
||
return Err(Error::Unsupported(
|
||
UnsupportedFeature::ArithmeticEntropyCoding,
|
||
));
|
||
}
|
||
if frame.precision != 8 && frame.coding_process != CodingProcess::Lossless {
|
||
return Err(Error::Unsupported(UnsupportedFeature::SamplePrecision(
|
||
frame.precision,
|
||
)));
|
||
}
|
||
if frame.precision != 8 && frame.precision != 16 {
|
||
return Err(Error::Unsupported(UnsupportedFeature::SamplePrecision(
|
||
frame.precision,
|
||
)));
|
||
}
|
||
if component_count != 1 && component_count != 3 && component_count != 4 {
|
||
return Err(Error::Unsupported(UnsupportedFeature::ComponentCount(
|
||
component_count as u8,
|
||
)));
|
||
}
|
||
|
||
// Make sure we support the subsampling ratios used.
|
||
let _ = Upsampler::new(
|
||
&frame.components,
|
||
frame.image_size.width,
|
||
frame.image_size.height,
|
||
)?;
|
||
|
||
self.frame = Some(frame);
|
||
|
||
if stop_after_metadata {
|
||
return Ok(Vec::new());
|
||
}
|
||
|
||
planes = vec![Vec::new(); component_count];
|
||
planes_u16 = vec![Vec::new(); component_count];
|
||
}
|
||
|
||
// Scan header
|
||
Marker::SOS => {
|
||
if self.frame.is_none() {
|
||
return Err(Error::Format("scan encountered before frame".to_owned()));
|
||
}
|
||
|
||
let frame = self.frame.clone().unwrap();
|
||
let scan = parse_sos(&mut self.reader, &frame)?;
|
||
|
||
if frame.coding_process == CodingProcess::DctProgressive
|
||
&& self.coefficients.is_empty()
|
||
{
|
||
self.coefficients = frame
|
||
.components
|
||
.iter()
|
||
.map(|c| {
|
||
let block_count =
|
||
c.block_size.width as usize * c.block_size.height as usize;
|
||
vec![0; block_count * 64]
|
||
})
|
||
.collect();
|
||
}
|
||
|
||
if frame.coding_process == CodingProcess::Lossless {
|
||
let (marker, data) = self.decode_scan_lossless(&frame, &scan)?;
|
||
|
||
for (i, plane) in data
|
||
.into_iter()
|
||
.enumerate()
|
||
.filter(|&(_, ref plane)| !plane.is_empty())
|
||
{
|
||
planes_u16[i] = plane;
|
||
}
|
||
pending_marker = marker;
|
||
} else {
|
||
// This was previously buggy, so let's explain the log here a bit. When a
|
||
// progressive frame is encoded then the coefficients (DC, AC) of each
|
||
// component (=color plane) can be split amongst scans. In particular it can
|
||
// happen or at least occurs in the wild that a scan contains coefficient 0 of
|
||
// all components. If now one but not all components had all other coefficients
|
||
// delivered in previous scans then such a scan contains all components but
|
||
// completes only some of them! (This is technically NOT permitted for all
|
||
// other coefficients as the standard dictates that scans with coefficients
|
||
// other than the 0th must only contain ONE component so we would either
|
||
// complete it or not. We may want to detect and error in case more component
|
||
// are part of a scan than allowed.) What a weird edge case.
|
||
//
|
||
// But this means we track precisely which components get completed here.
|
||
let mut finished = [false; MAX_COMPONENTS];
|
||
|
||
if scan.successive_approximation_low == 0 {
|
||
for (&i, component_finished) in
|
||
scan.component_indices.iter().zip(&mut finished)
|
||
{
|
||
if self.coefficients_finished[i] == !0 {
|
||
continue;
|
||
}
|
||
for j in scan.spectral_selection.clone() {
|
||
self.coefficients_finished[i] |= 1 << j;
|
||
}
|
||
if self.coefficients_finished[i] == !0 {
|
||
*component_finished = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
let preference =
|
||
Self::select_worker(&frame, PreferWorkerKind::Multithreaded);
|
||
|
||
let (marker, data) = worker_scope
|
||
.get_or_init_worker(preference, |worker| {
|
||
self.decode_scan(&frame, &scan, worker, &finished)
|
||
})?;
|
||
|
||
if let Some(data) = data {
|
||
for (i, plane) in data
|
||
.into_iter()
|
||
.enumerate()
|
||
.filter(|&(_, ref plane)| !plane.is_empty())
|
||
{
|
||
if self.coefficients_finished[i] == !0 {
|
||
planes[i] = plane;
|
||
}
|
||
}
|
||
}
|
||
|
||
pending_marker = marker;
|
||
}
|
||
|
||
scans_processed += 1;
|
||
}
|
||
|
||
// Table-specification and miscellaneous markers
|
||
// Quantization table-specification
|
||
Marker::DQT => {
|
||
let tables = parse_dqt(&mut self.reader)?;
|
||
|
||
for (i, &table) in tables.iter().enumerate() {
|
||
if let Some(table) = table {
|
||
let mut unzigzagged_table = [0u16; 64];
|
||
|
||
for j in 0..64 {
|
||
unzigzagged_table[UNZIGZAG[j] as usize] = table[j];
|
||
}
|
||
|
||
self.quantization_tables[i] = Some(Arc::new(unzigzagged_table));
|
||
}
|
||
}
|
||
}
|
||
// Huffman table-specification
|
||
Marker::DHT => {
|
||
let is_baseline = self.frame.as_ref().map(|frame| frame.is_baseline);
|
||
let (dc_tables, ac_tables) = parse_dht(&mut self.reader, is_baseline)?;
|
||
|
||
let current_dc_tables = mem::take(&mut self.dc_huffman_tables);
|
||
self.dc_huffman_tables = dc_tables
|
||
.into_iter()
|
||
.zip(current_dc_tables.into_iter())
|
||
.map(|(a, b)| a.or(b))
|
||
.collect();
|
||
|
||
let current_ac_tables = mem::take(&mut self.ac_huffman_tables);
|
||
self.ac_huffman_tables = ac_tables
|
||
.into_iter()
|
||
.zip(current_ac_tables.into_iter())
|
||
.map(|(a, b)| a.or(b))
|
||
.collect();
|
||
}
|
||
// Arithmetic conditioning table-specification
|
||
Marker::DAC => {
|
||
return Err(Error::Unsupported(
|
||
UnsupportedFeature::ArithmeticEntropyCoding,
|
||
))
|
||
}
|
||
// Restart interval definition
|
||
Marker::DRI => self.restart_interval = parse_dri(&mut self.reader)?,
|
||
// Comment
|
||
Marker::COM => {
|
||
let _comment = parse_com(&mut self.reader)?;
|
||
}
|
||
// Application data
|
||
Marker::APP(..) => {
|
||
if let Some(data) = parse_app(&mut self.reader, marker)? {
|
||
match data {
|
||
AppData::Adobe(color_transform) => {
|
||
self.adobe_color_transform = Some(color_transform)
|
||
}
|
||
AppData::Jfif => {
|
||
// From the JFIF spec:
|
||
// "The APP0 marker is used to identify a JPEG FIF file.
|
||
// The JPEG FIF APP0 marker is mandatory right after the SOI marker."
|
||
// Some JPEGs in the wild does not follow this though, so we allow
|
||
// JFIF headers anywhere APP0 markers are allowed.
|
||
/*
|
||
if previous_marker != Marker::SOI {
|
||
return Err(Error::Format("the JFIF APP0 marker must come right after the SOI marker".to_owned()));
|
||
}
|
||
*/
|
||
|
||
self.is_jfif = true;
|
||
}
|
||
AppData::Avi1 => self.is_mjpeg = true,
|
||
AppData::Icc(icc) => self.icc_markers.push(icc),
|
||
AppData::Exif(data) => self.exif_data = Some(data),
|
||
}
|
||
}
|
||
}
|
||
// Restart
|
||
Marker::RST(..) => {
|
||
// Some encoders emit a final RST marker after entropy-coded data, which
|
||
// decode_scan does not take care of. So if we encounter one, we ignore it.
|
||
if previous_marker != Marker::SOS {
|
||
return Err(Error::Format(
|
||
"RST found outside of entropy-coded data".to_owned(),
|
||
));
|
||
}
|
||
}
|
||
|
||
// Define number of lines
|
||
Marker::DNL => {
|
||
// Section B.2.1
|
||
// "If a DNL segment (see B.2.5) is present, it shall immediately follow the first scan."
|
||
if previous_marker != Marker::SOS || scans_processed != 1 {
|
||
return Err(Error::Format(
|
||
"DNL is only allowed immediately after the first scan".to_owned(),
|
||
));
|
||
}
|
||
|
||
return Err(Error::Unsupported(UnsupportedFeature::DNL));
|
||
}
|
||
|
||
// Hierarchical mode markers
|
||
Marker::DHP | Marker::EXP => {
|
||
return Err(Error::Unsupported(UnsupportedFeature::Hierarchical))
|
||
}
|
||
|
||
// End of image
|
||
Marker::EOI => break,
|
||
|
||
_ => {
|
||
return Err(Error::Format(format!(
|
||
"{:?} marker found where not allowed",
|
||
marker
|
||
)))
|
||
}
|
||
}
|
||
|
||
previous_marker = marker;
|
||
}
|
||
|
||
if self.frame.is_none() {
|
||
return Err(Error::Format(
|
||
"end of image encountered before frame".to_owned(),
|
||
));
|
||
}
|
||
|
||
let frame = self.frame.as_ref().unwrap();
|
||
let preference = Self::select_worker(&frame, PreferWorkerKind::Multithreaded);
|
||
|
||
worker_scope.get_or_init_worker(preference, |worker| {
|
||
self.decode_planes(worker, planes, planes_u16)
|
||
})
|
||
}
|
||
|
||
fn decode_planes(
|
||
&mut self,
|
||
worker: &mut dyn Worker,
|
||
mut planes: Vec<Vec<u8>>,
|
||
planes_u16: Vec<Vec<u16>>,
|
||
) -> Result<Vec<u8>> {
|
||
if self.frame.is_none() {
|
||
return Err(Error::Format(
|
||
"end of image encountered before frame".to_owned(),
|
||
));
|
||
}
|
||
|
||
let frame = self.frame.as_ref().unwrap();
|
||
|
||
if {
|
||
let required_mem = frame
|
||
.components
|
||
.len()
|
||
.checked_mul(frame.output_size.width.into())
|
||
.and_then(|m| m.checked_mul(frame.output_size.height.into()));
|
||
required_mem.map_or(true, |m| self.decoding_buffer_size_limit < m)
|
||
} {
|
||
return Err(Error::Format(
|
||
"size of decoded image exceeds maximum allowed size".to_owned(),
|
||
));
|
||
}
|
||
|
||
// If we're decoding a progressive jpeg and a component is unfinished, render what we've got
|
||
if frame.coding_process == CodingProcess::DctProgressive
|
||
&& self.coefficients.len() == frame.components.len()
|
||
{
|
||
for (i, component) in frame.components.iter().enumerate() {
|
||
// Only dealing with unfinished components
|
||
if self.coefficients_finished[i] == !0 {
|
||
continue;
|
||
}
|
||
|
||
let quantization_table =
|
||
match self.quantization_tables[component.quantization_table_index].clone() {
|
||
Some(quantization_table) => quantization_table,
|
||
None => continue,
|
||
};
|
||
|
||
// Get the worker prepared
|
||
let row_data = RowData {
|
||
index: i,
|
||
component: component.clone(),
|
||
quantization_table,
|
||
};
|
||
worker.start(row_data)?;
|
||
|
||
// Send the rows over to the worker and collect the result
|
||
let coefficients_per_mcu_row = usize::from(component.block_size.width)
|
||
* usize::from(component.vertical_sampling_factor)
|
||
* 64;
|
||
|
||
let mut tasks = (0..frame.mcu_size.height).map(|mcu_y| {
|
||
let offset = usize::from(mcu_y) * coefficients_per_mcu_row;
|
||
let row_coefficients =
|
||
self.coefficients[i][offset..offset + coefficients_per_mcu_row].to_vec();
|
||
(i, row_coefficients)
|
||
});
|
||
|
||
// FIXME: additional potential work stealing opportunities for rayon case if we
|
||
// also internally can parallelize over components.
|
||
worker.append_rows(&mut tasks)?;
|
||
planes[i] = worker.get_result(i)?;
|
||
}
|
||
}
|
||
|
||
if frame.coding_process == CodingProcess::Lossless {
|
||
compute_image_lossless(frame, planes_u16)
|
||
} else {
|
||
compute_image(
|
||
&frame.components,
|
||
planes,
|
||
frame.output_size,
|
||
self.determine_color_transform(),
|
||
)
|
||
}
|
||
}
|
||
|
||
fn determine_color_transform(&self) -> ColorTransform {
|
||
if let Some(color_transform) = self.color_transform {
|
||
return color_transform;
|
||
}
|
||
|
||
let frame = self.frame.as_ref().unwrap();
|
||
|
||
if frame.components.len() == 1 {
|
||
return ColorTransform::Grayscale;
|
||
}
|
||
|
||
// Using logic for determining colour as described here: https://entropymine.wordpress.com/2018/10/22/how-is-a-jpeg-images-color-type-determined/
|
||
|
||
if frame.components.len() == 3 {
|
||
match (
|
||
frame.components[0].identifier,
|
||
frame.components[1].identifier,
|
||
frame.components[2].identifier,
|
||
) {
|
||
(1, 2, 3) => {
|
||
return ColorTransform::YCbCr;
|
||
}
|
||
(1, 34, 35) => {
|
||
return ColorTransform::JcsBgYcc;
|
||
}
|
||
(82, 71, 66) => {
|
||
return ColorTransform::RGB;
|
||
}
|
||
(114, 103, 98) => {
|
||
return ColorTransform::JcsBgRgb;
|
||
}
|
||
_ => {}
|
||
}
|
||
|
||
if self.is_jfif {
|
||
return ColorTransform::YCbCr;
|
||
}
|
||
}
|
||
|
||
if let Some(colour_transform) = self.adobe_color_transform {
|
||
match colour_transform {
|
||
AdobeColorTransform::Unknown => {
|
||
if frame.components.len() == 3 {
|
||
return ColorTransform::RGB;
|
||
} else if frame.components.len() == 4 {
|
||
return ColorTransform::CMYK;
|
||
}
|
||
}
|
||
AdobeColorTransform::YCbCr => {
|
||
return ColorTransform::YCbCr;
|
||
}
|
||
AdobeColorTransform::YCCK => {
|
||
return ColorTransform::YCCK;
|
||
}
|
||
}
|
||
} else if frame.components.len() == 4 {
|
||
return ColorTransform::CMYK;
|
||
}
|
||
|
||
if frame.components.len() == 4 {
|
||
ColorTransform::YCCK
|
||
} else if frame.components.len() == 3 {
|
||
ColorTransform::YCbCr
|
||
} else {
|
||
ColorTransform::Unknown
|
||
}
|
||
}
|
||
|
||
fn read_marker(&mut self) -> Result<Marker> {
|
||
loop {
|
||
// This should be an error as the JPEG spec doesn't allow extraneous data between marker segments.
|
||
// libjpeg allows this though and there are images in the wild utilising it, so we are
|
||
// forced to support this behavior.
|
||
// Sony Ericsson P990i is an example of a device which produce this sort of JPEGs.
|
||
while read_u8(&mut self.reader)? != 0xFF {}
|
||
|
||
// Section B.1.1.2
|
||
// All markers are assigned two-byte codes: an X’FF’ byte followed by a
|
||
// byte which is not equal to 0 or X’FF’ (see Table B.1). Any marker may
|
||
// optionally be preceded by any number of fill bytes, which are bytes
|
||
// assigned code X’FF’.
|
||
let mut byte = read_u8(&mut self.reader)?;
|
||
|
||
// Section B.1.1.2
|
||
// "Any marker may optionally be preceded by any number of fill bytes, which are bytes assigned code X’FF’."
|
||
while byte == 0xFF {
|
||
byte = read_u8(&mut self.reader)?;
|
||
}
|
||
|
||
if byte != 0x00 && byte != 0xFF {
|
||
return Ok(Marker::from_u8(byte).unwrap());
|
||
}
|
||
}
|
||
}
|
||
|
||
fn decode_scan(
|
||
&mut self,
|
||
frame: &FrameInfo,
|
||
scan: &ScanInfo,
|
||
worker: &mut dyn Worker,
|
||
finished: &[bool; MAX_COMPONENTS],
|
||
) -> Result<(Option<Marker>, Option<Vec<Vec<u8>>>)> {
|
||
assert!(scan.component_indices.len() <= MAX_COMPONENTS);
|
||
|
||
let components: Vec<Component> = scan
|
||
.component_indices
|
||
.iter()
|
||
.map(|&i| frame.components[i].clone())
|
||
.collect();
|
||
|
||
// Verify that all required quantization tables has been set.
|
||
if components
|
||
.iter()
|
||
.any(|component| self.quantization_tables[component.quantization_table_index].is_none())
|
||
{
|
||
return Err(Error::Format("use of unset quantization table".to_owned()));
|
||
}
|
||
|
||
if self.is_mjpeg {
|
||
fill_default_mjpeg_tables(
|
||
scan,
|
||
&mut self.dc_huffman_tables,
|
||
&mut self.ac_huffman_tables,
|
||
);
|
||
}
|
||
|
||
// Verify that all required huffman tables has been set.
|
||
if scan.spectral_selection.start == 0
|
||
&& scan
|
||
.dc_table_indices
|
||
.iter()
|
||
.any(|&i| self.dc_huffman_tables[i].is_none())
|
||
{
|
||
return Err(Error::Format(
|
||
"scan makes use of unset dc huffman table".to_owned(),
|
||
));
|
||
}
|
||
if scan.spectral_selection.end > 1
|
||
&& scan
|
||
.ac_table_indices
|
||
.iter()
|
||
.any(|&i| self.ac_huffman_tables[i].is_none())
|
||
{
|
||
return Err(Error::Format(
|
||
"scan makes use of unset ac huffman table".to_owned(),
|
||
));
|
||
}
|
||
|
||
// Prepare the worker thread for the work to come.
|
||
for (i, component) in components.iter().enumerate() {
|
||
if finished[i] {
|
||
let row_data = RowData {
|
||
index: i,
|
||
component: component.clone(),
|
||
quantization_table: self.quantization_tables
|
||
[component.quantization_table_index]
|
||
.clone()
|
||
.unwrap(),
|
||
};
|
||
|
||
worker.start(row_data)?;
|
||
}
|
||
}
|
||
|
||
let is_progressive = frame.coding_process == CodingProcess::DctProgressive;
|
||
let is_interleaved = components.len() > 1;
|
||
let mut dummy_block = [0i16; 64];
|
||
let mut huffman = HuffmanDecoder::new();
|
||
let mut dc_predictors = [0i16; MAX_COMPONENTS];
|
||
let mut mcus_left_until_restart = self.restart_interval;
|
||
let mut expected_rst_num = 0;
|
||
let mut eob_run = 0;
|
||
let mut mcu_row_coefficients = vec![vec![]; components.len()];
|
||
|
||
if !is_progressive {
|
||
for (i, component) in components.iter().enumerate().filter(|&(i, _)| finished[i]) {
|
||
let coefficients_per_mcu_row = component.block_size.width as usize
|
||
* component.vertical_sampling_factor as usize
|
||
* 64;
|
||
mcu_row_coefficients[i] = vec![0i16; coefficients_per_mcu_row];
|
||
}
|
||
}
|
||
|
||
// 4.8.2
|
||
// When reading from the stream, if the data is non-interleaved then an MCU consists of
|
||
// exactly one block (effectively a 1x1 sample).
|
||
let (mcu_horizontal_samples, mcu_vertical_samples) = if is_interleaved {
|
||
let horizontal = components
|
||
.iter()
|
||
.map(|component| component.horizontal_sampling_factor as u16)
|
||
.collect::<Vec<_>>();
|
||
let vertical = components
|
||
.iter()
|
||
.map(|component| component.vertical_sampling_factor as u16)
|
||
.collect::<Vec<_>>();
|
||
(horizontal, vertical)
|
||
} else {
|
||
(vec![1], vec![1])
|
||
};
|
||
|
||
// This also affects how many MCU values we read from stream. If it's a non-interleaved stream,
|
||
// the MCUs will be exactly the block count.
|
||
let (max_mcu_x, max_mcu_y) = if is_interleaved {
|
||
(frame.mcu_size.width, frame.mcu_size.height)
|
||
} else {
|
||
(
|
||
components[0].block_size.width,
|
||
components[0].block_size.height,
|
||
)
|
||
};
|
||
|
||
for mcu_y in 0..max_mcu_y {
|
||
if mcu_y * 8 >= frame.image_size.height {
|
||
break;
|
||
}
|
||
|
||
for mcu_x in 0..max_mcu_x {
|
||
if mcu_x * 8 >= frame.image_size.width {
|
||
break;
|
||
}
|
||
|
||
if self.restart_interval > 0 {
|
||
if mcus_left_until_restart == 0 {
|
||
match huffman.take_marker(&mut self.reader)? {
|
||
Some(Marker::RST(n)) => {
|
||
if n != expected_rst_num {
|
||
return Err(Error::Format(format!(
|
||
"found RST{} where RST{} was expected",
|
||
n, expected_rst_num
|
||
)));
|
||
}
|
||
|
||
huffman.reset();
|
||
// Section F.2.1.3.1
|
||
dc_predictors = [0i16; MAX_COMPONENTS];
|
||
// Section G.1.2.2
|
||
eob_run = 0;
|
||
|
||
expected_rst_num = (expected_rst_num + 1) % 8;
|
||
mcus_left_until_restart = self.restart_interval;
|
||
}
|
||
Some(marker) => {
|
||
return Err(Error::Format(format!(
|
||
"found marker {:?} inside scan where RST{} was expected",
|
||
marker, expected_rst_num
|
||
)))
|
||
}
|
||
None => {
|
||
return Err(Error::Format(format!(
|
||
"no marker found where RST{} was expected",
|
||
expected_rst_num
|
||
)))
|
||
}
|
||
}
|
||
}
|
||
|
||
mcus_left_until_restart -= 1;
|
||
}
|
||
|
||
for (i, component) in components.iter().enumerate() {
|
||
for v_pos in 0..mcu_vertical_samples[i] {
|
||
for h_pos in 0..mcu_horizontal_samples[i] {
|
||
let coefficients = if is_progressive {
|
||
let block_y = (mcu_y * mcu_vertical_samples[i] + v_pos) as usize;
|
||
let block_x = (mcu_x * mcu_horizontal_samples[i] + h_pos) as usize;
|
||
let block_offset =
|
||
(block_y * component.block_size.width as usize + block_x) * 64;
|
||
&mut self.coefficients[scan.component_indices[i]]
|
||
[block_offset..block_offset + 64]
|
||
} else if finished[i] {
|
||
// Because the worker thread operates in batches as if we were always interleaved, we
|
||
// need to distinguish between a single-shot buffer and one that's currently in process
|
||
// (for a non-interleaved) stream
|
||
let mcu_batch_current_row = if is_interleaved {
|
||
0
|
||
} else {
|
||
mcu_y % component.vertical_sampling_factor as u16
|
||
};
|
||
|
||
let block_y = (mcu_batch_current_row * mcu_vertical_samples[i]
|
||
+ v_pos) as usize;
|
||
let block_x = (mcu_x * mcu_horizontal_samples[i] + h_pos) as usize;
|
||
let block_offset =
|
||
(block_y * component.block_size.width as usize + block_x) * 64;
|
||
&mut mcu_row_coefficients[i][block_offset..block_offset + 64]
|
||
} else {
|
||
&mut dummy_block[..64]
|
||
}
|
||
.try_into()
|
||
.unwrap();
|
||
|
||
if scan.successive_approximation_high == 0 {
|
||
decode_block(
|
||
&mut self.reader,
|
||
coefficients,
|
||
&mut huffman,
|
||
self.dc_huffman_tables[scan.dc_table_indices[i]].as_ref(),
|
||
self.ac_huffman_tables[scan.ac_table_indices[i]].as_ref(),
|
||
scan.spectral_selection.clone(),
|
||
scan.successive_approximation_low,
|
||
&mut eob_run,
|
||
&mut dc_predictors[i],
|
||
)?;
|
||
} else {
|
||
decode_block_successive_approximation(
|
||
&mut self.reader,
|
||
coefficients,
|
||
&mut huffman,
|
||
self.ac_huffman_tables[scan.ac_table_indices[i]].as_ref(),
|
||
scan.spectral_selection.clone(),
|
||
scan.successive_approximation_low,
|
||
&mut eob_run,
|
||
)?;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Send the coefficients from this MCU row to the worker thread for dequantization and idct.
|
||
for (i, component) in components.iter().enumerate() {
|
||
if finished[i] {
|
||
// In the event of non-interleaved streams, if we're still building the buffer out,
|
||
// keep going; don't send it yet. We also need to ensure we don't skip over the last
|
||
// row(s) of the image.
|
||
if !is_interleaved && (mcu_y + 1) * 8 < frame.image_size.height {
|
||
if (mcu_y + 1) % component.vertical_sampling_factor as u16 > 0 {
|
||
continue;
|
||
}
|
||
}
|
||
|
||
let coefficients_per_mcu_row = component.block_size.width as usize
|
||
* component.vertical_sampling_factor as usize
|
||
* 64;
|
||
|
||
let row_coefficients = if is_progressive {
|
||
// Because non-interleaved streams will have multiple MCU rows concatenated together,
|
||
// the row for calculating the offset is different.
|
||
let worker_mcu_y = if is_interleaved {
|
||
mcu_y
|
||
} else {
|
||
// Explicitly doing floor-division here
|
||
mcu_y / component.vertical_sampling_factor as u16
|
||
};
|
||
|
||
let offset = worker_mcu_y as usize * coefficients_per_mcu_row;
|
||
self.coefficients[scan.component_indices[i]]
|
||
[offset..offset + coefficients_per_mcu_row]
|
||
.to_vec()
|
||
} else {
|
||
mem::replace(
|
||
&mut mcu_row_coefficients[i],
|
||
vec![0i16; coefficients_per_mcu_row],
|
||
)
|
||
};
|
||
|
||
// FIXME: additional potential work stealing opportunities for rayon case if we
|
||
// also internally can parallelize over components.
|
||
worker.append_row((i, row_coefficients))?;
|
||
}
|
||
}
|
||
}
|
||
|
||
let mut marker = huffman.take_marker(&mut self.reader)?;
|
||
while let Some(Marker::RST(_)) = marker {
|
||
marker = self.read_marker().ok();
|
||
}
|
||
|
||
if finished.iter().any(|&c| c) {
|
||
// Retrieve all the data from the worker thread.
|
||
let mut data = vec![Vec::new(); frame.components.len()];
|
||
|
||
for (i, &component_index) in scan.component_indices.iter().enumerate() {
|
||
if finished[i] {
|
||
data[component_index] = worker.get_result(i)?;
|
||
}
|
||
}
|
||
|
||
Ok((marker, Some(data)))
|
||
} else {
|
||
Ok((marker, None))
|
||
}
|
||
}
|
||
}
|
||
|
||
fn decode_block<R: Read>(
|
||
reader: &mut R,
|
||
coefficients: &mut [i16; 64],
|
||
huffman: &mut HuffmanDecoder,
|
||
dc_table: Option<&HuffmanTable>,
|
||
ac_table: Option<&HuffmanTable>,
|
||
spectral_selection: Range<u8>,
|
||
successive_approximation_low: u8,
|
||
eob_run: &mut u16,
|
||
dc_predictor: &mut i16,
|
||
) -> Result<()> {
|
||
debug_assert_eq!(coefficients.len(), 64);
|
||
|
||
if spectral_selection.start == 0 {
|
||
// Section F.2.2.1
|
||
// Figure F.12
|
||
let value = huffman.decode(reader, dc_table.unwrap())?;
|
||
let diff = match value {
|
||
0 => 0,
|
||
1..=11 => huffman.receive_extend(reader, value)?,
|
||
_ => {
|
||
// Section F.1.2.1.1
|
||
// Table F.1
|
||
return Err(Error::Format(
|
||
"invalid DC difference magnitude category".to_owned(),
|
||
));
|
||
}
|
||
};
|
||
|
||
// Malicious JPEG files can cause this add to overflow, therefore we use wrapping_add.
|
||
// One example of such a file is tests/crashtest/images/dc-predictor-overflow.jpg
|
||
*dc_predictor = dc_predictor.wrapping_add(diff);
|
||
coefficients[0] = *dc_predictor << successive_approximation_low;
|
||
}
|
||
|
||
let mut index = cmp::max(spectral_selection.start, 1);
|
||
|
||
if index < spectral_selection.end && *eob_run > 0 {
|
||
*eob_run -= 1;
|
||
return Ok(());
|
||
}
|
||
|
||
// Section F.1.2.2.1
|
||
while index < spectral_selection.end {
|
||
if let Some((value, run)) = huffman.decode_fast_ac(reader, ac_table.unwrap())? {
|
||
index += run;
|
||
|
||
if index >= spectral_selection.end {
|
||
break;
|
||
}
|
||
|
||
coefficients[UNZIGZAG[index as usize] as usize] = value << successive_approximation_low;
|
||
index += 1;
|
||
} else {
|
||
let byte = huffman.decode(reader, ac_table.unwrap())?;
|
||
let r = byte >> 4;
|
||
let s = byte & 0x0f;
|
||
|
||
if s == 0 {
|
||
match r {
|
||
15 => index += 16, // Run length of 16 zero coefficients.
|
||
_ => {
|
||
*eob_run = (1 << r) - 1;
|
||
|
||
if r > 0 {
|
||
*eob_run += huffman.get_bits(reader, r)?;
|
||
}
|
||
|
||
break;
|
||
}
|
||
}
|
||
} else {
|
||
index += r;
|
||
|
||
if index >= spectral_selection.end {
|
||
break;
|
||
}
|
||
|
||
coefficients[UNZIGZAG[index as usize] as usize] =
|
||
huffman.receive_extend(reader, s)? << successive_approximation_low;
|
||
index += 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn decode_block_successive_approximation<R: Read>(
|
||
reader: &mut R,
|
||
coefficients: &mut [i16; 64],
|
||
huffman: &mut HuffmanDecoder,
|
||
ac_table: Option<&HuffmanTable>,
|
||
spectral_selection: Range<u8>,
|
||
successive_approximation_low: u8,
|
||
eob_run: &mut u16,
|
||
) -> Result<()> {
|
||
debug_assert_eq!(coefficients.len(), 64);
|
||
|
||
let bit = 1 << successive_approximation_low;
|
||
|
||
if spectral_selection.start == 0 {
|
||
// Section G.1.2.1
|
||
|
||
if huffman.get_bits(reader, 1)? == 1 {
|
||
coefficients[0] |= bit;
|
||
}
|
||
} else {
|
||
// Section G.1.2.3
|
||
|
||
if *eob_run > 0 {
|
||
*eob_run -= 1;
|
||
refine_non_zeroes(reader, coefficients, huffman, spectral_selection, 64, bit)?;
|
||
return Ok(());
|
||
}
|
||
|
||
let mut index = spectral_selection.start;
|
||
|
||
while index < spectral_selection.end {
|
||
let byte = huffman.decode(reader, ac_table.unwrap())?;
|
||
let r = byte >> 4;
|
||
let s = byte & 0x0f;
|
||
|
||
let mut zero_run_length = r;
|
||
let mut value = 0;
|
||
|
||
match s {
|
||
0 => {
|
||
match r {
|
||
15 => {
|
||
// Run length of 16 zero coefficients.
|
||
// We don't need to do anything special here, zero_run_length is 15
|
||
// and then value (which is zero) gets written, resulting in 16
|
||
// zero coefficients.
|
||
}
|
||
_ => {
|
||
*eob_run = (1 << r) - 1;
|
||
|
||
if r > 0 {
|
||
*eob_run += huffman.get_bits(reader, r)?;
|
||
}
|
||
|
||
// Force end of block.
|
||
zero_run_length = 64;
|
||
}
|
||
}
|
||
}
|
||
1 => {
|
||
if huffman.get_bits(reader, 1)? == 1 {
|
||
value = bit;
|
||
} else {
|
||
value = -bit;
|
||
}
|
||
}
|
||
_ => return Err(Error::Format("unexpected huffman code".to_owned())),
|
||
}
|
||
|
||
let range = Range {
|
||
start: index,
|
||
end: spectral_selection.end,
|
||
};
|
||
index = refine_non_zeroes(reader, coefficients, huffman, range, zero_run_length, bit)?;
|
||
|
||
if value != 0 {
|
||
coefficients[UNZIGZAG[index as usize] as usize] = value;
|
||
}
|
||
|
||
index += 1;
|
||
}
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn refine_non_zeroes<R: Read>(
|
||
reader: &mut R,
|
||
coefficients: &mut [i16; 64],
|
||
huffman: &mut HuffmanDecoder,
|
||
range: Range<u8>,
|
||
zrl: u8,
|
||
bit: i16,
|
||
) -> Result<u8> {
|
||
debug_assert_eq!(coefficients.len(), 64);
|
||
|
||
let last = range.end - 1;
|
||
let mut zero_run_length = zrl;
|
||
|
||
for i in range {
|
||
let index = UNZIGZAG[i as usize] as usize;
|
||
|
||
let coefficient = &mut coefficients[index];
|
||
|
||
if *coefficient == 0 {
|
||
if zero_run_length == 0 {
|
||
return Ok(i);
|
||
}
|
||
|
||
zero_run_length -= 1;
|
||
} else if huffman.get_bits(reader, 1)? == 1 && *coefficient & bit == 0 {
|
||
if *coefficient > 0 {
|
||
*coefficient = coefficient
|
||
.checked_add(bit)
|
||
.ok_or_else(|| Error::Format("Coefficient overflow".to_owned()))?;
|
||
} else {
|
||
*coefficient = coefficient
|
||
.checked_sub(bit)
|
||
.ok_or_else(|| Error::Format("Coefficient overflow".to_owned()))?;
|
||
}
|
||
}
|
||
}
|
||
|
||
Ok(last)
|
||
}
|
||
|
||
fn compute_image(
|
||
components: &[Component],
|
||
mut data: Vec<Vec<u8>>,
|
||
output_size: Dimensions,
|
||
color_transform: ColorTransform,
|
||
) -> Result<Vec<u8>> {
|
||
if data.is_empty() || data.iter().any(Vec::is_empty) {
|
||
return Err(Error::Format("not all components have data".to_owned()));
|
||
}
|
||
|
||
if components.len() == 1 {
|
||
let component = &components[0];
|
||
let mut decoded: Vec<u8> = data.remove(0);
|
||
|
||
let width = component.size.width as usize;
|
||
let height = component.size.height as usize;
|
||
let size = width * height;
|
||
let line_stride = component.block_size.width as usize * component.dct_scale;
|
||
|
||
// if the image width is a multiple of the block size,
|
||
// then we don't have to move bytes in the decoded data
|
||
if usize::from(output_size.width) != line_stride {
|
||
// The first line already starts at index 0, so we need to move only lines 1..height
|
||
// We move from the top down because all lines are being moved backwards.
|
||
for y in 1..height {
|
||
let destination_idx = y * width;
|
||
let source_idx = y * line_stride;
|
||
let end = source_idx + width;
|
||
decoded.copy_within(source_idx..end, destination_idx);
|
||
}
|
||
}
|
||
decoded.resize(size, 0);
|
||
Ok(decoded)
|
||
} else {
|
||
compute_image_parallel(components, data, output_size, color_transform)
|
||
}
|
||
}
|
||
|
||
pub(crate) fn choose_color_convert_func(
|
||
component_count: usize,
|
||
color_transform: ColorTransform,
|
||
) -> Result<fn(&[Vec<u8>], &mut [u8])> {
|
||
match component_count {
|
||
3 => match color_transform {
|
||
ColorTransform::None => Ok(color_no_convert),
|
||
ColorTransform::Grayscale => Err(Error::Format(
|
||
"Invalid number of channels (3) for Grayscale data".to_string(),
|
||
)),
|
||
ColorTransform::RGB => Ok(color_convert_line_rgb),
|
||
ColorTransform::YCbCr => Ok(color_convert_line_ycbcr),
|
||
ColorTransform::CMYK => Err(Error::Format(
|
||
"Invalid number of channels (3) for CMYK data".to_string(),
|
||
)),
|
||
ColorTransform::YCCK => Err(Error::Format(
|
||
"Invalid number of channels (3) for YCCK data".to_string(),
|
||
)),
|
||
ColorTransform::JcsBgYcc => Err(Error::Unsupported(
|
||
UnsupportedFeature::ColorTransform(ColorTransform::JcsBgYcc),
|
||
)),
|
||
ColorTransform::JcsBgRgb => Err(Error::Unsupported(
|
||
UnsupportedFeature::ColorTransform(ColorTransform::JcsBgRgb),
|
||
)),
|
||
ColorTransform::Unknown => Err(Error::Format("Unknown colour transform".to_string())),
|
||
},
|
||
4 => match color_transform {
|
||
ColorTransform::None => Ok(color_no_convert),
|
||
ColorTransform::Grayscale => Err(Error::Format(
|
||
"Invalid number of channels (4) for Grayscale data".to_string(),
|
||
)),
|
||
ColorTransform::RGB => Err(Error::Format(
|
||
"Invalid number of channels (4) for RGB data".to_string(),
|
||
)),
|
||
ColorTransform::YCbCr => Err(Error::Format(
|
||
"Invalid number of channels (4) for YCbCr data".to_string(),
|
||
)),
|
||
ColorTransform::CMYK => Ok(color_convert_line_cmyk),
|
||
ColorTransform::YCCK => Ok(color_convert_line_ycck),
|
||
|
||
ColorTransform::JcsBgYcc => Err(Error::Unsupported(
|
||
UnsupportedFeature::ColorTransform(ColorTransform::JcsBgYcc),
|
||
)),
|
||
ColorTransform::JcsBgRgb => Err(Error::Unsupported(
|
||
UnsupportedFeature::ColorTransform(ColorTransform::JcsBgRgb),
|
||
)),
|
||
ColorTransform::Unknown => Err(Error::Format("Unknown colour transform".to_string())),
|
||
},
|
||
_ => panic!(),
|
||
}
|
||
}
|
||
|
||
fn color_convert_line_rgb(data: &[Vec<u8>], output: &mut [u8]) {
|
||
assert!(data.len() == 3, "wrong number of components for rgb");
|
||
let [r, g, b]: &[Vec<u8>; 3] = data.try_into().unwrap();
|
||
for (((chunk, r), g), b) in output
|
||
.chunks_exact_mut(3)
|
||
.zip(r.iter())
|
||
.zip(g.iter())
|
||
.zip(b.iter())
|
||
{
|
||
chunk[0] = *r;
|
||
chunk[1] = *g;
|
||
chunk[2] = *b;
|
||
}
|
||
}
|
||
|
||
fn color_convert_line_ycbcr(data: &[Vec<u8>], output: &mut [u8]) {
|
||
assert!(data.len() == 3, "wrong number of components for ycbcr");
|
||
let [y, cb, cr]: &[_; 3] = data.try_into().unwrap();
|
||
|
||
#[cfg(not(feature = "platform_independent"))]
|
||
let arch_specific_pixels = {
|
||
if let Some(ycbcr) = crate::arch::get_color_convert_line_ycbcr() {
|
||
#[allow(unsafe_code)]
|
||
unsafe {
|
||
ycbcr(y, cb, cr, output)
|
||
}
|
||
} else {
|
||
0
|
||
}
|
||
};
|
||
|
||
#[cfg(feature = "platform_independent")]
|
||
let arch_specific_pixels = 0;
|
||
|
||
for (((chunk, y), cb), cr) in output
|
||
.chunks_exact_mut(3)
|
||
.zip(y.iter())
|
||
.zip(cb.iter())
|
||
.zip(cr.iter())
|
||
.skip(arch_specific_pixels)
|
||
{
|
||
let (r, g, b) = ycbcr_to_rgb(*y, *cb, *cr);
|
||
chunk[0] = r;
|
||
chunk[1] = g;
|
||
chunk[2] = b;
|
||
}
|
||
}
|
||
|
||
fn color_convert_line_ycck(data: &[Vec<u8>], output: &mut [u8]) {
|
||
assert!(data.len() == 4, "wrong number of components for ycck");
|
||
let [c, m, y, k]: &[Vec<u8>; 4] = data.try_into().unwrap();
|
||
|
||
for ((((chunk, c), m), y), k) in output
|
||
.chunks_exact_mut(4)
|
||
.zip(c.iter())
|
||
.zip(m.iter())
|
||
.zip(y.iter())
|
||
.zip(k.iter())
|
||
{
|
||
let (r, g, b) = ycbcr_to_rgb(*c, *m, *y);
|
||
chunk[0] = r;
|
||
chunk[1] = g;
|
||
chunk[2] = b;
|
||
chunk[3] = 255 - *k;
|
||
}
|
||
}
|
||
|
||
fn color_convert_line_cmyk(data: &[Vec<u8>], output: &mut [u8]) {
|
||
assert!(data.len() == 4, "wrong number of components for cmyk");
|
||
let [c, m, y, k]: &[Vec<u8>; 4] = data.try_into().unwrap();
|
||
|
||
for ((((chunk, c), m), y), k) in output
|
||
.chunks_exact_mut(4)
|
||
.zip(c.iter())
|
||
.zip(m.iter())
|
||
.zip(y.iter())
|
||
.zip(k.iter())
|
||
{
|
||
chunk[0] = 255 - c;
|
||
chunk[1] = 255 - m;
|
||
chunk[2] = 255 - y;
|
||
chunk[3] = 255 - k;
|
||
}
|
||
}
|
||
|
||
fn color_no_convert(data: &[Vec<u8>], output: &mut [u8]) {
|
||
let mut output_iter = output.iter_mut();
|
||
|
||
for pixel in data {
|
||
for d in pixel {
|
||
*(output_iter.next().unwrap()) = *d;
|
||
}
|
||
}
|
||
}
|
||
|
||
const FIXED_POINT_OFFSET: i32 = 20;
|
||
const HALF: i32 = (1 << FIXED_POINT_OFFSET) / 2;
|
||
|
||
// ITU-R BT.601
|
||
// Based on libjpeg-turbo's jdcolext.c
|
||
fn ycbcr_to_rgb(y: u8, cb: u8, cr: u8) -> (u8, u8, u8) {
|
||
let y = y as i32 * (1 << FIXED_POINT_OFFSET) + HALF;
|
||
let cb = cb as i32 - 128;
|
||
let cr = cr as i32 - 128;
|
||
|
||
let r = clamp_fixed_point(y + stbi_f2f(1.40200) * cr);
|
||
let g = clamp_fixed_point(y - stbi_f2f(0.34414) * cb - stbi_f2f(0.71414) * cr);
|
||
let b = clamp_fixed_point(y + stbi_f2f(1.77200) * cb);
|
||
(r, g, b)
|
||
}
|
||
|
||
fn stbi_f2f(x: f32) -> i32 {
|
||
(x * ((1 << FIXED_POINT_OFFSET) as f32) + 0.5) as i32
|
||
}
|
||
|
||
fn clamp_fixed_point(value: i32) -> u8 {
|
||
(value >> FIXED_POINT_OFFSET).min(255).max(0) as u8
|
||
}
|