react-native-tiny-wavpack-decoder 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 Jairaj Jangle
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,148 @@
+# react-native-tiny-wavpack-decoder
+
+A lightweight React Native Turbo Module for decoding WavPack audio files to WAV format on iOS and Android. Built with the New Architecture for optimal performance, this module supports progress updates during decoding and is designed for seamless integration into React Native apps.
+
+## Features
+- Decode WavPack (.wv) files to WAV format.
+- Cross-platform support for iOS (13.0+) and Android (API 21+).
+- Progress updates via event emitter for real-time feedback.
+- Configurable decoding options (e.g., max samples, bits per sample.
+- Thread-safe decoding on iOS with concurrent queue support.
+
+## Requirements
+- React Native 0.75 or higher with New Architecture enabled.
+- iOS 13.0 or later.
+- Android API 21 or later.
+- Node.js 16+ for development.
+
+## Installation
+
+1. **Install the package**:
+   
+   Using yarn:
+   
+   ```bash
+   yarn add react-native-tiny-wavpack-decoder
+   ```
+   
+   using npm:
+   
+   ```bash
+   npm install react-native-tiny-wavpack-decoder
+   ```
+
+2. **Link native dependencies**:
+
+   - For iOS, install CocoaPods dependencies:
+     ```bash
+     cd ios && pod install
+     ```
+   - For Android, the module is auto-linked via React Native.
+
+3. **Enable New Architecture** (if not already enabled):
+   - In `ios/Podfile`, ensure:
+     ```ruby
+     use_react_native!(
+       :path => '../node_modules/react-native',
+       :new_architecture => true
+     )
+     ```
+   - In `android/app/build.gradle`, enable Turbo Modules:
+     ```gradle
+     newArchEnabled=true
+     ```
+
+4. **Rebuild the app**:
+   ```bash
+   npx react-native run-ios
+   # or
+   npx react-native run-android
+   ```
+
+## Usage
+
+### Basic Decoding
+Decode a WavPack file to WAV using the `decode` method. The module requires file paths accessible by the app (e.g., in the document directory).
+
+```typescript
+import TinyWavPackDecoder from 'react-native-tiny-wavpack-decoder';
+import * as RNFS from '@dr.pogodin/react-native-fs';
+
+const decodeWavPack = async () => {
+  const inputPath = `${RNFS.DocumentDirectoryPath}/sample.wv`; // Ensure file exists
+  const outputPath = `${RNFS.DocumentDirectoryPath}/output.wav`;
+
+  try {
+    const result = await TinyWavPackDecoder.decode(inputPath, outputPath, {
+      maxSamples: -1, // Decode all samples
+      bitsPerSample: 16, // Output bit depth (8, 16, 24, or 32)
+    });
+    console.log('Decode result:', result); // "Success"
+  } catch (error) {
+    console.error('Decode error:', error.message);
+  }
+};
+```
+
+### Progress Updates
+Subscribe to decoding progress events (0.0 to 1.0) using `addProgressListener`. 
+
+```typescript
+import { useEffect } from 'react';
+import TinyWavPackDecoder from 'react-native-tiny-wavpack-decoder';
+
+const App = () => {
+  useEffect(() => {
+    const subscription = TinyWavPackDecoder.addProgressListener((progress) => {
+      console.log(`Progress: ${(progress * 100).toFixed(2)}%`);
+    });
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+
+  // Trigger decodeWavPack() as shown above
+};
+```
+
+### Options
+The `decode` method accepts an options object with the following properties:
+
+| Option          | Type                     | Default | Description                                                                 |
+|-----------------|--------------------------|---------|-----------------------------------------------------------------------------|
+| `maxSamples`    | `number`                | `-1`    | Maximum number of samples to decode. Use `-1` for all samples.              |
+| `bitsPerSample` | `8 | 16 | 24 | 32`   | `16`    | Output bit depth. Must be 8, 16, 24, or 32.                                 |
+
+### Example App
+The `example/` directory contains a sample app demonstrating decoding and progress updates. To run it:
+
+```bash
+cd example
+npm install
+npm run ios
+# or
+npm run android
+```
+
+Place a `sample.wv` file in the app’s document directory (e.g., via `RNFS.DocumentDirectoryPath`).
+
+## Notes
+- **File Access**: Ensure input and output paths are valid and accessible. Use libraries like `@dr.pogodin/react-native-fs` to manage files.
+- **Thread Safety**: iOS uses a concurrent dispatch queue for decoding, but rapid concurrent calls may require additional thread-safety measures (see Limitations).
+- **Progress Events**: Ensure listeners are set up before starting decoding.
+- **New Architecture**: This module requires Turbo Modules and the New Architecture. Ensure your app is configured accordingly.
+
+## Limitations
+- The module uses a static `FILE*` in the C code, which may cause crashes if multiple decoding operations are triggered concurrently. A thread-safe version is planned (see [issue #TBD]).
+- Progress updates are tied to the decoding buffer size (4096 samples), which may result in coarse-grained updates for small files.
+- Android performance may vary on low-end devices due to JNI overhead.
+
+## Contributing
+Contributions are welcome! Please open an issue or pull request on the [GitHub repository](https://github.com/JairajJangle/react-native-tiny-wavpack-decoder) for bugs, features, or improvements.
+
+## License
+MIT License. See [LICENSE](LICENSE) for details.
+
+## Acknowledgments
+- Built with [WavPack](https://www.wavpack.com/)'s Tiny Decoder source for efficient audio decoding.
+- Uses React Native’s New Architecture for modern performance.

package/android/build.gradle

@@ -0,0 +1,112 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['TinyWavPackDecoder_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["TinyWavPackDecoder_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.tinywavpackdecoder"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+        cmake {
+            arguments "-DANDROID_STL=c++_shared"
+        }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+        path "src/main/cpp/CMakeLists.txt"
+    }
+}
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}
+
+react {
+  jsRootDir = file("../src/")
+  libraryName = "TinyWavPackDecoder"
+  codegenJavaPackageName = "com.tinywavpackdecoder"
+}

package/android/generated/java/com/tinywavpackdecoder/NativeTinyWavPackDecoderSpec.java

@@ -0,0 +1,47 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.tinywavpackdecoder;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public abstract class NativeTinyWavPackDecoderSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "TinyWavPackDecoderModule";
+
+  public NativeTinyWavPackDecoderSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void decodeWavPack(String inputPath, String outputPath, @Nullable Double maxSamples, @Nullable Double bitsPerSample, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void addListener(String eventType);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void removeListeners(double count);
+}

package/android/generated/jni/CMakeLists.txt

@@ -0,0 +1,36 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+file(GLOB react_codegen_SRCS CONFIGURE_DEPENDS *.cpp react/renderer/components/RNTinyWavPackDecoderSpec/*.cpp)
+
+add_library(
+  react_codegen_RNTinyWavPackDecoderSpec
+  OBJECT
+  ${react_codegen_SRCS}
+)
+
+target_include_directories(react_codegen_RNTinyWavPackDecoderSpec PUBLIC . react/renderer/components/RNTinyWavPackDecoderSpec)
+
+target_link_libraries(
+  react_codegen_RNTinyWavPackDecoderSpec
+  fbjni
+  jsi
+  # We need to link different libraries based on whether we are building rncore or not, that's necessary
+  # because we want to break a circular dependency between react_codegen_rncore and reactnative
+  reactnative
+)
+
+target_compile_options(
+  react_codegen_RNTinyWavPackDecoderSpec
+  PRIVATE
+  -DLOG_TAG=\"ReactNative\"
+  -fexceptions
+  -frtti
+  -std=c++20
+  -Wall
+)

package/android/generated/jni/RNTinyWavPackDecoderSpec-generated.cpp

@@ -0,0 +1,44 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJniCpp.js
+ */
+
+#include "RNTinyWavPackDecoderSpec.h"
+
+namespace facebook::react {
+
+static facebook::jsi::Value __hostFunction_NativeTinyWavPackDecoderSpecJSI_decodeWavPack(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "decodeWavPack", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Double;Ljava/lang/Double;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeTinyWavPackDecoderSpecJSI_addListener(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, VoidKind, "addListener", "(Ljava/lang/String;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeTinyWavPackDecoderSpecJSI_removeListeners(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, VoidKind, "removeListeners", "(D)V", args, count, cachedMethodId);
+}
+
+NativeTinyWavPackDecoderSpecJSI::NativeTinyWavPackDecoderSpecJSI(const JavaTurboModule::InitParams &params)
+  : JavaTurboModule(params) {
+  methodMap_["decodeWavPack"] = MethodMetadata {4, __hostFunction_NativeTinyWavPackDecoderSpecJSI_decodeWavPack};
+  methodMap_["addListener"] = MethodMetadata {1, __hostFunction_NativeTinyWavPackDecoderSpecJSI_addListener};
+  methodMap_["removeListeners"] = MethodMetadata {1, __hostFunction_NativeTinyWavPackDecoderSpecJSI_removeListeners};
+}
+
+std::shared_ptr<TurboModule> RNTinyWavPackDecoderSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params) {
+  if (moduleName == "TinyWavPackDecoderModule") {
+    return std::make_shared<NativeTinyWavPackDecoderSpecJSI>(params);
+  }
+  return nullptr;
+}
+
+} // namespace facebook::react

package/android/generated/jni/RNTinyWavPackDecoderSpec.h

@@ -0,0 +1,31 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJniH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+/**
+ * JNI C++ class for module 'NativeTinyWavPackDecoder'
+ */
+class JSI_EXPORT NativeTinyWavPackDecoderSpecJSI : public JavaTurboModule {
+public:
+  NativeTinyWavPackDecoderSpecJSI(const JavaTurboModule::InitParams &params);
+};
+
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> RNTinyWavPackDecoderSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params);
+
+} // namespace facebook::react

package/android/generated/jni/react/renderer/components/RNTinyWavPackDecoderSpec/RNTinyWavPackDecoderSpecJSI-generated.cpp

@@ -0,0 +1,46 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleCpp.js
+ */
+
+#include "RNTinyWavPackDecoderSpecJSI.h"
+
+namespace facebook::react {
+
+static jsi::Value __hostFunction_NativeTinyWavPackDecoderCxxSpecJSI_decodeWavPack(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeTinyWavPackDecoderCxxSpecJSI *>(&turboModule)->decodeWavPack(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asString(rt),
+    count <= 1 ? throw jsi::JSError(rt, "Expected argument in position 1 to be passed") : args[1].asString(rt),
+    count <= 2 || args[2].isUndefined() ? std::nullopt : std::make_optional(args[2].asNumber()),
+    count <= 3 || args[3].isUndefined() ? std::nullopt : std::make_optional(args[3].asNumber())
+  );
+}
+static jsi::Value __hostFunction_NativeTinyWavPackDecoderCxxSpecJSI_addListener(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  static_cast<NativeTinyWavPackDecoderCxxSpecJSI *>(&turboModule)->addListener(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asString(rt)
+  );
+  return jsi::Value::undefined();
+}
+static jsi::Value __hostFunction_NativeTinyWavPackDecoderCxxSpecJSI_removeListeners(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  static_cast<NativeTinyWavPackDecoderCxxSpecJSI *>(&turboModule)->removeListeners(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asNumber()
+  );
+  return jsi::Value::undefined();
+}
+
+NativeTinyWavPackDecoderCxxSpecJSI::NativeTinyWavPackDecoderCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
+  : TurboModule("TinyWavPackDecoderModule", jsInvoker) {
+  methodMap_["decodeWavPack"] = MethodMetadata {4, __hostFunction_NativeTinyWavPackDecoderCxxSpecJSI_decodeWavPack};
+  methodMap_["addListener"] = MethodMetadata {1, __hostFunction_NativeTinyWavPackDecoderCxxSpecJSI_addListener};
+  methodMap_["removeListeners"] = MethodMetadata {1, __hostFunction_NativeTinyWavPackDecoderCxxSpecJSI_removeListeners};
+}
+
+
+} // namespace facebook::react

package/android/generated/jni/react/renderer/components/RNTinyWavPackDecoderSpec/RNTinyWavPackDecoderSpecJSI.h

@@ -0,0 +1,89 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include <react/bridging/Bridging.h>
+
+namespace facebook::react {
+
+
+  class JSI_EXPORT NativeTinyWavPackDecoderCxxSpecJSI : public TurboModule {
+protected:
+  NativeTinyWavPackDecoderCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
+
+public:
+  virtual jsi::Value decodeWavPack(jsi::Runtime &rt, jsi::String inputPath, jsi::String outputPath, std::optional<double> maxSamples, std::optional<double> bitsPerSample) = 0;
+  virtual void addListener(jsi::Runtime &rt, jsi::String eventType) = 0;
+  virtual void removeListeners(jsi::Runtime &rt, double count) = 0;
+
+};
+
+template <typename T>
+class JSI_EXPORT NativeTinyWavPackDecoderCxxSpec : public TurboModule {
+public:
+  jsi::Value create(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
+    return delegate_.create(rt, propName);
+  }
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override {
+    return delegate_.getPropertyNames(runtime);
+  }
+
+  static constexpr std::string_view kModuleName = "TinyWavPackDecoderModule";
+
+protected:
+  NativeTinyWavPackDecoderCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule(std::string{NativeTinyWavPackDecoderCxxSpec::kModuleName}, jsInvoker),
+      delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
+
+
+private:
+  class Delegate : public NativeTinyWavPackDecoderCxxSpecJSI {
+  public:
+    Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
+      NativeTinyWavPackDecoderCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {
+
+    }
+
+    jsi::Value decodeWavPack(jsi::Runtime &rt, jsi::String inputPath, jsi::String outputPath, std::optional<double> maxSamples, std::optional<double> bitsPerSample) override {
+      static_assert(
+          bridging::getParameterCount(&T::decodeWavPack) == 5,
+          "Expected decodeWavPack(...) to have 5 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::decodeWavPack, jsInvoker_, instance_, std::move(inputPath), std::move(outputPath), std::move(maxSamples), std::move(bitsPerSample));
+    }
+    void addListener(jsi::Runtime &rt, jsi::String eventType) override {
+      static_assert(
+          bridging::getParameterCount(&T::addListener) == 2,
+          "Expected addListener(...) to have 2 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::addListener, jsInvoker_, instance_, std::move(eventType));
+    }
+    void removeListeners(jsi::Runtime &rt, double count) override {
+      static_assert(
+          bridging::getParameterCount(&T::removeListeners) == 2,
+          "Expected removeListeners(...) to have 2 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::removeListeners, jsInvoker_, instance_, std::move(count));
+    }
+
+  private:
+    friend class NativeTinyWavPackDecoderCxxSpec;
+    T *instance_;
+  };
+
+  Delegate delegate_;
+};
+
+} // namespace facebook::react

package/android/gradle.properties

@@ -0,0 +1,5 @@
+TinyWavPackDecoder_kotlinVersion=2.0.21
+TinyWavPackDecoder_minSdkVersion=24
+TinyWavPackDecoder_targetSdkVersion=34
+TinyWavPackDecoder_compileSdkVersion=35
+TinyWavPackDecoder_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.tinywavpackdecoder">
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,54 @@
+# android/src/main/cpp/CMakeLists.txt
+cmake_minimum_required(VERSION 3.4.1)
+
+# Add logging library for android logcat
+find_library(log-lib log)
+
+# Set the path to the tiny wavpack library source files
+set(WAVPACK_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../src/tiny-wavpack/lib)
+
+# Set the path to the common decoder interface implementation
+set(COMMON_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../src/tiny-wavpack/common)
+
+# Add the tiny wavpack library source files
+add_library(tiny_wavpack
+            STATIC
+            ${WAVPACK_SRC_DIR}/bits.c
+            ${WAVPACK_SRC_DIR}/float.c
+            ${WAVPACK_SRC_DIR}/metadata.c
+            ${WAVPACK_SRC_DIR}/unpack.c
+            ${WAVPACK_SRC_DIR}/words.c
+            ${WAVPACK_SRC_DIR}/wputils.c)
+
+# Include directories for the tiny wavpack library
+target_include_directories(tiny_wavpack PUBLIC ${WAVPACK_SRC_DIR})
+
+# Add the common decoder implementation
+add_library(common_decoder
+            STATIC
+            ${COMMON_SRC_DIR}/TinyWavPackDecoderInterface.c)
+
+# Includes both the common and WavPack headers
+target_include_directories(common_decoder PUBLIC 
+                          ${COMMON_SRC_DIR}
+                          ${WAVPACK_SRC_DIR})
+
+# Link wavpack library to common decoder
+target_link_libraries(common_decoder tiny_wavpack)
+
+# Add the JNI implementation
+add_library(tiny-wavpack-decoder
+            SHARED
+            TinyWavPackDecoderModule.cpp)
+
+# Include directories for the JNI implementation
+target_include_directories(tiny-wavpack-decoder PUBLIC
+                          ${COMMON_SRC_DIR}
+                          ${WAVPACK_SRC_DIR})
+
+# Link the libraries
+target_link_libraries(tiny-wavpack-decoder
+                     common_decoder
+                     tiny_wavpack
+                     ${log-lib}
+                     android)