///|
priv struct Filter {
id : Int32
parameters : Array[UInt32]
decoder : &Hdf5CustomFilter?
}
///|
fn parse_filters(
message : HeaderMessage,
custom_filters~ : Array[&Hdf5CustomFilter] = [],
) -> Array[Filter] raise Hdf5Error {
guard (message.flags.to_int() & 2) == 0 else {
raise InvalidField("shared filter pipeline message was not resolved")
}
let reader = Reader::new(message.data)
let version = reader.read_u8().to_int()
guard version == 1 || version == 2 else {
raise UnsupportedFeature("unsupported filter pipeline version")
}
let count = reader.read_u8().to_int()
guard count <= 32 else { raise InvalidField("too many filters") }
if version == 1 {
reader.skip(6)
}
let filters : Array[Filter] = []
for _ in 0..= 256 {
reader.read_u16_le().to_int()
} else {
0
}
let flags = reader.read_u16_le().to_int()
guard (flags & 0xFFFE) == 0 else {
raise InvalidField("invalid filter flags")
}
let parameter_count = reader.read_u16_le().to_int()
reader.skip(name_size)
let parameters : Array[UInt32] = []
for _ in 0.. filter.id() == id) {
Some(index) => Some(custom_filters[index])
None => None
}
filters.push({ id, parameters, decoder, })
}
filters
}
///|
fn strip_fletcher32(data : Bytes) -> Bytes raise Hdf5Error {
guard data.length() >= 4 else {
raise InvalidField("truncated Fletcher32 chunk")
}
let size = data.length() - 4
let mut first = 0U
let mut second = 0U
let mut offset = 0
while offset < size {
let high = data[offset].to_uint() << 8
let low = if offset + 1 < size { data[offset + 1].to_uint() } else { 0U }
first = first + high + low
first = (first & 0xFFFFU) + (first >> 16)
second = second + first
second = (second & 0xFFFFU) + (second >> 16)
offset = offset + 2
}
first = (first & 0xFFFFU) + (first >> 16)
second = (second & 0xFFFFU) + (second >> 16)
let checksum = (second << 16) | first
let legacy = ((checksum & 0x00FF00FFU) << 8) | ((checksum & 0xFF00FF00U) >> 8)
let stored = Reader::at(data, size).read_u32_le()
guard stored == checksum || stored == legacy else {
raise InvalidField("Fletcher32 checksum mismatch")
}
data.get_view(start=0, end=size).unwrap().to_owned()
}
///|
priv struct NbitField {
size : Int32
order : Int32
precision : Int32
offset : Int32
}
///|
priv enum NbitNode {
NbitAtomic(NbitField)
NbitArray(Int32, Int32)
NbitCompound(Int32, Array[(Int32, Int32)])
NbitNoop(Int32)
}
///|
priv struct NbitCursor {
input : Bytes
mut bit : Int64
}
///|
fn nbit_read_parameter(
parameters : Array[UInt32],
cursor : FixedArray[Int32],
) -> Int32 raise Hdf5Error {
guard cursor[0] >= 0 && cursor[0] < parameters.length() else {
raise InvalidField("truncated N-bit filter parameters")
}
let value = parameters[cursor[0]]
cursor[0] = cursor[0] + 1
guard value <= 0x7FFFFFFFU else {
raise UnsupportedFeature("N-bit filter parameter is too large")
}
value.reinterpret_as_int()
}
///|
fn nbit_node_size(
nodes : Array[NbitNode],
index : Int32,
) -> Int32 raise Hdf5Error {
guard index >= 0 && index < nodes.length() else {
raise InvalidField("invalid N-bit datatype node")
}
match nodes[index] {
NbitAtomic(field) => field.size
NbitArray(size, _) => size
NbitCompound(size, _) => size
NbitNoop(size) => size
}
}
///|
fn nbit_parse_node(
parameters : Array[UInt32],
cursor : FixedArray[Int32],
nodes : Array[NbitNode],
datatype_class : Int32,
depth : Int32,
) -> Int32 raise Hdf5Error {
guard depth <= 16 else {
raise UnsupportedFeature("N-bit datatype nesting is too deep")
}
match datatype_class {
1 => {
let size = nbit_read_parameter(parameters, cursor)
let order = nbit_read_parameter(parameters, cursor)
let encoded_precision = nbit_read_parameter(parameters, cursor)
let offset = nbit_read_parameter(parameters, cursor)
let precision = if encoded_precision == 0 {
size * 8
} else {
encoded_precision
}
guard size > 0 &&
size <= 0x0FFFFFFF &&
(order == 0 || order == 1) &&
precision > 0 &&
precision.to_int64() <= size.to_int64() * 8L &&
offset >= 0 &&
offset.to_int64() + precision.to_int64() <= size.to_int64() * 8L else {
raise InvalidField("invalid N-bit atomic datatype")
}
nodes.push(NbitAtomic({ size, order, precision, offset, }))
}
2 => {
let size = nbit_read_parameter(parameters, cursor)
let base_class = nbit_read_parameter(parameters, cursor)
let base = nbit_parse_node(
parameters,
cursor,
nodes,
base_class,
depth + 1,
)
let base_size = nbit_node_size(nodes, base)
guard size > 0 && base_size > 0 && size % base_size == 0 else {
raise InvalidField("invalid N-bit array datatype")
}
nodes.push(NbitArray(size, base))
}
3 => {
let size = nbit_read_parameter(parameters, cursor)
let member_count = nbit_read_parameter(parameters, cursor)
guard size > 0 && member_count >= 0 && member_count <= 0xFFF else {
raise InvalidField("invalid N-bit compound datatype")
}
let members : Array[(Int32, Int32)] = []
let mut used_size = 0
for _ in 0..= 0 &&
member_size > 0 &&
used_size <= size - member_size &&
member_offset <= size - member_size else {
raise InvalidField("invalid N-bit compound member")
}
used_size = used_size + member_size
members.push((member_offset, child))
}
nodes.push(NbitCompound(size, members))
}
4 => {
let size = nbit_read_parameter(parameters, cursor)
guard size > 0 else { raise InvalidField("invalid N-bit no-op datatype") }
nodes.push(NbitNoop(size))
}
_ => raise InvalidField("invalid N-bit datatype class")
}
nodes.length() - 1
}
///|
fn nbit_bit_mask(count : Int32) -> Int32 {
if count == 0 {
0
} else {
(1 << count) - 1
}
}
///|
fn NbitCursor::read_bits(
self : NbitCursor,
count : Int32,
) -> Int32 raise Hdf5Error {
guard count >= 0 &&
count <= 8 &&
self.bit >= 0L &&
self.bit + count.to_int64() <= self.input.length().to_int64() * 8L else {
raise InvalidField("truncated N-bit chunk")
}
let byte_index = (self.bit / 8L).to_int()
let bit_offset = (self.bit % 8L).to_int()
let available = 8 - bit_offset
let value = if count <= available {
(self.input[byte_index].to_int() >> (available - count)) &
nbit_bit_mask(count)
} else {
let first = available
let second = count - first
((self.input[byte_index].to_int() & nbit_bit_mask(first)) << second) |
(
(self.input[byte_index + 1].to_int() >> (8 - second)) &
nbit_bit_mask(second)
)
}
self.bit = self.bit + count.to_int64()
value
}
///|
fn nbit_decompress_atomic(
output : FixedArray[Byte],
data_offset : Int32,
cursor : NbitCursor,
field : NbitField,
) -> Unit raise Hdf5Error {
guard data_offset >= 0 &&
data_offset <= output.length() - field.size &&
field.size > 0 else {
raise InvalidField("N-bit atomic value exceeds its chunk")
}
let datatype_len = field.size.to_int64() * 8L
let begin_i : Int32 = if field.order == 0 {
let sum = field.precision.to_int64() + field.offset.to_int64()
if sum % 8L != 0L {
(sum / 8L).to_int()
} else {
(sum / 8L - 1L).to_int()
}
} else {
((datatype_len - field.precision.to_int64() - field.offset.to_int64()) / 8L).to_int()
}
let end_i : Int32 = if field.order == 0 {
field.offset / 8
} else if field.offset % 8 != 0 {
((datatype_len - field.offset.to_int64()) / 8L).to_int()
} else {
((datatype_len - field.offset.to_int64()) / 8L - 1L).to_int()
}
guard begin_i >= 0 && end_i >= 0 && begin_i < field.size && end_i < field.size else {
raise InvalidField("invalid N-bit atomic bit range")
}
let mut k = begin_i
let mut finished = false
while !finished {
let (dat_len, dat_offset) = if begin_i != end_i {
if k == begin_i {
let tail = (
datatype_len - field.precision.to_int64() - field.offset.to_int64()
) %
8L
(8 - tail.to_int(), 0)
} else if k == end_i {
let length = 8 - field.offset % 8
(length, 8 - length)
} else {
(8, 0)
}
} else {
(field.precision, field.offset % 8)
}
guard dat_len >= 0 &&
dat_len <= 8 &&
dat_offset >= 0 &&
dat_offset + dat_len <= 8 else {
raise InvalidField("invalid N-bit atomic byte width")
}
let value = cursor.read_bits(dat_len)
output[data_offset + k] = (value << dat_offset).to_byte()
if field.order == 0 {
if k == end_i {
finished = true
} else {
k = k - 1
}
} else if k == end_i {
finished = true
} else {
k = k + 1
}
}
}
///|
fn nbit_decompress_node(
nodes : Array[NbitNode],
index : Int32,
output : FixedArray[Byte],
data_offset : Int32,
cursor : NbitCursor,
) -> Unit raise Hdf5Error {
guard index >= 0 && index < nodes.length() else {
raise InvalidField("invalid N-bit datatype node")
}
match nodes[index] {
NbitAtomic(field) =>
nbit_decompress_atomic(output, data_offset, cursor, field)
NbitArray(size, base) => {
let base_size = nbit_node_size(nodes, base)
guard base_size > 0 && size > 0 && size % base_size == 0 else {
raise InvalidField("invalid N-bit array datatype")
}
for element in 0..<(size / base_size) {
nbit_decompress_node(
nodes,
base,
output,
data_offset + element * base_size,
cursor,
)
}
}
NbitCompound(_, members) =>
for (member_offset, child) in members {
nbit_decompress_node(
nodes,
child,
output,
data_offset + member_offset,
cursor,
)
}
NbitNoop(size) => {
guard data_offset >= 0 && data_offset <= output.length() - size else {
raise InvalidField("N-bit no-op value exceeds its chunk")
}
for byte_index in 0.. Bytes raise Hdf5Error {
guard parameters.length() >= 3 &&
parameters[0].reinterpret_as_int() == parameters.length() else {
raise InvalidField("invalid N-bit filter parameter count")
}
guard parameters[1] <= 1U else {
raise InvalidField("invalid N-bit compression flag")
}
if parameters[1] == 1U {
guard data.length() == expected_size else {
raise InvalidField("uncompressed N-bit chunk size mismatch")
}
return data
}
let cursor = FixedArray::make(1, 0)
cursor[0] = 2
let element_count = nbit_read_parameter(parameters, cursor)
let datatype_class = nbit_read_parameter(parameters, cursor)
let nodes : Array[NbitNode] = []
let root = nbit_parse_node(parameters, cursor, nodes, datatype_class, 0)
guard cursor[0] == parameters.length() else {
raise InvalidField("N-bit filter parameter has trailing values")
}
let element_size = nbit_node_size(nodes, root)
guard element_count > 0 &&
element_size > 0 &&
element_count <= 0x7FFFFFFF / element_size &&
element_count * element_size == expected_size else {
raise InvalidField("N-bit output size does not match declared shape")
}
let output = FixedArray::make(expected_size, b'\x00')
let bit_cursor : NbitCursor = { input: data, bit: 0L, }
for element in 0.. Unit raise Hdf5Error {
guard count >= 0 &&
count <= 8 &&
value >= 0 &&
self.bit >= 0L &&
self.bit + count.to_int64() <= self.output.length().to_int64() * 8L else {
raise InvalidField("invalid N-bit output bit range")
}
let mut consumed = 0
while consumed < count {
let byte_index = (self.bit / 8L).to_int()
let bit_offset = (self.bit % 8L).to_int()
let available = 8 - bit_offset
let take = if count - consumed < available {
count - consumed
} else {
available
}
let shift = count - consumed - take
let part = (value >> shift) & nbit_bit_mask(take)
self.output[byte_index] = (self.output[byte_index].to_int() |
(part << (available - take))).to_byte()
self.bit = self.bit + take.to_int64()
consumed = consumed + take
}
}
///|
fn nbit_node_bit_count(
nodes : Array[NbitNode],
index : Int32,
) -> Int64 raise Hdf5Error {
guard index >= 0 && index < nodes.length() else {
raise InvalidField("invalid N-bit datatype node")
}
match nodes[index] {
NbitAtomic(field) => field.precision.to_int64()
NbitArray(size, base) => {
let base_size = nbit_node_size(nodes, base)
guard base_size > 0 && size > 0 && size % base_size == 0 else {
raise InvalidField("invalid N-bit array datatype")
}
let count = (size / base_size).to_int64()
let base_bits = nbit_node_bit_count(nodes, base)
guard count <= 0x7FFFFFFFFFFFFFFFL / base_bits else {
raise InvalidField("N-bit datatype is too large")
}
count * base_bits
}
NbitCompound(_, members) => {
let mut bits = 0L
for (_, child) in members {
let child_bits = nbit_node_bit_count(nodes, child)
guard bits <= 0x7FFFFFFFFFFFFFFFL - child_bits else {
raise InvalidField("N-bit datatype is too large")
}
bits = bits + child_bits
}
bits
}
NbitNoop(size) => size.to_int64() * 8L
}
}
///|
fn nbit_compress_atomic(
data : Bytes,
data_offset : Int32,
cursor : NbitWriteCursor,
field : NbitField,
) -> Unit raise Hdf5Error {
guard data_offset >= 0 &&
data_offset <= data.length() - field.size &&
field.size > 0 else {
raise InvalidField("N-bit atomic value exceeds its chunk")
}
let datatype_len = field.size.to_int64() * 8L
let begin_i : Int32 = if field.order == 0 {
let sum = field.precision.to_int64() + field.offset.to_int64()
if sum % 8L != 0L {
(sum / 8L).to_int()
} else {
(sum / 8L - 1L).to_int()
}
} else {
((datatype_len - field.precision.to_int64() - field.offset.to_int64()) / 8L).to_int()
}
let end_i : Int32 = if field.order == 0 {
field.offset / 8
} else if field.offset % 8 != 0 {
((datatype_len - field.offset.to_int64()) / 8L).to_int()
} else {
((datatype_len - field.offset.to_int64()) / 8L - 1L).to_int()
}
guard begin_i >= 0 && end_i >= 0 && begin_i < field.size && end_i < field.size else {
raise InvalidField("invalid N-bit atomic bit range")
}
let mut k = begin_i
let mut finished = false
while !finished {
let (dat_len, value) = if begin_i != end_i {
if k == begin_i {
let tail = (
datatype_len - field.precision.to_int64() - field.offset.to_int64()
) %
8L
let width = (8L - tail).to_int()
(width, data[data_offset + k].to_int() & nbit_bit_mask(width))
} else if k == end_i {
let width = 8 - field.offset % 8
(width, data[data_offset + k].to_int() >> (8 - width))
} else {
(8, data[data_offset + k].to_int())
}
} else {
(
field.precision,
(data[data_offset + k].to_int() >> (field.offset % 8)) &
nbit_bit_mask(field.precision),
)
}
guard dat_len >= 0 && dat_len <= 8 else {
raise InvalidField("invalid N-bit atomic byte width")
}
cursor.write_bits(value, dat_len)
if field.order == 0 {
if k == end_i {
finished = true
} else {
k = k - 1
}
} else if k == end_i {
finished = true
} else {
k = k + 1
}
}
}
///|
fn nbit_compress_node(
nodes : Array[NbitNode],
index : Int32,
data : Bytes,
data_offset : Int32,
cursor : NbitWriteCursor,
) -> Unit raise Hdf5Error {
guard index >= 0 && index < nodes.length() else {
raise InvalidField("invalid N-bit datatype node")
}
match nodes[index] {
NbitAtomic(field) => nbit_compress_atomic(data, data_offset, cursor, field)
NbitArray(size, base) => {
let base_size = nbit_node_size(nodes, base)
guard base_size > 0 && size > 0 && size % base_size == 0 else {
raise InvalidField("invalid N-bit array datatype")
}
for element in 0..<(size / base_size) {
nbit_compress_node(
nodes,
base,
data,
data_offset + element * base_size,
cursor,
)
}
}
NbitCompound(_, members) =>
for (member_offset, child) in members {
nbit_compress_node(
nodes,
child,
data,
data_offset + member_offset,
cursor,
)
}
NbitNoop(size) => {
guard data_offset >= 0 && data_offset <= data.length() - size else {
raise InvalidField("N-bit no-op value exceeds its chunk")
}
for byte_index in 0.. Bytes raise Hdf5Error {
guard data.length() == expected_size &&
parameters.length() >= 3 &&
parameters[0].reinterpret_as_int() == parameters.length() else {
raise InvalidField("invalid N-bit filter parameter count")
}
guard parameters[1] <= 1U else {
raise InvalidField("invalid N-bit compression flag")
}
if parameters[1] == 1U {
return data
}
let cursor = FixedArray::make(1, 0)
cursor[0] = 2
let element_count = nbit_read_parameter(parameters, cursor)
let datatype_class = nbit_read_parameter(parameters, cursor)
let nodes : Array[NbitNode] = []
let root = nbit_parse_node(parameters, cursor, nodes, datatype_class, 0)
guard cursor[0] == parameters.length() else {
raise InvalidField("N-bit filter parameter has trailing values")
}
let element_size = nbit_node_size(nodes, root)
guard element_count > 0 &&
element_size > 0 &&
element_count <= 0x7FFFFFFF / element_size &&
element_count * element_size == expected_size else {
raise InvalidField("N-bit input size does not match declared shape")
}
let element_bits = nbit_node_bit_count(nodes, root)
guard element_count.to_int64() <= 0x7FFFFFFFFFFFFFFFL / element_bits else {
raise InvalidField("N-bit chunk is too large")
}
let total_bits = element_count.to_int64() * element_bits
let output_size = total_bits / 8L + 1L
guard output_size > 0L && output_size <= 0x7FFFFFFFL else {
raise InvalidField("N-bit chunk is too large")
}
let output = FixedArray::make(output_size.to_int(), b'\x00')
let bit_cursor : NbitWriteCursor = { output, bit: 0L, }
for element in 0.. UInt64 {
let mut value = 0UL
for index in 0..> (index % 4 * 8)) & 0xFFUL
value = value | (byte << (index * 8))
}
value
}
///|
fn scaleoffset_write_scalar(
output : FixedArray[Byte],
offset : Int32,
size : Int32,
order : Int32,
value : UInt64,
) -> Unit {
for byte_index in 0..> shift) & 0xFFUL).to_byte()
}
}
///|
fn scaleoffset_float_factor32(digits : Int32) -> Float {
@math.powf(Float(10.0), Float::from_int(digits))
}
///|
fn scaleoffset_float_factor64(digits : Int32) -> Double {
@math.pow(10.0, Double::from_int(digits))
}
///|
fn decode_scaleoffset(
data : Bytes,
filter : Filter,
element_size : Int32,
expected_size : Int32,
) -> Bytes raise Hdf5Error {
guard element_size > 0 &&
expected_size >= 0 &&
expected_size % element_size == 0 else {
raise InvalidField("invalid scale-offset chunk size")
}
guard filter.parameters.length() == 20 else {
raise UnsupportedFeature("unsupported scale-offset parameters")
}
let scale_type = filter.parameters[0].reinterpret_as_int()
let datatype_class = filter.parameters[3].reinterpret_as_int()
let datatype_size = filter.parameters[4].reinterpret_as_int()
let sign = filter.parameters[5].reinterpret_as_int()
let order = filter.parameters[6].reinterpret_as_int()
let fill_available = filter.parameters[7].reinterpret_as_int()
let filter_value = filter.parameters[1].reinterpret_as_int()
guard datatype_size == element_size &&
(sign == 0 || sign == 1) &&
(order == 0 || order == 1) &&
(fill_available == 0 || fill_available == 1) else {
raise InvalidField("invalid scale-offset filter parameters")
}
let is_integer = datatype_class == 0 && scale_type == 2
let is_float = datatype_class == 1 &&
scale_type == 0 &&
(element_size == 4 || element_size == 8)
guard is_integer || is_float else {
raise UnsupportedFeature("scale-offset datatype class is not supported")
}
if is_integer && filter_value == element_size * 8 {
guard data.length() == expected_size else {
raise InvalidField("unfiltered scale-offset chunk has the wrong size")
}
return data
}
guard data.length() >= 21 else {
raise InvalidField("truncated scale-offset chunk")
}
let reader = Reader::new(data)
let minbits = reader.read_u32_le().reinterpret_as_int()
let minval_size = data[4].to_int()
guard minbits >= 0 &&
minbits < element_size * 8 &&
minval_size >= 0 &&
minval_size <= 8 &&
(!is_float || minval_size >= element_size) else {
raise InvalidField("invalid scale-offset chunk header")
}
let mut minval = 0UL
for index in 0..= 0 &&
total_bits <= 0x7FFFFFFF &&
(total_bits + 7) / 8 <= (data.length() - 21).to_int64() else {
raise InvalidField("truncated scale-offset bit stream")
}
let fill = if fill_available == 1 {
scaleoffset_parameter_value(filter.parameters, element_size)
} else {
0UL
}
let maximum_digits = if element_size == 4 { 38 } else { 308 }
guard !is_float || (filter_value >= 0 && filter_value <= maximum_digits) else {
raise UnsupportedFeature("unsupported floating-point scale factor")
}
let minimum = if is_float {
read_float_at(data, 5, element_size, true)
} else {
0.0
}
let factor32 = if is_float && element_size == 4 {
scaleoffset_float_factor32(filter_value)
} else {
Float(1.0)
}
let factor64 = if is_float && element_size == 8 {
scaleoffset_float_factor64(filter_value)
} else {
1.0
}
let marker = if minbits == 0 { 0UL } else { (1UL << minbits) - 1UL }
let mask = if element_size == 8 {
0xFFFFFFFFFFFFFFFFUL
} else {
(1UL << (element_size * 8)) - 1UL
}
let output = FixedArray::make(expected_size, b'\x00')
let mut bit_index = 0
for element in 0.. 0 {
let byte_index = bit_index / 8
let bit_offset = bit_index % 8
let available = 8 - bit_offset
let take = if remaining < available { remaining } else { available }
let part = (data[21 + byte_index].to_uint() >> (available - take)) &
((1U << take) - 1U)
packed = (packed << take) | part.to_uint64()
bit_index = bit_index + take
remaining = remaining - take
}
let decoded = if fill_available == 1 && packed == marker {
Some(fill)
} else {
None
}
let offset = element * element_size
match decoded {
Some(value) =>
scaleoffset_write_scalar(output, offset, element_size, order, value)
None =>
if is_float {
if element_size == 4 {
let value = Float::from_double(packed.to_double()) / factor32 +
Float::from_double(minimum)
scaleoffset_write_scalar(
output,
offset,
element_size,
order,
value.reinterpret_as_uint().to_uint64(),
)
} else {
let value = packed.to_double() / factor64 + minimum
scaleoffset_write_scalar(
output,
offset,
element_size,
order,
value.reinterpret_as_uint64(),
)
}
} else {
scaleoffset_write_scalar(
output,
offset,
element_size,
order,
(packed + minval) & mask,
)
}
}
}
output.unsafe_reinterpret_as_bytes()
}
///|
fn decode_filters(
data : Bytes,
filters : Array[Filter],
mask : UInt32,
element_size : Int32,
expected_size : Int32,
) -> Bytes raise Hdf5Error {
guard filters.length() == 32 || mask >> filters.length() == 0U else {
raise InvalidField("chunk filter mask exceeds pipeline")
}
guard expected_size >= 0 &&
expected_size <= 0x7FFFFFFF - filters.length() * 32 else {
raise InvalidField("filtered chunk is too large")
}
let limit = expected_size + filters.length() * 32
let mut output = data
let mut index = filters.length()
while index > 0 {
index = index - 1
if (mask & (1U << index)) != 0U {
continue
}
let filter = filters[index]
output = match filter.id {
1 => {
guard filter.parameters.length() == 1 && filter.parameters[0] <= 9U else {
raise InvalidField("invalid deflate parameters")
}
guard output.length() >= 2 && output[0].to_int() >> 4 <= 7 else {
raise InvalidField("invalid zlib window size")
}
@zlib.unzlib(output[:], checksum=true, limit~) catch {
_ => raise InvalidField("invalid or oversized deflate chunk")
}
}
2 => {
guard filter.parameters.length() == 1 else {
raise InvalidField("invalid shuffle element size")
}
let shuffle_size = if element_size > 0 {
element_size
} else {
let parameter = filter.parameters[0]
guard parameter > 0U && parameter <= 0x7FFFFFFFU else {
raise InvalidField("invalid shuffle element size")
}
parameter.reinterpret_as_int()
}
guard filter.parameters[0] == shuffle_size.reinterpret_as_uint() else {
raise InvalidField("invalid shuffle element size")
}
guard output.length() <= limit else {
raise InvalidField("oversized shuffle chunk")
}
let elements = output.length() / shuffle_size
let restored = FixedArray::make(output.length(), b'\x00')
for byte_index in 0.. {
guard filter.parameters.length() == 0 else {
raise InvalidField("invalid Fletcher32 parameters")
}
strip_fletcher32(output)
}
5 => decode_nbit(output, filter.parameters, expected_size)
6 => decode_scaleoffset(output, filter, element_size, expected_size)
_ =>
match filter.decoder {
Some(decoder) => {
let decoded = decoder.decode(
output,
filter.parameters,
element_size,
expected_size,
)
guard decoded.length() <= limit else {
raise InvalidField("oversized custom filter chunk")
}
decoded
}
None =>
raise UnsupportedFeature(
"filter " + filter.id.to_string() + " is not supported",
)
}
}
}
guard output.length() == expected_size else {
raise InvalidField("decoded chunk size does not match declared shape")
}
output
}