GitHub

Filters

HDF5 supports filters for compression and validation: these are applied sequentially to each chunk of a dataset when writing data, and in reverse order when reading data.

These can be set by passing a filter or vector of filters as a filters property to DatasetCreateProperties or via the filters keyword argument of create_dataset.

Example

HDF5.Filters — Module

HDF5.Filters

This module contains the interface for using filters in HDF5.jl.

Example Usage

using HDF5
using HDF5.Filters

# Create a new file
fn = tempname()

# Create test data
data = rand(1000, 1000)

# Open temp file for writing
f = h5open(fn, "w") 

# Create datasets
dsdeflate = create_dataset(f, "deflate", datatype(data), dataspace(data),
                           chunk=(100, 100), deflate=3)

dsshufdef = create_dataset(f, "shufdef", datatype(data), dataspace(data),
                           chunk=(100, 100), shuffle=true, deflate=3)

dsfiltdef = create_dataset(f, "filtdef", datatype(data), dataspace(data),
                           chunk=(100, 100), filters=Filters.Deflate(3))

dsfiltshufdef = create_dataset(f, "filtshufdef", datatype(data), dataspace(data),
                               chunk=(100, 100), filters=[Filters.Shuffle(), Filters.Deflate(3)])

# Write data
write(dsdeflate, data)
write(dsshufdef, data)
write(dsfiltdef, data)
write(dsfiltshufdef, data)

close(f)

Additonal Examples

See test/filter.jl for further examples.

source

Built-in Filters

HDF5.Filters.Deflate — Type
Deflate(level=5)

Deflate/ZLIB lossless compression filter. level is an integer between 0 and 9, inclusive, denoting the compression level, with 0 being no compression, 9 being the highest compression (but slowest speed).

External links

source
HDF5.Filters.Shuffle — Type
Shuffle()

The shuffle filter de-interlaces a block of data by reordering the bytes. All the bytes from one consistent byte position of each data element are placed together in one block; all bytes from a second consistent byte position of each data element are placed together a second block; etc. For example, given three data elements of a 4-byte datatype stored as 012301230123, shuffling will re-order data as 000111222333. This can be a valuable step in an effective compression algorithm because the bytes in each byte position are often closely related to each other and putting them together can increase the compression ratio.

As implied above, the primary value of the shuffle filter lies in its coordinated use with a compression filter; it does not provide data compression when used alone. When the shuffle filter is applied to a dataset immediately prior to the use of a compression filter, the compression ratio achieved is often superior to that achieved by the use of a compression filter without the shuffle filter.

External links

source
HDF5.Filters.Szip — Type
Szip(coding=:nn, pixels_per_block=8)

Szip compression lossless filter. Options:

  • coding: the coding method: either :ec (entropy coding) or :nn (nearest neighbors, default)
  • pixels_per_block: The number of pixels or data elements in each data block (typically 8, 10, 16, or 32)

External links

source
HDF5.Filters.ExternalFilter — Type
ExternalFilter(filter_id::API.H5Z_filter_t, flags::Cuint, data::Vector{Cuint}, name::String, config::Cuint)
ExternalFilter(filter_id, flags, data::Integer...)
ExternalFilter(filter_id, data::AbstractVector{<:Integer} = Cuint[])

Intended to support arbitrary, unregistered, external filters. Allows the quick creation of filters using internal/proprietary filters without subtyping HDF5.Filters.Filter. Users are instead encouraged to define subtypes on HDF5.Filters.Filter.

Fields / Arguments

  • filter_id - (required) Integer filter identifer.
  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • name - (optional) String describing the name of the filter. Defaults to "Unknown Filter with id [filter_id]"
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See also:

flags bits

  • API.H5Z_FLAG_OPTIONAL
  • API.H5Z_FLAG_MANDATORY

config bits

  • API.H5Z_FILTER_CONFIG_ENCODE_ENABLED
  • API.H5Z_FILTER_CONFIG_DECODE_ENABLED
source

External Filter Packages

Several external Julia packages implement HDF5 filter plugins in Julia. As they are independent of HDF5.jl, they must be installed in order to use their plugins.

The H5Zbitshuffle.jl, H5Zblosc.jl, H5Zbzip2.jl, H5Zlz4.jl, and H5Zzstd.jl packages are maintained as independent subdirectory packages within the HDF5.jl repository.

H5Zblosc.jl

H5Zbzip2.jl

H5Zlz4.jl

H5Zzstd.jl

H5Zbitshuffle

H5Zbitshuffle.BitshuffleFilter — Type
BitshuffleFilter(blocksize=0,compressor=:none,comp_level=0)

The Bitshuffle filter can optionally include compression :lz4 or :zstd. For :zstd, comp_level determines the compression level: regular levels are 1 (fastest) to 22 (smallest); negative levels are faster still at the cost of compression. This is ignored for :lz4 compression. Like the C plugin, the level is stored as an unsigned integer, so comp_level % Cint recovers a negative level. If blocksize is zero the default bitshuffle blocksize is used.

source
H5Zbitshuffle.H5Zbitshuffle — Module

The bitshuffle filter for HDF5. See https://github.com/HDFGroup/hdf5_plugins/blob/master/docs/RegisteredFilterPlugins.md#bitshuffle and https://github.com/kiyo-masui/bitshuffle for details.

source

H5ZChunkCodecZstd.jl and H5ZChunkCodecBzip2.jl

H5ZChunkCodecZstd.jl and H5ZChunkCodecBzip2.jl implement the Zstandard and Bzip2 filters with ChunkCodecs.jl. They are alternatives to H5Zzstd.jl and H5Zbzip2.jl; see Multiple implementations of a filter below.

H5ZChunkCodecZstd.ChunkCodecZstdFilter — Type
ChunkCodecZstdFilter(clevel)

Zstandard compression filter (filter id 32015) implemented with ChunkCodecLibZstd. Uses the same cd_values as H5Zzstd.ZstdFilter, so data is interchangeable. clevel is the compression level; negative levels are faster at the cost of compression.

source
H5ZChunkCodecZstd.H5ZChunkCodecZstd — Module
H5ZChunkCodecZstd

The Zstandard HDF5 filter (id 32015) implemented with ChunkCodecs.jl.

This is an alternative to H5Zzstd. The data written is compatible with that package, and both can be loaded at the same time; see HDF5.Filters.set_priority! and the filter_priority preference of HDF5.jl for choosing which one libhdf5 uses. The provider name of this package is :H5ZChunkCodecZstd.

source
H5ZChunkCodecBzip2.ChunkCodecBzip2Filter — Type
ChunkCodecBzip2Filter(blockSize100k)

Bzip2 compression filter (filter id 307) implemented with ChunkCodecLibBzip2. Uses the same cd_values as H5Zbzip2.Bzip2Filter, so data is interchangeable.

source
H5ZChunkCodecBzip2.H5ZChunkCodecBzip2 — Module
H5ZChunkCodecBzip2

The Bzip2 HDF5 filter (id 307) implemented with ChunkCodecs.jl.

This is an alternative to H5Zbzip2. The data written is compatible with that package, and both can be loaded at the same time; see HDF5.Filters.set_priority! and the filter_priority preference of HDF5.jl for choosing which one libhdf5 uses. The provider name of this package is :H5ZChunkCodecBzip2.

source

H5ZzstdC.jl

H5ZzstdC.jl registers the native C implementation of the Zstandard filter, which is packaged as H5ZzstdC_jll, as an alternative to H5Zzstd.jl. The plugin is built against a specific HDF5_jll, so this package can only be installed with that version. See Multiple implementations of a filter below.

H5ZzstdC.ZstdCFilter — Type
ZstdCFilter(clevel)

Zstandard compression filter (filter id 32015) implemented by a native C plugin. Uses the same cd_values as H5Zzstd.ZstdFilter, so data is interchangeable. clevel is the compression level; negative levels are faster at the cost of compression.

source
H5ZzstdC.H5ZzstdC — Module
H5ZzstdC

The Zstandard HDF5 filter (id 32015) implemented by the native C plugin that H5ZzstdC_jll packages.

This is an alternative to H5Zzstd, which implements the filter in Julia. The data written is compatible with that package, and both can be loaded at the same time; see HDF5.Filters.set_priority! and the filter_priority preference of HDF5.jl for choosing which one libhdf5 uses. The provider name of this package is :H5ZzstdC.

Unlike a plugin that libhdf5 finds on HDF5_PLUGIN_PATH (the :native provider), this package registers the filter of the C plugin with libhdf5 itself, so it takes part in the priorities like the other filter packages and does not need a search path. Since the plugin is built against a specific HDF5_jll, this package can only be installed with that version.

source

Multiple implementations of a filter

libhdf5 holds a single function for each filter id, but a filter id may be implemented in several ways: by different Julia packages (for example H5Zzstd.jl, which uses CodecZstd.jl, H5ZzstdC.jl, which uses a C plugin, and H5ZChunkCodecZstd.jl, which uses ChunkCodecs.jl) or by a native plugin that libhdf5 loads itself from the HDF5_PLUGIN_PATH (for example plugins built from hdf5_plugins or distributed with NetCDF). All of these implementations can be loaded together. HDF5.jl keeps track of each implementation (a provider, named after its package, e.g. :H5Zzstd, or :native) and registers the one with the highest priority with libhdf5. The data written is the same regardless of which implementation runs, so files remain interchangeable.

By default, the implementation that was loaded first is used. A filter type such as ZstdFilter only describes the parameters of the filter; the implementation that runs is whichever is currently active for the filter id.

using HDF5, H5Zzstd, H5ZChunkCodecZstd
using HDF5.Filters

Filters.implementations(:zstd)       # H5Zzstd and H5ZChunkCodecZstd
Filters.active_implementation(:zstd) # :H5Zzstd
Filters.set_priority!(:zstd, :H5ZChunkCodecZstd, :H5Zzstd)
Filters.active_implementation(:zstd) # :H5ZChunkCodecZstd
Filters.set_priority!(:zstd, :native, :H5ZChunkCodecZstd) # prefer a plugin on HDF5_PLUGIN_PATH, if there is one

Filters can be referred to by id, by filter type, or by a name: :bzip2, :blosc, :lz4, :bitshuffle, or :zstd. A provider that is listed but unavailable is skipped, so a priority list may end with a fallback. Providers that are not listed are used after the listed ones, in the order they were loaded.

The :native provider relies on libhdf5 loading a plugin when it is asked whether a filter is available, which requires libhdf5 1.14 or later. With older libraries :native is never found, and the next provider is used.

Configuration with Preferences.jl

The priorities can be set persistently with Preferences.jl in the LocalPreferences.toml of the active project:

[HDF5]
# Which implementation to use, highest priority first. Keys are filter ids or names,
# "default" applies to every filter without its own entry.
filter_priority = { zstd = ["H5ZChunkCodecZstd", "H5Zzstd"], "32001" = ["native", "H5Zblosc"] }
# Providers that are never selected automatically
filter_disabled = ["H5Zbzip2"]
# Set to false to stop packages from registering their filters with libhdf5 when they are loaded.
# Nothing is registered until `Filters.activate_all!()` or `Filters.activate!` is called.
filter_auto_register = false

The same can be done from Julia with Preferences.set_preferences!(HDF5, "filter_priority" => Dict("zstd" => ["H5ZChunkCodecZstd"])). The preferences are read when HDF5.jl is loaded; Filters.load_preferences!() reads them again. Priorities set with Filters.set_priority! or Filters.activate! take precedence over the preferences.

Writing a filter package

A filter package defines a subtype of Filter and calls register_filter from its __init__. This records the filter as an implementation, with the name of the package defining the type as its provider, and registers it with libhdf5 unless another implementation takes priority. Use the provider keyword to choose another name.

HDF5.Filters.implementations — Function
implementations(id) -> Vector{Implementation}

The implementations of filter id (a filter id, type or name) that have been loaded, in order of loading.

source
HDF5.Filters.active_implementation — Function
active_implementation(id) -> Union{Symbol,Nothing}

The provider whose implementation of filter id is registered with libhdf5, :native if libhdf5 is using a plugin it loaded itself, or nothing if the Julia side has not registered the filter.

source
HDF5.Filters.priority — Function
priority(id) -> Vector{Symbol}

The configured provider priority for filter id (a filter id, type or name), highest first. Priorities set with set_priority! take precedence over the filter_priority preference, which has the filter's own entry take precedence over its "default" entry. Providers that are not listed are tried afterwards in the order they were loaded.

source
HDF5.Filters.set_priority! — Function
set_priority!(id, providers...)

Prefer the implementations of the filter id (a filter id, type or name such as :zstd) in the order given by providers, e.g. set_priority!(:zstd, :H5ZChunkCodecZstd, :native), and select the implementation accordingly. Use :native for plugins found by libhdf5 on HDF5_PLUGIN_PATH. This overrides the filter_priority preference until reset_priority!.

source
HDF5.Filters.activate! — Function
activate!(F::Type{<:Filter})
activate!(id, provider)

Make the implementation F, or the implementation of filter id from provider, the one that libhdf5 uses, regardless of priorities and of filter_auto_register. Use the provider :native to use a plugin that libhdf5 finds on HDF5_PLUGIN_PATH. The choice holds until the priorities change.

source
HDF5.Filters.activate_all! — Function
activate_all!()

Select an implementation for every loaded filter, ignoring filter_auto_register. Use this after loading packages when automatic registration is disabled.

source
HDF5.Filters.select_implementation! — Function
select_implementation!(id; force=false)

Register the highest priority available implementation of filter id with libhdf5. Nothing happens if filter_auto_register is false, unless force=true.

source
HDF5.Filters.load_preferences! — Function
load_preferences!()

(Re)read the filter settings from Preferences.jl and re-select the implementation of every filter id that has been registered. The recognized preferences of HDF5.jl are

  • filter_auto_register (Bool, default true): If false, implementations are recorded when their package is loaded but nothing is registered with libhdf5 until activate! or activate_all! is called.
  • filter_disabled (list of provider names): Providers that are never selected automatically, e.g. ["H5Zbzip2"].
  • filter_priority (table): Maps a filter id, a name from FILTER_NAMES, or "default" to a list of provider names in decreasing priority, e.g. zstd = ["H5ZChunkCodecZstd", "H5Zzstd"]. Use "native" to refer to a plugin found by libhdf5 on HDF5_PLUGIN_PATH.

Set them with, for example,

using Preferences, HDF5
set_preferences!(HDF5, "filter_priority" => Dict("zstd" => ["native", "H5Zzstd"]))

and restart Julia (or call HDF5.Filters.load_preferences!()).

source
HDF5.Filters.filter_id — Function
filter_id(x)

Resolve a filter id, a filter type, a filter name from FILTER_NAMES (such as :zstd), or a string containing an integer filter id to an API.H5Z_filter_t.

source
HDF5.Filters.NATIVE — Constant
NATIVE

The reserved provider name :native. It stands for the filter plugins that libhdf5 loads itself from HDF5_PLUGIN_PATH (for example plugins built from hdf5_plugins or shipped with NetCDF_jll). Place :native in a priority list to prefer such a plugin over a Julia implementation. This requires libhdf5 1.14 or later, which loads a plugin when it is asked whether a filter is available.

source
HDF5.Filters.Implementation — Type
Implementation

A record of one implementation of a filter id: the provider (by default the name of the package that defines the filter type, e.g. :H5Zzstd) and the Filter subtype type.

source

Other External Filters

Additional filters can be dynamically loaded by the HDF5 library. See External Links below for more information.

Using an ExternalFilter

ExternalFilter can be used to insert a dynamically loaded filter into the FilterPipeline in an ad-hoc fashion.

Example for bitshuffle

If we do not have a defined subtype of Filter for the bitshuffle filter we can create an ExternalFilter. From the header file or list of registered plugins, we see that the bitshuffle filter has an id of 32008.

Furthermore, the header describes two options:

  1. block_size (optional). Default is 0.
  2. compression - This can be 0 or BSHUF_H5_COMPRESS_LZ4 (2 as defined in the C header)
using HDF5.Filters

bitshuf = ExternalFilter(32008, Cuint[0, 0])
bitshuf_comp = ExternalFilter(32008, Cuint[0, 2])

data_A = rand(0:31, 1024)
data_B = rand(32:63, 1024)

filename, _ = mktemp()
h5open(filename, "w") do h5f
    # Indexing style
    h5f["ex_data_A", chunk=(32,), filters=bitshuf] = data_A
    # Procedural style
    d, dt = create_dataset(h5f, "ex_data_B", data_B, chunk=(32,), filters=[bitshuf_comp])
    write(d, data_B)
end

Registered Filter Helpers

The HDF Group maintains a list of registered filters which have been assigned a filter ID number. The module Filters.Registered contains information about registered filters including functions to create an ExternalFilter for each registered filter.

Creating a new Filter type

Examining the bitshuffle filter source code we see that three additional data components get prepended to the options. These are

  1. The major version
  2. The minor version
  3. The element size in bytes of the type via H5Tget_size.
import HDF5.Filters: FILTERS, Filter, FilterPipeline, filterid
using HDF5.API

const H5Z_BSHUF_ID = API.H5Z_filter_t(32008)
struct BitShuffleFilter <: HDF5.Filters.Filter
    major::Cuint
    minor::Cuint
    elem_size::Cuint
    block_size::Cuint
    compression::Cuint
    BitShuffleFilter(block_size, compression) = new(0, 0, 0, block_size, compression)
end
# filterid is the only required method of the filter interface
# since we are using an externally registered filter
filterid(::Type{BitShuffleFilter}) = H5Z_BSHUF_ID
FILTERS[H5Z_BSHUF_ID] = BitShuffleFilter

function Base.push!(p::FilterPipeline, f::BitShuffleFilter)
    ref = Ref(f)
    GC.@preserve ref begin
        API.h5p_set_filter(p.plist, H5Z_BSHUF_ID, API.H5Z_FLAG_OPTIONAL, 2, pointer_from_objref(ref) + sizeof(Cuint)*3)
    end
    return p
end

Because the first three elements are not provided directly via h5p_set_filter, we also needed to implement a custom Base.push! into the FilterPipeline.

Filter Interface

The filter interface is used to describe filters and obtain information on them.

HDF5.Filters.Filter — Type
Filter

Abstract type to describe HDF5 Filters. See the Extended Help for information on implementing a new filter.

Extended Help

Filter interface

The Filter interface is implemented upon the Filter subtype.

See API.h5z_register for details.

Required Methods to Implement

  • filterid - registered filter ID
  • filter_func - implement the actual filter

Optional Methods to Implement

  • filtername - defaults to "Unnamed Filter"
  • encoder_present - defaults to true
  • decoder_present - defaults to true
  • can_apply_func - defaults to nothing
  • set_local_func - defaults to nothing

Advanced Methods to Implement

  • can_apply_cfunc - Defaults to wrapping @cfunction around the result of can_apply_func
  • set_local_cfunc - Defaults to wrapping @cfunction around the result of set_local_func
  • filter_cfunc - Defaults to wrapping @cfunction around the result of filter_func
  • register_with_hdf5 - Defaults to using the above functions to register the filter with libhdf5. register_filter records the filter as an implementation and selects the one to register; see set_priority!.

Implement the Advanced Methods to avoid @cfunction from generating a runtime closure which may not work on all systems.

source
HDF5.Filters.FilterPipeline — Type
FilterPipeline(plist::DatasetCreateProperties)

The filter pipeline associated with plist. Acts like a AbstractVector{Filter}, supporting the following operations:

  • length(pipeline): the number of filters.
  • pipeline[i] to return the ith filter.
  • pipeline[FilterType] to return a filter of type FilterType
  • push!(pipline, filter) to add an extra filter to the pipeline.
  • append!(pipeline, filters) to add multiple filters to the pipeline.
  • delete!(pipeline, FilterType) to remove a filter of type FilterType from the pipeline.
  • empty!(pipeline) to remove all filters from the pipeline.
source
HDF5.Filters.isavailable — Function
isavailable(filter_or_id)

Given a subtype of Filters.Filter or the filter ID number as an integer, return true if the filter is available and false otherwise.

source
HDF5.Filters.isdecoderenabled — Function
isdecoderenabled(filter_or_id)

Given a subtype of Filters.Filter or the filter ID number as an integer, return true if the filter can decode or decompress data.

source
HDF5.Filters.isencoderenabled — Function
isencoderenabled(filter_or_id)

Given a subtype of Filters.Filter or the filter ID number as an integer, return true if the filter can encode or compress data.

source
HDF5.Filters.can_apply_func — Function
can_apply_func(::Type{F}) where {F<:Filter}

Return a function indicating whether the filter can be applied or nothing if no function exists. The function signature is func(dcpl_id::API.hid_t, type_id::API.hid_t, space_id::API.hid_t). See API.h5z_register

source
HDF5.Filters.can_apply_cfunc — Function
can_apply_cfunc(::Type{F}) where {F<:Filter}

Return a C function pointer for the can apply function. By default, this will return the result of using @cfunction on the function specified by can_apply_func(F) or C_NULL if nothing.

Overriding this will allow @cfunction to return a Ptr{Nothing} rather than a CFunction` closure which may not work on all systems.

source
HDF5.Filters.set_local_func — Function
set_local_func(::Type{F}) where {F<:Filter}

Return a function that sets dataset specific parameters or nothing if no function exists. The function signature is func(dcpl_id::API.hid_t, type_id::API.hid_t, space_id::API.hid_t). See API.h5z_register.

source
HDF5.Filters.set_local_cfunc — Function
set_local_cfunc(::Type{F}) where {F<:Filter}

Return a C function pointer for the set local function. By default, this will return the result of using @cfunction on the function specified by set_local_func(F) or C_NULL if nothing.

Overriding this will allow @cfunction to return a Ptr{Nothing} rather than a CFunction` closure which may not work on all systems.

source
HDF5.Filters.filter_cfunc — Function
filter_cfunc(::Type{F}) where {F<:Filter}

Return a C function pointer for the filter function. By default, this will return the result of using @cfunction on the function specified by filter_func(F) or will throw an error if nothing.

Overriding this will allow @cfunction to return a Ptr{Nothing} rather than a CFunction` closure which may not work on all systems.

source
HDF5.Filters.register_filter — Function
register_filter(::Type{F}; provider=Symbol(parentmodule(F))) where F <: Filter

Make the filter type F available as an implementation of its filter id and, unless a higher priority implementation exists or automatic registration is disabled, register it with the HDF5 library via API.h5z_register. Also add F to the FILTERS dictionary if it becomes the active implementation.

Filter packages call this from __init__. Several packages may implement the same filter id; see set_priority! and load_preferences! for choosing which one is used.

source

Registered Filters

HDF5.Filters.Registered — Module
HDF5.Filters.Registered

Module containing convenience methods to create ExternalFilter instances of HDF5 registered filters.

This module does not implement any filter or guarantee filter availability. Rather the functions within this module create ExternalFilter instances for convenience. These instances can be used to determine if a filter is available. They can also be incorporated as part of a filter pipeline.

Examine REGISTERED_FILTERS, a Dict{H5Z_filter_t, Function}, for a list of filter functions contained within this module, which are exported.

julia> foreach(println, sort(collect(values(HDF5.Filters.Registered.REGISTERED_FILTERS)); by=string));
APAXFilter
BLOSC2Filter
BLOSCFilter
BZIP2Filter
BitGroomFilter
B³DFilter
CBFFilter
CCSDS_123Filter
Delta_RiceFilter
FAPECFilter
FCIDECOMPFilter
FLACFilter
Granular_BitRoundFilter
JPEGFilter
JPEG_LSFilter
JPEG_XRFilter
LPC_RiceFilter
LZ4Filter
LZFFilter
LZOFilter
MAFISCFilter
SPDPFilter
SZ3Filter
SZFilter
SnappyFilter
VBZFilter
ZstandardFilter
bitshuffleFilter
fpzipFilter
zfpFilter
source
HDF5.Filters.Registered.APAXFilter — Function
APAXFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
APAXFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for APAX with filter id 32005. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.BLOSC2Filter — Function
BLOSC2Filter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
BLOSC2Filter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for BLOSC2 with filter id 32026. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.BLOSCFilter — Function
BLOSCFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
BLOSCFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for BLOSC with filter id 32001. Users are instead encouraged to use the Julia package H5Zblosc.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.BZIP2Filter — Function
BZIP2Filter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
BZIP2Filter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for BZIP2 with filter id 307. Users are instead encouraged to use the Julia package H5Zbzip2.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.BitGroomFilter — Function
BitGroomFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
BitGroomFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for BitGroom with filter id 32022. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.B³DFilter — Function
B³DFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
B³DFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for B³D with filter id 32016. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.CBFFilter — Function
CBFFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
CBFFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for CBF with filter id 32006. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.CCSDS_123Filter — Function
CCSDS_123Filter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
CCSDS_123Filter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for CCSDS_123 with filter id 32011. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.Delta_RiceFilter — Function
Delta_RiceFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
Delta_RiceFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for Delta_Rice with filter id 32025. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.FAPECFilter — Function
FAPECFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
FAPECFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for FAPEC with filter id 32021. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.FCIDECOMPFilter — Function
FCIDECOMPFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
FCIDECOMPFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for FCIDECOMP with filter id 32018. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.FLACFilter — Function
FLACFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
FLACFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for FLAC with filter id 32027. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.Granular_BitRoundFilter — Function
Granular_BitRoundFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
Granular_BitRoundFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for Granular_BitRound with filter id 32023. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.JPEGFilter — Function
JPEGFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
JPEGFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for JPEG with filter id 32019. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.JPEG_LSFilter — Function
JPEG_LSFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
JPEG_LSFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for JPEG_LS with filter id 32012. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.JPEG_XRFilter — Function
JPEG_XRFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
JPEG_XRFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for JPEG_XR with filter id 32007. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.LPC_RiceFilter — Function
LPC_RiceFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
LPC_RiceFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for LPC_Rice with filter id 32010. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.LZ4Filter — Function
LZ4Filter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
LZ4Filter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for LZ4 with filter id 32004. Users are instead encouraged to use the Julia package H5Zlz4.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.LZFFilter — Function
LZFFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
LZFFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for LZF with filter id 32000. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.LZOFilter — Function
LZOFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
LZOFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for LZO with filter id 305. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.MAFISCFilter — Function
MAFISCFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
MAFISCFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for MAFISC with filter id 32002. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.SPDPFilter — Function
SPDPFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
SPDPFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for SPDP with filter id 32009. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.SZ3Filter — Function
SZ3Filter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
SZ3Filter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for SZ3 with filter id 32024. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.SZFilter — Function
SZFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
SZFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for SZ with filter id 32017. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.SnappyFilter — Function
SnappyFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
SnappyFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for Snappy with filter id 32003. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.VBZFilter — Function
VBZFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
VBZFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for VBZ with filter id 32020. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.ZstandardFilter — Function
ZstandardFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
ZstandardFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for Zstandard with filter id 32015. Users are instead encouraged to use the Julia package H5Zzstd.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.bitshuffleFilter — Function
bitshuffleFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
bitshuffleFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for bitshuffle with filter id 32008. Users are instead encouraged to use the Julia package H5Zbitshuffle.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.fpzipFilter — Function
fpzipFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
fpzipFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for fpzip with filter id 32014. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source
HDF5.Filters.Registered.zfpFilter — Function
zfpFilter(flags=API.H5Z_FLAG_MANDATORY, data::AbstractVector{<: Integer}=Cuint[], config::Cuint=0)
zfpFilter(flags=API.H5Z_FLAG_MANDATORY, data::Integer...)

Create an ExternalFilter for zfp with filter id 32013. Users should consider defining a subtype of Filter to specify the data.

Fields / Arguments

  • flags - (optional) bit vector describing general properties of the filter. Defaults to API.H5Z_FLAG_MANDATORY
  • data - (optional) auxillary data for the filter. See cd_values. Defaults to Cuint[]
  • config - (optional) bit vector representing information about the filter regarding whether it is able to encode data, decode data, neither, or both. Defaults to 0.

See ExternalFilter for valid argument values.

source