@nirs4all/formats-wasm 0.2.11 → 0.2.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (88) hide show
  1. package/THIRD_PARTY_NOTICES.md +49 -0
  2. package/nirs4all_formats_wasm_bg.wasm +0 -0
  3. package/package.json +4 -2
  4. package/reader-backports/hdf5-reader/Cargo.toml +119 -0
  5. package/reader-backports/hdf5-reader/LICENSE-APACHE +164 -0
  6. package/reader-backports/hdf5-reader/LICENSE-MIT +21 -0
  7. package/reader-backports/hdf5-reader/PROVENANCE.json +80 -0
  8. package/reader-backports/hdf5-reader/README.md +308 -0
  9. package/reader-backports/hdf5-reader/UPSTREAM-Cargo.toml +44 -0
  10. package/reader-backports/hdf5-reader/UPSTREAM-VCS.json +6 -0
  11. package/reader-backports/hdf5-reader/src/attribute_api.rs +847 -0
  12. package/reader-backports/hdf5-reader/src/btree_v1.rs +726 -0
  13. package/reader-backports/hdf5-reader/src/btree_v2.rs +2068 -0
  14. package/reader-backports/hdf5-reader/src/cache.rs +354 -0
  15. package/reader-backports/hdf5-reader/src/checksum.rs +56 -0
  16. package/reader-backports/hdf5-reader/src/chunk_index.rs +423 -0
  17. package/reader-backports/hdf5-reader/src/dataset.rs +4733 -0
  18. package/reader-backports/hdf5-reader/src/datatype_api.rs +497 -0
  19. package/reader-backports/hdf5-reader/src/error.rs +167 -0
  20. package/reader-backports/hdf5-reader/src/extensible_array.rs +1886 -0
  21. package/reader-backports/hdf5-reader/src/filters/deflate.rs +93 -0
  22. package/reader-backports/hdf5-reader/src/filters/fletcher32.rs +52 -0
  23. package/reader-backports/hdf5-reader/src/filters/lz4.rs +178 -0
  24. package/reader-backports/hdf5-reader/src/filters/mod.rs +326 -0
  25. package/reader-backports/hdf5-reader/src/filters/nbit.rs +586 -0
  26. package/reader-backports/hdf5-reader/src/filters/scaleoffset.rs +827 -0
  27. package/reader-backports/hdf5-reader/src/filters/shuffle.rs +99 -0
  28. package/reader-backports/hdf5-reader/src/fixed_array.rs +763 -0
  29. package/reader-backports/hdf5-reader/src/fractal_heap.rs +2029 -0
  30. package/reader-backports/hdf5-reader/src/global_heap.rs +284 -0
  31. package/reader-backports/hdf5-reader/src/group.rs +795 -0
  32. package/reader-backports/hdf5-reader/src/io.rs +413 -0
  33. package/reader-backports/hdf5-reader/src/lib.rs +916 -0
  34. package/reader-backports/hdf5-reader/src/local_heap.rs +261 -0
  35. package/reader-backports/hdf5-reader/src/messages/attribute.rs +304 -0
  36. package/reader-backports/hdf5-reader/src/messages/attribute_info.rs +96 -0
  37. package/reader-backports/hdf5-reader/src/messages/btree_k.rs +36 -0
  38. package/reader-backports/hdf5-reader/src/messages/continuation.rs +46 -0
  39. package/reader-backports/hdf5-reader/src/messages/dataspace.rs +259 -0
  40. package/reader-backports/hdf5-reader/src/messages/datatype.rs +938 -0
  41. package/reader-backports/hdf5-reader/src/messages/external_files.rs +50 -0
  42. package/reader-backports/hdf5-reader/src/messages/fill_value.rs +233 -0
  43. package/reader-backports/hdf5-reader/src/messages/filter_pipeline.rs +147 -0
  44. package/reader-backports/hdf5-reader/src/messages/group_info.rs +103 -0
  45. package/reader-backports/hdf5-reader/src/messages/layout.rs +476 -0
  46. package/reader-backports/hdf5-reader/src/messages/link.rs +170 -0
  47. package/reader-backports/hdf5-reader/src/messages/link_info.rs +127 -0
  48. package/reader-backports/hdf5-reader/src/messages/mod.rs +374 -0
  49. package/reader-backports/hdf5-reader/src/messages/modification_time.rs +83 -0
  50. package/reader-backports/hdf5-reader/src/messages/shared.rs +164 -0
  51. package/reader-backports/hdf5-reader/src/messages/shared_table.rs +67 -0
  52. package/reader-backports/hdf5-reader/src/messages/symbol_table_msg.rs +51 -0
  53. package/reader-backports/hdf5-reader/src/object_header.rs +1749 -0
  54. package/reader-backports/hdf5-reader/src/reference.rs +90 -0
  55. package/reader-backports/hdf5-reader/src/shared_message_table.rs +425 -0
  56. package/reader-backports/hdf5-reader/src/storage.rs +538 -0
  57. package/reader-backports/hdf5-reader/src/superblock.rs +285 -0
  58. package/reader-backports/hdf5-reader/src/symbol_table.rs +277 -0
  59. package/reader-backports/netcdf-reader/Cargo.toml +141 -0
  60. package/reader-backports/netcdf-reader/LICENSE-APACHE +164 -0
  61. package/reader-backports/netcdf-reader/LICENSE-MIT +21 -0
  62. package/reader-backports/netcdf-reader/PROVENANCE.json +55 -0
  63. package/reader-backports/netcdf-reader/README.md +308 -0
  64. package/reader-backports/netcdf-reader/UPSTREAM-Cargo.toml +48 -0
  65. package/reader-backports/netcdf-reader/UPSTREAM-VCS.json +6 -0
  66. package/reader-backports/netcdf-reader/src/cf/axes.rs +419 -0
  67. package/reader-backports/netcdf-reader/src/cf/bounds.rs +108 -0
  68. package/reader-backports/netcdf-reader/src/cf/crs.rs +269 -0
  69. package/reader-backports/netcdf-reader/src/cf/mod.rs +30 -0
  70. package/reader-backports/netcdf-reader/src/cf/time.rs +1122 -0
  71. package/reader-backports/netcdf-reader/src/classic/data.rs +1465 -0
  72. package/reader-backports/netcdf-reader/src/classic/header.rs +1097 -0
  73. package/reader-backports/netcdf-reader/src/classic/mod.rs +240 -0
  74. package/reader-backports/netcdf-reader/src/classic/storage.rs +211 -0
  75. package/reader-backports/netcdf-reader/src/classic/types.rs +93 -0
  76. package/reader-backports/netcdf-reader/src/classic/variable.rs +1162 -0
  77. package/reader-backports/netcdf-reader/src/error.rs +59 -0
  78. package/reader-backports/netcdf-reader/src/lib.rs +1531 -0
  79. package/reader-backports/netcdf-reader/src/masked.rs +173 -0
  80. package/reader-backports/netcdf-reader/src/nc4/attributes.rs +203 -0
  81. package/reader-backports/netcdf-reader/src/nc4/dimensions.rs +139 -0
  82. package/reader-backports/netcdf-reader/src/nc4/groups.rs +308 -0
  83. package/reader-backports/netcdf-reader/src/nc4/mod.rs +572 -0
  84. package/reader-backports/netcdf-reader/src/nc4/types.rs +309 -0
  85. package/reader-backports/netcdf-reader/src/nc4/variables.rs +420 -0
  86. package/reader-backports/netcdf-reader/src/types.rs +18 -0
  87. package/reader-backports/netcdf-reader/src/unpack.rs +113 -0
  88. package/reader-backports/netcdf-reader/src/user_defined.rs +569 -0
@@ -0,0 +1,586 @@
1
+ use crate::error::{Error, Result};
2
+
3
+ const NBIT_CLASS_ATOMIC: u32 = 1;
4
+ const NBIT_CLASS_ARRAY: u32 = 2;
5
+ const NBIT_CLASS_COMPOUND: u32 = 3;
6
+ const NBIT_CLASS_NOOP: u32 = 4;
7
+ const NBIT_ORDER_LE: u32 = 0;
8
+ const NBIT_ORDER_BE: u32 = 1;
9
+
10
+ #[derive(Debug, Clone)]
11
+ struct AtomicDesc {
12
+ size: usize,
13
+ order: u32,
14
+ precision: usize,
15
+ offset: usize,
16
+ }
17
+
18
+ #[derive(Debug, Clone)]
19
+ enum TypeDesc {
20
+ Atomic(AtomicDesc),
21
+ Array {
22
+ size: usize,
23
+ base: Box<TypeDesc>,
24
+ },
25
+ Compound {
26
+ size: usize,
27
+ members: Vec<(usize, TypeDesc)>,
28
+ },
29
+ NoOp {
30
+ size: usize,
31
+ },
32
+ }
33
+
34
+ impl TypeDesc {
35
+ fn size(&self) -> usize {
36
+ match self {
37
+ TypeDesc::Atomic(desc) => desc.size,
38
+ TypeDesc::Array { size, .. } => *size,
39
+ TypeDesc::Compound { size, .. } => *size,
40
+ TypeDesc::NoOp { size } => *size,
41
+ }
42
+ }
43
+
44
+ fn decode_into(&self, out: &mut [u8], offset: usize, bits: &mut BitReader<'_>) -> Result<()> {
45
+ match self {
46
+ TypeDesc::Atomic(desc) => decode_atomic(out, offset, bits, desc),
47
+ TypeDesc::Array { size, base } => {
48
+ let base_size = base.size();
49
+ if base_size == 0 || size % base_size != 0 {
50
+ return Err(filter_error(
51
+ "nbit array size is inconsistent with its base type",
52
+ ));
53
+ }
54
+ for i in 0..(*size / base_size) {
55
+ base.decode_into(out, offset + i * base_size, bits)?;
56
+ }
57
+ Ok(())
58
+ }
59
+ TypeDesc::Compound { size, members } => {
60
+ for (member_offset, member) in members {
61
+ let member_end = member_offset
62
+ .checked_add(member.size())
63
+ .ok_or_else(|| filter_error("nbit compound member offset overflowed"))?;
64
+ if member_end > *size {
65
+ return Err(filter_error(
66
+ "nbit compound member extends past the record size",
67
+ ));
68
+ }
69
+ member.decode_into(out, offset + member_offset, bits)?;
70
+ }
71
+ Ok(())
72
+ }
73
+ TypeDesc::NoOp { size } => {
74
+ let end = offset
75
+ .checked_add(*size)
76
+ .ok_or_else(|| filter_error("nbit output size overflowed"))?;
77
+ let slice = out
78
+ .get_mut(offset..end)
79
+ .ok_or_else(|| filter_error("nbit output range is out of bounds"))?;
80
+ for byte in slice {
81
+ *byte = bits.read_bits(8)?;
82
+ }
83
+ Ok(())
84
+ }
85
+ }
86
+ }
87
+ }
88
+
89
+ struct BitReader<'a> {
90
+ data: &'a [u8],
91
+ byte_idx: usize,
92
+ bits_left: u8,
93
+ }
94
+
95
+ impl<'a> BitReader<'a> {
96
+ fn new(data: &'a [u8]) -> Self {
97
+ Self {
98
+ data,
99
+ byte_idx: 0,
100
+ bits_left: 8,
101
+ }
102
+ }
103
+
104
+ fn read_bits(&mut self, count: usize) -> Result<u8> {
105
+ if count > 8 {
106
+ return Err(filter_error(
107
+ "nbit attempted to read more than one byte of packed bits",
108
+ ));
109
+ }
110
+ if count == 0 {
111
+ return Ok(0);
112
+ }
113
+
114
+ let mut remaining = count;
115
+ let mut value = 0u16;
116
+
117
+ while remaining > 0 {
118
+ let current = self
119
+ .data
120
+ .get(self.byte_idx)
121
+ .copied()
122
+ .ok_or_else(|| filter_error("nbit packed stream ended early"))?;
123
+ let take = remaining.min(self.bits_left as usize);
124
+ let shift = self.bits_left as usize - take;
125
+ let chunk = (current >> shift) & low_mask(take);
126
+ value = (value << take) | u16::from(chunk);
127
+ self.bits_left -= take as u8;
128
+ remaining -= take;
129
+
130
+ if self.bits_left == 0 {
131
+ self.byte_idx += 1;
132
+ self.bits_left = 8;
133
+ }
134
+ }
135
+
136
+ Ok(value as u8)
137
+ }
138
+ }
139
+
140
+ pub fn decompress(data: &[u8], client_data: &[u32]) -> Result<Vec<u8>> {
141
+ decompress_inner(data, client_data, None)
142
+ }
143
+
144
+ pub fn decompress_with_limit(
145
+ data: &[u8],
146
+ client_data: &[u32],
147
+ max_output_len: usize,
148
+ ) -> Result<Vec<u8>> {
149
+ decompress_inner(data, client_data, Some(max_output_len))
150
+ }
151
+
152
+ fn decompress_inner(
153
+ data: &[u8],
154
+ client_data: &[u32],
155
+ max_output_len: Option<usize>,
156
+ ) -> Result<Vec<u8>> {
157
+ if client_data.len() < 3 {
158
+ return Err(filter_error("nbit filter is missing required client data"));
159
+ }
160
+
161
+ let expected = usize_from_u32(client_data[0], "nbit parameter count")?;
162
+ if client_data.len() != expected {
163
+ return Err(filter_error(
164
+ "nbit client data length does not match the encoded parameter count",
165
+ ));
166
+ }
167
+
168
+ if client_data[1] != 0 {
169
+ validate_output_limit(data.len(), max_output_len)?;
170
+ return Ok(data.to_vec());
171
+ }
172
+
173
+ let element_count = usize_from_u32(client_data[2], "nbit element count")?;
174
+ let mut index = 3;
175
+ let desc = parse_desc(client_data, &mut index)?;
176
+ if index != client_data.len() {
177
+ return Err(filter_error(
178
+ "nbit client data contained trailing parameters",
179
+ ));
180
+ }
181
+
182
+ let size = desc.size();
183
+ let total_size = element_count
184
+ .checked_mul(size)
185
+ .ok_or_else(|| filter_error("nbit output size overflowed"))?;
186
+ validate_output_limit(total_size, max_output_len)?;
187
+ let mut out = super::zeroed_output(total_size, "nbit")?;
188
+ let mut bits = BitReader::new(data);
189
+
190
+ for i in 0..element_count {
191
+ desc.decode_into(&mut out, i * size, &mut bits)?;
192
+ }
193
+
194
+ Ok(out)
195
+ }
196
+
197
+ fn validate_output_limit(len: usize, max_output_len: Option<usize>) -> Result<()> {
198
+ if let Some(max_output_len) = max_output_len {
199
+ if len > max_output_len {
200
+ return Err(filter_error(&format!(
201
+ "nbit output size {len} exceeds limit {max_output_len}"
202
+ )));
203
+ }
204
+ }
205
+ Ok(())
206
+ }
207
+
208
+ fn parse_desc(params: &[u32], index: &mut usize) -> Result<TypeDesc> {
209
+ let class = *params
210
+ .get(*index)
211
+ .ok_or_else(|| filter_error("nbit client data ended while parsing a type descriptor"))?;
212
+ *index += 1;
213
+
214
+ match class {
215
+ NBIT_CLASS_ATOMIC => {
216
+ let size = next_usize(params, index, "nbit atomic size")?;
217
+ let order = next_u32(params, index, "nbit atomic byte order")?;
218
+ let precision = next_usize(params, index, "nbit atomic precision")?;
219
+ let offset = next_usize(params, index, "nbit atomic offset")?;
220
+ let desc = AtomicDesc {
221
+ size,
222
+ order,
223
+ precision,
224
+ offset,
225
+ };
226
+ validate_atomic(&desc)?;
227
+ Ok(TypeDesc::Atomic(desc))
228
+ }
229
+ NBIT_CLASS_ARRAY => {
230
+ let size = next_usize(params, index, "nbit array size")?;
231
+ let base = parse_desc(params, index)?;
232
+ let base_size = base.size();
233
+ if base_size == 0 || size % base_size != 0 {
234
+ return Err(filter_error(
235
+ "nbit array size is inconsistent with its base type",
236
+ ));
237
+ }
238
+ Ok(TypeDesc::Array {
239
+ size,
240
+ base: Box::new(base),
241
+ })
242
+ }
243
+ NBIT_CLASS_COMPOUND => {
244
+ let size = next_usize(params, index, "nbit compound size")?;
245
+ let member_count = next_usize(params, index, "nbit compound member count")?;
246
+ let mut members = Vec::with_capacity(member_count);
247
+ for _ in 0..member_count {
248
+ let member_offset = next_usize(params, index, "nbit compound member offset")?;
249
+ let member = parse_desc(params, index)?;
250
+ members.push((member_offset, member));
251
+ }
252
+ Ok(TypeDesc::Compound { size, members })
253
+ }
254
+ NBIT_CLASS_NOOP => Ok(TypeDesc::NoOp {
255
+ size: next_usize(params, index, "nbit no-op size")?,
256
+ }),
257
+ _ => Err(filter_error("nbit encountered an unknown descriptor class")),
258
+ }
259
+ }
260
+
261
+ fn decode_atomic(
262
+ out: &mut [u8],
263
+ offset: usize,
264
+ bits: &mut BitReader<'_>,
265
+ desc: &AtomicDesc,
266
+ ) -> Result<()> {
267
+ let end = offset
268
+ .checked_add(desc.size)
269
+ .ok_or_else(|| filter_error("nbit output size overflowed"))?;
270
+ let slice = out
271
+ .get_mut(offset..end)
272
+ .ok_or_else(|| filter_error("nbit output range is out of bounds"))?;
273
+
274
+ let datatype_len = desc.size * 8;
275
+ let (begin, end_idx, ascending) = match desc.order {
276
+ NBIT_ORDER_LE => {
277
+ let begin = if (desc.precision + desc.offset) % 8 != 0 {
278
+ (desc.precision + desc.offset) / 8
279
+ } else {
280
+ (desc.precision + desc.offset) / 8 - 1
281
+ };
282
+ (begin, desc.offset / 8, false)
283
+ }
284
+ NBIT_ORDER_BE => {
285
+ let begin = (datatype_len - desc.precision - desc.offset) / 8;
286
+ let end = if desc.offset % 8 != 0 {
287
+ (datatype_len - desc.offset) / 8
288
+ } else {
289
+ (datatype_len - desc.offset) / 8 - 1
290
+ };
291
+ (begin, end, true)
292
+ }
293
+ _ => return Err(filter_error("nbit encountered an unknown byte order")),
294
+ };
295
+
296
+ if ascending {
297
+ for (k, byte) in slice.iter_mut().enumerate().take(end_idx + 1).skip(begin) {
298
+ *byte = read_atomic_byte(bits, desc, datatype_len, begin, end_idx, k)?;
299
+ }
300
+ } else {
301
+ for k in (end_idx..=begin).rev() {
302
+ slice[k] = read_atomic_byte(bits, desc, datatype_len, begin, end_idx, k)?;
303
+ }
304
+ }
305
+
306
+ Ok(())
307
+ }
308
+
309
+ fn read_atomic_byte(
310
+ bits: &mut BitReader<'_>,
311
+ desc: &AtomicDesc,
312
+ datatype_len: usize,
313
+ begin: usize,
314
+ end: usize,
315
+ byte_index: usize,
316
+ ) -> Result<u8> {
317
+ let (bit_count, bit_offset) = if begin != end {
318
+ if byte_index == begin {
319
+ let remainder = (datatype_len - desc.precision - desc.offset) % 8;
320
+ (if remainder == 0 { 8 } else { 8 - remainder }, 0)
321
+ } else if byte_index == end {
322
+ let bit_count = if desc.offset % 8 == 0 {
323
+ 8
324
+ } else {
325
+ 8 - (desc.offset % 8)
326
+ };
327
+ (bit_count, 8 - bit_count)
328
+ } else {
329
+ (8, 0)
330
+ }
331
+ } else {
332
+ (desc.precision, desc.offset % 8)
333
+ };
334
+
335
+ let value = bits.read_bits(bit_count)?;
336
+ Ok(value << bit_offset)
337
+ }
338
+
339
+ fn validate_atomic(desc: &AtomicDesc) -> Result<()> {
340
+ if desc.size == 0 {
341
+ return Err(filter_error("nbit atomic size must be non-zero"));
342
+ }
343
+ if desc.precision == 0 || desc.precision > desc.size * 8 {
344
+ return Err(filter_error("nbit atomic precision is invalid"));
345
+ }
346
+ if desc.precision + desc.offset > desc.size * 8 {
347
+ return Err(filter_error(
348
+ "nbit atomic precision and offset exceed the type width",
349
+ ));
350
+ }
351
+ Ok(())
352
+ }
353
+
354
+ fn next_u32(params: &[u32], index: &mut usize, what: &str) -> Result<u32> {
355
+ let value = *params
356
+ .get(*index)
357
+ .ok_or_else(|| filter_error(&format!("{what} is missing")))?;
358
+ *index += 1;
359
+ Ok(value)
360
+ }
361
+
362
+ fn next_usize(params: &[u32], index: &mut usize, what: &str) -> Result<usize> {
363
+ usize_from_u32(next_u32(params, index, what)?, what)
364
+ }
365
+
366
+ fn usize_from_u32(value: u32, what: &str) -> Result<usize> {
367
+ usize::try_from(value).map_err(|_| filter_error(&format!("{what} does not fit in usize")))
368
+ }
369
+
370
+ fn low_mask(bits: usize) -> u8 {
371
+ if bits >= 8 {
372
+ u8::MAX
373
+ } else {
374
+ ((1u16 << bits) - 1) as u8
375
+ }
376
+ }
377
+
378
+ fn filter_error(message: &str) -> Error {
379
+ Error::FilterError(message.into())
380
+ }
381
+
382
+ #[cfg(test)]
383
+ mod tests {
384
+ use super::*;
385
+
386
+ struct BitWriter {
387
+ data: Vec<u8>,
388
+ bits_left: u8,
389
+ }
390
+
391
+ impl BitWriter {
392
+ fn new() -> Self {
393
+ Self {
394
+ data: vec![0],
395
+ bits_left: 8,
396
+ }
397
+ }
398
+
399
+ fn write_bits(&mut self, value: u8, count: usize) {
400
+ if count == 0 {
401
+ return;
402
+ }
403
+
404
+ let mut remaining = count;
405
+ while remaining > 0 {
406
+ let take = remaining.min(self.bits_left as usize);
407
+ let shift = remaining - take;
408
+ let chunk = (value >> shift) & low_mask(take);
409
+ let idx = self.data.len() - 1;
410
+ self.data[idx] |= chunk << (self.bits_left as usize - take);
411
+ self.bits_left -= take as u8;
412
+ remaining -= take;
413
+ if self.bits_left == 0 {
414
+ self.data.push(0);
415
+ self.bits_left = 8;
416
+ }
417
+ }
418
+ }
419
+
420
+ fn finish(mut self) -> Vec<u8> {
421
+ if self.bits_left == 8 {
422
+ self.data.pop();
423
+ }
424
+ self.data
425
+ }
426
+ }
427
+
428
+ fn encode_atomic(writer: &mut BitWriter, bytes: &[u8], desc: &AtomicDesc) {
429
+ let datatype_len = desc.size * 8;
430
+ match desc.order {
431
+ NBIT_ORDER_LE => {
432
+ let begin = if (desc.precision + desc.offset) % 8 != 0 {
433
+ (desc.precision + desc.offset) / 8
434
+ } else {
435
+ (desc.precision + desc.offset) / 8 - 1
436
+ };
437
+ let end = desc.offset / 8;
438
+ for k in (end..=begin).rev() {
439
+ let (bit_count, bit_offset) = if begin != end {
440
+ if k == begin {
441
+ let remainder = (datatype_len - desc.precision - desc.offset) % 8;
442
+ (if remainder == 0 { 8 } else { 8 - remainder }, 0)
443
+ } else if k == end {
444
+ let bit_count = if desc.offset % 8 == 0 {
445
+ 8
446
+ } else {
447
+ 8 - (desc.offset % 8)
448
+ };
449
+ (bit_count, 8 - bit_count)
450
+ } else {
451
+ (8, 0)
452
+ }
453
+ } else {
454
+ (desc.precision, desc.offset % 8)
455
+ };
456
+ writer.write_bits((bytes[k] >> bit_offset) & low_mask(bit_count), bit_count);
457
+ }
458
+ }
459
+ NBIT_ORDER_BE => {
460
+ let begin = (datatype_len - desc.precision - desc.offset) / 8;
461
+ let end = if desc.offset % 8 != 0 {
462
+ (datatype_len - desc.offset) / 8
463
+ } else {
464
+ (datatype_len - desc.offset) / 8 - 1
465
+ };
466
+ for (k, byte) in bytes.iter().enumerate().take(end + 1).skip(begin) {
467
+ let (bit_count, bit_offset) = if begin != end {
468
+ if k == begin {
469
+ let remainder = (datatype_len - desc.precision - desc.offset) % 8;
470
+ (if remainder == 0 { 8 } else { 8 - remainder }, 0)
471
+ } else if k == end {
472
+ let bit_count = if desc.offset % 8 == 0 {
473
+ 8
474
+ } else {
475
+ 8 - (desc.offset % 8)
476
+ };
477
+ (bit_count, 8 - bit_count)
478
+ } else {
479
+ (8, 0)
480
+ }
481
+ } else {
482
+ (desc.precision, desc.offset % 8)
483
+ };
484
+ writer.write_bits((*byte >> bit_offset) & low_mask(bit_count), bit_count);
485
+ }
486
+ }
487
+ _ => panic!("unexpected order"),
488
+ }
489
+ }
490
+
491
+ fn encode_desc(writer: &mut BitWriter, bytes: &[u8], desc: &TypeDesc) {
492
+ match desc {
493
+ TypeDesc::Atomic(atomic) => encode_atomic(writer, bytes, atomic),
494
+ TypeDesc::Array { size, base } => {
495
+ let base_size = base.size();
496
+ for i in 0..(*size / base_size) {
497
+ encode_desc(writer, &bytes[i * base_size..(i + 1) * base_size], base);
498
+ }
499
+ }
500
+ TypeDesc::Compound { members, .. } => {
501
+ for (offset, member) in members {
502
+ let end = offset + member.size();
503
+ encode_desc(writer, &bytes[*offset..end], member);
504
+ }
505
+ }
506
+ TypeDesc::NoOp { size } => {
507
+ for byte in &bytes[..*size] {
508
+ writer.write_bits(*byte, 8);
509
+ }
510
+ }
511
+ }
512
+ }
513
+
514
+ fn encode_stream(desc: &TypeDesc, element_count: usize, raw: &[u8]) -> Vec<u8> {
515
+ let size = desc.size();
516
+ let mut writer = BitWriter::new();
517
+ for i in 0..element_count {
518
+ encode_desc(&mut writer, &raw[i * size..(i + 1) * size], desc);
519
+ }
520
+ writer.finish()
521
+ }
522
+
523
+ #[test]
524
+ fn decompresses_atomic_little_endian_values() {
525
+ let desc = TypeDesc::Atomic(AtomicDesc {
526
+ size: 2,
527
+ order: NBIT_ORDER_LE,
528
+ precision: 12,
529
+ offset: 0,
530
+ });
531
+ let raw = vec![0xBC, 0x0A, 0x23, 0x01, 0xFF, 0x0F];
532
+ let encoded = encode_stream(&desc, 3, &raw);
533
+ let client_data = vec![8, 0, 3, NBIT_CLASS_ATOMIC, 2, NBIT_ORDER_LE, 12, 0];
534
+
535
+ let decoded = decompress(&encoded, &client_data).unwrap();
536
+ assert_eq!(decoded, raw);
537
+ }
538
+
539
+ #[test]
540
+ fn decompresses_compound_records_with_nested_array_and_noop_members() {
541
+ let desc = TypeDesc::Compound {
542
+ size: 6,
543
+ members: vec![
544
+ (
545
+ 0,
546
+ TypeDesc::Array {
547
+ size: 4,
548
+ base: Box::new(TypeDesc::Atomic(AtomicDesc {
549
+ size: 2,
550
+ order: NBIT_ORDER_LE,
551
+ precision: 10,
552
+ offset: 0,
553
+ })),
554
+ },
555
+ ),
556
+ (4, TypeDesc::NoOp { size: 2 }),
557
+ ],
558
+ };
559
+ let raw = vec![
560
+ 0xFF, 0x03, 0x55, 0x01, 0xDE, 0xAD, 0x00, 0x00, 0x99, 0x02, 0xBE, 0xEF,
561
+ ];
562
+ let encoded = encode_stream(&desc, 2, &raw);
563
+ let client_data = vec![
564
+ 17,
565
+ 0,
566
+ 2,
567
+ NBIT_CLASS_COMPOUND,
568
+ 6,
569
+ 2,
570
+ 0,
571
+ NBIT_CLASS_ARRAY,
572
+ 4,
573
+ NBIT_CLASS_ATOMIC,
574
+ 2,
575
+ NBIT_ORDER_LE,
576
+ 10,
577
+ 0,
578
+ 4,
579
+ NBIT_CLASS_NOOP,
580
+ 2,
581
+ ];
582
+
583
+ let decoded = decompress(&encoded, &client_data).unwrap();
584
+ assert_eq!(decoded, raw);
585
+ }
586
+ }