use super::brotli::brotli_store;
use super::{HUFF_ALPHABET_SIZE, HUFF_MAX_BIT_LENGTH, JpegData, JpegError};
use crate::bit_writer::BitWriter;
#[derive(Clone, Copy)]
enum Dist {
Val(u32),
BitsOffset(u32, u32),
}
use Dist::{BitsOffset, Val};
const fn bits(n: u32) -> Dist {
BitsOffset(n, 0)
}
fn write_u32(w: &mut BitWriter, dists: [Dist; 4], value: u32) -> Result<(), JpegError> {
let mut best: Option<(u32, u32)> = None; let mut total_bits = u32::MAX;
for (s, d) in dists.iter().enumerate() {
match *d {
Val(v) => {
if v == value {
w.write(2, s as u64);
return Ok(());
}
}
BitsOffset(extra, offset) => {
if value < offset {
continue;
}
if (value - offset) as u64 >= (1u64 << extra) {
continue;
}
if 2 + extra < total_bits {
total_bits = 2 + extra;
best = Some((s as u32, extra));
}
}
}
}
let Some((selector, extra)) = best else {
return Err(JpegError::UnsupportedMode(
"value not representable in reconstruction data",
));
};
let offset = match dists[selector as usize] {
BitsOffset(_, o) => o,
Val(_) => unreachable!("selector resolved to a direct branch"),
};
w.write(2, selector as u64);
w.write(extra as usize, (value - offset) as u64);
Ok(())
}
fn write_bool(w: &mut BitWriter, v: bool) {
w.write(1, v as u64);
}
const TYPE_GRAY: u64 = 0;
const TYPE_YCBCR: u64 = 1;
const TYPE_RGB: u64 = 2;
const TYPE_CUSTOM: u64 = 3;
pub(crate) fn encode_jbrd(jpg: &JpegData) -> Result<Vec<u8>, JpegError> {
let mut out = encode_fields(jpg)?;
let mut payload = Vec::new();
for app in &jpg.app_data {
payload.extend_from_slice(app);
}
for com in &jpg.com_data {
payload.extend_from_slice(com);
}
for chunk in &jpg.inter_marker_data {
payload.extend_from_slice(chunk);
}
payload.extend_from_slice(&jpg.tail_data);
out.extend_from_slice(&brotli_store(&payload));
Ok(out)
}
fn encode_fields(jpg: &JpegData) -> Result<Vec<u8>, JpegError> {
let mut w = BitWriter::new();
write_bool(&mut w, jpg.components.len() == 1);
if jpg.marker_order.last() != Some(&0xD9) {
return Err(JpegError::UnexpectedMarker(0xD9));
}
for (i, &m) in jpg.marker_order.iter().enumerate() {
if m < 0xC0 {
return Err(JpegError::UnexpectedMarker(m));
}
if m == 0xD9 && i + 1 != jpg.marker_order.len() {
return Err(JpegError::UnexpectedMarker(m));
}
w.write(6, (m - 0xC0) as u64);
}
for app in &jpg.app_data {
write_u32(
&mut w,
[Val(0), Val(1), BitsOffset(1, 2), BitsOffset(2, 4)],
0,
)?;
let len = checked_seg_len(app)?;
w.write(16, len as u64);
}
for com in &jpg.com_data {
let len = checked_seg_len(com)?;
w.write(16, len as u64);
}
let num_quant = jpg.quant.len();
if !(1..=3).contains(&num_quant) {
return Err(JpegError::BadTable("quantization"));
}
write_u32(&mut w, [Val(1), Val(2), Val(3), Val(4)], num_quant as u32)?;
for q in &jpg.quant {
if q.precision > 1 || q.index > 3 {
return Err(JpegError::BadTable("quantization"));
}
w.write(1, q.precision as u64);
w.write(2, q.index as u64);
write_bool(&mut w, q.is_last);
}
let ids: Vec<u32> = jpg.components.iter().map(|c| c.id).collect();
let component_type = match ids.as_slice() {
[1] => TYPE_GRAY,
[1, 2, 3] => TYPE_YCBCR,
[0x52, 0x47, 0x42] => TYPE_RGB,
_ => TYPE_CUSTOM,
};
w.write(2, component_type);
if component_type == TYPE_CUSTOM {
if ids.len() != 1 && ids.len() != 3 {
return Err(JpegError::UnsupportedMode(
"component count not reconstructible",
));
}
write_u32(&mut w, [Val(1), Val(2), Val(3), Val(4)], ids.len() as u32)?;
for &id in &ids {
if id > 0xFF {
return Err(JpegError::BadFrameHeader);
}
w.write(8, id as u64);
}
}
for c in &jpg.components {
if c.quant_idx as usize >= jpg.quant.len() {
return Err(JpegError::BadTable("quantization"));
}
w.write(2, c.quant_idx as u64);
}
let num_huff = jpg.huffman_code.len() as u32;
write_u32(
&mut w,
[
Val(4),
BitsOffset(3, 2),
BitsOffset(4, 10),
BitsOffset(6, 26),
],
num_huff,
)?;
for hc in &jpg.huffman_code {
write_bool(&mut w, (hc.slot_id >> 4) != 0);
w.write(2, (hc.slot_id & 0x0F) as u64);
write_bool(&mut w, hc.is_last);
let mut num_symbols = 0usize;
for i in 0..=HUFF_MAX_BIT_LENGTH {
write_u32(
&mut w,
[Val(0), Val(1), BitsOffset(3, 2), bits(8)],
hc.counts[i],
)?;
num_symbols += hc.counts[i] as usize;
}
if num_symbols == 0 {
continue;
}
if num_symbols > HUFF_ALPHABET_SIZE + 1 {
return Err(JpegError::BadTable("Huffman"));
}
for i in 0..num_symbols {
write_u32(
&mut w,
[
bits(2),
BitsOffset(2, 4),
BitsOffset(4, 8),
BitsOffset(8, 1),
],
hc.values[i],
)?;
}
if hc.values[num_symbols - 1] != HUFF_ALPHABET_SIZE as u32 {
return Err(JpegError::BadTable("Huffman"));
}
}
for scan in &jpg.scan_info {
if scan.num_components == 0 || scan.num_components >= 4 {
return Err(JpegError::BadScanHeader);
}
write_u32(
&mut w,
[Val(1), Val(2), Val(3), Val(4)],
scan.num_components,
)?;
w.write(6, scan.ss as u64);
w.write(6, scan.se as u64);
w.write(4, scan.al as u64);
w.write(4, scan.ah as u64);
for i in 0..scan.num_components as usize {
let c = &scan.components[i];
w.write(2, c.comp_idx as u64);
w.write(2, c.ac_tbl_idx as u64);
w.write(2, c.dc_tbl_idx as u64);
}
write_u32(
&mut w,
[Val(0), Val(1), Val(2), BitsOffset(3, 3)],
scan.last_needed_pass,
)?;
}
if jpg.marker_order.contains(&0xDD) {
w.write(16, jpg.restart_interval as u64);
}
static COUNT_DIST: [Dist; 4] = [
Val(0),
BitsOffset(2, 1),
BitsOffset(4, 4),
BitsOffset(16, 20),
];
static BLOCK_DIST: [Dist; 4] = [
Val(0),
BitsOffset(3, 1),
BitsOffset(5, 9),
BitsOffset(28, 41),
];
for scan in &jpg.scan_info {
write_u32(&mut w, COUNT_DIST, scan.reset_points.len() as u32)?;
let mut last: i64 = -1;
for &block_idx in &scan.reset_points {
let delta = (block_idx as i64) - (last + 1);
if delta < 0 {
return Err(JpegError::BadEntropyData);
}
write_u32(&mut w, BLOCK_DIST, delta as u32)?;
last = block_idx as i64;
}
write_u32(&mut w, COUNT_DIST, scan.extra_zero_runs.len() as u32)?;
let mut last: i64 = -1;
for ezr in &scan.extra_zero_runs {
write_u32(
&mut w,
[
Val(1),
BitsOffset(2, 2),
BitsOffset(4, 5),
BitsOffset(8, 20),
],
ezr.num_extra_zero_runs,
)?;
let delta = (ezr.block_idx as i64) - (last + 1);
if delta < 0 {
return Err(JpegError::BadEntropyData);
}
write_u32(&mut w, BLOCK_DIST, delta as u32)?;
last = ezr.block_idx as i64;
}
}
for chunk in &jpg.inter_marker_data {
if chunk.len() > u16::MAX as usize {
return Err(JpegError::UnsupportedMode("inter-marker chunk too large"));
}
w.write(16, chunk.len() as u64);
}
const MAX_TAIL: usize = 4_260_096;
if jpg.tail_data.len() > MAX_TAIL {
return Err(JpegError::UnsupportedMode("trailing data too large"));
}
write_u32(
&mut w,
[
Val(0),
BitsOffset(8, 1),
BitsOffset(16, 257),
BitsOffset(22, 65793),
],
jpg.tail_data.len() as u32,
)?;
write_bool(&mut w, jpg.has_zero_padding_bit);
if jpg.has_zero_padding_bit {
if jpg.padding_bits.len() >= 1 << 24 {
return Err(JpegError::UnsupportedMode("too many padding bits"));
}
w.write(24, jpg.padding_bits.len() as u64);
for &bit in &jpg.padding_bits {
write_bool(&mut w, bit != 0);
}
}
w.zero_pad_to_byte();
Ok(w.into_bytes())
}
fn checked_seg_len(seg: &[u8]) -> Result<usize, JpegError> {
if seg.len() < 3 {
return Err(JpegError::BadSegmentLength(
seg.first().copied().unwrap_or(0),
));
}
let len = seg.len() - 1;
if len > u16::MAX as usize {
return Err(JpegError::BadSegmentLength(seg[0]));
}
Ok(len)
}
#[cfg(test)]
mod tests {
use super::*;
fn read_u32(bits_seq: &[u8], pos: &mut usize, dists: [Dist; 4]) -> u32 {
let mut take = |n: usize| -> u32 {
let mut v = 0u32;
for i in 0..n {
v |= (bits_seq[*pos + i] as u32) << i;
}
*pos += n;
v
};
let selector = take(2) as usize;
match dists[selector] {
Val(v) => v,
BitsOffset(extra, offset) => take(extra as usize) + offset,
}
}
fn to_bit_seq(bytes: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
for &b in bytes {
for i in 0..8 {
out.push((b >> i) & 1);
}
}
out
}
#[test]
fn u32_roundtrips_across_distributions() {
let cases: Vec<([Dist; 4], Vec<u32>)> = vec![
(
[Val(0), Val(1), BitsOffset(3, 2), bits(8)],
vec![0, 1, 2, 9, 10, 200, 255],
),
(
[
bits(2),
BitsOffset(2, 4),
BitsOffset(4, 8),
BitsOffset(8, 1),
],
vec![0, 1, 3, 4, 7, 8, 23, 24, 256],
),
(
[
Val(4),
BitsOffset(3, 2),
BitsOffset(4, 10),
BitsOffset(6, 26),
],
vec![2, 4, 5, 9, 10, 25, 26, 89],
),
(
[
Val(0),
BitsOffset(8, 1),
BitsOffset(16, 257),
BitsOffset(22, 65793),
],
vec![0, 1, 256, 257, 65792, 65793, 4_260_096],
),
(
[
Val(0),
BitsOffset(3, 1),
BitsOffset(5, 9),
BitsOffset(28, 41),
],
vec![0, 1, 8, 9, 40, 41, 1_000_000],
),
];
for (dists, values) in cases {
for v in values {
let mut w = BitWriter::new();
write_u32(&mut w, dists, v).expect("value should be representable");
let nbits = w.bits_written();
w.zero_pad_to_byte();
let seq = to_bit_seq(&w.into_bytes());
let mut pos = 0;
let got = read_u32(&seq, &mut pos, dists);
assert_eq!(got, v, "round-trip failed for {v}");
assert_eq!(pos, nbits, "consumed {pos} bits, wrote {nbits}, for {v}");
}
}
}
#[test]
fn u32_prefers_direct_then_shortest() {
let mut w = BitWriter::new();
write_u32(
&mut w,
[
Val(4),
BitsOffset(3, 2),
BitsOffset(4, 10),
BitsOffset(6, 26),
],
4,
)
.unwrap();
assert_eq!(w.bits_written(), 2);
let mut w = BitWriter::new();
write_u32(&mut w, [Val(0), Val(1), BitsOffset(3, 2), bits(8)], 2).unwrap();
assert_eq!(w.bits_written(), 5);
let mut w = BitWriter::new();
write_u32(
&mut w,
[
bits(2),
BitsOffset(2, 4),
BitsOffset(4, 8),
BitsOffset(8, 1),
],
8,
)
.unwrap();
assert_eq!(w.bits_written(), 6);
}
#[test]
fn u32_rejects_unrepresentable() {
assert!(write_u32(&mut BitWriter::new(), [Val(1), Val(2), Val(3), Val(4)], 7).is_err());
}
}