remove chunkbuffer as variable

Author: patrick-zippenfenig

Sources/OmFileFormatSwift/OmFileFormat.swift

@@ -575,12 +575,11 @@ public final class OmFileReader<Backend: OmFileReaderBackend> {
     /// Future implementations could use async io via lib uring
     ///
     /// `into` is a 2d flat array with `arrayDim1Length` count elements in the fast dimension
-    /// `chunkBuffer` is used to temporary decompress chunks of data
     /// `arrayDim1Range` defines the offset in dimension 1 what is applied to the read into array
     /// `arrayDim1Length` if dim0Slow.count is greater than 1, the arrayDim1Length will be used as a stride. Like `nTime` in a 2d fast time array
     /// `dim0Slow` the slow dimension to read. Typically a location range
     /// `dim1Read` the fast dimension to read. Typical a time range
-    public func read(into: UnsafeMutablePointer<Float>, arrayDim1Range: Range<Int>, arrayDim1Length: Int, chunkBuffer: UnsafeMutableRawPointer, dim0Slow dim0Read: Range<Int>, dim1 dim1Read: Range<Int>) throws {
+    public func read(into: UnsafeMutablePointer<Float>, arrayDim1Range: Range<Int>, arrayDim1Length: Int, dim0Slow dim0Read: Range<Int>, dim1 dim1Read: Range<Int>) throws {
 
         //assert(arrayDim1Range.count == dim1Read.count)
 
@@ -622,17 +621,7 @@ public final class OmFileReader<Backend: OmFileReaderBackend> {
             guard error == ERROR_OK else {
                 throw OmFileFormatSwiftError.omDecoder(error: String(cString: om_error_string(error)))
             }
-            try reader.fn.decode(decoder: &decoder, into: into, chunkBuffer: chunkBuffer)
-        }
-    }
-    
-    /// Read data into existing output float buffer. Allocate buffer on demand
-    public func read(into: UnsafeMutablePointer<Float>, arrayDim1Range: Range<Int>, arrayDim1Length: Int, dim0Slow dim0Read: Range<Int>, dim1 dim1Read: Range<Int>) throws {
-        //assert(arrayDim1Range.count == dim1Read.count)
-        let bufferSize = P4NDEC256_BOUND(n: chunk0*chunk1, bytesPerElement: compression.bytesPerElement)
-        try withUnsafeTemporaryAllocation(byteCount: bufferSize, alignment: 4) { buffer in
-            try read(into: into, arrayDim1Range: arrayDim1Range, arrayDim1Length: arrayDim1Length, chunkBuffer: buffer.baseAddress!, dim0Slow: dim0Read, dim1: dim1Read)
-            
+            try reader.fn.decode(decoder: &decoder, into: into)
         }
     }
 

Sources/OmFileFormatSwift/OmFileReader2.swift

@@ -219,10 +219,7 @@ public struct OmFileReader2Array<Backend: OmFileReaderBackend, OmType: OmFileArr
                         guard error == ERROR_OK else {
                             throw OmFileFormatSwiftError.omDecoder(error: String(cString: om_error_string(error)))
                         }
-                        let chunkBufferSize = om_decoder_read_buffer_size(&decoder)
-                        let chunkBuffer = UnsafeMutableRawBufferPointer.allocate(byteCount: Int(chunkBufferSize), alignment: 1)
-                        try fn.decode(decoder: &decoder, into: into, chunkBuffer: chunkBuffer.baseAddress!)
-                        chunkBuffer.deallocate()
+                        try fn.decode(decoder: &decoder, into: into)
                     })
                 })
             })
@@ -267,30 +264,34 @@ public struct OmFileReader2Array<Backend: OmFileReaderBackend, OmType: OmFileArr
 
 extension OmFileReaderBackend {
     /// Read and decode
-    func decode(decoder: UnsafePointer<OmDecoder_t>, into: UnsafeMutableRawPointer, chunkBuffer: UnsafeMutableRawPointer) throws {
+    func decode(decoder: UnsafePointer<OmDecoder_t>, into: UnsafeMutableRawPointer) throws {
         var indexRead = OmDecoder_indexRead_t()
         om_decoder_init_index_read(decoder, &indexRead)
 
-        /// Loop over index blocks and read index data
-        while om_decoder_next_index_read(decoder, &indexRead) {
-            //print("Read index \(indexRead)")
-            let indexData = self.getData(offset: Int(indexRead.offset), count: Int(indexRead.count))
-            
-            var dataRead = OmDecoder_dataRead_t()
-            om_decoder_init_data_read(&dataRead, &indexRead)
-            
-            var error: OmError_t = ERROR_OK
-            /// Loop over data blocks and read compressed data chunks
-            while om_decoder_next_data_read(decoder, &dataRead, indexData, indexRead.count, &error) {
-                //print("Read data \(dataRead) for chunk index \(dataRead.chunkIndex)")
-                let dataData = self.getData(offset: Int(dataRead.offset), count: Int(dataRead.count))
-                guard om_decoder_decode_chunks(decoder, dataRead.chunkIndex, dataData, dataRead.count, into, chunkBuffer, &error) else {
+        /// The size to decode a single chunk
+        let bufferSize = om_decoder_read_buffer_size(decoder)
+        try withUnsafeTemporaryAllocation(byteCount: Int(bufferSize), alignment: 1) { buffer in
+            /// Loop over index blocks and read index data
+            while om_decoder_next_index_read(decoder, &indexRead) {
+                //print("Read index \(indexRead)")
+                let indexData = self.getData(offset: Int(indexRead.offset), count: Int(indexRead.count))
+                
+                var dataRead = OmDecoder_dataRead_t()
+                om_decoder_init_data_read(&dataRead, &indexRead)
+                
+                var error: OmError_t = ERROR_OK
+                /// Loop over data blocks and read compressed data chunks
+                while om_decoder_next_data_read(decoder, &dataRead, indexData, indexRead.count, &error) {
+                    //print("Read data \(dataRead) for chunk index \(dataRead.chunkIndex)")
+                    let dataData = self.getData(offset: Int(dataRead.offset), count: Int(dataRead.count))
+                    guard om_decoder_decode_chunks(decoder, dataRead.chunkIndex, dataData, dataRead.count, into, buffer.baseAddress, &error) else {
+                        throw OmFileFormatSwiftError.omDecoder(error: String(cString: om_error_string(error)))
+                    }
+                }
+                guard error == ERROR_OK else {
                     throw OmFileFormatSwiftError.omDecoder(error: String(cString: om_error_string(error)))
                 }
             }
-            guard error == ERROR_OK else {
-                throw OmFileFormatSwiftError.omDecoder(error: String(cString: om_error_string(error)))
-            }
         }
     }