zstd

algo: compression_algorithm private var isInitialized = false init(algorithm: compression_algorithm = COMPRESSION_LZFSE) { self.algo = algorithm } func append(_ input: Data, isFinal: Bool, outChunkSize: Int = 64 * 1024) -> [Data] { if !isInitialized { let status = compression_stream_init(&stream, COMPRESSION_STREAM_ENCODE, algo) precondition(status != COMPRESSION_STATUS_ERROR, "compression_stream_init failed") isInitialized = true } var outputs: [Data] = [] input.withUnsafeBytes { (srcBuf: UnsafeRawBufferPointer) in var flags: Int32 = isFinal ? Int32(COMPRESSION_STREAM_FINALIZE.rawValue) : 0 stream.src_ptr = srcBuf.bindMemory(to: UInt8.self).baseAddress stream.src_size = srcBuf.count var out = Data(count: outChunkSize) out.withUnsafeMutableBytes { dstBuf in while true { stream.dst_ptr = dstBuf.bindMemory(to: UInt8.self).baseAddress stream.dst_size = dstBuf.count let status = compression_stream_process(&stream, flags) let produced = dstBuf.count - stream.dst_size if produced > 0 { outputs.append(Data(bytes: dstBuf.baseAddress!, count: produced)) } if status == COMPRESSION_STATUS_OK && stream.src_size == 0 && stream.dst_size > 0 { break // need more input to continue } else if status == COMPRESSION_STATUS_OK && stream.dst_size == 0 { // output buffer filled; loop to drain more continue } else if status == COMPRESSION_STATUS_END { break } else if status == COMPRESSION_STATUS_ERROR { preconditionFailure("compression_stream_process failed") } else { // Shouldn’t happen break } } } } return outputs } deinit { if isInitialized { compression_stream_destroy(&stream) } } } ``` Usage: ```swift let compressor = StreamCompressor(algorithm: COMPRESSION_LZFSE) var compressed: [Data] = [] for (i, chunk) in chunks.enumerated() { let final = i == chunks.count - 1 compressed.append(contentsOf: compressor.append(chunk, isFinal: final)) } // `compressed` now contains the zstd-adjacent (LZFSE) stream ``` If you truly need the ZSTD format (interop requirement), you’ll have to ship the reference C library (`libzstd`) in your app (static link it and call through a tiny Swift wrapper). That’s still “third-party,” even if you vendor the sources instead of using SPM/CocoaPods. There is no system-provided ZSTD on iOS today. ([GitHub][3]) tl;dr: iOS doesn’t expose ZSTD. Use `Compression` with LZFSE for built-in streaming, or vendor `libzstd` and bridge to it if you must emit/ingest ZSTD. ([Microsoft Learn][1], [Apple Developer][2], [GitHub][3]) [1]: https://learn.microsoft.com/en-us/dotnet/api/compression.com... "CompressionAlgorithm Enum (Compression)" [2]: https://developer.apple.com/documentation/compression/compre... "COMPRESSION_LZFSE | Apple Developer Documentation" [3]: https://github.com/facebook/zstd?utm_source=chatgpt.com "facebook/zstd: Zstandard - Fast real-time compression ..."

ctions only allow basic things. After looking closer at the upstream implementation, I noticed that is uses functions of the core API that are now deprecated and it doesn't allow access to low-level (de)compression contexts. To me it looks like a PoC/demo implementation that isn't maintained the same way as the zstd core API, probably that's also the reason it's in the contrib directory. My use-case seemed to require a complete rewrite of the seekable format, so I decided to implement it from scratch in Rust using bindings to the advanced zstd compression API, available from zstd 1.4.0. The result is a single dependency library crate[2], and a CLI crate[3] for the seekable format that feels similar to the regular zstd tool. Any feedback is highly appreciated! [1]: https://github.com/facebook/zstd/tree/dev/contrib/seekable_f... [2]: https://crates.io/crates/zeekstd [3]: https://github.com/rorosen/zeekstd/tree/main/cli