feat: implement compression stream in c++

example/ios/Podfile.lock

@@ -1764,7 +1764,7 @@ EXTERNAL SOURCES:
 SPEC CHECKSUMS:
   boost: 1dca942403ed9342f98334bf4c3621f011aa7946
   DoubleConversion: f16ae600a246532c4020132d54af21d0ddb2a385
-  FastIO: 120a9c95af04ba7671b95aa2b5862f64a59a47bf
+  FastIO: 58c29380cf3ea0dfc4e65554dfa51a43a1468b9a
   FBLazyVector: aa59bef5c46e93168bffcf3dc37ee1e176de799a
   fmt: 10c6e61f4be25dc963c36bd73fc7b1705fe975be
   glog: 08b301085f15bcbb6ff8632a8ebaf239aae04e6a

example/server/createServer.ts

@@ -20,7 +20,7 @@ export function createServer(payload: string | Bun.BufferSource, port: number) {
             return new Response('No body provided', { status: 400 })
           }
 
-          const writer = Bun.file('uploaded_file').writer()
+          const writer = Bun.file('uploaded_file.jpg.gz').writer()
 
           for await (const chunk of req.body) {
             // Write each chunk to file

packages/react-native-fast-io/FastIO.podspec

@@ -14,7 +14,8 @@ Pod::Spec.new do |s|
   s.source       = { :git => "https://github.com/grabbou/react-native-fast-io.git", :tag => "#{s.version}" }
 
   s.source_files = [
-    "ios/**/*.{h,m,swift}"
+    "ios/**/*.{h,m,swift}",
+    "cpp/**/*.{h,hpp,cpp}"
   ]
 
   s.pod_target_xcconfig = {

packages/react-native-fast-io/android/CMakeLists.txt

@@ -8,6 +8,8 @@ set (CMAKE_CXX_STANDARD 20)
 # Define C++ library and add all sources
 add_library(${PACKAGE_NAME} SHARED
         src/main/cpp/cpp-adapter.cpp
+        ../cpp/HybridCompressor.cpp
+        ../cpp/HybridCompressorFactory.cpp
 )
 
 # Add Nitrogen specs :)
@@ -16,14 +18,17 @@ include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/FastIO+autolinking.cma
 # Set up local includes
 include_directories(
         "src/main/cpp"
-        # "../cpp"
+        "../cpp"
 )
 
+find_package(ZLIB REQUIRED)
 find_library(LOG_LIB log)
 
 # Link all libraries together
 target_link_libraries(
         ${PACKAGE_NAME}
         ${LOG_LIB}
+        ${ZLIB_LIBRARIES}
         android                                   # <-- Android core
 )
+

packages/react-native-fast-io/cpp/HybridCompressor.cpp

@@ -0,0 +1,76 @@
+#include "HybridCompressor.hpp"
+#include <stdexcept>
+#include <iostream>
+
+namespace margelo::nitro::fastio {
+
+HybridCompressor::HybridCompressor(CompressionAlgorithm algorithm) : HybridObject(TAG), format_(algorithm) {
+  std::cout << "Initializing compressor with algorithm: " << static_cast<int>(algorithm) << std::endl;
+
+  stream_.zalloc = Z_NULL;
+  stream_.zfree = Z_NULL;
+  stream_.opaque = Z_NULL;
+
+  int windowBits = 15;
+  switch (algorithm) {
+    case CompressionAlgorithm::GZIP:
+      windowBits += 16;
+      break;
+    case CompressionAlgorithm::DEFLATE_RAW:
+      windowBits = -windowBits;
+      break;
+    default:
+      break;
+  }
+
+  if (deflateInit2(&stream_, Z_DEFAULT_COMPRESSION, Z_DEFLATED, windowBits, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
+    throw std::runtime_error("Failed to initialize compression");
+  }
+}
+
+HybridCompressor::~HybridCompressor() {
+  deflateEnd(&stream_);
+}
+
+std::shared_ptr<ArrayBuffer> HybridCompressor::compressBuffer(const uint8_t* source, size_t sourceSize, bool finalize) {
+  uint8_t* destBuffer = new uint8_t[64 * 1024];
+
+  stream_.next_in = const_cast<Bytef*>(source);
+  stream_.avail_in = sourceSize;
+  stream_.next_out = destBuffer;
+  stream_.avail_out = 64 * 1024;
+
+  int status = deflate(&stream_, finalize ? Z_FINISH : Z_NO_FLUSH);
+
+  if (status == Z_STREAM_ERROR) {
+    delete[] destBuffer;
+    throw std::runtime_error("Compression error");
+  }
+
+  if (stream_.avail_in != 0) {
+    delete[] destBuffer;
+    throw std::runtime_error("Unexpected remaining input data");
+  }
+
+  size_t currentOffset = 64 * 1024 - stream_.avail_out;
+
+  return ArrayBuffer::makeBuffer(
+                                 destBuffer,
+                                 currentOffset,
+                                 [=] { delete[] destBuffer; }
+                                 );
+}
+
+std::shared_ptr<ArrayBuffer> HybridCompressor::compress(const std::shared_ptr<ArrayBuffer>& chunk) {
+  return compressBuffer(
+                        chunk->data(),
+                        chunk->size()
+                        );
+}
+
+std::shared_ptr<ArrayBuffer> HybridCompressor::finalize() {
+  static const uint8_t dummyByte = 0;
+  return compressBuffer(&dummyByte, 0, true);
+}
+
+}

packages/react-native-fast-io/cpp/HybridCompressor.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <zlib.h>
+
+#include "HybridCompressorSpec.hpp"
+#include "CompressionAlgorithm.hpp"
+
+namespace margelo::nitro::fastio {
+
+  class HybridCompressor : public HybridCompressorSpec {
+  public:
+    explicit HybridCompressor(CompressionAlgorithm algorithm);
+    ~HybridCompressor();
+
+    std::shared_ptr<ArrayBuffer> compress(const std::shared_ptr<ArrayBuffer>& chunk);
+    std::shared_ptr<ArrayBuffer> finalize();
+
+  private:
+    std::shared_ptr<ArrayBuffer> compressBuffer(const uint8_t* source, size_t sourceSize, bool finalize = false);
+
+    z_stream stream_{};
+    CompressionAlgorithm format_;
+
+    static const std::array<uint32_t, 256> CRC_TABLE;
+  };
+
+}

packages/react-native-fast-io/cpp/HybridCompressorFactory.cpp

@@ -0,0 +1,11 @@
+#include "HybridCompressorFactory.hpp"
+#include "HybridCompressor.hpp"
+#include <stdexcept>
+
+namespace margelo::nitro::fastio {
+
+std::shared_ptr<HybridCompressorSpec> HybridCompressorFactory::create(CompressionAlgorithm algorithm) {
+  return std::make_shared<HybridCompressor>(algorithm);
+}
+
+}

packages/react-native-fast-io/cpp/HybridCompressorFactory.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <memory>
+#include "HybridCompressorFactorySpec.hpp"
+#include "HybridCompressor.hpp"
+
+namespace margelo::nitro::fastio {
+
+class HybridCompressorFactory : public HybridCompressorFactorySpec {
+public:
+  HybridCompressorFactory() : HybridObject(TAG) {}
+
+  std::shared_ptr<HybridCompressorSpec> create(CompressionAlgorithm algorithm) override;
+};
+
+}