fix avoid per-frame heap allocations of support buffers #24

- Add StreamBuffers struct to hold persistent buffers for audio processing
- Fix to allocate once per session instead of ~50 malloc/free per second per call
- Fix formatting in STREAM_API_SYNTAX help text

Signed-off-by: Dario Pellegrino <dario.pellegrino@voismart.it>

Author: dariopellegrino00

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.18)
 project(mod_openai_audio_stream
         VERSION 1.0.0
         DESCRIPTION "Audio streaming module for FreeSWITCH."
-        HOMEPAGE_URL "https://github.com/VoiSmart/mod_openai_audio_stream") 
+        HOMEPAGE_URL "https://github.com/VoiSmart/mod_openai_realtime") 
 
 include(GNUInstallDirs)
 

mod_openai_audio_stream.c

@@ -170,9 +170,9 @@ static switch_status_t send_json(switch_core_session_t *session, char* json) {
 #define STREAM_API_SYNTAX \
 "USAGE:\n" \
 "--------------------------------------------------------------------------------\n" \
-"uuid_openai_audio_stream <uuid> start <wss-url> <mono | mixed | stereo> \n" \
-"       [8k | 16k | 24k | <other rate>] [mute_user]\n" \
-"       where <rate> = 8k|16k|24k or any multiple of 8000 (default: 8k)\n" \
+"uuid_openai_audio_stream <uuid> start <wss-url> <mono | mixed | stereo>\n" \
+"                        [8k | 16k | 24k | <other rate>] [mute_user]\n" \
+"                        where <rate> = 8k|16k|24k or any multiple of 8000 (default: 8k)\n" \
 "uuid_openai_audio_stream <uuid> [stop | pause | resume]\n" \
 "uuid_openai_audio_stream <uuid> [mute | unmute] [user | openai | all]\n" \
 "uuid_openai_audio_stream <uuid> send_json <base64json>\n" \

mod_openai_audio_stream.h

@@ -35,6 +35,7 @@ struct private_data {
     switch_buffer_t *sbuffer;
     int rtp_packets;
     switch_buffer_t *playback_buffer;
+    void *stream_buffers;
 };
 
 typedef struct private_data private_t;

openai_audio_streamer_glue.cpp

@@ -15,6 +15,19 @@
 
 #define FRAME_SIZE_8000  320 /* 1000x0.02 (20ms)= 160 x(16bit= 2 bytes) 320 frame size*/
 
+// Persistent buffers for stream_frame to avoid per-frame heap allocations
+struct StreamBuffers {
+    std::vector<uint8_t> flush_buffer;
+    std::vector<spx_int16_t> resample_buffer;
+    std::vector<uint8_t> data_buf;
+
+    StreamBuffers() {
+        flush_buffer.reserve(SWITCH_RECOMMENDED_BUFFER_SIZE);
+        resample_buffer.reserve(SWITCH_RECOMMENDED_BUFFER_SIZE / sizeof(spx_int16_t));
+        data_buf.resize(SWITCH_RECOMMENDED_BUFFER_SIZE);
+    }
+};
+
 class AudioStreamer {
 public:
 
@@ -526,6 +539,7 @@ namespace {
                                             tls_cafile, tls_keyfile, tls_certfile, tls_disable_hostname_validation, sampling, disable_audiofiles); 
 
             tech_pvt->pAudioStreamer = static_cast<void *>(as);
+            tech_pvt->stream_buffers = static_cast<void *>(new StreamBuffers());
 
             switch_mutex_init(&tech_pvt->mutex, SWITCH_MUTEX_NESTED, pool);
 
@@ -567,6 +581,11 @@ namespace {
             delete as;
             tech_pvt->pAudioStreamer = nullptr;
         }
+        if (tech_pvt->stream_buffers) {
+            auto* sb = static_cast<StreamBuffers*>(tech_pvt->stream_buffers);
+            delete sb;
+            tech_pvt->stream_buffers = nullptr;
+        }
     }
 
     void finish(private_t* tech_pvt) {
@@ -936,23 +955,21 @@ extern "C" {
             return SWITCH_TRUE;
         }
 
-        // Pre-allocate reusable buffers to avoid repeated allocations
-        std::vector<uint8_t> flush_buffer;
-        std::vector<spx_int16_t> resample_buffer;
+        // Get persistent buffers (allocated once per session, reused across all frames)
+        auto *bufs = static_cast<StreamBuffers*>(tech_pvt->stream_buffers);
 
         auto flush_sbuffer = [&]() {
             switch_size_t inuse = switch_buffer_inuse(tech_pvt->sbuffer);
             if (inuse > 0) {
-                flush_buffer.resize(inuse);
-                switch_buffer_read(tech_pvt->sbuffer, flush_buffer.data(), inuse);
+                bufs->flush_buffer.resize(inuse);
+                switch_buffer_read(tech_pvt->sbuffer, bufs->flush_buffer.data(), inuse);
                 switch_buffer_zero(tech_pvt->sbuffer);
-                pAudioStreamer->writeAudioDelta(flush_buffer.data(), inuse);
+                pAudioStreamer->writeAudioDelta(bufs->flush_buffer.data(), inuse);
             }
         };
 
-        std::vector<uint8_t> data_buf(SWITCH_RECOMMENDED_BUFFER_SIZE);
         switch_frame_t frame{};
-        frame.data = data_buf.data();
+        frame.data = bufs->data_buf.data();
         frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;
 
         while (switch_core_media_bug_read(bug, &frame, SWITCH_TRUE) == SWITCH_STATUS_SUCCESS) {
@@ -1003,23 +1020,23 @@ extern "C" {
                 }
             }
 
-            resample_buffer.resize(out_len * tech_pvt->channels);
+            bufs->resample_buffer.resize(out_len * tech_pvt->channels);
 
             if (tech_pvt->channels == 1) {
                 speex_resampler_process_int(
                     tech_pvt->resampler,
                     0,
                     static_cast<const spx_int16_t *>(frame.data),
                     &in_len,
-                    resample_buffer.data(),
+                    bufs->resample_buffer.data(),
                     &out_len
                 );
             } else {
                 speex_resampler_process_interleaved_int(
                     tech_pvt->resampler,
                     static_cast<const spx_int16_t *>(frame.data),
                     &in_len,
-                    resample_buffer.data(),
+                    bufs->resample_buffer.data(),
                     &out_len
                 );
             }
@@ -1028,7 +1045,7 @@ extern "C" {
             if (bytes_written > 0) {
                 // For 20ms packets, send immediately without buffering
                 if (tech_pvt->rtp_packets == 1) {
-                    pAudioStreamer->writeAudioDelta(reinterpret_cast<uint8_t *>(resample_buffer.data()), bytes_written);
+                    pAudioStreamer->writeAudioDelta(reinterpret_cast<uint8_t *>(bufs->resample_buffer.data()), bytes_written);
                 } else {
                     // Check if buffer has enough space before writing
                     switch_size_t free_space = switch_buffer_freespace(tech_pvt->sbuffer);
@@ -1039,7 +1056,7 @@ extern "C" {
                     if (bytes_written <= free_space) {
                         switch_buffer_write(
                             tech_pvt->sbuffer,
-                            reinterpret_cast<const uint8_t *>(resample_buffer.data()),
+                            reinterpret_cast<const uint8_t *>(bufs->resample_buffer.data()),
                             bytes_written
                         );
                         if (switch_buffer_freespace(tech_pvt->sbuffer) == 0) {