qualia_core_db/medical/dicom_codecs/
jpeg_12bit.rs1use super::jpeg::JpegError;
6use super::jpeg_12bit_scan::{
7 decode_block_into, idct_basis, write_block_to_plane, FragmentCursor, HuffTable, ScanBitReader,
8};
9
10#[derive(Clone, Copy)]
11struct CompSpec {
12 id: u8,
13 h: usize,
14 v: usize,
15 tq: usize,
16}
17
18pub fn decode_jpeg_12bit_frame(
21 fragments: &[&[u8]],
22 rows: u16,
23 cols: u16,
24 spp: u16,
25 photometric: &str,
26) -> Result<Vec<u8>, JpegError> {
27 let mut cur = FragmentCursor::new(fragments);
28 if cur.next_u8()? != 0xFF || cur.next_u8()? != 0xD8 {
29 return Err(JpegError::CorruptStream("missing JPEG SOI marker"));
30 }
31 let mut qtables: [Option<[u16; 64]>; 4] = [None, None, None, None];
32 let mut dc_tables: [Option<HuffTable>; 4] = [None, None, None, None];
33 let mut ac_tables: [Option<HuffTable>; 4] = [None, None, None, None];
34 let mut restart_interval: usize = 0;
35 let mut comps: Vec<CompSpec> = Vec::new();
36 let mut planes: Vec<Vec<u16>> = Vec::new();
37 let mut decoded_mask: Vec<bool> = Vec::new();
38 let mut plane_dims: Vec<(usize, usize)> = Vec::new();
39 let (mut h_max, mut v_max) = (1usize, 1usize);
40 let basis = idct_basis();
41 let mut carry_marker: Option<u8> = None;
42
43 loop {
44 let marker = if let Some(m) = carry_marker.take() {
45 m
46 } else {
47 let mut b = cur.next_u8()?;
48 while b != 0xFF { b = cur.next_u8()?; }
49 let mut m = cur.next_u8()?;
50 while m == 0xFF { m = cur.next_u8()?; }
51 m
52 };
53 if marker == 0xD9 {
54 break;
55 }
56 if marker == 0x00 || marker == 0x01 || (0xD0..=0xD8).contains(&marker) {
57 continue;
58 }
59 let seg_len = cur.next_u16_be()? as usize;
60 if seg_len < 2 {
61 return Err(JpegError::CorruptStream("invalid 12-bit JPEG marker length"));
62 }
63 let mut rem = seg_len - 2;
64 match marker {
65 0xDB => {
66 while rem > 0 {
67 let hdr = cur.next_u8()?;
68 rem -= 1;
69 let (pq, tq) = (hdr >> 4, (hdr & 0x0F) as usize);
70 if pq > 1 || tq >= 4 {
71 return Err(JpegError::CorruptStream("invalid 12-bit DQT header"));
72 }
73 let need = if pq == 0 { 64 } else { 128 };
74 if rem < need {
75 return Err(JpegError::CorruptStream("truncated 12-bit DQT table"));
76 }
77 let mut tbl = [0u16; 64];
78 for entry in &mut tbl {
79 let v = if pq == 0 { cur.next_u8()? as u16 } else { cur.next_u16_be()? };
80 if v == 0 {
81 return Err(JpegError::CorruptStream("zero JPEG quantization entry"));
82 }
83 *entry = v;
84 }
85 qtables[tq] = Some(tbl);
86 rem -= need;
87 }
88 }
89 0xC4 => {
90 while rem > 0 {
91 let hdr = cur.next_u8()?;
92 rem -= 1;
93 let (tc, th) = (hdr >> 4, (hdr & 0x0F) as usize);
94 if tc > 1 || th >= 4 || rem < 16 {
95 return Err(JpegError::CorruptStream("invalid 12-bit DHT header"));
96 }
97 let mut bits = [0u8; 16];
98 for b in &mut bits { *b = cur.next_u8()?; }
99 rem -= 16;
100 let total: usize = bits.iter().map(|&b| b as usize).sum();
101 if total > 256 || rem < total {
102 return Err(JpegError::CorruptStream("invalid 12-bit DHT symbol count"));
103 }
104 let mut vals = vec![0u8; total];
105 for v in &mut vals { *v = cur.next_u8()?; }
106 rem -= total;
107 let ht = HuffTable::build(&bits, vals)?;
108 if tc == 0 { dc_tables[th] = Some(ht); } else { ac_tables[th] = Some(ht); }
109 }
110 }
111 0xDD => {
112 if rem != 2 {
113 return Err(JpegError::CorruptStream("invalid JPEG DRI length"));
114 }
115 restart_interval = cur.next_u16_be()? as usize;
116 }
117 0xC1 => {
118 if !comps.is_empty() {
119 return Err(JpegError::CorruptStream("duplicate SOF1 marker"));
120 }
121 if rem < 6 {
122 return Err(JpegError::CorruptStream("invalid SOF1 length"));
123 }
124 let prec = cur.next_u8()?;
125 let h = cur.next_u16_be()?;
126 let w = cur.next_u16_be()?;
127 let nf = cur.next_u8()?;
128 if prec != 12 {
129 return Err(JpegError::BitPrecisionMismatch);
130 }
131 if h != rows || w != cols {
132 return Err(JpegError::DimensionMismatch);
133 }
134 if nf as u16 != spp || rem != 6 + 3 * nf as usize {
135 return Err(JpegError::ColorOrSubsamplingMismatch);
136 }
137 for _ in 0..nf as usize {
138 let id = cur.next_u8()?;
139 let hv = cur.next_u8()?;
140 let tq = cur.next_u8()? as usize;
141 let (hs, vs) = ((hv >> 4) as usize, (hv & 0x0F) as usize);
142 if !(1..=4).contains(&hs) || !(1..=4).contains(&vs) || tq >= 4 || comps.iter().any(|c| c.id == id) {
143 return Err(JpegError::CorruptStream("invalid 12-bit SOF1 component"));
144 }
145 h_max = h_max.max(hs);
146 v_max = v_max.max(vs);
147 comps.push(CompSpec { id, h: hs, v: vs, tq });
148 }
149 let hv_vec: Vec<(usize, usize)> = comps.iter().map(|c| (c.h, c.v)).collect();
150 match photometric {
151 "MONOCHROME1" | "MONOCHROME2" if comps.len() == 1 => {}
152 "RGB" | "YBR_FULL" if hv_vec == [(1, 1); 3] => {}
153 "YBR_FULL_422" if hv_vec == [(2, 1), (1, 1), (1, 1)] => {}
154 _ => return Err(JpegError::ColorOrSubsamplingMismatch),
155 }
156 for c in &comps {
157 let pw = (cols as usize * c.h).div_ceil(h_max);
158 let ph = (rows as usize * c.v).div_ceil(v_max);
159 plane_dims.push((pw, ph));
160 planes.push(vec![0u16; pw * ph]);
161 decoded_mask.push(false);
162 }
163 }
164 0xC0 | 0xC2..=0xC3 | 0xC5..=0xC7 | 0xC9..=0xCB | 0xCD..=0xCF | 0xF7 => {
165 return Err(JpegError::Unsupported("12-bit frame requires SOF1 Extended Sequential"));
166 }
167 0xDA => {
168 if comps.is_empty() || rem < 4 {
169 return Err(JpegError::CorruptStream("SOS before SOF1 or truncated"));
170 }
171 let ns = cur.next_u8()? as usize;
172 if ns == 0 || (ns != 1 && ns != comps.len()) || rem != 4 + 2 * ns {
173 return Err(JpegError::CorruptStream("invalid 12-bit SOS component count"));
174 }
175 let mut scan_comps = Vec::with_capacity(ns);
176 for _ in 0..ns {
177 let cs = cur.next_u8()?;
178 let td_ta = cur.next_u8()?;
179 let (td, ta) = ((td_ta >> 4) as usize, (td_ta & 0x0F) as usize);
180 let cidx = comps.iter().position(|c| c.id == cs).ok_or(JpegError::CorruptStream("unknown SOS component"))?;
181 if td >= 4 || ta >= 4 || scan_comps.iter().any(|&(idx, _, _)| idx == cidx) {
182 return Err(JpegError::CorruptStream("invalid SOS selector"));
183 }
184 scan_comps.push((cidx, td, ta));
185 }
186 let (ss, se, ah_al) = (cur.next_u8()?, cur.next_u8()?, cur.next_u8()?);
187 if ss != 0 || se != 63 || ah_al != 0 {
188 return Err(JpegError::Unsupported("12-bit JPEG must be sequential DCT"));
189 }
190 let mcu_cols = if ns == 1 {
191 plane_dims[scan_comps[0].0].0.div_ceil(8)
192 } else {
193 (cols as usize).div_ceil(h_max * 8)
194 };
195 let mcu_rows = if ns == 1 {
196 plane_dims[scan_comps[0].0].1.div_ceil(8)
197 } else {
198 (rows as usize).div_ceil(v_max * 8)
199 };
200 let mut rdr = ScanBitReader::new(&mut cur);
201 let mut dc_pred = vec![0i32; comps.len()];
202 let mut mcu_idx = 0usize;
203 let total_mcus = mcu_cols * mcu_rows;
204 for my in 0..mcu_rows {
205 for mx in 0..mcu_cols {
206 if restart_interval > 0 && mcu_idx > 0 && mcu_idx % restart_interval == 0 && mcu_idx < total_mcus {
207 rdr.consume_restart((mcu_idx / restart_interval) - 1)?;
208 dc_pred.fill(0);
209 }
210 for &(cidx, td, ta) in &scan_comps {
211 let dc_tbl = dc_tables[td].as_ref().ok_or(JpegError::CorruptStream("missing 12-bit DC Huffman table"))?;
212 let ac_tbl = ac_tables[ta].as_ref().ok_or(JpegError::CorruptStream("missing 12-bit AC Huffman table"))?;
213 let qtbl = qtables[comps[cidx].tq].as_ref().ok_or(JpegError::CorruptStream("missing 12-bit quantization table"))?;
214 let (ch, cv) = if ns == 1 { (1, 1) } else { (comps[cidx].h, comps[cidx].v) };
215 let (pw, ph) = plane_dims[cidx];
216 for vy in 0..cv {
217 for hx in 0..ch {
218 let blk = decode_block_into(&mut rdr, dc_tbl, ac_tbl, qtbl, &mut dc_pred[cidx], &basis)?;
219 write_block_to_plane(&mut planes[cidx], pw, ph, mx * ch + hx, my * cv + vy, &blk);
220 }
221 }
222 decoded_mask[cidx] = true;
223 }
224 mcu_idx += 1;
225 }
226 }
227 carry_marker = rdr.finish_scan()?;
228 }
229 _ => cur.skip_exact(rem)?,
230 }
231 }
232
233 if comps.is_empty() || decoded_mask.iter().any(|&ok| !ok) {
234 return Err(JpegError::CorruptStream("12-bit JPEG missing SOF1 or component scan"));
235 }
236 let out_len = (rows as usize) * (cols as usize) * (spp as usize) * 2;
237 let mut out = Vec::with_capacity(out_len);
238 for y in 0..rows as usize {
239 for x in 0..cols as usize {
240 if spp == 1 {
241 let v = planes[0][y * plane_dims[0].0 + x];
242 out.extend_from_slice(&v.to_le_bytes());
243 } else if photometric == "RGB" {
244 for c in 0..3 {
245 let v = planes[c][y * plane_dims[c].0 + x];
246 out.extend_from_slice(&v.to_le_bytes());
247 }
248 } else {
249 let yv = planes[0][y * plane_dims[0].0 + x] as f64;
250 let cx = if photometric == "YBR_FULL_422" { x >> 1 } else { x };
251 let cb = planes[1][y * plane_dims[1].0 + cx] as f64 - 2048.0;
252 let cr = planes[2][y * plane_dims[2].0 + cx] as f64 - 2048.0;
253 let r = (yv + 1.402 * cr).round().clamp(0.0, 4095.0) as u16;
254 let g = (yv - 0.344_136_286_201_022_14 * cb - 0.714_136_286_201_022_1 * cr)
255 .round().clamp(0.0, 4095.0) as u16;
256 let b = (yv + 1.772 * cb).round().clamp(0.0, 4095.0) as u16;
257 out.extend_from_slice(&r.to_le_bytes());
258 out.extend_from_slice(&g.to_le_bytes());
259 out.extend_from_slice(&b.to_le_bytes());
260 }
261 }
262 }
263 Ok(out)
264}