1use std::sync::Arc;
4
5#[cfg(feature = "rayon")]
6use rayon::prelude::*;
7
8use crate::block_decode;
9use crate::cache::{BlockCache, BlockKey, BlockKind};
10use crate::error::{Error, Result};
11use crate::header::ByteOrder;
12use crate::ifd::{Ifd, RasterLayout};
13use crate::source::TiffSource;
14use crate::{read_gdal_block_payload, GdalStructuralMetadata, Window};
15
16const TAG_JPEG_TABLES: u16 = 347;
17
18pub(crate) fn read_window(
19 source: &dyn TiffSource,
20 ifd: &Ifd,
21 byte_order: ByteOrder,
22 cache: &BlockCache,
23 window: Window,
24 gdal_structural_metadata: Option<&GdalStructuralMetadata>,
25) -> Result<Vec<u8>> {
26 let layout = ifd.raster_layout()?;
27 if window.is_empty() {
28 return Ok(Vec::new());
29 }
30
31 let output_len = window.output_len(&layout)?;
32 let mut output = vec![0u8; output_len];
33 let window_row_end = window.row_end();
34 let output_row_bytes = window.cols * layout.pixel_stride_bytes();
35
36 let specs = collect_strip_specs(ifd, &layout)?;
37 let relevant_specs: Vec<_> = specs
38 .iter()
39 .copied()
40 .filter(|spec| {
41 let spec_row_end = spec.row_start + spec.rows_in_strip;
42 spec.row_start < window_row_end && spec_row_end > window.row_off
43 })
44 .collect();
45
46 #[cfg(not(feature = "rayon"))]
47 let decoded_blocks: Result<Vec<_>> = relevant_specs
48 .iter()
49 .map(|&spec| {
50 read_strip_block(
51 source,
52 ifd,
53 byte_order,
54 cache,
55 spec,
56 &layout,
57 gdal_structural_metadata,
58 )
59 .map(|block| (spec, block))
60 })
61 .collect();
62
63 #[cfg(feature = "rayon")]
64 let decoded_blocks: Result<Vec<_>> = relevant_specs
65 .par_iter()
66 .map(|&spec| {
67 read_strip_block(
68 source,
69 ifd,
70 byte_order,
71 cache,
72 spec,
73 &layout,
74 gdal_structural_metadata,
75 )
76 .map(|block| (spec, block))
77 })
78 .collect();
79
80 for (spec, block) in decoded_blocks? {
81 let block = &*block;
82 let block_row_end = spec.row_start + spec.rows_in_strip;
83 let copy_row_start = spec.row_start.max(window.row_off);
84 let copy_row_end = block_row_end.min(window_row_end);
85
86 if layout.planar_configuration == 1 {
87 let src_row_bytes = layout.row_bytes();
88 let copy_bytes_per_row = window.cols * layout.pixel_stride_bytes();
89 for row in copy_row_start..copy_row_end {
90 let src_row_index = row - spec.row_start;
91 let dest_row_index = row - window.row_off;
92 let src_offset =
93 src_row_index * src_row_bytes + window.col_off * layout.pixel_stride_bytes();
94 let dest_offset = dest_row_index * output_row_bytes;
95 output[dest_offset..dest_offset + copy_bytes_per_row]
96 .copy_from_slice(&block[src_offset..src_offset + copy_bytes_per_row]);
97 }
98 } else {
99 let src_row_bytes = layout.sample_plane_row_bytes();
100 for row in copy_row_start..copy_row_end {
101 let src_row_index = row - spec.row_start;
102 let dest_row_index = row - window.row_off;
103 let src_row =
104 &block[src_row_index * src_row_bytes..(src_row_index + 1) * src_row_bytes];
105 let dest_row = &mut output
106 [dest_row_index * output_row_bytes..(dest_row_index + 1) * output_row_bytes];
107 for col in window.col_off..window.col_end() {
108 let src = &src_row
109 [col * layout.bytes_per_sample..(col + 1) * layout.bytes_per_sample];
110 let dest_col_index = col - window.col_off;
111 let pixel_base = dest_col_index * layout.pixel_stride_bytes()
112 + spec.plane * layout.bytes_per_sample;
113 dest_row[pixel_base..pixel_base + layout.bytes_per_sample].copy_from_slice(src);
114 }
115 }
116 }
117 }
118
119 Ok(output)
120}
121
122fn collect_strip_specs(ifd: &Ifd, layout: &RasterLayout) -> Result<Vec<StripBlockSpec>> {
123 let offsets = ifd
124 .strip_offsets()
125 .ok_or(Error::TagNotFound(crate::ifd::TAG_STRIP_OFFSETS))?;
126 let counts = ifd
127 .strip_byte_counts()
128 .ok_or(Error::TagNotFound(crate::ifd::TAG_STRIP_BYTE_COUNTS))?;
129 if offsets.len() != counts.len() {
130 return Err(Error::InvalidImageLayout(format!(
131 "StripOffsets has {} entries but StripByteCounts has {}",
132 offsets.len(),
133 counts.len()
134 )));
135 }
136
137 let rows_per_strip = ifd.rows_per_strip().unwrap_or(ifd.height());
138 if rows_per_strip == 0 {
139 return Err(Error::InvalidImageLayout(
140 "RowsPerStrip must be greater than zero".into(),
141 ));
142 }
143 let rows_per_strip = rows_per_strip as usize;
144 let strips_per_plane = layout.height.div_ceil(rows_per_strip);
145 let expected = match layout.planar_configuration {
146 1 => strips_per_plane,
147 2 => strips_per_plane * layout.samples_per_pixel,
148 planar => return Err(Error::UnsupportedPlanarConfiguration(planar)),
149 };
150 if offsets.len() != expected {
151 return Err(Error::InvalidImageLayout(format!(
152 "expected {expected} strips, found {}",
153 offsets.len()
154 )));
155 }
156
157 Ok((0..expected)
158 .map(|strip_index| {
159 let plane = if layout.planar_configuration == 1 {
160 0
161 } else {
162 strip_index / strips_per_plane
163 };
164 let plane_strip_index = if layout.planar_configuration == 1 {
165 strip_index
166 } else {
167 strip_index % strips_per_plane
168 };
169 let row_start = plane_strip_index * rows_per_strip;
170 let rows_in_strip = rows_per_strip.min(layout.height.saturating_sub(row_start));
171 StripBlockSpec {
172 index: strip_index,
173 plane,
174 row_start,
175 offset: offsets[strip_index],
176 byte_count: counts[strip_index],
177 rows_in_strip,
178 }
179 })
180 .collect())
181}
182
183#[derive(Clone, Copy)]
184struct StripBlockSpec {
185 index: usize,
186 plane: usize,
187 row_start: usize,
188 offset: u64,
189 byte_count: u64,
190 rows_in_strip: usize,
191}
192
193fn read_strip_block(
194 source: &dyn TiffSource,
195 ifd: &Ifd,
196 byte_order: ByteOrder,
197 cache: &BlockCache,
198 spec: StripBlockSpec,
199 layout: &RasterLayout,
200 gdal_structural_metadata: Option<&GdalStructuralMetadata>,
201) -> Result<Arc<Vec<u8>>> {
202 let cache_key = BlockKey {
203 ifd_index: ifd.index,
204 kind: BlockKind::Strip,
205 block_index: spec.index,
206 };
207 if let Some(cached) = cache.get(&cache_key) {
208 return Ok(cached);
209 }
210
211 let compressed = if gdal_structural_metadata.is_some() {
212 Vec::new()
213 } else if let Some(bytes) = source.as_slice() {
214 let start = usize::try_from(spec.offset).map_err(|_| Error::OffsetOutOfBounds {
215 offset: spec.offset,
216 length: spec.byte_count,
217 data_len: bytes.len() as u64,
218 })?;
219 let len = usize::try_from(spec.byte_count).map_err(|_| Error::OffsetOutOfBounds {
220 offset: spec.offset,
221 length: spec.byte_count,
222 data_len: bytes.len() as u64,
223 })?;
224 let end = start.checked_add(len).ok_or(Error::OffsetOutOfBounds {
225 offset: spec.offset,
226 length: spec.byte_count,
227 data_len: bytes.len() as u64,
228 })?;
229 if end > bytes.len() {
230 return Err(Error::OffsetOutOfBounds {
231 offset: spec.offset,
232 length: spec.byte_count,
233 data_len: bytes.len() as u64,
234 });
235 }
236 bytes[start..end].to_vec()
237 } else {
238 let len = usize::try_from(spec.byte_count).map_err(|_| Error::OffsetOutOfBounds {
239 offset: spec.offset,
240 length: spec.byte_count,
241 data_len: source.len(),
242 })?;
243 source.read_exact_at(spec.offset, len)?
244 };
245
246 let compressed = match gdal_structural_metadata {
247 Some(metadata) => {
248 read_gdal_block_payload(source, metadata, byte_order, spec.offset, spec.byte_count)?
249 }
250 None => compressed,
251 };
252
253 let jpeg_tables = ifd
254 .tag(TAG_JPEG_TABLES)
255 .and_then(|tag| tag.value.as_bytes());
256 let decoded = block_decode::decode_compressed_block(block_decode::BlockDecodeRequest {
257 ifd,
258 layout: *layout,
259 byte_order,
260 compressed: &compressed,
261 index: spec.index,
262 jpeg_tables,
263 block_width: layout.width,
264 block_height: spec.rows_in_strip,
265 })?;
266 Ok(cache.insert(cache_key, decoded))
267}