| 1 |
#![allow(clippy::too_many_arguments)] |
| 2 |
use std::borrow::Cow; |
| 3 |
use std::io::{self, Write}; |
| 4 |
use std::{error, fmt}; |
| 5 |
|
| 6 |
use crate::error::{ |
| 7 |
EncodingError, ImageError, ImageResult, UnsupportedError, UnsupportedErrorKind, |
| 8 |
}; |
| 9 |
use crate::traits::PixelWithColorType; |
| 10 |
use crate::utils::clamp; |
| 11 |
use crate::{ |
| 12 |
ColorType, DynamicImage, ExtendedColorType, GenericImageView, ImageBuffer, ImageEncoder, |
| 13 |
ImageFormat, Luma, Pixel, Rgb, |
| 14 |
}; |
| 15 |
|
| 16 |
use num_traits::ToPrimitive; |
| 17 |
|
| 18 |
use super::entropy::build_huff_lut_const; |
| 19 |
use super::transform; |
| 20 |
|
| 21 |
// Markers |
| 22 |
// Baseline DCT |
| 23 |
static SOF0: u8 = 0xC0; |
| 24 |
// Huffman Tables |
| 25 |
static DHT: u8 = 0xC4; |
| 26 |
// Start of Image (standalone) |
| 27 |
static SOI: u8 = 0xD8; |
| 28 |
// End of image (standalone) |
| 29 |
static EOI: u8 = 0xD9; |
| 30 |
// Start of Scan |
| 31 |
static SOS: u8 = 0xDA; |
| 32 |
// Quantization Tables |
| 33 |
static DQT: u8 = 0xDB; |
| 34 |
// Application segments start and end |
| 35 |
static APP0: u8 = 0xE0; |
| 36 |
static APP1: u8 = 0xE1; |
| 37 |
static APP2: u8 = 0xE2; |
| 38 |
|
| 39 |
// section K.1 |
| 40 |
// table K.1 |
| 41 |
#[rustfmt::skip] |
| 42 |
static STD_LUMA_QTABLE: [u8; 64] = [ |
| 43 |
16, 11, 10, 16, 24, 40, 51, 61, |
| 44 |
12, 12, 14, 19, 26, 58, 60, 55, |
| 45 |
14, 13, 16, 24, 40, 57, 69, 56, |
| 46 |
14, 17, 22, 29, 51, 87, 80, 62, |
| 47 |
18, 22, 37, 56, 68, 109, 103, 77, |
| 48 |
24, 35, 55, 64, 81, 104, 113, 92, |
| 49 |
49, 64, 78, 87, 103, 121, 120, 101, |
| 50 |
72, 92, 95, 98, 112, 100, 103, 99, |
| 51 |
]; |
| 52 |
|
| 53 |
// table K.2 |
| 54 |
#[rustfmt::skip] |
| 55 |
static STD_CHROMA_QTABLE: [u8; 64] = [ |
| 56 |
17, 18, 24, 47, 99, 99, 99, 99, |
| 57 |
18, 21, 26, 66, 99, 99, 99, 99, |
| 58 |
24, 26, 56, 99, 99, 99, 99, 99, |
| 59 |
47, 66, 99, 99, 99, 99, 99, 99, |
| 60 |
99, 99, 99, 99, 99, 99, 99, 99, |
| 61 |
99, 99, 99, 99, 99, 99, 99, 99, |
| 62 |
99, 99, 99, 99, 99, 99, 99, 99, |
| 63 |
99, 99, 99, 99, 99, 99, 99, 99, |
| 64 |
]; |
| 65 |
|
| 66 |
// section K.3 |
| 67 |
// Code lengths and values for table K.3 |
| 68 |
static STD_LUMA_DC_CODE_LENGTHS: [u8; 16] = [ |
| 69 |
0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 70 |
]; |
| 71 |
|
| 72 |
static STD_LUMA_DC_VALUES: [u8; 12] = [ |
| 73 |
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, |
| 74 |
]; |
| 75 |
|
| 76 |
static STD_LUMA_DC_HUFF_LUT: [(u8, u16); 256] = |
| 77 |
build_huff_lut_const(&STD_LUMA_DC_CODE_LENGTHS, &STD_LUMA_DC_VALUES); |
| 78 |
|
| 79 |
// Code lengths and values for table K.4 |
| 80 |
static STD_CHROMA_DC_CODE_LENGTHS: [u8; 16] = [ |
| 81 |
0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, |
| 82 |
]; |
| 83 |
|
| 84 |
static STD_CHROMA_DC_VALUES: [u8; 12] = [ |
| 85 |
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, |
| 86 |
]; |
| 87 |
|
| 88 |
static STD_CHROMA_DC_HUFF_LUT: [(u8, u16); 256] = |
| 89 |
build_huff_lut_const(&STD_CHROMA_DC_CODE_LENGTHS, &STD_CHROMA_DC_VALUES); |
| 90 |
|
| 91 |
// Code lengths and values for table k.5 |
| 92 |
static STD_LUMA_AC_CODE_LENGTHS: [u8; 16] = [ |
| 93 |
0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, |
| 94 |
]; |
| 95 |
|
| 96 |
static STD_LUMA_AC_VALUES: [u8; 162] = [ |
| 97 |
0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, |
| 98 |
0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, |
| 99 |
0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, |
| 100 |
0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, |
| 101 |
0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, |
| 102 |
0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, |
| 103 |
0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, |
| 104 |
0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, |
| 105 |
0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, |
| 106 |
0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, |
| 107 |
0xF9, 0xFA, |
| 108 |
]; |
| 109 |
|
| 110 |
static STD_LUMA_AC_HUFF_LUT: [(u8, u16); 256] = |
| 111 |
build_huff_lut_const(&STD_LUMA_AC_CODE_LENGTHS, &STD_LUMA_AC_VALUES); |
| 112 |
|
| 113 |
// Code lengths and values for table k.6 |
| 114 |
static STD_CHROMA_AC_CODE_LENGTHS: [u8; 16] = [ |
| 115 |
0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, |
| 116 |
]; |
| 117 |
static STD_CHROMA_AC_VALUES: [u8; 162] = [ |
| 118 |
0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, |
| 119 |
0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0, |
| 120 |
0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, |
| 121 |
0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, |
| 122 |
0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, |
| 123 |
0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, |
| 124 |
0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, |
| 125 |
0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, |
| 126 |
0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, |
| 127 |
0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, |
| 128 |
0xF9, 0xFA, |
| 129 |
]; |
| 130 |
|
| 131 |
static STD_CHROMA_AC_HUFF_LUT: [(u8, u16); 256] = |
| 132 |
build_huff_lut_const(&STD_CHROMA_AC_CODE_LENGTHS, &STD_CHROMA_AC_VALUES); |
| 133 |
|
| 134 |
static DCCLASS: u8 = 0; |
| 135 |
static ACCLASS: u8 = 1; |
| 136 |
|
| 137 |
static LUMADESTINATION: u8 = 0; |
| 138 |
static CHROMADESTINATION: u8 = 1; |
| 139 |
|
| 140 |
static LUMAID: u8 = 1; |
| 141 |
static CHROMABLUEID: u8 = 2; |
| 142 |
static CHROMAREDID: u8 = 3; |
| 143 |
|
| 144 |
/// The permutation of dct coefficients. |
| 145 |
#[rustfmt::skip] |
| 146 |
static UNZIGZAG: [u8; 64] = [ |
| 147 |
0, 1, 8, 16, 9, 2, 3, 10, |
| 148 |
17, 24, 32, 25, 18, 11, 4, 5, |
| 149 |
12, 19, 26, 33, 40, 48, 41, 34, |
| 150 |
27, 20, 13, 6, 7, 14, 21, 28, |
| 151 |
35, 42, 49, 56, 57, 50, 43, 36, |
| 152 |
29, 22, 15, 23, 30, 37, 44, 51, |
| 153 |
58, 59, 52, 45, 38, 31, 39, 46, |
| 154 |
53, 60, 61, 54, 47, 55, 62, 63, |
| 155 |
]; |
| 156 |
|
| 157 |
// E x i f \0 \0 |
| 158 |
/// The header for an EXIF APP1 segment |
| 159 |
static EXIF_HEADER: [u8; 6] = [0x45, 0x78, 0x69, 0x66, 0x00, 0x00]; |
| 160 |
|
| 161 |
/// A representation of a JPEG component |
| 162 |
#[derive(Copy, Clone)] |
| 163 |
struct Component { |
| 164 |
/// The Component's identifier |
| 165 |
id: u8, |
| 166 |
|
| 167 |
/// Horizontal sampling factor |
| 168 |
h: u8, |
| 169 |
|
| 170 |
/// Vertical sampling factor |
| 171 |
v: u8, |
| 172 |
|
| 173 |
/// The quantization table selector |
| 174 |
tq: u8, |
| 175 |
|
| 176 |
/// Index to the Huffman DC Table |
| 177 |
dc_table: u8, |
| 178 |
|
| 179 |
/// Index to the AC Huffman Table |
| 180 |
ac_table: u8, |
| 181 |
|
| 182 |
/// The dc prediction of the component |
| 183 |
_dc_pred: i32, |
| 184 |
} |
| 185 |
|
| 186 |
pub(crate) struct BitWriter<W> { |
| 187 |
w: W, |
| 188 |
accumulator: u32, |
| 189 |
nbits: u8, |
| 190 |
} |
| 191 |
|
| 192 |
impl<W: Write> BitWriter<W> { |
| 193 |
fn new(w: W) -> Self { |
| 194 |
BitWriter { |
| 195 |
w, |
| 196 |
accumulator: 0, |
| 197 |
nbits: 0, |
| 198 |
} |
| 199 |
} |
| 200 |
|
| 201 |
fn write_bits(&mut self, bits: u16, size: u8) -> io::Result<()> { |
| 202 |
if size == 0 { |
| 203 |
return Ok(()); |
| 204 |
} |
| 205 |
|
| 206 |
self.nbits += size; |
| 207 |
self.accumulator |= u32::from(bits) << (32 - self.nbits) as usize; |
| 208 |
|
| 209 |
while self.nbits >= 8 { |
| 210 |
let byte = self.accumulator >> 24; |
| 211 |
self.w.write_all(&[byte as u8])?; |
| 212 |
|
| 213 |
if byte == 0xFF { |
| 214 |
self.w.write_all(&[0x00])?; |
| 215 |
} |
| 216 |
|
| 217 |
self.nbits -= 8; |
| 218 |
self.accumulator <<= 8; |
| 219 |
} |
| 220 |
|
| 221 |
Ok(()) |
| 222 |
} |
| 223 |
|
| 224 |
fn pad_byte(&mut self) -> io::Result<()> { |
| 225 |
self.write_bits(0x7F, 7) |
| 226 |
} |
| 227 |
|
| 228 |
fn huffman_encode(&mut self, val: u8, table: &[(u8, u16); 256]) -> io::Result<()> { |
| 229 |
let (size, code) = table[val as usize]; |
| 230 |
|
| 231 |
assert!(size <= 16, "bad huffman value"); |
| 232 |
|
| 233 |
self.write_bits(code, size) |
| 234 |
} |
| 235 |
|
| 236 |
fn write_block( |
| 237 |
&mut self, |
| 238 |
block: &[i32; 64], |
| 239 |
prevdc: i32, |
| 240 |
dctable: &[(u8, u16); 256], |
| 241 |
actable: &[(u8, u16); 256], |
| 242 |
) -> io::Result<i32> { |
| 243 |
// Differential DC encoding |
| 244 |
let dcval = block[0]; |
| 245 |
let diff = dcval - prevdc; |
| 246 |
let (size, value) = encode_coefficient(diff); |
| 247 |
|
| 248 |
self.huffman_encode(size, dctable)?; |
| 249 |
self.write_bits(value, size)?; |
| 250 |
|
| 251 |
// Figure F.2 |
| 252 |
let mut zero_run = 0; |
| 253 |
|
| 254 |
for &k in &UNZIGZAG[1..] { |
| 255 |
if block[k as usize] == 0 { |
| 256 |
zero_run += 1; |
| 257 |
} else { |
| 258 |
while zero_run > 15 { |
| 259 |
self.huffman_encode(0xF0, actable)?; |
| 260 |
zero_run -= 16; |
| 261 |
} |
| 262 |
|
| 263 |
let (size, value) = encode_coefficient(block[k as usize]); |
| 264 |
let symbol = (zero_run << 4) | size; |
| 265 |
|
| 266 |
self.huffman_encode(symbol, actable)?; |
| 267 |
self.write_bits(value, size)?; |
| 268 |
|
| 269 |
zero_run = 0; |
| 270 |
} |
| 271 |
} |
| 272 |
|
| 273 |
if block[UNZIGZAG[63] as usize] == 0 { |
| 274 |
self.huffman_encode(0x00, actable)?; |
| 275 |
} |
| 276 |
|
| 277 |
Ok(dcval) |
| 278 |
} |
| 279 |
|
| 280 |
fn write_marker(&mut self, marker: u8) -> io::Result<()> { |
| 281 |
self.w.write_all(&[0xFF, marker]) |
| 282 |
} |
| 283 |
|
| 284 |
fn write_segment(&mut self, marker: u8, data: &[u8]) -> io::Result<()> { |
| 285 |
self.w.write_all(&[0xFF, marker])?; |
| 286 |
self.w.write_all(&(data.len() as u16 + 2).to_be_bytes())?; |
| 287 |
self.w.write_all(data) |
| 288 |
} |
| 289 |
} |
| 290 |
|
| 291 |
/// Represents a unit in which the density of an image is measured |
| 292 |
#[derive(Clone, Copy, Debug, Eq, PartialEq)] |
| 293 |
pub enum PixelDensityUnit { |
| 294 |
/// Represents the absence of a unit, the values indicate only a |
| 295 |
/// [pixel aspect ratio](https://en.wikipedia.org/wiki/Pixel_aspect_ratio) |
| 296 |
PixelAspectRatio, |
| 297 |
|
| 298 |
/// Pixels per inch (2.54 cm) |
| 299 |
Inches, |
| 300 |
|
| 301 |
/// Pixels per centimeter |
| 302 |
Centimeters, |
| 303 |
} |
| 304 |
|
| 305 |
/// Represents the pixel density of an image |
| 306 |
/// |
| 307 |
/// For example, a 300 DPI image is represented by: |
| 308 |
/// |
| 309 |
/// ```rust |
| 310 |
/// use image::codecs::jpeg::*; |
| 311 |
/// let hdpi = PixelDensity::dpi(300); |
| 312 |
/// assert_eq!(hdpi, PixelDensity {density: (300,300), unit: PixelDensityUnit::Inches}) |
| 313 |
/// ``` |
| 314 |
#[derive(Clone, Copy, Debug, Eq, PartialEq)] |
| 315 |
pub struct PixelDensity { |
| 316 |
/// A couple of values for (Xdensity, Ydensity) |
| 317 |
pub density: (u16, u16), |
| 318 |
/// The unit in which the density is measured |
| 319 |
pub unit: PixelDensityUnit, |
| 320 |
} |
| 321 |
|
| 322 |
impl PixelDensity { |
| 323 |
/// Creates the most common pixel density type: |
| 324 |
/// the horizontal and the vertical density are equal, |
| 325 |
/// and measured in pixels per inch. |
| 326 |
#[must_use] |
| 327 |
pub fn dpi(density: u16) -> Self { |
| 328 |
PixelDensity { |
| 329 |
density: (density, density), |
| 330 |
unit: PixelDensityUnit::Inches, |
| 331 |
} |
| 332 |
} |
| 333 |
} |
| 334 |
|
| 335 |
impl Default for PixelDensity { |
| 336 |
/// Returns a pixel density with a pixel aspect ratio of 1 |
| 337 |
fn default() -> Self { |
| 338 |
PixelDensity { |
| 339 |
density: (1, 1), |
| 340 |
unit: PixelDensityUnit::PixelAspectRatio, |
| 341 |
} |
| 342 |
} |
| 343 |
} |
| 344 |
|
| 345 |
/// Errors that can occur when encoding a JPEG image |
| 346 |
#[derive(Debug, Copy, Clone)] |
| 347 |
enum EncoderError { |
| 348 |
/// JPEG does not support this size |
| 349 |
InvalidSize(u32, u32), |
| 350 |
} |
| 351 |
|
| 352 |
impl fmt::Display for EncoderError { |
| 353 |
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| 354 |
match self { |
| 355 |
EncoderError::InvalidSize(w, h) => f.write_fmt(format_args!( |
| 356 |
"Invalid image size ({w} x {h}) to encode as JPEG: \ |
| 357 |
width and height must be >= 1 and <= 65535" |
| 358 |
)), |
| 359 |
} |
| 360 |
} |
| 361 |
} |
| 362 |
|
| 363 |
impl From<EncoderError> for ImageError { |
| 364 |
fn from(e: EncoderError) -> ImageError { |
| 365 |
ImageError::Encoding(EncodingError::new(ImageFormat::Jpeg.into(), e)) |
| 366 |
} |
| 367 |
} |
| 368 |
|
| 369 |
impl error::Error for EncoderError {} |
| 370 |
|
| 371 |
/// The representation of a JPEG encoder |
| 372 |
pub struct JpegEncoder<W> { |
| 373 |
writer: BitWriter<W>, |
| 374 |
|
| 375 |
components: Vec<Component>, |
| 376 |
tables: Vec<[u8; 64]>, |
| 377 |
|
| 378 |
luma_dctable: Cow<'static, [(u8, u16); 256]>, |
| 379 |
luma_actable: Cow<'static, [(u8, u16); 256]>, |
| 380 |
chroma_dctable: Cow<'static, [(u8, u16); 256]>, |
| 381 |
chroma_actable: Cow<'static, [(u8, u16); 256]>, |
| 382 |
|
| 383 |
pixel_density: PixelDensity, |
| 384 |
|
| 385 |
icc_profile: Vec<u8>, |
| 386 |
exif: Vec<u8>, |
| 387 |
} |
| 388 |
|
| 389 |
impl<W: Write> JpegEncoder<W> { |
| 390 |
/// Create a new encoder that writes its output to ```w``` |
| 391 |
pub fn new(w: W) -> JpegEncoder<W> { |
| 392 |
JpegEncoder::new_with_quality(w, 75) |
| 393 |
} |
| 394 |
|
| 395 |
/// Create a new encoder that writes its output to ```w```, and has |
| 396 |
/// the quality parameter ```quality``` with a value in the range 1-100 |
| 397 |
/// where 1 is the worst and 100 is the best. |
| 398 |
pub fn new_with_quality(w: W, quality: u8) -> JpegEncoder<W> { |
| 399 |
let components = vec![ |
| 400 |
Component { |
| 401 |
id: LUMAID, |
| 402 |
h: 1, |
| 403 |
v: 1, |
| 404 |
tq: LUMADESTINATION, |
| 405 |
dc_table: LUMADESTINATION, |
| 406 |
ac_table: LUMADESTINATION, |
| 407 |
_dc_pred: 0, |
| 408 |
}, |
| 409 |
Component { |
| 410 |
id: CHROMABLUEID, |
| 411 |
h: 1, |
| 412 |
v: 1, |
| 413 |
tq: CHROMADESTINATION, |
| 414 |
dc_table: CHROMADESTINATION, |
| 415 |
ac_table: CHROMADESTINATION, |
| 416 |
_dc_pred: 0, |
| 417 |
}, |
| 418 |
Component { |
| 419 |
id: CHROMAREDID, |
| 420 |
h: 1, |
| 421 |
v: 1, |
| 422 |
tq: CHROMADESTINATION, |
| 423 |
dc_table: CHROMADESTINATION, |
| 424 |
ac_table: CHROMADESTINATION, |
| 425 |
_dc_pred: 0, |
| 426 |
}, |
| 427 |
]; |
| 428 |
|
| 429 |
// Derive our quantization table scaling value using the libjpeg algorithm |
| 430 |
let scale = u32::from(clamp(quality, 1, 100)); |
| 431 |
let scale = if scale < 50 { |
| 432 |
5000 / scale |
| 433 |
} else { |
| 434 |
200 - scale * 2 |
| 435 |
}; |
| 436 |
|
| 437 |
let mut tables = vec![STD_LUMA_QTABLE, STD_CHROMA_QTABLE]; |
| 438 |
for t in tables.iter_mut() { |
| 439 |
for v in t.iter_mut() { |
| 440 |
*v = clamp((u32::from(*v) * scale + 50) / 100, 1, u32::from(u8::MAX)) as u8; |
| 441 |
} |
| 442 |
} |
| 443 |
|
| 444 |
JpegEncoder { |
| 445 |
writer: BitWriter::new(w), |
| 446 |
|
| 447 |
components, |
| 448 |
tables, |
| 449 |
|
| 450 |
luma_dctable: Cow::Borrowed(&STD_LUMA_DC_HUFF_LUT), |
| 451 |
luma_actable: Cow::Borrowed(&STD_LUMA_AC_HUFF_LUT), |
| 452 |
chroma_dctable: Cow::Borrowed(&STD_CHROMA_DC_HUFF_LUT), |
| 453 |
chroma_actable: Cow::Borrowed(&STD_CHROMA_AC_HUFF_LUT), |
| 454 |
|
| 455 |
pixel_density: PixelDensity::default(), |
| 456 |
|
| 457 |
icc_profile: Vec::new(), |
| 458 |
exif: Vec::new(), |
| 459 |
} |
| 460 |
} |
| 461 |
|
| 462 |
/// Set the pixel density of the images the encoder will encode. |
| 463 |
/// If this method is not called, then a default pixel aspect ratio of 1x1 will be applied, |
| 464 |
/// and no DPI information will be stored in the image. |
| 465 |
pub fn set_pixel_density(&mut self, pixel_density: PixelDensity) { |
| 466 |
self.pixel_density = pixel_density; |
| 467 |
} |
| 468 |
|
| 469 |
/// Encodes the image stored in the raw byte buffer ```image``` |
| 470 |
/// that has dimensions ```width``` and ```height``` |
| 471 |
/// and ```ColorType``` ```c``` |
| 472 |
/// |
| 473 |
/// The Image in encoded with subsampling ratio 4:2:2 |
| 474 |
/// |
| 475 |
/// # Panics |
| 476 |
/// |
| 477 |
/// Panics if `width * height * color_type.bytes_per_pixel() != image.len()`. |
| 478 |
#[track_caller] |
| 479 |
pub fn encode( |
| 480 |
&mut self, |
| 481 |
image: &[u8], |
| 482 |
width: u32, |
| 483 |
height: u32, |
| 484 |
color_type: ExtendedColorType, |
| 485 |
) -> ImageResult<()> { |
| 486 |
let expected_buffer_len = color_type.buffer_size(width, height); |
| 487 |
assert_eq!( |
| 488 |
expected_buffer_len, |
| 489 |
image.len() as u64, |
| 490 |
"Invalid buffer length: expected {expected_buffer_len} got {} for {width}x{height} image", |
| 491 |
image.len(), |
| 492 |
); |
| 493 |
|
| 494 |
match color_type { |
| 495 |
ExtendedColorType::L8 => { |
| 496 |
let image: ImageBuffer<Luma<_>, _> = |
| 497 |
ImageBuffer::from_raw(width, height, image).unwrap(); |
| 498 |
self.encode_image(&image) |
| 499 |
} |
| 500 |
ExtendedColorType::Rgb8 => { |
| 501 |
let image: ImageBuffer<Rgb<_>, _> = |
| 502 |
ImageBuffer::from_raw(width, height, image).unwrap(); |
| 503 |
self.encode_image(&image) |
| 504 |
} |
| 505 |
_ => Err(ImageError::Unsupported( |
| 506 |
UnsupportedError::from_format_and_kind( |
| 507 |
ImageFormat::Jpeg.into(), |
| 508 |
UnsupportedErrorKind::Color(color_type), |
| 509 |
), |
| 510 |
)), |
| 511 |
} |
| 512 |
} |
| 513 |
|
| 514 |
fn write_exif(&mut self) -> ImageResult<()> { |
| 515 |
if !self.exif.is_empty() { |
| 516 |
let mut formatted = EXIF_HEADER.to_vec(); |
| 517 |
formatted.extend_from_slice(&self.exif); |
| 518 |
self.writer.write_segment(APP1, &formatted)?; |
| 519 |
} |
| 520 |
|
| 521 |
Ok(()) |
| 522 |
} |
| 523 |
|
| 524 |
/// Encodes the given image. |
| 525 |
/// |
| 526 |
/// As a special feature this does not require the whole image to be present in memory at the |
| 527 |
/// same time such that it may be computed on the fly, which is why this method exists on this |
| 528 |
/// encoder but not on others. Instead the encoder will iterate over 8-by-8 blocks of pixels at |
| 529 |
/// a time, inspecting each pixel exactly once. You can rely on this behaviour when calling |
| 530 |
/// this method. |
| 531 |
/// |
| 532 |
/// The Image in encoded with subsampling ratio 4:2:2 |
| 533 |
pub fn encode_image<I: GenericImageView>(&mut self, image: &I) -> ImageResult<()> |
| 534 |
where |
| 535 |
I::Pixel: PixelWithColorType, |
| 536 |
{ |
| 537 |
let n = I::Pixel::CHANNEL_COUNT; |
| 538 |
let color_type = I::Pixel::COLOR_TYPE; |
| 539 |
let num_components = if n == 1 || n == 2 { 1 } else { 3 }; |
| 540 |
|
| 541 |
let (width, height) = match (u16::try_from(image.width()), u16::try_from(image.height())) { |
| 542 |
(Ok(w @ 1..), Ok(h @ 1..)) => (w, h), |
| 543 |
_ => return Err(EncoderError::InvalidSize(image.width(), image.height()).into()), |
| 544 |
}; |
| 545 |
|
| 546 |
self.writer.write_marker(SOI)?; |
| 547 |
|
| 548 |
let mut buf = Vec::new(); |
| 549 |
|
| 550 |
build_jfif_header(&mut buf, self.pixel_density); |
| 551 |
self.writer.write_segment(APP0, &buf)?; |
| 552 |
self.write_exif()?; |
| 553 |
|
| 554 |
// Write ICC profile chunks if present |
| 555 |
self.write_icc_profile_chunks()?; |
| 556 |
|
| 557 |
build_frame_header( |
| 558 |
&mut buf, |
| 559 |
8, |
| 560 |
width, |
| 561 |
height, |
| 562 |
&self.components[..num_components], |
| 563 |
); |
| 564 |
self.writer.write_segment(SOF0, &buf)?; |
| 565 |
|
| 566 |
assert_eq!(self.tables.len(), 2); |
| 567 |
let numtables = if num_components == 1 { 1 } else { 2 }; |
| 568 |
|
| 569 |
for (i, table) in self.tables[..numtables].iter().enumerate() { |
| 570 |
build_quantization_segment(&mut buf, 8, i as u8, table); |
| 571 |
self.writer.write_segment(DQT, &buf)?; |
| 572 |
} |
| 573 |
|
| 574 |
build_huffman_segment( |
| 575 |
&mut buf, |
| 576 |
DCCLASS, |
| 577 |
LUMADESTINATION, |
| 578 |
&STD_LUMA_DC_CODE_LENGTHS, |
| 579 |
&STD_LUMA_DC_VALUES, |
| 580 |
); |
| 581 |
self.writer.write_segment(DHT, &buf)?; |
| 582 |
|
| 583 |
build_huffman_segment( |
| 584 |
&mut buf, |
| 585 |
ACCLASS, |
| 586 |
LUMADESTINATION, |
| 587 |
&STD_LUMA_AC_CODE_LENGTHS, |
| 588 |
&STD_LUMA_AC_VALUES, |
| 589 |
); |
| 590 |
self.writer.write_segment(DHT, &buf)?; |
| 591 |
|
| 592 |
if num_components == 3 { |
| 593 |
build_huffman_segment( |
| 594 |
&mut buf, |
| 595 |
DCCLASS, |
| 596 |
CHROMADESTINATION, |
| 597 |
&STD_CHROMA_DC_CODE_LENGTHS, |
| 598 |
&STD_CHROMA_DC_VALUES, |
| 599 |
); |
| 600 |
self.writer.write_segment(DHT, &buf)?; |
| 601 |
|
| 602 |
build_huffman_segment( |
| 603 |
&mut buf, |
| 604 |
ACCLASS, |
| 605 |
CHROMADESTINATION, |
| 606 |
&STD_CHROMA_AC_CODE_LENGTHS, |
| 607 |
&STD_CHROMA_AC_VALUES, |
| 608 |
); |
| 609 |
self.writer.write_segment(DHT, &buf)?; |
| 610 |
} |
| 611 |
|
| 612 |
build_scan_header(&mut buf, &self.components[..num_components]); |
| 613 |
self.writer.write_segment(SOS, &buf)?; |
| 614 |
|
| 615 |
if ExtendedColorType::Rgb8 == color_type || ExtendedColorType::Rgba8 == color_type { |
| 616 |
self.encode_rgb(image) |
| 617 |
} else { |
| 618 |
self.encode_gray(image) |
| 619 |
}?; |
| 620 |
|
| 621 |
self.writer.pad_byte()?; |
| 622 |
self.writer.write_marker(EOI)?; |
| 623 |
Ok(()) |
| 624 |
} |
| 625 |
|
| 626 |
fn encode_gray<I: GenericImageView>(&mut self, image: &I) -> io::Result<()> { |
| 627 |
let mut yblock = [0u8; 64]; |
| 628 |
let mut y_dcprev = 0; |
| 629 |
let mut dct_yblock = [0i32; 64]; |
| 630 |
|
| 631 |
for y in (0..image.height()).step_by(8) { |
| 632 |
for x in (0..image.width()).step_by(8) { |
| 633 |
copy_blocks_gray(image, x, y, &mut yblock); |
| 634 |
|
| 635 |
// Level shift and fdct |
| 636 |
// Coeffs are scaled by 8 |
| 637 |
transform::fdct(&yblock, &mut dct_yblock); |
| 638 |
|
| 639 |
// Quantization |
| 640 |
for (i, dct) in dct_yblock.iter_mut().enumerate() { |
| 641 |
*dct = ((*dct / 8) as f32 / f32::from(self.tables[0][i])).round() as i32; |
| 642 |
} |
| 643 |
|
| 644 |
let la = &*self.luma_actable; |
| 645 |
let ld = &*self.luma_dctable; |
| 646 |
|
| 647 |
y_dcprev = self.writer.write_block(&dct_yblock, y_dcprev, ld, la)?; |
| 648 |
} |
| 649 |
} |
| 650 |
|
| 651 |
Ok(()) |
| 652 |
} |
| 653 |
|
| 654 |
fn encode_rgb<I: GenericImageView>(&mut self, image: &I) -> io::Result<()> { |
| 655 |
let mut y_dcprev = 0; |
| 656 |
let mut cb_dcprev = 0; |
| 657 |
let mut cr_dcprev = 0; |
| 658 |
|
| 659 |
let mut dct_yblock = [0i32; 64]; |
| 660 |
let mut dct_cb_block = [0i32; 64]; |
| 661 |
let mut dct_cr_block = [0i32; 64]; |
| 662 |
|
| 663 |
let mut yblock = [0u8; 64]; |
| 664 |
let mut cb_block = [0u8; 64]; |
| 665 |
let mut cr_block = [0u8; 64]; |
| 666 |
|
| 667 |
for y in (0..image.height()).step_by(8) { |
| 668 |
for x in (0..image.width()).step_by(8) { |
| 669 |
// RGB -> YCbCr |
| 670 |
copy_blocks_ycbcr(image, x, y, &mut yblock, &mut cb_block, &mut cr_block); |
| 671 |
|
| 672 |
// Level shift and fdct |
| 673 |
// Coeffs are scaled by 8 |
| 674 |
transform::fdct(&yblock, &mut dct_yblock); |
| 675 |
transform::fdct(&cb_block, &mut dct_cb_block); |
| 676 |
transform::fdct(&cr_block, &mut dct_cr_block); |
| 677 |
|
| 678 |
// Quantization |
| 679 |
for i in 0usize..64 { |
| 680 |
dct_yblock[i] = |
| 681 |
((dct_yblock[i] / 8) as f32 / f32::from(self.tables[0][i])).round() as i32; |
| 682 |
dct_cb_block[i] = ((dct_cb_block[i] / 8) as f32 / f32::from(self.tables[1][i])) |
| 683 |
.round() as i32; |
| 684 |
dct_cr_block[i] = ((dct_cr_block[i] / 8) as f32 / f32::from(self.tables[1][i])) |
| 685 |
.round() as i32; |
| 686 |
} |
| 687 |
|
| 688 |
let la = &*self.luma_actable; |
| 689 |
let ld = &*self.luma_dctable; |
| 690 |
let cd = &*self.chroma_dctable; |
| 691 |
let ca = &*self.chroma_actable; |
| 692 |
|
| 693 |
y_dcprev = self.writer.write_block(&dct_yblock, y_dcprev, ld, la)?; |
| 694 |
cb_dcprev = self.writer.write_block(&dct_cb_block, cb_dcprev, cd, ca)?; |
| 695 |
cr_dcprev = self.writer.write_block(&dct_cr_block, cr_dcprev, cd, ca)?; |
| 696 |
} |
| 697 |
} |
| 698 |
|
| 699 |
Ok(()) |
| 700 |
} |
| 701 |
|
| 702 |
fn write_icc_profile_chunks(&mut self) -> io::Result<()> { |
| 703 |
if self.icc_profile.is_empty() { |
| 704 |
return Ok(()); |
| 705 |
} |
| 706 |
|
| 707 |
const MAX_CHUNK_SIZE: usize = 65533 - 14; |
| 708 |
const MAX_CHUNK_COUNT: usize = 255; |
| 709 |
const MAX_ICC_PROFILE_SIZE: usize = MAX_CHUNK_SIZE * MAX_CHUNK_COUNT; |
| 710 |
|
| 711 |
if self.icc_profile.len() > MAX_ICC_PROFILE_SIZE { |
| 712 |
return Err(io::Error::new( |
| 713 |
io::ErrorKind::InvalidInput, |
| 714 |
"ICC profile too large", |
| 715 |
)); |
| 716 |
} |
| 717 |
|
| 718 |
let chunk_iter = self.icc_profile.chunks(MAX_CHUNK_SIZE); |
| 719 |
let num_chunks = chunk_iter.len() as u8; |
| 720 |
let mut segment = Vec::new(); |
| 721 |
|
| 722 |
for (i, chunk) in chunk_iter.enumerate() { |
| 723 |
let chunk_number = (i + 1) as u8; |
| 724 |
let length = 14 + chunk.len(); |
| 725 |
|
| 726 |
segment.clear(); |
| 727 |
segment.reserve(length); |
| 728 |
segment.extend_from_slice(b"ICC_PROFILE\0"); |
| 729 |
segment.push(chunk_number); |
| 730 |
segment.push(num_chunks); |
| 731 |
segment.extend_from_slice(chunk); |
| 732 |
|
| 733 |
self.writer.write_segment(APP2, &segment)?; |
| 734 |
} |
| 735 |
|
| 736 |
Ok(()) |
| 737 |
} |
| 738 |
} |
| 739 |
|
| 740 |
impl<W: Write> ImageEncoder for JpegEncoder<W> { |
| 741 |
#[track_caller] |
| 742 |
fn write_image( |
| 743 |
mut self, |
| 744 |
buf: &[u8], |
| 745 |
width: u32, |
| 746 |
height: u32, |
| 747 |
color_type: ExtendedColorType, |
| 748 |
) -> ImageResult<()> { |
| 749 |
self.encode(buf, width, height, color_type) |
| 750 |
} |
| 751 |
|
| 752 |
fn set_icc_profile(&mut self, icc_profile: Vec<u8>) -> Result<(), UnsupportedError> { |
| 753 |
self.icc_profile = icc_profile; |
| 754 |
Ok(()) |
| 755 |
} |
| 756 |
|
| 757 |
fn set_exif_metadata(&mut self, exif: Vec<u8>) -> Result<(), UnsupportedError> { |
| 758 |
self.exif = exif; |
| 759 |
Ok(()) |
| 760 |
} |
| 761 |
|
| 762 |
fn make_compatible_img( |
| 763 |
&self, |
| 764 |
_: crate::io::encoder::MethodSealedToImage, |
| 765 |
img: &DynamicImage, |
| 766 |
) -> Option<DynamicImage> { |
| 767 |
use ColorType::*; |
| 768 |
match img.color() { |
| 769 |
L8 | Rgb8 => None, |
| 770 |
La8 | L16 | La16 => Some(img.to_luma8().into()), |
| 771 |
Rgba8 | Rgb16 | Rgb32F | Rgba16 | Rgba32F => Some(img.to_rgb8().into()), |
| 772 |
} |
| 773 |
} |
| 774 |
} |
| 775 |
|
| 776 |
fn build_jfif_header(m: &mut Vec<u8>, density: PixelDensity) { |
| 777 |
m.clear(); |
| 778 |
m.extend_from_slice(b"JFIF"); |
| 779 |
m.extend_from_slice(&[ |
| 780 |
0, |
| 781 |
0x01, |
| 782 |
0x02, |
| 783 |
match density.unit { |
| 784 |
PixelDensityUnit::PixelAspectRatio => 0x00, |
| 785 |
PixelDensityUnit::Inches => 0x01, |
| 786 |
PixelDensityUnit::Centimeters => 0x02, |
| 787 |
}, |
| 788 |
]); |
| 789 |
m.extend_from_slice(&density.density.0.to_be_bytes()); |
| 790 |
m.extend_from_slice(&density.density.1.to_be_bytes()); |
| 791 |
m.extend_from_slice(&[0, 0]); |
| 792 |
} |
| 793 |
|
| 794 |
fn build_frame_header( |
| 795 |
m: &mut Vec<u8>, |
| 796 |
precision: u8, |
| 797 |
width: u16, |
| 798 |
height: u16, |
| 799 |
components: &[Component], |
| 800 |
) { |
| 801 |
m.clear(); |
| 802 |
|
| 803 |
m.push(precision); |
| 804 |
m.extend_from_slice(&height.to_be_bytes()); |
| 805 |
m.extend_from_slice(&width.to_be_bytes()); |
| 806 |
m.push(components.len() as u8); |
| 807 |
|
| 808 |
for &comp in components { |
| 809 |
let hv = (comp.h << 4) | comp.v; |
| 810 |
m.extend_from_slice(&[comp.id, hv, comp.tq]); |
| 811 |
} |
| 812 |
} |
| 813 |
|
| 814 |
fn build_scan_header(m: &mut Vec<u8>, components: &[Component]) { |
| 815 |
m.clear(); |
| 816 |
|
| 817 |
m.push(components.len() as u8); |
| 818 |
|
| 819 |
for &comp in components { |
| 820 |
let tables = (comp.dc_table << 4) | comp.ac_table; |
| 821 |
m.extend_from_slice(&[comp.id, tables]); |
| 822 |
} |
| 823 |
|
| 824 |
// spectral start and end, approx. high and low |
| 825 |
m.extend_from_slice(&[0, 63, 0]); |
| 826 |
} |
| 827 |
|
| 828 |
fn build_huffman_segment( |
| 829 |
m: &mut Vec<u8>, |
| 830 |
class: u8, |
| 831 |
destination: u8, |
| 832 |
numcodes: &[u8; 16], |
| 833 |
values: &[u8], |
| 834 |
) { |
| 835 |
m.clear(); |
| 836 |
|
| 837 |
let tcth = (class << 4) | destination; |
| 838 |
m.push(tcth); |
| 839 |
|
| 840 |
m.extend_from_slice(numcodes); |
| 841 |
|
| 842 |
let sum: usize = numcodes.iter().map(|&x| x as usize).sum(); |
| 843 |
|
| 844 |
assert_eq!(sum, values.len()); |
| 845 |
|
| 846 |
m.extend_from_slice(values); |
| 847 |
} |
| 848 |
|
| 849 |
fn build_quantization_segment(m: &mut Vec<u8>, precision: u8, identifier: u8, qtable: &[u8; 64]) { |
| 850 |
m.clear(); |
| 851 |
|
| 852 |
let p = if precision == 8 { 0 } else { 1 }; |
| 853 |
|
| 854 |
let pqtq = (p << 4) | identifier; |
| 855 |
m.push(pqtq); |
| 856 |
|
| 857 |
for &i in &UNZIGZAG[..] { |
| 858 |
m.push(qtable[i as usize]); |
| 859 |
} |
| 860 |
} |
| 861 |
|
| 862 |
fn encode_coefficient(coefficient: i32) -> (u8, u16) { |
| 863 |
let mut magnitude = coefficient.unsigned_abs() as u16; |
| 864 |
let mut num_bits = 0u8; |
| 865 |
|
| 866 |
while magnitude > 0 { |
| 867 |
magnitude >>= 1; |
| 868 |
num_bits += 1; |
| 869 |
} |
| 870 |
|
| 871 |
let mask = (1 << num_bits as usize) - 1; |
| 872 |
|
| 873 |
let val = if coefficient < 0 { |
| 874 |
(coefficient - 1) as u16 & mask |
| 875 |
} else { |
| 876 |
coefficient as u16 & mask |
| 877 |
}; |
| 878 |
|
| 879 |
(num_bits, val) |
| 880 |
} |
| 881 |
|
| 882 |
#[inline] |
| 883 |
fn rgb_to_ycbcr<P: Pixel>(pixel: P) -> (u8, u8, u8) { |
| 884 |
let [r, g, b] = pixel.to_rgb().0; |
| 885 |
let r: i32 = i32::from(r.to_u8().unwrap()); |
| 886 |
let g: i32 = i32::from(g.to_u8().unwrap()); |
| 887 |
let b: i32 = i32::from(b.to_u8().unwrap()); |
| 888 |
|
| 889 |
/* |
| 890 |
JPEG RGB -> YCbCr is defined as following equations using Bt.601 Full Range matrix: |
| 891 |
Y = 0.29900 * R + 0.58700 * G + 0.11400 * B |
| 892 |
Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B + 128 |
| 893 |
Cr = 0.50000 * R - 0.41869 * G - 0.08131 * B + 128 |
| 894 |
|
| 895 |
To avoid using slow floating point conversion is done in fixed point, |
| 896 |
using following coefficients with rounding to nearest integer mode: |
| 897 |
*/ |
| 898 |
|
| 899 |
const C_YR: i32 = 19595; // 0.29900 = 19595 * 2^-16 |
| 900 |
const C_YG: i32 = 38469; // 0.58700 = 38469 * 2^-16 |
| 901 |
const C_YB: i32 = 7471; // 0.11400 = 7471 * 2^-16 |
| 902 |
const Y_ROUNDING: i32 = (1 << 15) - 1; // + 0.5 to perform rounding shift right in-place |
| 903 |
const C_UR: i32 = 11059; // 0.16874 = 11059 * 2^-16 |
| 904 |
const C_UG: i32 = 21709; // 0.33126 = 21709 * 2^-16 |
| 905 |
const C_UB: i32 = 32768; // 0.5 = 32768 * 2^-16 |
| 906 |
const UV_BIAS_ROUNDING: i32 = (128 * (1 << 16)) + ((1 << 15) - 1); // 128 + 0.5 = ((128 * (1 << 16)) + ((1 << 15) - 1)) * 2^-16 ; + 0.5 to perform rounding shift right in-place |
| 907 |
const C_VR: i32 = C_UB; // 0.5 = 32768 * 2^-16 |
| 908 |
const C_VG: i32 = 27439; // 0.41869 = 27439 * 2^-16 |
| 909 |
const C_VB: i32 = 5329; // 0.08131409 = 5329 * 2^-16 |
| 910 |
|
| 911 |
let y = (C_YR * r + C_YG * g + C_YB * b + Y_ROUNDING) >> 16; |
| 912 |
let cb = (-C_UR * r - C_UG * g + C_UB * b + UV_BIAS_ROUNDING) >> 16; |
| 913 |
let cr = (C_VR * r - C_VG * g - C_VB * b + UV_BIAS_ROUNDING) >> 16; |
| 914 |
|
| 915 |
(y as u8, cb as u8, cr as u8) |
| 916 |
} |
| 917 |
|
| 918 |
/// Returns the pixel at (x,y) if (x,y) is in the image, |
| 919 |
/// otherwise the closest pixel in the image |
| 920 |
#[inline] |
| 921 |
fn pixel_at_or_near<I: GenericImageView>(source: &I, x: u32, y: u32) -> I::Pixel { |
| 922 |
if source.in_bounds(x, y) { |
| 923 |
source.get_pixel(x, y) |
| 924 |
} else { |
| 925 |
source.get_pixel(x.min(source.width() - 1), y.min(source.height() - 1)) |
| 926 |
} |
| 927 |
} |
| 928 |
|
| 929 |
fn copy_blocks_ycbcr<I: GenericImageView>( |
| 930 |
source: &I, |
| 931 |
x0: u32, |
| 932 |
y0: u32, |
| 933 |
yb: &mut [u8; 64], |
| 934 |
cbb: &mut [u8; 64], |
| 935 |
crb: &mut [u8; 64], |
| 936 |
) { |
| 937 |
for y in 0..8 { |
| 938 |
for x in 0..8 { |
| 939 |
let pixel = pixel_at_or_near(source, x + x0, y + y0); |
| 940 |
let (yc, cb, cr) = rgb_to_ycbcr(pixel); |
| 941 |
|
| 942 |
yb[(y * 8 + x) as usize] = yc; |
| 943 |
cbb[(y * 8 + x) as usize] = cb; |
| 944 |
crb[(y * 8 + x) as usize] = cr; |
| 945 |
} |
| 946 |
} |
| 947 |
} |
| 948 |
|
| 949 |
fn copy_blocks_gray<I: GenericImageView>(source: &I, x0: u32, y0: u32, gb: &mut [u8; 64]) { |
| 950 |
use num_traits::cast::ToPrimitive; |
| 951 |
for y in 0..8 { |
| 952 |
for x in 0..8 { |
| 953 |
let pixel = pixel_at_or_near(source, x0 + x, y0 + y); |
| 954 |
let [luma] = pixel.to_luma().0; |
| 955 |
gb[(y * 8 + x) as usize] = luma.to_u8().unwrap(); |
| 956 |
} |
| 957 |
} |
| 958 |
} |
| 959 |
|
| 960 |
#[cfg(test)] |
| 961 |
mod tests { |
| 962 |
use std::io::Cursor; |
| 963 |
|
| 964 |
#[cfg(feature = "benchmarks")] |
| 965 |
extern crate test; |
| 966 |
#[cfg(feature = "benchmarks")] |
| 967 |
use test::Bencher; |
| 968 |
|
| 969 |
use crate::{ColorType, DynamicImage, ExtendedColorType, ImageEncoder, ImageError}; |
| 970 |
use crate::{ImageDecoder as _, ImageFormat}; |
| 971 |
|
| 972 |
use super::super::JpegDecoder; |
| 973 |
use super::{ |
| 974 |
build_frame_header, build_huffman_segment, build_jfif_header, build_quantization_segment, |
| 975 |
build_scan_header, Component, JpegEncoder, PixelDensity, DCCLASS, LUMADESTINATION, |
| 976 |
STD_LUMA_DC_CODE_LENGTHS, STD_LUMA_DC_VALUES, |
| 977 |
}; |
| 978 |
|
| 979 |
fn decode(encoded: &[u8]) -> Vec<u8> { |
| 980 |
let decoder = JpegDecoder::new(Cursor::new(encoded)).expect("Could not decode image"); |
| 981 |
|
| 982 |
let mut decoded = vec![0; decoder.total_bytes() as usize]; |
| 983 |
decoder |
| 984 |
.read_image(&mut decoded) |
| 985 |
.expect("Could not decode image"); |
| 986 |
decoded |
| 987 |
} |
| 988 |
|
| 989 |
#[test] |
| 990 |
fn roundtrip_sanity_check() { |
| 991 |
// create a 1x1 8-bit image buffer containing a single red pixel |
| 992 |
let img = [255u8, 0, 0]; |
| 993 |
|
| 994 |
// encode it into a memory buffer |
| 995 |
let mut encoded_img = Vec::new(); |
| 996 |
{ |
| 997 |
let encoder = JpegEncoder::new_with_quality(&mut encoded_img, 100); |
| 998 |
encoder |
| 999 |
.write_image(&img, 1, 1, ExtendedColorType::Rgb8) |
| 1000 |
.expect("Could not encode image"); |
| 1001 |
} |
| 1002 |
|
| 1003 |
// decode it from the memory buffer |
| 1004 |
{ |
| 1005 |
let decoded = decode(&encoded_img); |
| 1006 |
// note that, even with the encode quality set to 100, we do not get the same image |
| 1007 |
// back. Therefore, we're going to assert that it's at least red-ish: |
| 1008 |
assert_eq!(3, decoded.len()); |
| 1009 |
assert!(decoded[0] > 0x80); |
| 1010 |
assert!(decoded[1] < 0x80); |
| 1011 |
assert!(decoded[2] < 0x80); |
| 1012 |
} |
| 1013 |
} |
| 1014 |
|
| 1015 |
#[test] |
| 1016 |
fn grayscale_roundtrip_sanity_check() { |
| 1017 |
// create a 2x2 8-bit image buffer containing a white diagonal |
| 1018 |
let img = [255u8, 0, 0, 255]; |
| 1019 |
|
| 1020 |
// encode it into a memory buffer |
| 1021 |
let mut encoded_img = Vec::new(); |
| 1022 |
{ |
| 1023 |
let encoder = JpegEncoder::new_with_quality(&mut encoded_img, 100); |
| 1024 |
encoder |
| 1025 |
.write_image(&img[..], 2, 2, ExtendedColorType::L8) |
| 1026 |
.expect("Could not encode image"); |
| 1027 |
} |
| 1028 |
|
| 1029 |
// decode it from the memory buffer |
| 1030 |
{ |
| 1031 |
let decoded = decode(&encoded_img); |
| 1032 |
// note that, even with the encode quality set to 100, we do not get the same image |
| 1033 |
// back. Therefore, we're going to assert that the diagonal is at least white-ish: |
| 1034 |
assert_eq!(4, decoded.len()); |
| 1035 |
assert!(decoded[0] > 0x80); |
| 1036 |
assert!(decoded[1] < 0x80); |
| 1037 |
assert!(decoded[2] < 0x80); |
| 1038 |
assert!(decoded[3] > 0x80); |
| 1039 |
} |
| 1040 |
} |
| 1041 |
|
| 1042 |
#[test] |
| 1043 |
fn jfif_header_density_check() { |
| 1044 |
let mut buffer = Vec::new(); |
| 1045 |
build_jfif_header(&mut buffer, PixelDensity::dpi(300)); |
| 1046 |
assert_eq!( |
| 1047 |
buffer, |
| 1048 |
vec![ |
| 1049 |
b'J', |
| 1050 |
b'F', |
| 1051 |
b'I', |
| 1052 |
b'F', |
| 1053 |
0, |
| 1054 |
1, |
| 1055 |
2, // JFIF version 1.2 |
| 1056 |
1, // density is in dpi |
| 1057 |
300u16.to_be_bytes()[0], |
| 1058 |
300u16.to_be_bytes()[1], |
| 1059 |
300u16.to_be_bytes()[0], |
| 1060 |
300u16.to_be_bytes()[1], |
| 1061 |
0, |
| 1062 |
0, // No thumbnail |
| 1063 |
] |
| 1064 |
); |
| 1065 |
} |
| 1066 |
|
| 1067 |
#[test] |
| 1068 |
fn test_image_too_large() { |
| 1069 |
// JPEG cannot encode images larger than 65,535×65,535 |
| 1070 |
// create a 65,536×1 8-bit black image buffer |
| 1071 |
let img = [0; 65_536]; |
| 1072 |
// Try to encode an image that is too large |
| 1073 |
let mut encoded = Vec::new(); |
| 1074 |
let encoder = JpegEncoder::new_with_quality(&mut encoded, 100); |
| 1075 |
let result = encoder.write_image(&img, 65_536, 1, ExtendedColorType::L8); |
| 1076 |
if !matches!(result, Err(ImageError::Encoding(_))) { |
| 1077 |
panic!( |
| 1078 |
"Encoding an image that is too large should return an \ |
| 1079 |
EncodingError; it returned {result:?} instead" |
| 1080 |
) |
| 1081 |
} |
| 1082 |
} |
| 1083 |
|
| 1084 |
#[test] |
| 1085 |
fn test_build_jfif_header() { |
| 1086 |
let mut buf = vec![]; |
| 1087 |
let density = PixelDensity::dpi(100); |
| 1088 |
build_jfif_header(&mut buf, density); |
| 1089 |
assert_eq!( |
| 1090 |
buf, |
| 1091 |
[0x4A, 0x46, 0x49, 0x46, 0x00, 0x01, 0x02, 0x01, 0, 100, 0, 100, 0, 0] |
| 1092 |
); |
| 1093 |
} |
| 1094 |
|
| 1095 |
#[test] |
| 1096 |
fn test_build_frame_header() { |
| 1097 |
let mut buf = vec![]; |
| 1098 |
let components = vec![ |
| 1099 |
Component { |
| 1100 |
id: 1, |
| 1101 |
h: 1, |
| 1102 |
v: 1, |
| 1103 |
tq: 5, |
| 1104 |
dc_table: 5, |
| 1105 |
ac_table: 5, |
| 1106 |
_dc_pred: 0, |
| 1107 |
}, |
| 1108 |
Component { |
| 1109 |
id: 2, |
| 1110 |
h: 1, |
| 1111 |
v: 1, |
| 1112 |
tq: 4, |
| 1113 |
dc_table: 4, |
| 1114 |
ac_table: 4, |
| 1115 |
_dc_pred: 0, |
| 1116 |
}, |
| 1117 |
]; |
| 1118 |
build_frame_header(&mut buf, 5, 100, 150, &components); |
| 1119 |
assert_eq!( |
| 1120 |
buf, |
| 1121 |
[5, 0, 150, 0, 100, 2, 1, (1 << 4) | 1, 5, 2, (1 << 4) | 1, 4] |
| 1122 |
); |
| 1123 |
} |
| 1124 |
|
| 1125 |
#[test] |
| 1126 |
fn test_build_scan_header() { |
| 1127 |
let mut buf = vec![]; |
| 1128 |
let components = vec![ |
| 1129 |
Component { |
| 1130 |
id: 1, |
| 1131 |
h: 1, |
| 1132 |
v: 1, |
| 1133 |
tq: 5, |
| 1134 |
dc_table: 5, |
| 1135 |
ac_table: 5, |
| 1136 |
_dc_pred: 0, |
| 1137 |
}, |
| 1138 |
Component { |
| 1139 |
id: 2, |
| 1140 |
h: 1, |
| 1141 |
v: 1, |
| 1142 |
tq: 4, |
| 1143 |
dc_table: 4, |
| 1144 |
ac_table: 4, |
| 1145 |
_dc_pred: 0, |
| 1146 |
}, |
| 1147 |
]; |
| 1148 |
build_scan_header(&mut buf, &components); |
| 1149 |
assert_eq!(buf, [2, 1, (5 << 4) | 5, 2, (4 << 4) | 4, 0, 63, 0]); |
| 1150 |
} |
| 1151 |
|
| 1152 |
#[test] |
| 1153 |
fn test_build_huffman_segment() { |
| 1154 |
let mut buf = vec![]; |
| 1155 |
build_huffman_segment( |
| 1156 |
&mut buf, |
| 1157 |
DCCLASS, |
| 1158 |
LUMADESTINATION, |
| 1159 |
&STD_LUMA_DC_CODE_LENGTHS, |
| 1160 |
&STD_LUMA_DC_VALUES, |
| 1161 |
); |
| 1162 |
assert_eq!( |
| 1163 |
buf, |
| 1164 |
vec![ |
| 1165 |
0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, |
| 1166 |
10, 11 |
| 1167 |
] |
| 1168 |
); |
| 1169 |
} |
| 1170 |
|
| 1171 |
#[test] |
| 1172 |
fn test_build_quantization_segment() { |
| 1173 |
let mut buf = vec![]; |
| 1174 |
let qtable = [0u8; 64]; |
| 1175 |
build_quantization_segment(&mut buf, 8, 1, &qtable); |
| 1176 |
let mut expected = vec![]; |
| 1177 |
expected.push(1); |
| 1178 |
expected.extend_from_slice(&[0; 64]); |
| 1179 |
assert_eq!(buf, expected); |
| 1180 |
} |
| 1181 |
|
| 1182 |
#[test] |
| 1183 |
fn check_color_types() { |
| 1184 |
const ALL: &[ColorType] = &[ |
| 1185 |
ColorType::L8, |
| 1186 |
ColorType::L16, |
| 1187 |
ColorType::La8, |
| 1188 |
ColorType::Rgb8, |
| 1189 |
ColorType::Rgba8, |
| 1190 |
ColorType::La16, |
| 1191 |
ColorType::Rgb16, |
| 1192 |
ColorType::Rgba16, |
| 1193 |
ColorType::Rgb32F, |
| 1194 |
ColorType::Rgba32F, |
| 1195 |
]; |
| 1196 |
|
| 1197 |
for color in ALL { |
| 1198 |
let image = DynamicImage::new(1, 1, *color); |
| 1199 |
|
| 1200 |
image |
| 1201 |
.write_to(&mut Cursor::new(vec![]), ImageFormat::Jpeg) |
| 1202 |
.expect("supported or converted"); |
| 1203 |
} |
| 1204 |
} |
| 1205 |
|
| 1206 |
#[cfg(feature = "benchmarks")] |
| 1207 |
#[bench] |
| 1208 |
fn bench_jpeg_encoder_new(b: &mut Bencher) { |
| 1209 |
b.iter(|| { |
| 1210 |
let mut y = vec![]; |
| 1211 |
let _x = JpegEncoder::new(&mut y); |
| 1212 |
}); |
| 1213 |
} |
| 1214 |
} |
| 1215 |
|
| 1216 |
// Tests regressions of `encode_image` against #1412, confusion about the subimage's position vs. |
| 1217 |
// dimensions. (We no longer have a position, four `u32` returns was confusing). |
| 1218 |
#[test] |
| 1219 |
fn sub_image_encoder_regression_1412() { |
| 1220 |
let image = DynamicImage::new_rgb8(1280, 720); |
| 1221 |
let subimg = crate::imageops::crop_imm(&image, 0, 358, 425, 361); |
| 1222 |
|
| 1223 |
let mut encoded_crop = vec![]; |
| 1224 |
let mut encoder = JpegEncoder::new(&mut encoded_crop); |
| 1225 |
|
| 1226 |
let result = encoder.encode_image(&*subimg); |
| 1227 |
assert!(result.is_ok(), "Failed to encode subimage: {result:?}"); |
| 1228 |
} |