Debian Codegraph @

.cargo/vendor/zune-jpeg/src/mcu_prog.rs

raw
1 /*
2 * Copyright (c) 2023.
3 *
4 * This software is free software;
5 *
6 * You can redistribute it or modify it under terms of the MIT, Apache License or Zlib license
7 */
8
9 //!Routines for progressive decoding
10 /*
11 This file is needlessly complicated,
12
13 It is that way to ensure we don't burn memory anyhow
14
15 Memory is a scarce resource in some environments, I would like this to be viable
16 in such environments
17
18 Half of the complexity comes from the jpeg spec, because progressive decoding,
19 is one hell of a ride.
20
21 */
22 use alloc::string::ToString;
23 use alloc::vec::Vec;
24 use alloc::{format, vec};
25 use core::cmp::min;
26
27 use zune_core::bytestream::{ZByteReaderTrait, ZReader};
28 use zune_core::colorspace::ColorSpace;
29 use zune_core::log::{debug, error, warn};
30
31 use crate::bitstream::BitStream;
32 use crate::components::SampleRatios;
33 use crate::decoder::{JpegDecoder, MAX_COMPONENTS};
34 use crate::errors::DecodeErrors;
35 use crate::headers::parse_sos;
36 use crate::marker::Marker;
37 use crate::mcu::DCT_BLOCK;
38 use crate::misc::{calculate_padded_width, setup_component_params};
39
40 impl<T: ZByteReaderTrait> JpegDecoder<T> {
41 /// Decode a progressive image
42 ///
43 /// This routine decodes a progressive image, stopping if it finds any error.
44 #[allow(
45 clippy::needless_range_loop,
46 clippy::cast_sign_loss,
47 clippy::redundant_else,
48 clippy::too_many_lines
49 )]
50 #[inline(never)]
51 pub(crate) fn decode_mcu_ycbcr_progressive(
52 &mut self, pixels: &mut [u8]
53 ) -> Result<(), DecodeErrors> {
54 setup_component_params(self)?;
55
56 let mut mcu_height;
57
58 // memory location for decoded pixels for components
59 let mut block: [Vec<i16>; MAX_COMPONENTS] = [vec![], vec![], vec![], vec![]];
60 let mut mcu_width;
61
62 let mut seen_scans = 1;
63
64 if self.input_colorspace == ColorSpace::Luma && self.is_interleaved {
65 warn!("Grayscale image with down-sampled component, resetting component details");
66 self.reset_params();
67 }
68
69 if self.is_interleaved {
70 // this helps us catch component errors.
71 self.set_upsampling()?;
72 }
73 if self.is_interleaved {
74 mcu_width = self.mcu_x;
75 mcu_height = self.mcu_y;
76 } else {
77 mcu_width = (self.info.width as usize + 7) / 8;
78 mcu_height = (self.info.height as usize + 7) / 8;
79 }
80 if self.is_interleaved
81 && self.input_colorspace.num_components() > 1
82 && self.options.jpeg_get_out_colorspace().num_components() == 1
83 && (self.sub_sample_ratio == SampleRatios::V
84 || self.sub_sample_ratio == SampleRatios::HV)
85 {
86 // For a specific set of images, e.g interleaved,
87 // when converting from YcbCr to grayscale, we need to
88 // take into account mcu height since the MCU decoding needs to take
89 // it into account for padding purposes and the post processor
90 // parses two rows per mcu width.
91 //
92 // set coeff to be 2 to ensure that we increment two rows
93 // for every mcu processed also
94 mcu_height *= self.v_max;
95 mcu_height /= self.h_max;
96 self.coeff = 2;
97 }
98
99 mcu_width *= 64;
100
101 for i in 0..self.input_colorspace.num_components() {
102 let comp = &self.components[i];
103 let len = mcu_width * comp.vertical_sample * comp.horizontal_sample * mcu_height;
104
105 block[i] = vec![0; len];
106 }
107
108 let mut stream = BitStream::new_progressive(self.succ_low, self.spec_start, self.spec_end);
109
110 // there are multiple scans in the stream, this should resolve the first scan
111 let result = self.parse_entropy_coded_data(&mut stream, &mut block);
112
113 if result.is_err() {
114 return if self.options.strict_mode() {
115 Err(result.err().unwrap())
116 } else {
117 error!("{}", result.err().unwrap());
118 // Go process it and return as much as we can, exiting here
119 return self.finish_progressive_decoding(&block, pixels);
120 };
121 }
122
123 // extract marker
124 let mut marker = stream
125 .marker
126 .take()
127 .ok_or(DecodeErrors::FormatStatic("Marker missing where expected"))?;
128
129 // if marker is EOI, we are done, otherwise continue scanning.
130 //
131 // In case we have a premature image, we print a warning or return
132 // an error, depending on the strictness of the decoder, so there
133 // is that logic to handle too
134 'eoi: while marker != Marker::EOI {
135 match marker {
136 Marker::SOS => {
137 parse_sos(self)?;
138
139 stream.update_progressive_params(
140 self.succ_high,
141 self.succ_low,
142 self.spec_start,
143 self.spec_end
144 );
145 // after every SOS, marker, parse data for that scan.
146 let result = self.parse_entropy_coded_data(&mut stream, &mut block);
147
148 // Do not error out too fast, allows the decoder to continue as much as possible
149 // even after errors
150 if result.is_err() {
151 return if self.options.strict_mode() {
152 Err(result.err().unwrap())
153 } else {
154 error!("{}", result.err().unwrap());
155 break 'eoi;
156 };
157 }
158 // extract marker, might either indicate end of image or we continue
159 // scanning(hence the continue statement to determine).
160 match get_marker(&mut self.stream, &mut stream) {
161 Ok(marker_n) => {
162 marker = marker_n;
163 seen_scans += 1;
164 if seen_scans > self.options.jpeg_get_max_scans() {
165 return Err(DecodeErrors::Format(format!(
166 "Too many scans, exceeded limit of {}",
167 self.options.jpeg_get_max_scans()
168 )));
169 }
170
171 stream.reset();
172 continue 'eoi;
173 }
174 Err(msg) => {
175 if self.options.strict_mode() {
176 return Err(msg);
177 }
178 error!("{:?}", msg);
179 break 'eoi;
180 }
181 }
182 }
183 Marker::RST(_n) => {
184 self.handle_rst(&mut stream)?;
185 }
186 _ => {
187 self.parse_marker_inner(marker)?;
188 }
189 }
190
191 match get_marker(&mut self.stream, &mut stream) {
192 Ok(marker_n) => {
193 marker = marker_n;
194 }
195 Err(e) => {
196 if self.options.strict_mode() {
197 return Err(e);
198 }
199 error!("{}", e);
200 // If we can't get the marker, just break away
201 // allows us to decode some corrupt images
202 // e.g https://github.com/etemesi254/zune-image/issues/294
203 break 'eoi;
204 }
205 }
206 }
207
208 self.finish_progressive_decoding(&block, pixels)
209 }
210
211 /// Reset progressive parameters
212 fn reset_prog_params(&mut self, stream: &mut BitStream) {
213 stream.reset();
214 self.components.iter_mut().for_each(|x| x.dc_pred = 0);
215
216 // Also reset JPEG restart intervals
217 self.todo = if self.restart_interval != 0 { self.restart_interval } else { usize::MAX };
218 }
219
220 #[allow(clippy::too_many_lines, clippy::cast_sign_loss)]
221 fn parse_entropy_coded_data(
222 &mut self, stream: &mut BitStream, buffer: &mut [Vec<i16>; MAX_COMPONENTS]
223 ) -> Result<(), DecodeErrors> {
224 self.reset_prog_params(stream);
225
226 if usize::from(self.num_scans) > self.input_colorspace.num_components() {
227 return Err(DecodeErrors::Format(format!(
228 "Number of scans {} cannot be greater than number of components, {}",
229 self.num_scans,
230 self.input_colorspace.num_components()
231 )));
232 }
233 if self.num_scans == 1 {
234 // Safety checks
235 if self.spec_end != 0 && self.spec_start == 0 {
236 return Err(DecodeErrors::FormatStatic(
237 "Can't merge DC and AC corrupt jpeg"
238 ));
239 }
240 // non interleaved data, process one block at a time in trivial scanline order
241
242 let k = self.z_order[0];
243
244 if k >= self.components.len() {
245 return Err(DecodeErrors::Format(format!(
246 "Cannot find component {k}, corrupt image"
247 )));
248 }
249
250 let (mcu_width, mcu_height);
251
252 if self.components[k].vertical_sample != 1
253 || self.components[k].horizontal_sample != 1
254 || !self.is_interleaved
255 {
256 // For non interleaved scans
257 // mcu's is the image dimensions divided by 8
258 mcu_width = self.info.width.div_ceil(8) as usize;
259 mcu_height = self.info.height.div_ceil(8) as usize;
260 } else {
261 // For other channels, in an interleaved mcu, number of MCU's
262 // are determined by some weird maths done in headers.rs->parse_sos()
263 mcu_width = self.mcu_x;
264 mcu_height = self.mcu_y;
265 }
266
267 for i in 0..mcu_height {
268 for j in 0..mcu_width {
269 if self.spec_start != 0 && self.succ_high == 0 && stream.eob_run > 0 {
270 // handle EOB runs here.
271 stream.eob_run -= 1;
272 } else {
273 let start = 64 * (j + i * (self.components[k].width_stride / 8));
274
275 let data: &mut [i16; 64] = buffer
276 .get_mut(k)
277 .unwrap()
278 .get_mut(start..start + 64)
279 .ok_or(DecodeErrors::FormatStatic("Slice to Small"))?
280 .try_into()
281 .unwrap();
282
283 if self.spec_start == 0 {
284 let pos = self.components[k].dc_huff_table & (MAX_COMPONENTS - 1);
285 let dc_table = self
286 .dc_huffman_tables
287 .get(pos)
288 .ok_or(DecodeErrors::FormatStatic(
289 "No huffman table for DC component"
290 ))?
291 .as_ref()
292 .ok_or(DecodeErrors::FormatStatic(
293 "Huffman table at index {} not initialized"
294 ))?;
295
296 let dc_pred = &mut self.components[k].dc_pred;
297
298 if self.succ_high == 0 {
299 // first scan for this mcu
300 stream.decode_prog_dc_first(
301 &mut self.stream,
302 dc_table,
303 &mut data[0],
304 dc_pred
305 )?;
306 } else {
307 // refining scans for this MCU
308 stream.decode_prog_dc_refine(&mut self.stream, &mut data[0])?;
309 }
310 } else {
311 let pos = self.components[k].ac_huff_table;
312 let ac_table = self
313 .ac_huffman_tables
314 .get(pos)
315 .ok_or_else(|| {
316 DecodeErrors::Format(format!(
317 "No huffman table for component:{pos}"
318 ))
319 })?
320 .as_ref()
321 .ok_or_else(|| {
322 DecodeErrors::Format(format!(
323 "Huffman table at index {pos} not initialized"
324 ))
325 })?;
326
327 if self.succ_high == 0 {
328 debug_assert!(stream.eob_run == 0, "EOB run is not zero");
329
330 stream.decode_mcu_ac_first(&mut self.stream, ac_table, data)?;
331 } else {
332 // refinement scan
333 stream.decode_mcu_ac_refine(&mut self.stream, ac_table, data)?;
334 }
335 // Check for a marker.
336 // It can appear in stream CC https://github.com/etemesi254/zune-image/issues/300
337 // if let Some(marker) = stream.marker.take() {
338 // self.parse_marker_inner(marker)?;
339 // }
340 }
341 }
342
343 // + EOB and investigate effect.
344 self.todo -= 1;
345
346 self.handle_rst_main(stream)?;
347 }
348 }
349 } else {
350 if self.spec_end != 0 {
351 return Err(DecodeErrors::HuffmanDecode(
352 "Can't merge dc and AC corrupt jpeg".to_string()
353 ));
354 }
355 // process scan n elements in order
356
357 // Do the error checking with allocs here.
358 // Make the one in the inner loop free of allocations.
359 for k in 0..self.num_scans {
360 let n = self.z_order[k as usize];
361
362 if n >= self.components.len() {
363 return Err(DecodeErrors::Format(format!(
364 "Cannot find component {n}, corrupt image"
365 )));
366 }
367
368 let component = &mut self.components[n];
369 let _ = self
370 .dc_huffman_tables
371 .get(component.dc_huff_table)
372 .ok_or_else(|| {
373 DecodeErrors::Format(format!(
374 "No huffman table for component:{}",
375 component.dc_huff_table
376 ))
377 })?
378 .as_ref()
379 .ok_or_else(|| {
380 DecodeErrors::Format(format!(
381 "Huffman table at index {} not initialized",
382 component.dc_huff_table
383 ))
384 })?;
385 }
386 // Interleaved scan
387
388 // Components shall not be interleaved in progressive mode, except for
389 // the DC coefficients in the first scan for each component of a progressive frame.
390 for i in 0..self.mcu_y {
391 for j in 0..self.mcu_x {
392 // process scan n elements in order
393 for k in 0..self.num_scans {
394 let n = self.z_order[k as usize];
395 let component = &mut self.components[n];
396 let huff_table = self
397 .dc_huffman_tables
398 .get(component.dc_huff_table)
399 .ok_or(DecodeErrors::FormatStatic("No huffman table for component"))?
400 .as_ref()
401 .ok_or(DecodeErrors::FormatStatic(
402 "Huffman table at index not initialized"
403 ))?;
404
405 for v_samp in 0..component.vertical_sample {
406 for h_samp in 0..component.horizontal_sample {
407 let x2 = j * component.horizontal_sample + h_samp;
408 let y2 = i * component.vertical_sample + v_samp;
409 let position = 64 * (x2 + y2 * component.width_stride / 8);
410 let buf_n = &mut buffer[n];
411
412 let Some(data) = &mut buf_n.get_mut(position) else {
413 // TODO: (CAE), this is another weird sub-sampling bug, so on fix
414 // remove this
415 return Err(DecodeErrors::FormatStatic("Invalid image"));
416 };
417
418 if self.succ_high == 0 {
419 stream.decode_prog_dc_first(
420 &mut self.stream,
421 huff_table,
422 data,
423 &mut component.dc_pred
424 )?;
425 } else {
426 stream.decode_prog_dc_refine(&mut self.stream, data)?;
427 }
428 }
429 }
430 }
431 // We want wrapping subtraction here because it means
432 // we get a higher number in the case this underflows
433 self.todo -= 1;
434 // after every scan that's a mcu, count down restart markers.
435 self.handle_rst_main(stream)?;
436 }
437 }
438 }
439 return Ok(());
440 }
441
442 pub(crate) fn handle_rst_main(&mut self, stream: &mut BitStream) -> Result<(), DecodeErrors> {
443 if self.todo == 0 {
444 stream.refill(&mut self.stream)?;
445 }
446
447 if self.todo == 0
448 && self.restart_interval != 0
449 && stream.marker.is_none()
450 && !stream.seen_eoi
451 {
452 // if no marker and we are to reset RST, look for the marker, this matches
453 // libjpeg-turbo behaviour and allows us to decode images in
454 // https://github.com/etemesi254/zune-image/issues/261
455 let _start = self.stream.position()?;
456 // skip bytes until we find marker
457 let marker = get_marker(&mut self.stream, stream);
458
459 // In some images, the RST marker on the last section may not be available
460 // as it is maybe stopped by an EOI marker, see in the case of https://github.com/etemesi254/zune-image/issues/292
461 // what happened was that we would go looking for the RST marker exhausting all the data
462 // in the image and this would return an error, so for now
463 // translate it to a warning, but return the image decoded up
464 // until that point
465 if let Ok(marker) = marker {
466 let _end = self.stream.position()?;
467 stream.marker = Some(marker);
468 // NB some warnings may be false positives.
469 warn!(
470 "{} Extraneous bytes before marker {:?}",
471 _end - _start,
472 marker
473 );
474 } else {
475 warn!("RST marker was not found, where expected, image may be garbled")
476 }
477 }
478 if self.todo == 0 {
479 self.handle_rst(stream)?
480 }
481 Ok(())
482 }
483 #[allow(clippy::too_many_lines)]
484 #[allow(clippy::needless_range_loop, clippy::cast_sign_loss)]
485 fn finish_progressive_decoding(
486 &mut self, block: &[Vec<i16>; MAX_COMPONENTS], pixels: &mut [u8]
487 ) -> Result<(), DecodeErrors> {
488 // This function is complicated because we need to replicate
489 // the function in mcu.rs
490 //
491 // The advantage is that we do very little allocation and very lot
492 // channel reusing.
493 // The trick is to notice that we repeat the same procedure per MCU
494 // width.
495 //
496 // So we can set it up that we only allocate temporary storage large enough
497 // to store a single mcu width, then reuse it per invocation.
498 //
499 // This is advantageous to us.
500 //
501 // Remember we need to have the whole MCU buffer so we store 3 unprocessed
502 // channels in memory, and then we allocate the whole output buffer in memory, both of
503 // which are huge.
504 //
505 //
506
507 let mcu_height = if self.is_interleaved {
508 self.mcu_y
509 } else {
510 // For non-interleaved images( (1*1) subsampling)
511 // number of MCU's are the widths (+7 to account for paddings) divided by 8.
512 self.info.height.div_ceil(8) as usize
513 };
514
515 // Size of our output image(width*height)
516 let is_hv = usize::from(self.is_interleaved);
517 let upsampler_scratch_size = is_hv * self.components[0].width_stride;
518 let width = usize::from(self.info.width);
519 let padded_width = calculate_padded_width(width, self.sub_sample_ratio);
520
521 let mut upsampler_scratch_space = vec![0; upsampler_scratch_size];
522 let mut tmp = [0_i32; DCT_BLOCK];
523
524 for (pos, comp) in self.components.iter_mut().enumerate() {
525 // Allocate only needed components.
526 //
527 // For special colorspaces i.e YCCK and CMYK, just allocate all of the needed
528 // components.
529 if min(
530 self.options.jpeg_get_out_colorspace().num_components() - 1,
531 pos
532 ) == pos
533 || self.input_colorspace == ColorSpace::YCCK
534 || self.input_colorspace == ColorSpace::CMYK
535 {
536 // allocate enough space to hold a whole MCU width
537 // this means we should take into account sampling ratios
538 // `*8` is because each MCU spans 8 widths.
539 let len = comp.width_stride * comp.vertical_sample * 8;
540
541 comp.needed = true;
542 comp.raw_coeff = vec![0; len];
543 } else {
544 comp.needed = false;
545 }
546 }
547
548 let mut pixels_written = 0;
549
550 // dequantize, idct and color convert.
551 for i in 0..mcu_height {
552 'component: for (position, component) in &mut self.components.iter_mut().enumerate() {
553 if !component.needed {
554 continue 'component;
555 }
556 let qt_table = &component.quantization_table;
557
558 // step is the number of pixels this iteration wil be handling
559 // Given by the number of mcu's height and the length of the component block
560 // Since the component block contains the whole channel as raw pixels
561 // we this evenly divides the pixels into MCU blocks
562 //
563 // For interleaved images, this gives us the exact pixels comprising a whole MCU
564 // block
565 let step = block[position].len() / mcu_height;
566 // where we will be reading our pixels from.
567 let start = i * step;
568
569 let slice = &block[position][start..start + step];
570
571 let temp_channel = &mut component.raw_coeff;
572
573 // The next logical step is to iterate width wise.
574 // To figure out how many pixels we iterate by we use effective pixels
575 // Given to us by component.x
576 // iterate per effective pixels.
577 let mcu_x = component.width_stride / 8;
578
579 // iterate per every vertical sample.
580 for k in 0..component.vertical_sample {
581 for j in 0..mcu_x {
582 // after writing a single stride, we need to skip 8 rows.
583 // This does the row calculation
584 let width_stride = k * 8 * component.width_stride;
585 let start = j * 64 + width_stride;
586
587 // See https://github.com/etemesi254/zune-image/issues/262 sample 3.
588 let Some(qt_slice) = slice.get(start..start + 64) else {
589 return Err(DecodeErrors::FormatStatic(
590 "Invalid slice , would panic, invalid image"
591 ));
592 };
593 // dequantize
594 for ((x, out), qt_val) in
595 qt_slice.iter().zip(tmp.iter_mut()).zip(qt_table.iter())
596 {
597 *out = i32::from(*x) * qt_val;
598 }
599 // determine where to write.
600 let sl = &mut temp_channel[component.idct_pos..];
601
602 component.idct_pos += 8;
603 // tmp now contains a dequantized block so idct it
604 (self.idct_func)(&mut tmp, sl, component.width_stride);
605 }
606 // after every write of 8, skip 7 since idct write stride wise 8 times.
607 //
608 // Remember each MCU is 8x8 block, so each idct will write 8 strides into
609 // sl
610 //
611 // and component.idct_pos is one stride long
612 component.idct_pos += 7 * component.width_stride;
613 }
614 component.idct_pos = 0;
615 }
616
617 // process that width up until it's impossible
618 self.post_process(
619 pixels,
620 i,
621 mcu_height,
622 width,
623 padded_width,
624 &mut pixels_written,
625 &mut upsampler_scratch_space
626 )?;
627 }
628
629 debug!("Finished decoding image");
630
631 return Ok(());
632 }
633 pub(crate) fn reset_params(&mut self) {
634 /*
635 Apparently, grayscale images which can be down sampled exists, which is weird in the sense
636 that it has one component Y, which is not usually down sampled.
637
638 This means some calculations will be wrong, so for that we explicitly reset params
639 for such occurrences, warn and reset the image info to appear as if it were
640 a non-sampled image to ensure decoding works
641 */
642 self.h_max = 1;
643 self.v_max = 1;
644 self.sub_sample_ratio = SampleRatios::None;
645 self.is_interleaved = false;
646 self.components[0].vertical_sample = 1;
647 self.components[0].width_stride = (((self.info.width as usize) + 7) / 8) * 8;
648 self.components[0].horizontal_sample = 1;
649 }
650 }
651
652 ///Get a marker from the bit-stream.
653 ///
654 /// This reads until it gets a marker or end of file is encountered
655 pub fn get_marker<T>(
656 reader: &mut ZReader<T>, stream: &mut BitStream
657 ) -> Result<Marker, DecodeErrors>
658 where
659 T: ZByteReaderTrait
660 {
661 if let Some(marker) = stream.marker {
662 stream.marker = None;
663 return Ok(marker);
664 }
665
666 // read until we get a marker
667
668 while !reader.eof()? {
669 let marker = reader.read_u8_err()?;
670
671 if marker == 255 {
672 let mut r = reader.read_u8_err()?;
673 // 0xFF 0XFF(some images may be like that)
674 while r == 0xFF {
675 r = reader.read_u8_err()?;
676 }
677
678 if r != 0 {
679 return Marker::from_u8(r)
680 .ok_or_else(|| DecodeErrors::Format(format!("Unknown marker 0xFF{r:X}")));
681 }
682 }
683 }
684 return Err(DecodeErrors::ExhaustedData);
685 }
686
687 // #[cfg(test)]
688 // mod tests{
689 // use zune_core::bytestream::ZCursor;
690 // use crate::JpegDecoder;
691 //
692 // #[test]
693 // fn make_test(){
694 // let img = "/Users/etemesi/Downloads/wrong_sampling.jpeg";
695 // let data = ZCursor::new(std::fs::read(img).unwrap());
696 // let mut decoder = JpegDecoder::new(data);
697 // decoder.decode().unwrap();
698 //
699 // }
700 // }