use dcmnorm_core::ops::{AttributeAction, AttributeOp};
use dcmnorm_core::{PrimitiveValue, Tag};
use dcmnorm_encoding::adapters::{
decode_error, encode_error, DecodeResult, EncodeOptions, EncodeResult, PixelDataObject,
PixelDataReader, PixelDataWriter,
};
use dcmnorm_encoding::snafu::prelude::*;
use dcmnorm_jpeg::{ColorTransform, Decoder};
use jpeg_encoder::ColorType;
use std::borrow::Cow;
use std::io::Cursor;
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct JpegAdapter;
impl PixelDataReader for JpegAdapter {
fn decode(&self, src: &dyn PixelDataObject, dst: &mut Vec<u8>) -> DecodeResult<()> {
let cols = src
.cols()
.context(decode_error::MissingAttributeSnafu { name: "Columns" })?;
let rows = src
.rows()
.context(decode_error::MissingAttributeSnafu { name: "Rows" })?;
let samples_per_pixel =
src.samples_per_pixel()
.context(decode_error::MissingAttributeSnafu {
name: "SamplesPerPixel",
})?;
let bits_allocated = src
.bits_allocated()
.context(decode_error::MissingAttributeSnafu {
name: "BitsAllocated",
})?;
if bits_allocated != 8 && bits_allocated != 16 {
whatever!("BitsAllocated other than 8 or 16 is not supported");
}
let nr_frames = src.number_of_frames().unwrap_or(1) as usize;
let bytes_per_sample = bits_allocated / 8;
let stride: usize = bytes_per_sample as usize * cols as usize * rows as usize;
let base_offset = dst.len();
dst.resize(
base_offset + (samples_per_pixel as usize * stride) * nr_frames,
0,
);
let raw = src
.raw_pixel_data()
.whatever_context("Expected to have raw pixel data available")?;
let fragments: Vec<u8> = raw.fragments.into_iter().flatten().collect();
let fragments_len = fragments.len() as u64;
let mut cursor = Cursor::new(fragments);
let mut dst_offset = base_offset;
'frame_loop: for i in 0..nr_frames {
let mut decoder = Decoder::new(&mut cursor);
set_default_color_transform(&mut decoder, src);
let decoded = decoder
.decode()
.map_err(|e| Box::new(e) as Box<_>)
.with_whatever_context(|_| format!("JPEG decoding failure on frame {i}"))?;
let decoded_len = decoded.len();
dst[dst_offset..(dst_offset + decoded_len)].copy_from_slice(&decoded);
dst_offset += decoded_len;
if next_even(cursor.position()) >= next_even(fragments_len) {
break;
}
if cursor.position() + 2 >= fragments_len {
break;
}
loop {
let Some(next_byte_1) = cursor.get_ref().get(cursor.position() as usize).copied()
else {
break 'frame_loop;
};
if next_byte_1 != 0xFF {
cursor.set_position(cursor.position() + 1);
continue;
}
let Some(next_byte_2) = cursor
.get_ref()
.get(cursor.position() as usize + 1)
.copied()
else {
break 'frame_loop;
};
if next_byte_2 == 0xD8 {
break;
}
cursor.set_position(cursor.position() + 1);
}
}
Ok(())
}
fn decode_frame(
&self,
src: &dyn PixelDataObject,
frame: u32,
dst: &mut Vec<u8>,
) -> DecodeResult<()> {
let cols = src
.cols()
.context(decode_error::MissingAttributeSnafu { name: "Columns" })?;
let rows = src
.rows()
.context(decode_error::MissingAttributeSnafu { name: "Rows" })?;
let samples_per_pixel =
src.samples_per_pixel()
.context(decode_error::MissingAttributeSnafu {
name: "SamplesPerPixel",
})?;
let bits_allocated = src
.bits_allocated()
.context(decode_error::MissingAttributeSnafu {
name: "BitsAllocated",
})?;
ensure_whatever!(
bits_allocated == 8 || bits_allocated == 16,
"BitsAllocated other than 8 or 16 is not supported"
);
let nr_frames = src.number_of_frames().unwrap_or(1) as usize;
ensure!(
nr_frames > frame as usize,
decode_error::FrameRangeOutOfBoundsSnafu
);
let bytes_per_sample = bits_allocated / 8;
let stride: usize = bytes_per_sample as usize * cols as usize * rows as usize;
let expected_len = samples_per_pixel as usize * stride;
let base_offset = dst.len();
let number_of_fragments = src.number_of_fragments().unwrap_or(0) as usize;
let frame_data = if number_of_fragments == 1 || number_of_fragments == nr_frames {
src.fragment(frame as usize).with_whatever_context(|| {
format!("Missing fragment #{frame} for the frame requested")
})?
} else {
let raw = src
.raw_pixel_data()
.whatever_context("Expected to have raw pixel data available")?;
let base_offset = raw.offset_table.get(frame as usize).copied();
let base_offset = if frame == 0 {
base_offset.unwrap_or(0) as usize
} else {
base_offset
.with_whatever_context(|| format!("Missing offset for frame #{frame}"))?
as usize
};
let next_offset = raw.offset_table.get(frame as usize + 1);
let mut offset = 0;
let mut fragments = Vec::new();
for fragment in &raw.fragments {
if offset >= base_offset {
fragments.extend_from_slice(fragment);
}
offset += fragment.len() + 8;
if let Some(&next_offset) = next_offset {
if offset >= next_offset as usize {
break;
}
}
}
Cow::Owned(fragments)
};
let mut cursor = Cursor::new(&*frame_data);
let mut decoder = Decoder::new(&mut cursor);
set_default_color_transform(&mut decoder, src);
let decoded = decoder
.decode()
.map_err(|e| Box::new(e) as Box<_>)
.whatever_context("JPEG decoder failure")?;
if decoded.len() != expected_len {
whatever!(
"JPEG decoded length mismatch: expected {expected_len} bytes, got {}",
decoded.len()
);
}
if base_offset == 0 {
*dst = decoded;
} else {
dst.resize(base_offset + expected_len, 0);
dst[base_offset..(base_offset + expected_len)].copy_from_slice(&decoded);
}
Ok(())
}
}
fn set_default_color_transform<R: std::io::Read>(
decoder: &mut Decoder<R>,
src: &dyn PixelDataObject,
) {
if src.photometric_interpretation().map(str::trim) == Some("RGB") {
decoder.set_default_color_transform(ColorTransform::RGB);
}
}
impl PixelDataWriter for JpegAdapter {
fn encode_frame(
&self,
src: &dyn PixelDataObject,
frame: u32,
options: EncodeOptions,
dst: &mut Vec<u8>,
) -> EncodeResult<Vec<AttributeOp>> {
let cols = src
.cols()
.context(encode_error::MissingAttributeSnafu { name: "Columns" })?;
let rows = src
.rows()
.context(encode_error::MissingAttributeSnafu { name: "Rows" })?;
let samples_per_pixel =
src.samples_per_pixel()
.context(encode_error::MissingAttributeSnafu {
name: "SamplesPerPixel",
})?;
let bits_allocated = src
.bits_allocated()
.context(encode_error::MissingAttributeSnafu {
name: "BitsAllocated",
})?;
let bits_stored = src
.bits_stored()
.context(encode_error::MissingAttributeSnafu { name: "BitsStored" })?;
ensure_whatever!(
bits_allocated == 8 || bits_allocated == 16,
"BitsAllocated other than 8 or 16 is not supported"
);
let quality = options.quality.unwrap_or(85);
let bytes_per_sample = (bits_allocated / 8) as usize;
let frame_size =
cols as usize * rows as usize * samples_per_pixel as usize * bytes_per_sample;
let color_type = match samples_per_pixel {
1 => ColorType::Luma,
3 => ColorType::Rgb,
_ => {
whatever!("Unsupported samples per pixel: {}", samples_per_pixel)
}
};
let len_before = dst.len();
let pixeldata_uncompressed = src
.fragment(0)
.context(encode_error::MissingAttributeSnafu { name: "Pixel Data" })?;
let frame_data = pixeldata_uncompressed
.get(frame_size * frame as usize..frame_size * (frame as usize + 1))
.whatever_context("Frame index out of bounds")?;
let frame_data = narrow_8bit(frame_data, bits_stored)?;
let mut encoder = jpeg_encoder::Encoder::new(&mut *dst, quality);
encoder.set_progressive(false);
let chroma_subsampled = encoder.sampling_factor() != jpeg_encoder::SamplingFactor::F_1_1;
encoder
.encode(&frame_data, cols, rows, color_type)
.whatever_context("JPEG encoding failed")?;
let compressed_frame_size = dst.len() - len_before;
let compression_ratio = frame_size as f64 / compressed_frame_size as f64;
let compression_ratio = format!("{compression_ratio:.6}");
let mut changes = vec![
AttributeOp::new(
Tag(0x0028, 0x0100),
AttributeAction::Set(PrimitiveValue::from(8_u16)),
),
AttributeOp::new(
Tag(0x0028, 0x0101),
AttributeAction::Set(PrimitiveValue::from(8_u16)),
),
AttributeOp::new(
Tag(0x0028, 0x0102),
AttributeAction::Set(PrimitiveValue::from(7_u16)),
),
AttributeOp::new(Tag(0x0028, 0x2110), AttributeAction::SetStr("01".into())),
AttributeOp::new(
Tag(0x0028, 0x2112),
AttributeAction::PushStr(compression_ratio.into()),
),
];
let pmi = src.photometric_interpretation();
if samples_per_pixel == 1 {
if pmi != Some("MONOCHROME1") && pmi != Some("MONOCHROME2") {
changes.push(AttributeOp::new(
Tag(0x0028, 0x0004),
AttributeAction::SetStr("MONOCHROME2".into()),
));
}
} else if samples_per_pixel == 3 {
let ybr = if chroma_subsampled {
"YBR_FULL_422"
} else {
"YBR_FULL"
};
if pmi != Some(ybr) {
changes.push(AttributeOp::new(
Tag(0x0028, 0x0004),
AttributeAction::SetStr(ybr.into()),
));
}
}
Ok(changes)
}
}
fn next_even(l: u64) -> u64 {
(l + 1) & !1
}
fn narrow_8bit(frame_data: &[u8], bits_stored: u16) -> EncodeResult<Cow<'_, [u8]>> {
debug_assert!(bits_stored >= 8);
match bits_stored {
8 => Ok(Cow::Borrowed(frame_data)),
9..=16 => {
let mut v = Vec::with_capacity(frame_data.len() / 2);
for chunk in frame_data.chunks(2) {
let b = u16::from(chunk[0]) | (u16::from(chunk[1]) << 8);
v.push((b >> (bits_stored - 8)) as u8);
}
Ok(Cow::Owned(v))
}
b => {
whatever!("Unsupported Bits Stored {}", b)
}
}
}
#[cfg(test)]
mod tests {
use super::JpegAdapter;
use dcmnorm_core::ops::{AttributeAction, AttributeOp};
use dcmnorm_core::Tag;
use dcmnorm_encoding::adapters::{
EncodeOptions, PixelDataObject, PixelDataWriter, RawPixelData,
};
use std::borrow::Cow;
struct NativeRgb {
size: u16,
samples: Vec<u8>,
}
impl PixelDataObject for NativeRgb {
fn transfer_syntax_uid(&self) -> &str {
"1.2.840.10008.1.2.1"
}
fn rows(&self) -> Option<u16> {
Some(self.size)
}
fn cols(&self) -> Option<u16> {
Some(self.size)
}
fn samples_per_pixel(&self) -> Option<u16> {
Some(3)
}
fn bits_allocated(&self) -> Option<u16> {
Some(8)
}
fn bits_stored(&self) -> Option<u16> {
Some(8)
}
fn photometric_interpretation(&self) -> Option<&str> {
Some("RGB")
}
fn number_of_frames(&self) -> Option<u32> {
Some(1)
}
fn number_of_fragments(&self) -> Option<u32> {
Some(1)
}
fn fragment(&self, fragment: usize) -> Option<Cow<'_, [u8]>> {
(fragment == 0).then(|| Cow::Borrowed(&self.samples[..]))
}
fn offset_table(&self) -> Option<Cow<'_, [u32]>> {
None
}
fn raw_pixel_data(&self) -> Option<RawPixelData> {
None
}
}
fn encode_red_square(quality: Option<u8>) -> (Vec<AttributeOp>, Vec<u8>) {
let size = 16;
let samples = [255u8, 0, 0]
.iter()
.copied()
.cycle()
.take(size as usize * size as usize * 3)
.collect();
let mut options = EncodeOptions::new();
options.quality = quality;
let mut encoded = Vec::new();
let ops = JpegAdapter
.encode_frame(&NativeRgb { size, samples }, 0, options, &mut encoded)
.expect("JPEG frame encoding should succeed");
(ops, encoded)
}
fn photometric_interpretation_set(ops: &[AttributeOp]) -> Option<String> {
ops.iter()
.find(|op| op.selector == Tag(0x0028, 0x0004).into())
.map(|op| match &op.action {
AttributeAction::SetStr(value) => value.to_string(),
other => panic!("unexpected Photometric Interpretation action {:?}", other),
})
}
#[test]
fn encoding_rgb_labels_the_result_ybr_full_422_when_chroma_is_subsampled() {
let (ops, encoded) = encode_red_square(None);
assert_eq!(
photometric_interpretation_set(&ops).as_deref(),
Some("YBR_FULL_422")
);
assert_eq!(&encoded[0..2], &[0xFF, 0xD8], "expected SOI marker");
assert_eq!(&encoded[2..4], &[0xFF, 0xE0], "expected APP0 marker");
assert_eq!(&encoded[6..11], b"JFIF\0", "expected JFIF identifier");
assert_eq!(sof0_luma_sampling(&encoded), 0x22);
}
#[test]
fn encoding_rgb_labels_the_result_ybr_full_without_chroma_subsampling() {
let (ops, encoded) = encode_red_square(Some(95));
assert_eq!(
photometric_interpretation_set(&ops).as_deref(),
Some("YBR_FULL")
);
assert_eq!(sof0_luma_sampling(&encoded), 0x11);
}
fn sof0_luma_sampling(jpeg: &[u8]) -> u8 {
let sof = jpeg
.windows(2)
.position(|w| w == [0xFF, 0xC0])
.expect("baseline SOF0 marker");
assert_eq!(jpeg[sof + 9], 3, "expected a 3-component frame");
jpeg[sof + 11]
}
}