Skip to main content

qualia_core_db/medical/dicom_codecs/
jpeg_12bit.rs

1//! Pure-Rust ITU-T T.81 SOF1 Extended Sequential 12-bit JPEG decoder (`1.2.840.10008.1.2.4.51`).
2//! Supports 8-bit (`Pq=0`) & 16-bit (`Pq=1`) DQT, extended DC/AC DHT categories (`0..=15`),
3//! `DRI`/`RSTm`, interleaved & non-interleaved sequential scans, IEEE-1180 `f64` separable IDCT,
4//! and 12-bit `MONOCHROME1`/`MONOCHROME2`/`RGB`/`YBR_FULL`/`YBR_FULL_422` LE `u16` output.
5use 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
18/// Decode one single-frame ITU-T T.81 SOF1 12-bit Extended Sequential JPEG stream
19/// into little-endian `u16` bytes (`0..=4095`). Fails before touching external caller buffers.
20pub 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}