whisper.rn 0.4.0-rc.4 → 0.4.0-rc.5

package/cpp/ggml.h

@@ -244,11 +244,10 @@
 #define WSP_GGML_ASSERT(x) \
     do { \
         if (!(x)) { \
-            fprintf(stderr, "WSP_GGML_ASSERT: %s:%d: %s\n", __FILE__, __LINE__, #x); \
-            fflush(stderr); \
             fflush(stdout); \
+            fprintf(stderr, "WSP_GGML_ASSERT: %s:%d: %s\n", __FILE__, __LINE__, #x); \
             wsp_ggml_print_backtrace(); \
-            exit(1); \
+            abort(); \
         } \
     } while (0)
 
@@ -284,6 +283,20 @@
     const type prefix##3 = (pointer)->array[3]; \
     WSP_GGML_UNUSED(prefix##3);
 
+#define WSP_GGML_TENSOR_UNARY_OP_LOCALS \
+    WSP_GGML_TENSOR_LOCALS(int64_t, ne0, src0, ne) \
+    WSP_GGML_TENSOR_LOCALS(size_t,  nb0, src0, nb) \
+    WSP_GGML_TENSOR_LOCALS(int64_t, ne,  dst,  ne) \
+    WSP_GGML_TENSOR_LOCALS(size_t,  nb,  dst,  nb)
+
+#define WSP_GGML_TENSOR_BINARY_OP_LOCALS \
+    WSP_GGML_TENSOR_LOCALS(int64_t, ne0, src0, ne) \
+    WSP_GGML_TENSOR_LOCALS(size_t,  nb0, src0, nb) \
+    WSP_GGML_TENSOR_LOCALS(int64_t, ne1, src1, ne) \
+    WSP_GGML_TENSOR_LOCALS(size_t,  nb1, src1, nb) \
+    WSP_GGML_TENSOR_LOCALS(int64_t, ne,  dst,  ne) \
+    WSP_GGML_TENSOR_LOCALS(size_t,  nb,  dst,  nb)
+
 #ifdef  __cplusplus
 extern "C" {
 #endif
@@ -382,6 +395,7 @@ extern "C" {
         WSP_GGML_OP_GROUP_NORM,
 
         WSP_GGML_OP_MUL_MAT,
+        WSP_GGML_OP_MUL_MAT_ID,
         WSP_GGML_OP_OUT_PROD,
 
         WSP_GGML_OP_SCALE,
@@ -403,18 +417,13 @@ extern "C" {
         WSP_GGML_OP_ROPE_BACK,
         WSP_GGML_OP_ALIBI,
         WSP_GGML_OP_CLAMP,
-        WSP_GGML_OP_CONV_1D,
-        WSP_GGML_OP_CONV_1D_STAGE_0,  // internal
-        WSP_GGML_OP_CONV_1D_STAGE_1,  // internal
         WSP_GGML_OP_CONV_TRANSPOSE_1D,
-        WSP_GGML_OP_CONV_2D,
-        WSP_GGML_OP_CONV_2D_STAGE_0, // internal
-        WSP_GGML_OP_CONV_2D_STAGE_1, // internal
+        WSP_GGML_OP_IM2COL,
         WSP_GGML_OP_CONV_TRANSPOSE_2D,
         WSP_GGML_OP_POOL_1D,
         WSP_GGML_OP_POOL_2D,
-
         WSP_GGML_OP_UPSCALE, // nearest interpolate
+        WSP_GGML_OP_ARGSORT,
 
         WSP_GGML_OP_FLASH_ATTN,
         WSP_GGML_OP_FLASH_FF,
@@ -454,7 +463,9 @@ extern "C" {
         WSP_GGML_UNARY_OP_GELU,
         WSP_GGML_UNARY_OP_GELU_QUICK,
         WSP_GGML_UNARY_OP_SILU,
-        WSP_GGML_UNARY_OP_LEAKY
+        WSP_GGML_UNARY_OP_LEAKY,
+
+        WSP_GGML_UNARY_OP_COUNT,
     };
 
     enum wsp_ggml_object_type {
@@ -637,6 +648,9 @@ extern "C" {
     WSP_GGML_API const char * wsp_ggml_op_name  (enum wsp_ggml_op   op);
     WSP_GGML_API const char * wsp_ggml_op_symbol(enum wsp_ggml_op   op);
 
+    WSP_GGML_API const char * wsp_ggml_unary_op_name(enum wsp_ggml_unary_op op);
+    WSP_GGML_API const char * wsp_ggml_op_desc(const struct wsp_ggml_tensor * t); // unary or op name
+
     WSP_GGML_API size_t  wsp_ggml_element_size(const struct wsp_ggml_tensor * tensor);
 
     WSP_GGML_API bool    wsp_ggml_is_quantized(enum wsp_ggml_type type);
@@ -1033,6 +1047,15 @@ extern "C" {
             struct wsp_ggml_tensor  * a,
             struct wsp_ggml_tensor  * b);
 
+    // indirect matrix multiplication
+    //  wsp_ggml_mul_mat_id(ctx, as, ids, id, b) ~= wsp_ggml_mul_mat(as[ids[id]], b)
+    WSP_GGML_API struct wsp_ggml_tensor * wsp_ggml_mul_mat_id(
+            struct wsp_ggml_context * ctx,
+            struct wsp_ggml_tensor  * as[],
+            struct wsp_ggml_tensor  * ids,
+            int                   id,
+            struct wsp_ggml_tensor  * b);
+
     // A: m columns, n rows,
     // B: p columns, n rows,
     // result is m columns, p rows
@@ -1288,6 +1311,14 @@ extern "C" {
             struct wsp_ggml_context * ctx,
             struct wsp_ggml_tensor  * a);
 
+    // fused soft_max(a*scale + mask)
+    // mask is optional
+    WSP_GGML_API struct wsp_ggml_tensor * wsp_ggml_soft_max_ext(
+            struct wsp_ggml_context * ctx,
+            struct wsp_ggml_tensor  * a,
+            struct wsp_ggml_tensor  * mask,
+            float                 scale);
+
     WSP_GGML_API struct wsp_ggml_tensor * wsp_ggml_soft_max_back(
             struct wsp_ggml_context * ctx,
             struct wsp_ggml_tensor  * a,
@@ -1376,8 +1407,13 @@ extern "C" {
             int                   n_dims,
             int                   mode,
             int                   n_ctx,
+            int                   n_orig_ctx,
             float                 freq_base,
             float                 freq_scale,
+            float                 ext_factor,
+            float                 attn_factor,
+            float                 beta_fast,
+            float                 beta_slow,
             float                 xpos_base,
             bool                  xpos_down);
 
@@ -1398,6 +1434,18 @@ extern "C" {
             float                 min,
             float                 max);
 
+    WSP_GGML_API struct wsp_ggml_tensor * wsp_ggml_im2col(
+            struct wsp_ggml_context * ctx,
+            struct wsp_ggml_tensor  * a,
+            struct wsp_ggml_tensor  * b,
+            int                  s0,
+            int                  s1,
+            int                  p0,
+            int                  p1,
+            int                  d0,
+            int                  d1,
+            bool                 is_2D);
+
     WSP_GGML_API struct wsp_ggml_tensor * wsp_ggml_conv_1d(
             struct wsp_ggml_context * ctx,
             struct wsp_ggml_tensor  * a,
@@ -1501,6 +1549,23 @@ extern "C" {
             struct wsp_ggml_tensor  * a,
             int                   scale_factor);
 
+    // sort rows
+    enum wsp_ggml_sort_order {
+        WSP_GGML_SORT_ASC,
+        WSP_GGML_SORT_DESC,
+    };
+
+    WSP_GGML_API struct wsp_ggml_tensor * wsp_ggml_argsort(
+            struct wsp_ggml_context * ctx,
+            struct wsp_ggml_tensor  * a,
+            enum wsp_ggml_sort_order  order);
+
+    // top k elements per row
+    WSP_GGML_API struct wsp_ggml_tensor * wsp_ggml_top_k(
+            struct wsp_ggml_context * ctx,
+            struct wsp_ggml_tensor  * a,
+            int                   k);
+
     WSP_GGML_API struct wsp_ggml_tensor * wsp_ggml_flash_attn(
             struct wsp_ggml_context * ctx,
             struct wsp_ggml_tensor  * q,
@@ -1562,7 +1627,6 @@ extern "C" {
             int                   kh);
 
     // used in sam
-
     WSP_GGML_API struct wsp_ggml_tensor * wsp_ggml_add_rel_pos(
             struct wsp_ggml_context * ctx,
             struct wsp_ggml_tensor  * a,
@@ -1737,7 +1801,7 @@ extern "C" {
     WSP_GGML_API struct wsp_ggml_cgraph * wsp_ggml_new_graph         (struct wsp_ggml_context * ctx); // size = WSP_GGML_DEFAULT_GRAPH_SIZE, grads = false
     WSP_GGML_API struct wsp_ggml_cgraph * wsp_ggml_new_graph_custom  (struct wsp_ggml_context * ctx, size_t size, bool grads);
     WSP_GGML_API struct wsp_ggml_cgraph * wsp_ggml_graph_dup         (struct wsp_ggml_context * ctx, struct wsp_ggml_cgraph * cgraph);
-    WSP_GGML_API struct wsp_ggml_cgraph * wsp_ggml_graph_view        (struct wsp_ggml_context * ctx, struct wsp_ggml_cgraph * cgraph, int i0, int i1);
+    WSP_GGML_API struct wsp_ggml_cgraph   wsp_ggml_graph_view        (struct wsp_ggml_cgraph * cgraph, int i0, int i1);
     WSP_GGML_API void                 wsp_ggml_graph_cpy         (struct wsp_ggml_cgraph * src, struct wsp_ggml_cgraph * dst);
     WSP_GGML_API void                 wsp_ggml_graph_reset       (struct wsp_ggml_cgraph * cgraph);  // zero grads
     WSP_GGML_API void                 wsp_ggml_graph_clear       (struct wsp_ggml_cgraph * cgraph);
@@ -1955,20 +2019,20 @@ extern "C" {
     // quantization
     //
 
-    // TODO: these would probably get removed in favor of the more general wsp_ggml_quantize_chunk
-    WSP_GGML_API size_t wsp_ggml_quantize_q4_0(const float * src, void * dst, int n, int k, int64_t * hist);
-    WSP_GGML_API size_t wsp_ggml_quantize_q4_1(const float * src, void * dst, int n, int k, int64_t * hist);
-    WSP_GGML_API size_t wsp_ggml_quantize_q5_0(const float * src, void * dst, int n, int k, int64_t * hist);
-    WSP_GGML_API size_t wsp_ggml_quantize_q5_1(const float * src, void * dst, int n, int k, int64_t * hist);
-    WSP_GGML_API size_t wsp_ggml_quantize_q8_0(const float * src, void * dst, int n, int k, int64_t * hist);
+    // TODO: these would probably get removed in favor of the more general wsp_ggml_wsp_quantize_chunk
+    WSP_GGML_API size_t wsp_ggml_wsp_quantize_q4_0(const float * src, void * dst, int n, int k, int64_t * hist);
+    WSP_GGML_API size_t wsp_ggml_wsp_quantize_q4_1(const float * src, void * dst, int n, int k, int64_t * hist);
+    WSP_GGML_API size_t wsp_ggml_wsp_quantize_q5_0(const float * src, void * dst, int n, int k, int64_t * hist);
+    WSP_GGML_API size_t wsp_ggml_wsp_quantize_q5_1(const float * src, void * dst, int n, int k, int64_t * hist);
+    WSP_GGML_API size_t wsp_ggml_wsp_quantize_q8_0(const float * src, void * dst, int n, int k, int64_t * hist);
 
-    WSP_GGML_API size_t wsp_ggml_quantize_q2_K(const float * src, void * dst, int n, int k, int64_t * hist);
-    WSP_GGML_API size_t wsp_ggml_quantize_q3_K(const float * src, void * dst, int n, int k, int64_t * hist);
-    WSP_GGML_API size_t wsp_ggml_quantize_q4_K(const float * src, void * dst, int n, int k, int64_t * hist);
-    WSP_GGML_API size_t wsp_ggml_quantize_q5_K(const float * src, void * dst, int n, int k, int64_t * hist);
-    WSP_GGML_API size_t wsp_ggml_quantize_q6_K(const float * src, void * dst, int n, int k, int64_t * hist);
+    WSP_GGML_API size_t wsp_ggml_wsp_quantize_q2_K(const float * src, void * dst, int n, int k, int64_t * hist);
+    WSP_GGML_API size_t wsp_ggml_wsp_quantize_q3_K(const float * src, void * dst, int n, int k, int64_t * hist);
+    WSP_GGML_API size_t wsp_ggml_wsp_quantize_q4_K(const float * src, void * dst, int n, int k, int64_t * hist);
+    WSP_GGML_API size_t wsp_ggml_wsp_quantize_q5_K(const float * src, void * dst, int n, int k, int64_t * hist);
+    WSP_GGML_API size_t wsp_ggml_wsp_quantize_q6_K(const float * src, void * dst, int n, int k, int64_t * hist);
 
-    WSP_GGML_API size_t wsp_ggml_quantize_chunk(enum wsp_ggml_type type, const float * src, void * dst, int start, int n, int64_t * hist);
+    WSP_GGML_API size_t wsp_ggml_wsp_quantize_chunk(enum wsp_ggml_type type, const float * src, void * dst, int start, int n, int64_t * hist);
 
     //
     // gguf
@@ -2033,6 +2097,7 @@ extern "C" {
     WSP_GGML_API double       wsp_gguf_get_val_f64 (const struct wsp_gguf_context * ctx, int key_id);
     WSP_GGML_API bool         wsp_gguf_get_val_bool(const struct wsp_gguf_context * ctx, int key_id);
     WSP_GGML_API const char * wsp_gguf_get_val_str (const struct wsp_gguf_context * ctx, int key_id);
+    WSP_GGML_API const void * wsp_gguf_get_val_data(const struct wsp_gguf_context * ctx, int key_id);
     WSP_GGML_API int          wsp_gguf_get_arr_n   (const struct wsp_gguf_context * ctx, int key_id);
     WSP_GGML_API const void * wsp_gguf_get_arr_data(const struct wsp_gguf_context * ctx, int key_id);
     WSP_GGML_API const char * wsp_gguf_get_arr_str (const struct wsp_gguf_context * ctx, int key_id, int i);

package/cpp/rn-audioutils.cpp

@@ -0,0 +1,68 @@
+#include "rn-audioutils.h"
+#include "rn-whisper-log.h"
+
+namespace rnaudioutils {
+
+std::vector<uint8_t> concat_short_buffers(const std::vector<short*>& buffers, const std::vector<int>& slice_n_samples) {
+    std::vector<uint8_t> output_data;
+
+    for (size_t i = 0; i < buffers.size(); i++) {
+        int size = slice_n_samples[i]; // Number of shorts
+        short* slice = buffers[i];
+
+        // Copy each short as two bytes
+        for (int j = 0; j < size; j++) {
+            output_data.push_back(static_cast<uint8_t>(slice[j] & 0xFF));         // Lower byte
+            output_data.push_back(static_cast<uint8_t>((slice[j] >> 8) & 0xFF));  // Higher byte
+        }
+    }
+
+    return output_data;
+}
+
+std::vector<uint8_t> remove_trailing_zeros(const std::vector<uint8_t>& audio_data) {
+    auto last = std::find_if(audio_data.rbegin(), audio_data.rend(), [](uint8_t byte) { return byte != 0; });
+    return std::vector<uint8_t>(audio_data.begin(), last.base());
+}
+
+void save_wav_file(const std::vector<uint8_t>& raw, const std::string& file) {
+    std::vector<uint8_t> data = remove_trailing_zeros(raw);
+    
+    std::ofstream output(file, std::ios::binary);
+
+    if (!output.is_open()) {
+        RNWHISPER_LOG_ERROR("Failed to open file for writing: %s\n", file.c_str());
+        return;
+    }
+
+    // WAVE header
+    output.write("RIFF", 4);
+    int32_t chunk_size = 36 + static_cast<int32_t>(data.size());
+    output.write(reinterpret_cast<char*>(&chunk_size), sizeof(chunk_size));
+    output.write("WAVE", 4);
+    output.write("fmt ", 4);
+    int32_t sub_chunk_size = 16;
+    output.write(reinterpret_cast<char*>(&sub_chunk_size), sizeof(sub_chunk_size));
+    short audio_format = 1;
+    output.write(reinterpret_cast<char*>(&audio_format), sizeof(audio_format));
+    short num_channels = 1;
+    output.write(reinterpret_cast<char*>(&num_channels), sizeof(num_channels));
+    int32_t sample_rate = WHISPER_SAMPLE_RATE;
+    output.write(reinterpret_cast<char*>(&sample_rate), sizeof(sample_rate));
+    int32_t byte_rate = WHISPER_SAMPLE_RATE * 2;
+    output.write(reinterpret_cast<char*>(&byte_rate), sizeof(byte_rate));
+    short block_align = 2;
+    output.write(reinterpret_cast<char*>(&block_align), sizeof(block_align));
+    short bits_per_sample = 16;
+    output.write(reinterpret_cast<char*>(&bits_per_sample), sizeof(bits_per_sample));
+    output.write("data", 4);
+    int32_t sub_chunk2_size = static_cast<int32_t>(data.size());
+    output.write(reinterpret_cast<char*>(&sub_chunk2_size), sizeof(sub_chunk2_size));
+    output.write(reinterpret_cast<const char*>(data.data()), data.size());
+
+    output.close();
+
+    RNWHISPER_LOG_INFO("Saved audio file: %s\n", file.c_str());
+}
+
+} // namespace rnaudioutils

package/cpp/rn-audioutils.h

@@ -0,0 +1,14 @@
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <cstdint>
+#include <cstring>
+#include <algorithm>
+#include "whisper.h"
+
+namespace rnaudioutils {
+
+std::vector<uint8_t> concat_short_buffers(const std::vector<short*>& buffers, const std::vector<int>& slice_n_samples);
+void save_wav_file(const std::vector<uint8_t>& raw, const std::string& file);
+
+} // namespace rnaudioutils

package/cpp/rn-whisper-log.h

@@ -0,0 +1,11 @@
+#if defined(__ANDROID__) && defined(RNWHISPER_ANDROID_ENABLE_LOGGING)
+#include <android/log.h>
+#define RNWHISPER_ANDROID_TAG "RNWHISPER_LOG_ANDROID"
+#define RNWHISPER_LOG_INFO(...)  __android_log_print(ANDROID_LOG_INFO , RNWHISPER_ANDROID_TAG, __VA_ARGS__)
+#define RNWHISPER_LOG_WARN(...)  __android_log_print(ANDROID_LOG_WARN , RNWHISPER_ANDROID_TAG, __VA_ARGS__)
+#define RNWHISPER_LOG_ERROR(...) __android_log_print(ANDROID_LOG_ERROR, RNWHISPER_ANDROID_TAG, __VA_ARGS__)
+#else
+#define RNWHISPER_LOG_INFO(...)  fprintf(stderr, __VA_ARGS__)
+#define RNWHISPER_LOG_WARN(...)  fprintf(stderr, __VA_ARGS__)
+#define RNWHISPER_LOG_ERROR(...) fprintf(stderr, __VA_ARGS__)
+#endif // __ANDROID__

package/cpp/rn-whisper.cpp

@@ -2,41 +2,11 @@
 #include <string>
 #include <vector>
 #include <unordered_map>
-#include "whisper.h"
+#include "rn-whisper.h"
 
-extern "C" {
+#define DEFAULT_MAX_AUDIO_SEC 30;
 
-std::unordered_map<int, bool> abort_map;
-
-bool* rn_whisper_assign_abort_map(int job_id) {
-  abort_map[job_id] = false;
-  return &abort_map[job_id];
-}
-
-void rn_whisper_remove_abort_map(int job_id) {
-  if (abort_map.find(job_id) != abort_map.end()) {
-    abort_map.erase(job_id);
-  }
-}
-
-void rn_whisper_abort_transcribe(int job_id) {
-  if (abort_map.find(job_id) != abort_map.end()) {
-    abort_map[job_id] = true;
-  }
-}
-
-bool rn_whisper_transcribe_is_aborted(int job_id) {
-  if (abort_map.find(job_id) != abort_map.end()) {
-    return abort_map[job_id];
-  }
-  return false;
-}
-
-void rn_whisper_abort_all_transcribe() {
-  for (auto it = abort_map.begin(); it != abort_map.end(); ++it) {
-    it->second = true;
-  }
-}
+namespace rnwhisper {
 
 void high_pass_filter(std::vector<float> & data, float cutoff, float sample_rate) {
     const float rc = 1.0f / (2.0f * M_PI * cutoff);
@@ -51,42 +21,154 @@ void high_pass_filter(std::vector<float> & data, float cutoff, float sample_rate
     }
 }
 
-bool rn_whisper_vad_simple(std::vector<float> & pcmf32, int sample_rate, int last_ms, float vad_thold, float freq_thold, bool verbose) {
-  const int n_samples      = pcmf32.size();
-  const int n_samples_last = (sample_rate * last_ms) / 1000;
+bool vad_simple_impl(std::vector<float> & pcmf32, int sample_rate, int last_ms, float vad_thold, float freq_thold, bool verbose) {
+    const int n_samples      = pcmf32.size();
+    const int n_samples_last = (sample_rate * last_ms) / 1000;
 
-  if (n_samples_last >= n_samples) {
-    // not enough samples - assume no speech
-    return false;
-  }
+    if (n_samples_last >= n_samples) {
+        // not enough samples - assume no speech
+        return false;
+    }
 
-  if (freq_thold > 0.0f) {
-    high_pass_filter(pcmf32, freq_thold, sample_rate);
-  }
+    if (freq_thold > 0.0f) {
+        high_pass_filter(pcmf32, freq_thold, sample_rate);
+    }
+
+    float energy_all  = 0.0f;
+    float energy_last = 0.0f;
+
+    for (int i = 0; i < n_samples; i++) {
+        energy_all += fabsf(pcmf32[i]);
 
-  float energy_all  = 0.0f;
-  float energy_last = 0.0f;
+        if (i >= n_samples - n_samples_last) {
+        energy_last += fabsf(pcmf32[i]);
+        }
+    }
+
+    energy_all  /= n_samples;
+    energy_last /= n_samples_last;
 
-  for (int i = 0; i < n_samples; i++) {
-    energy_all += fabsf(pcmf32[i]);
+    if (verbose) {
+        RNWHISPER_LOG_INFO("%s: energy_all: %f, energy_last: %f, vad_thold: %f, freq_thold: %f\n", __func__, energy_all, energy_last, vad_thold, freq_thold);
+    }
 
-    if (i >= n_samples - n_samples_last) {
-      energy_last += fabsf(pcmf32[i]);
+    if (energy_last > vad_thold*energy_all) {
+        return false;
     }
-  }
 
-  energy_all  /= n_samples;
-  energy_last /= n_samples_last;
+    return true;
+}
 
-  if (verbose) {
-    fprintf(stderr, "%s: energy_all: %f, energy_last: %f, vad_thold: %f, freq_thold: %f\n", __func__, energy_all, energy_last, vad_thold, freq_thold);
-  }
+void job::set_realtime_params(
+    vad_params params,
+    int sec,
+    int slice_sec,
+    const char* output_path
+) {
+    vad = params;
+    if (vad.vad_ms < 2000) vad.vad_ms = 2000;
+    audio_sec = sec > 0 ? sec : DEFAULT_MAX_AUDIO_SEC;
+    audio_slice_sec = slice_sec > 0 && slice_sec < audio_sec ? slice_sec : audio_sec;
+    audio_output_path = output_path;
+}
 
-  if (energy_last > vad_thold*energy_all) {
+bool job::vad_simple(int slice_index, int n_samples, int n) {
+    if (!vad.use_vad) return true;
+
+    short* pcm = pcm_slices[slice_index];
+    int sample_size = (int) (WHISPER_SAMPLE_RATE * vad.vad_ms / 1000);
+    if (n_samples + n > sample_size) {
+        int start = n_samples + n - sample_size;
+        std::vector<float> pcmf32(sample_size);
+        for (int i = 0; i < sample_size; i++) {
+            pcmf32[i] = (float)pcm[i + start] / 32768.0f;
+        }
+        return vad_simple_impl(pcmf32, WHISPER_SAMPLE_RATE, vad.last_ms, vad.vad_thold, vad.freq_thold, vad.verbose);
+    }
     return false;
-  }
+}
+
+void job::put_pcm_data(short* data, int slice_index, int n_samples, int n) {
+    if (pcm_slices.size() == slice_index) {
+        int n_slices = (int) (WHISPER_SAMPLE_RATE * audio_slice_sec);
+        pcm_slices.push_back(new short[n_slices]);
+    }
+    short* pcm = pcm_slices[slice_index];
+    for (int i = 0; i < n; i++) {
+        pcm[i + n_samples] = data[i];
+    }
+}
+
+float* job::pcm_slice_to_f32(int slice_index, int size) {
+    if (pcm_slices.size() > slice_index) {
+        float* pcmf32 = new float[size];
+        for (int i = 0; i < size; i++) {
+            pcmf32[i] = (float)pcm_slices[slice_index][i] / 32768.0f;
+        }
+        return pcmf32;
+    }
+    return nullptr;
+}
+
+bool job::is_aborted() {
+    return aborted;
+}
+
+void job::abort() {
+    aborted = true;
+}
+
+job::~job() {
+    RNWHISPER_LOG_INFO("rnwhisper::job::%s: job_id: %d\n", __func__, job_id);
+
+    for (size_t i = 0; i < pcm_slices.size(); i++) {
+        delete[] pcm_slices[i];
+    }
+    pcm_slices.clear();
+}
+
+std::unordered_map<int, job*> job_map;
+
+void job_abort_all() {
+    for (auto it = job_map.begin(); it != job_map.end(); ++it) {
+        it->second->abort();
+    }
+}
+
+job* job_new(int job_id, struct whisper_full_params params) {
+    job* ctx = new job();
+    ctx->job_id = job_id;
+    ctx->params = params;
+
+    job_map[job_id] = ctx;
+
+    // Abort handler
+    params.encoder_begin_callback = [](struct whisper_context * /*ctx*/, struct whisper_state * /*state*/, void * user_data) {
+        job *j = (job*)user_data;
+        return !j->is_aborted();
+    };
+    params.encoder_begin_callback_user_data = job_map[job_id];
+    params.abort_callback = [](void * user_data) {
+        job *j = (job*)user_data;
+        return j->is_aborted();
+    };
+    params.abort_callback_user_data = job_map[job_id];
+
+    return job_map[job_id];
+}
+
+job* job_get(int job_id) {
+    if (job_map.find(job_id) != job_map.end()) {
+        return job_map[job_id];
+    }
+    return nullptr;
+}
 
-  return true;
+void job_remove(int job_id) {
+    if (job_map.find(job_id) != job_map.end()) {
+        delete job_map[job_id];
+    }
+    job_map.erase(job_id);
 }
 
-}
+}

package/cpp/rn-whisper.h

@@ -1,17 +1,49 @@
+#ifndef RNWHISPER_H
+#define RNWHISPER_H
 
-#ifdef __cplusplus
 #include <string>
-#include <whisper.h>
-extern "C" {
-#endif
-
-bool* rn_whisper_assign_abort_map(int job_id);
-void rn_whisper_remove_abort_map(int job_id);
-void rn_whisper_abort_transcribe(int job_id);
-bool rn_whisper_transcribe_is_aborted(int job_id);
-void rn_whisper_abort_all_transcribe();
-bool rn_whisper_vad_simple(std::vector<float> & pcmf32, int sample_rate, int last_ms, float vad_thold, float freq_thold, bool verbose);
-
-#ifdef __cplusplus
-}
-#endif
+#include <vector>
+#include "whisper.h"
+#include "rn-whisper-log.h"
+#include "rn-audioutils.h"
+
+namespace rnwhisper {
+
+struct vad_params {
+    bool use_vad = false;
+    float vad_thold = 0.6f;
+    float freq_thold = 100.0f;
+    int vad_ms = 2000;
+    int last_ms = 1000;
+    bool verbose = false;
+};
+
+struct job {
+    int job_id;
+    bool aborted = false;
+    whisper_full_params params;
+
+    ~job();
+    bool is_aborted();
+    void abort();
+
+    // Realtime transcription only:
+    vad_params vad;
+    int audio_sec = 0;
+    int audio_slice_sec = 0;
+    const char* audio_output_path = nullptr;
+    std::vector<short *> pcm_slices;
+    void set_realtime_params(vad_params vad, int sec, int slice_sec, const char* output_path);
+    bool vad_simple(int slice_index, int n_samples, int n);
+    void put_pcm_data(short* pcm, int slice_index, int n_samples, int n);
+    float* pcm_slice_to_f32(int slice_index, int size);
+};
+
+void job_abort_all();
+job* job_new(int job_id, struct whisper_full_params params);
+void job_remove(int job_id);
+job* job_get(int job_id);
+
+} // namespace rnwhisper
+
+#endif // RNWHISPER_H