cleanup

Signed-off-by: Dave Horton <daveh@beachdognet.com>

mod_assemblyai_transcribe/aai_transcribe_glue.cpp

@@ -102,12 +102,11 @@ namespace {
     return path;
   }
 
-  static void eventCallback(const char* sessionId, const char* bugname, 
-    assemblyai::AudioPipe::NotifyEvent_t event, const char* message, bool finished) {
+  static void eventCallback(const char* sessionId, assemblyai::AudioPipe::NotifyEvent_t event, const char* message, bool finished) {
     switch_core_session_t* session = switch_core_session_locate(sessionId);
     if (session) {
       switch_channel_t *channel = switch_core_session_get_channel(session);
-      switch_media_bug_t *bug = (switch_media_bug_t*) switch_channel_get_private(channel, bugname);
+      switch_media_bug_t *bug = (switch_media_bug_t*) switch_channel_get_private(channel, MY_BUG_NAME);
       if (bug) {
         private_t* tech_pvt = (private_t*) switch_core_media_bug_get_user_data(bug);
         if (tech_pvt) {
@@ -195,8 +194,7 @@ namespace {
     tech_pvt->channels = channels;
     tech_pvt->id = ++idxCallCount;
     tech_pvt->buffer_overrun_notified = 0;
-    strncpy(tech_pvt->bugname, bugname, MAX_BUG_LEN);
-
+    
     size_t buflen = LWS_PRE + (FRAME_SIZE_8000 * desiredSampling / 8000 * channels * 1000 / RTP_PACKETIZATION_PERIOD * nAudioBufferSecs);
 
     const char* apiKey = switch_channel_get_variable(channel, "ASSEMBLYAI_API_KEY");
@@ -206,7 +204,7 @@ namespace {
       return SWITCH_STATUS_FALSE;
     }
 
-    assemblyai::AudioPipe* ap = new assemblyai::AudioPipe(tech_pvt->sessionId, bugname, tech_pvt->host, tech_pvt->port, tech_pvt->path, 
+    assemblyai::AudioPipe* ap = new assemblyai::AudioPipe(tech_pvt->sessionId, tech_pvt->host, tech_pvt->port, tech_pvt->path, 
       buflen, read_impl.decoded_bytes_per_packet, apiKey, eventCallback);
     if (!ap) {
       switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error allocating AudioPipe\n");
@@ -253,8 +251,7 @@ extern "C" {
   switch_status_t aai_transcribe_init() {
     switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "mod_assemblyai_transcribe: audio buffer (in secs):    %d secs\n", nAudioBufferSecs);
  
-    int logs = LLL_ERR | LLL_WARN | LLL_NOTICE ;
-    //| LLL_INFO | LLL_PARSER | LLL_HEADER | LLL_EXT | LLL_CLIENT  | LLL_LATENCY | LLL_DEBUG ;
+    int logs = LLL_ERR | LLL_WARN | LLL_NOTICE || LLL_INFO | LLL_PARSER | LLL_HEADER | LLL_EXT | LLL_CLIENT  | LLL_LATENCY | LLL_DEBUG ;
     
     assemblyai::AudioPipe::initialize(logs, lws_logger);
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "AudioPipe::initialize completed\n");
@@ -309,7 +306,7 @@ extern "C" {
 
 	switch_status_t aai_transcribe_session_stop(switch_core_session_t *session,int channelIsClosing, char* bugname) {
     switch_channel_t *channel = switch_core_session_get_channel(session);
-    switch_media_bug_t *bug = (switch_media_bug_t*) switch_channel_get_private(channel, bugname);
+    switch_media_bug_t *bug = (switch_media_bug_t*) switch_channel_get_private(channel, MY_BUG_NAME);
     if (!bug) {
       switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "aai_transcribe_session_stop: no bug - websocket conection already closed\n");
       return SWITCH_STATUS_FALSE;

mod_assemblyai_transcribe/audio_pipe.cpp

@@ -72,7 +72,7 @@ int AudioPipe::lws_callback(struct lws *wsi,
         lwsl_err("AudioPipe::lws_service_thread LWS_CALLBACK_CLIENT_CONNECTION_ERROR: %s, response status %d\n", in ? (char *)in : "(null)", rc); 
         if (ap) {
           ap->m_state = LWS_CLIENT_FAILED;
-          ap->m_callback(ap->m_uuid.c_str(), ap->m_bugname.c_str(), AudioPipe::CONNECT_FAIL, (char *) in, ap->isFinished());
+          ap->m_callback(ap->m_uuid.c_str(), AudioPipe::CONNECT_FAIL, (char *) in, ap->isFinished());
         }
         else {
           lwsl_err("AudioPipe::lws_service_thread LWS_CALLBACK_CLIENT_CONNECTION_ERROR unable to find wsi %p..\n", wsi); 
@@ -87,7 +87,7 @@ int AudioPipe::lws_callback(struct lws *wsi,
           *ppAp = ap;
           ap->m_vhd = vhd;
           ap->m_state = LWS_CLIENT_CONNECTED;
-          ap->m_callback(ap->m_uuid.c_str(), ap->m_bugname.c_str(), AudioPipe::CONNECT_SUCCESS, NULL,  ap->isFinished());
+          ap->m_callback(ap->m_uuid.c_str(), AudioPipe::CONNECT_SUCCESS, NULL,  ap->isFinished());
         }
         else {
           lwsl_err("AudioPipe::lws_service_thread LWS_CALLBACK_CLIENT_ESTABLISHED %s unable to find wsi %p..\n", ap->m_uuid.c_str(), wsi); 
@@ -105,12 +105,12 @@ int AudioPipe::lws_callback(struct lws *wsi,
           // closed by us
 
           lwsl_debug("%s socket closed by us\n", ap->m_uuid.c_str());
-          ap->m_callback(ap->m_uuid.c_str(), ap->m_bugname.c_str(), AudioPipe::CONNECTION_CLOSED_GRACEFULLY, NULL,  ap->isFinished());
+          ap->m_callback(ap->m_uuid.c_str(), AudioPipe::CONNECTION_CLOSED_GRACEFULLY, NULL,  ap->isFinished());
         }
         else if (ap->m_state == LWS_CLIENT_CONNECTED) {
           // closed by far end
           lwsl_info("%s socket closed by far end\n", ap->m_uuid.c_str());
-          ap->m_callback(ap->m_uuid.c_str(), ap->m_bugname.c_str(), AudioPipe::CONNECTION_DROPPED, NULL,  ap->isFinished());
+          ap->m_callback(ap->m_uuid.c_str(), AudioPipe::CONNECTION_DROPPED, NULL,  ap->isFinished());
         }
         ap->m_state = LWS_CLIENT_DISCONNECTED;
         ap->setClosed();
@@ -172,7 +172,7 @@ int AudioPipe::lws_callback(struct lws *wsi,
           if (lws_is_final_fragment(wsi)) {
             if (nullptr != ap->m_recv_buf) {
               std::string msg((char *)ap->m_recv_buf, ap->m_recv_buf_ptr - ap->m_recv_buf);
-              ap->m_callback(ap->m_uuid.c_str(), ap->m_bugname.c_str(), AudioPipe::MESSAGE, msg.c_str(),  ap->isFinished());
+              ap->m_callback(ap->m_uuid.c_str(), AudioPipe::MESSAGE, msg.c_str(),  ap->isFinished());
               if (nullptr != ap->m_recv_buf) free(ap->m_recv_buf);
             }
             ap->m_recv_buf = ap->m_recv_buf_ptr = nullptr;
@@ -261,7 +261,6 @@ static const lws_retry_bo_t retry = {
 };
 
 struct lws_context *AudioPipe::context = nullptr;
-std::thread AudioPipe::serviceThread;
 std::string AudioPipe::protocolName;
 std::mutex AudioPipe::mutex_connects;
 std::mutex AudioPipe::mutex_disconnects;
@@ -430,28 +429,26 @@ bool AudioPipe::lws_service_thread() {
 
 void AudioPipe::initialize(int loglevel, log_emit_function logger) {
 
-  //lws_set_log_level(loglevel, logger);
+  lws_set_log_level(loglevel, logger);
 
   lwsl_notice("AudioPipe::initialize starting\n"); 
   std::lock_guard<std::mutex> lock(mapMutex);
+  std::thread t(&AudioPipe::lws_service_thread);
   stopFlag = false;
-  serviceThread = std::thread(&AudioPipe::lws_service_thread);
+  t.detach();
 }
 
 bool AudioPipe::deinitialize() {
   lwsl_notice("AudioPipe::deinitialize\n"); 
   std::lock_guard<std::mutex> lock(mapMutex);
   stopFlag = true;
-    if (serviceThread.joinable()) {
-    serviceThread.join();
-  }
   return true;
 }
 
 // instance members
-AudioPipe::AudioPipe(const char* uuid, const char* bugname, const char* host, unsigned int port, const char* path,
+AudioPipe::AudioPipe(const char* uuid, const char* host, unsigned int port, const char* path,
   size_t bufLen, size_t minFreespace, const char* apiKey, notifyHandler_t callback) :
-  m_uuid(uuid), m_host(host), m_port(port), m_path(path), m_finished(false), m_bugname(bugname),
+  m_uuid(uuid), m_host(host), m_port(port), m_path(path), m_finished(false),
   m_audio_buffer_min_freespace(minFreespace), m_audio_buffer_max_len(bufLen), m_gracefulShutdown(false),
   m_audio_buffer_write_offset(LWS_PRE), m_recv_buf(nullptr), m_recv_buf_ptr(nullptr), 
   m_state(LWS_CLIENT_IDLE), m_wsi(nullptr), m_vhd(nullptr), m_apiKey(apiKey), m_callback(callback) {

mod_assemblyai_transcribe/audio_pipe.hpp

@@ -31,7 +31,7 @@ public:
     MESSAGE
   };
   typedef void (*log_emit_function)(int level, const char *line);
-  typedef void (*notifyHandler_t)(const char *sessionId,const char* bugname, NotifyEvent_t event, const char* message, bool finished);
+  typedef void (*notifyHandler_t)(const char *sessionId, NotifyEvent_t event, const char* message, bool finished);
 
   struct lws_per_vhost_data {
     struct lws_context *context;
@@ -44,7 +44,7 @@ public:
   static bool lws_service_thread();
 
   // constructor
-  AudioPipe(const char* uuid, const char* bugname, const char* host, unsigned int port, const char* path, 
+  AudioPipe(const char* uuid, const char* host, unsigned int port, const char* path, 
     size_t bufLen, size_t minFreespace, const char* apiKey, notifyHandler_t callback);
   ~AudioPipe();  
 
@@ -86,7 +86,6 @@ public:
   void operator=(const AudioPipe&) = delete;
 
 private:
-  static std::thread serviceThread;
 
   static int lws_callback(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len); 
   static struct lws_context *context;

mod_assemblyai_transcribe/mod_assemblyai_transcribe.c

@@ -74,7 +74,7 @@ static switch_status_t start_capture(switch_core_session_t *session, switch_medi
 	void *pUserData;
 	uint32_t samples_per_second;
 
-	if (switch_channel_get_private(channel, bugname)) {
+	if (switch_channel_get_private(channel, MY_BUG_NAME)) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "removing bug from previous transcribe\n");
 		do_stop(session, bugname);
 	}
@@ -94,7 +94,7 @@ static switch_status_t start_capture(switch_core_session_t *session, switch_medi
 	if ((status = switch_core_media_bug_add(session, "aai_transcribe", NULL, capture_callback, pUserData, 0, flags, &bug)) != SWITCH_STATUS_SUCCESS) {
 		return status;
 	}
-  switch_channel_set_private(channel, bugname, bug);
+  switch_channel_set_private(channel, MY_BUG_NAME, bug);
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "added media bug for assemblyai transcribe\n");
 
 	return SWITCH_STATUS_SUCCESS;
@@ -105,7 +105,7 @@ static switch_status_t do_stop(switch_core_session_t *session,  char* bugname)
 	switch_status_t status = SWITCH_STATUS_SUCCESS;
 
 	switch_channel_t *channel = switch_core_session_get_channel(session);
-	switch_media_bug_t *bug = switch_channel_get_private(channel, bugname);
+	switch_media_bug_t *bug = switch_channel_get_private(channel, MY_BUG_NAME);
 
 	if (bug) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Received user command command to stop transcribe.\n");

mod_audio_fork/audio_pipe.cpp

@@ -7,7 +7,6 @@
 #define MAX_RECV_BUF_SIZE (65 * 1024 * 10)
 #define RECV_BUF_REALLOC_SIZE (8 * 1024)
 
-using namespace drachtio;
 
 namespace {
   static const char* basicAuthUser = std::getenv("MOD_AUDIO_FORK_HTTP_AUTH_USER");
@@ -268,7 +267,6 @@ static const lws_retry_bo_t retry = {
 };
 
 struct lws_context *AudioPipe::context = nullptr;
-std::thread AudioPipe::serviceThread;
 std::string AudioPipe::protocolName;
 std::mutex AudioPipe::mutex_connects;
 std::mutex AudioPipe::mutex_disconnects;
@@ -438,21 +436,19 @@ bool AudioPipe::lws_service_thread() {
 
 void AudioPipe::initialize(const char* protocol, int loglevel, log_emit_function logger) {
   protocolName = protocol;
-  //lws_set_log_level(loglevel, logger);
+  lws_set_log_level(loglevel, logger);
 
   lwsl_notice("AudioPipe::initialize starting\n"); 
   std::lock_guard<std::mutex> lock(mapMutex);
+  std::thread t(&AudioPipe::lws_service_thread);
   stopFlag = false;
-  serviceThread = std::thread(&AudioPipe::lws_service_thread);
+  t.detach();
 }
 
 bool AudioPipe::deinitialize() {
   lwsl_notice("AudioPipe::deinitialize\n"); 
   std::lock_guard<std::mutex> lock(mapMutex);
   stopFlag = true;
-  if (serviceThread.joinable()) {
-    serviceThread.join();
-  }
   return true;
 }
 

mod_audio_fork/audio_pipe.hpp

@@ -10,140 +10,135 @@
 
 #include <libwebsockets.h>
 
-namespace drachtio {
+class AudioPipe {
+public:
+  enum LwsState_t {
+    LWS_CLIENT_IDLE,
+    LWS_CLIENT_CONNECTING,
+    LWS_CLIENT_CONNECTED,
+    LWS_CLIENT_FAILED,
+    LWS_CLIENT_DISCONNECTING,
+    LWS_CLIENT_DISCONNECTED
+  };
+  enum NotifyEvent_t {
+    CONNECT_SUCCESS,
+    CONNECT_FAIL,
+    CONNECTION_DROPPED,
+    CONNECTION_CLOSED_GRACEFULLY,
+    MESSAGE
+  };
+  typedef void (*log_emit_function)(int level, const char *line);
+  typedef void (*notifyHandler_t)(const char *sessionId, const char* bugname, NotifyEvent_t event, const char* message);
 
-  class AudioPipe {
-  public:
-    enum LwsState_t {
-      LWS_CLIENT_IDLE,
-      LWS_CLIENT_CONNECTING,
-      LWS_CLIENT_CONNECTED,
-      LWS_CLIENT_FAILED,
-      LWS_CLIENT_DISCONNECTING,
-      LWS_CLIENT_DISCONNECTED
-    };
-    enum NotifyEvent_t {
-      CONNECT_SUCCESS,
-      CONNECT_FAIL,
-      CONNECTION_DROPPED,
-      CONNECTION_CLOSED_GRACEFULLY,
-      MESSAGE
-    };
-    typedef void (*log_emit_function)(int level, const char *line);
-    typedef void (*notifyHandler_t)(const char *sessionId, const char* bugname, NotifyEvent_t event, const char* message);
-
-    struct lws_per_vhost_data {
-      struct lws_context *context;
-      struct lws_vhost *vhost;
-      const struct lws_protocols *protocol;
-    };
-
-    static void initialize(const char* protocolName, int loglevel, log_emit_function logger);
-    static bool deinitialize();
-    static bool lws_service_thread();
-
-    // constructor
-    AudioPipe(const char* uuid, const char* host, unsigned int port, const char* path, int sslFlags, 
-      size_t bufLen, size_t minFreespace, const char* username, const char* password, char* bugname, notifyHandler_t callback);
-    ~AudioPipe();  
-
-    LwsState_t getLwsState(void) { return m_state; }
-    void connect(void);
-    void bufferForSending(const char* text);
-    size_t binarySpaceAvailable(void) {
-      return m_audio_buffer_max_len - m_audio_buffer_write_offset;
-    }
-    size_t binaryMinSpace(void) {
-      return m_audio_buffer_min_freespace;
-    }
-    char * binaryWritePtr(void) { 
-      return (char *) m_audio_buffer + m_audio_buffer_write_offset;
-    }
-    void binaryWritePtrAdd(size_t len) {
-      m_audio_buffer_write_offset += len;
-    }
-    void binaryWritePtrResetToZero(void) {
-      m_audio_buffer_write_offset = 0;
-    }
-    void lockAudioBuffer(void) {
-      m_audio_mutex.lock();
-    }
-    void unlockAudioBuffer(void) ;
-    bool hasBasicAuth(void) {
-      return !m_username.empty() && !m_password.empty();
-    }
-
-    void getBasicAuth(std::string& username, std::string& password) {
-      username = m_username;
-      password = m_password;
-    }
-
-    void do_graceful_shutdown();
-    bool isGracefulShutdown(void) {
-      return m_gracefulShutdown;
-    }
-
-    void close() ;
-
-    // no default constructor or copying
-    AudioPipe() = delete;
-    AudioPipe(const AudioPipe&) = delete;
-    void operator=(const AudioPipe&) = delete;
-
-  private:
-    static std::thread serviceThread;
-
-    static int lws_callback(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len); 
-    static struct lws_context *context;
-    static std::string protocolName;
-    static std::mutex mutex_connects;
-    static std::mutex mutex_disconnects;
-    static std::mutex mutex_writes;
-    static std::list<AudioPipe*> pendingConnects;
-    static std::list<AudioPipe*> pendingDisconnects;
-    static std::list<AudioPipe*> pendingWrites;
-    static log_emit_function logger;
-
-    static std::mutex mapMutex;
-    static bool stopFlag;
-
-    static AudioPipe* findAndRemovePendingConnect(struct lws *wsi);
-    static AudioPipe* findPendingConnect(struct lws *wsi);
-    static void addPendingConnect(AudioPipe* ap);
-    static void addPendingDisconnect(AudioPipe* ap);
-    static void addPendingWrite(AudioPipe* ap);
-    static void processPendingConnects(lws_per_vhost_data *vhd);
-    static void processPendingDisconnects(lws_per_vhost_data *vhd);
-    static void processPendingWrites(void);
-    
-    bool connect_client(struct lws_per_vhost_data *vhd);
-
-    LwsState_t m_state;
-    std::string m_uuid;
-    std::string m_host;
-    std::string m_bugname;
-    unsigned int m_port;
-    std::string m_path;
-    std::string m_metadata;
-    std::mutex m_text_mutex;
-    std::mutex m_audio_mutex;
-    int m_sslFlags;
-    struct lws *m_wsi;
-    uint8_t *m_audio_buffer;
-    size_t m_audio_buffer_max_len;
-    size_t m_audio_buffer_write_offset;
-    size_t m_audio_buffer_min_freespace;
-    uint8_t* m_recv_buf;
-    uint8_t* m_recv_buf_ptr;
-    size_t m_recv_buf_len;
-    struct lws_per_vhost_data* m_vhd;
-    notifyHandler_t m_callback;
-    log_emit_function m_logger;
-    std::string m_username;
-    std::string m_password;
-    bool m_gracefulShutdown;
+  struct lws_per_vhost_data {
+    struct lws_context *context;
+    struct lws_vhost *vhost;
+    const struct lws_protocols *protocol;
   };
 
-} // namespace drachtio
+  static void initialize(const char* protocolName, int loglevel, log_emit_function logger);
+  static bool deinitialize();
+  static bool lws_service_thread();
+
+  // constructor
+  AudioPipe(const char* uuid, const char* host, unsigned int port, const char* path, int sslFlags, 
+    size_t bufLen, size_t minFreespace, const char* username, const char* password, char* bugname, notifyHandler_t callback);
+  ~AudioPipe();  
+
+  LwsState_t getLwsState(void) { return m_state; }
+  void connect(void);
+  void bufferForSending(const char* text);
+  size_t binarySpaceAvailable(void) {
+    return m_audio_buffer_max_len - m_audio_buffer_write_offset;
+  }
+  size_t binaryMinSpace(void) {
+    return m_audio_buffer_min_freespace;
+  }
+  char * binaryWritePtr(void) { 
+    return (char *) m_audio_buffer + m_audio_buffer_write_offset;
+  }
+  void binaryWritePtrAdd(size_t len) {
+    m_audio_buffer_write_offset += len;
+  }
+  void binaryWritePtrResetToZero(void) {
+    m_audio_buffer_write_offset = 0;
+  }
+  void lockAudioBuffer(void) {
+    m_audio_mutex.lock();
+  }
+  void unlockAudioBuffer(void) ;
+  bool hasBasicAuth(void) {
+    return !m_username.empty() && !m_password.empty();
+  }
+
+  void getBasicAuth(std::string& username, std::string& password) {
+    username = m_username;
+    password = m_password;
+  }
+
+  void do_graceful_shutdown();
+  bool isGracefulShutdown(void) {
+    return m_gracefulShutdown;
+  }
+
+  void close() ;
+
+  // no default constructor or copying
+  AudioPipe() = delete;
+  AudioPipe(const AudioPipe&) = delete;
+  void operator=(const AudioPipe&) = delete;
+
+private:
+
+  static int lws_callback(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len); 
+  static struct lws_context *context;
+  static std::string protocolName;
+  static std::mutex mutex_connects;
+  static std::mutex mutex_disconnects;
+  static std::mutex mutex_writes;
+  static std::list<AudioPipe*> pendingConnects;
+  static std::list<AudioPipe*> pendingDisconnects;
+  static std::list<AudioPipe*> pendingWrites;
+  static log_emit_function logger;
+
+  static std::mutex mapMutex;
+  static bool stopFlag;
+
+  static AudioPipe* findAndRemovePendingConnect(struct lws *wsi);
+  static AudioPipe* findPendingConnect(struct lws *wsi);
+  static void addPendingConnect(AudioPipe* ap);
+  static void addPendingDisconnect(AudioPipe* ap);
+  static void addPendingWrite(AudioPipe* ap);
+  static void processPendingConnects(lws_per_vhost_data *vhd);
+  static void processPendingDisconnects(lws_per_vhost_data *vhd);
+  static void processPendingWrites(void);
+  
+  bool connect_client(struct lws_per_vhost_data *vhd);
+
+  LwsState_t m_state;
+  std::string m_uuid;
+  std::string m_host;
+  std::string m_bugname;
+  unsigned int m_port;
+  std::string m_path;
+  std::string m_metadata;
+  std::mutex m_text_mutex;
+  std::mutex m_audio_mutex;
+  int m_sslFlags;
+  struct lws *m_wsi;
+  uint8_t *m_audio_buffer;
+  size_t m_audio_buffer_max_len;
+  size_t m_audio_buffer_write_offset;
+  size_t m_audio_buffer_min_freespace;
+  uint8_t* m_recv_buf;
+  uint8_t* m_recv_buf_ptr;
+  size_t m_recv_buf_len;
+  struct lws_per_vhost_data* m_vhd;
+  notifyHandler_t m_callback;
+  log_emit_function m_logger;
+  std::string m_username;
+  std::string m_password;
+  bool m_gracefulShutdown;
+};
 
 #endif

mod_audio_fork/lws_glue.cpp

@@ -156,7 +156,7 @@ namespace {
     }
   }
 
-  static void eventCallback(const char* sessionId, const char* bugname, drachtio::AudioPipe::NotifyEvent_t event, const char* message) {
+  static void eventCallback(const char* sessionId, const char* bugname, AudioPipe::NotifyEvent_t event, const char* message) {
     switch_core_session_t* session = switch_core_session_locate(sessionId);
     if (session) {
       switch_channel_t *channel = switch_core_session_get_channel(session);
@@ -165,16 +165,16 @@ namespace {
         private_t* tech_pvt = (private_t*) switch_core_media_bug_get_user_data(bug);
         if (tech_pvt) {
           switch (event) {
-            case drachtio::AudioPipe::CONNECT_SUCCESS:
+            case AudioPipe::CONNECT_SUCCESS:
               switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "connection successful\n");
               tech_pvt->responseHandler(session, EVENT_CONNECT_SUCCESS, NULL);
               if (strlen(tech_pvt->initialMetadata) > 0) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "sending initial metadata %s\n", tech_pvt->initialMetadata);
-                drachtio::AudioPipe *pAudioPipe = static_cast<drachtio::AudioPipe *>(tech_pvt->pAudioPipe);
+                AudioPipe *pAudioPipe = static_cast<AudioPipe *>(tech_pvt->pAudioPipe);
                 pAudioPipe->bufferForSending(tech_pvt->initialMetadata);
               }
             break;
-            case drachtio::AudioPipe::CONNECT_FAIL:
+            case AudioPipe::CONNECT_FAIL:
             {
               // first thing: we can no longer access the AudioPipe
               std::stringstream json;
@@ -184,18 +184,18 @@ namespace {
               switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "connection failed: %s\n", message);
             }
             break;
-            case drachtio::AudioPipe::CONNECTION_DROPPED:
+            case AudioPipe::CONNECTION_DROPPED:
               // first thing: we can no longer access the AudioPipe
               tech_pvt->pAudioPipe = nullptr;
               tech_pvt->responseHandler(session, EVENT_DISCONNECT, NULL);
               switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "connection dropped from far end\n");
             break;
-            case drachtio::AudioPipe::CONNECTION_CLOSED_GRACEFULLY:
+            case AudioPipe::CONNECTION_CLOSED_GRACEFULLY:
               // first thing: we can no longer access the AudioPipe
               tech_pvt->pAudioPipe = nullptr;
               switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "connection closed gracefully\n");
             break;
-            case drachtio::AudioPipe::MESSAGE:
+            case AudioPipe::MESSAGE:
               processIncomingMessage(tech_pvt, session, message);
             break;
           }
@@ -239,7 +239,7 @@ namespace {
     
     size_t buflen = LWS_PRE + (FRAME_SIZE_8000 * desiredSampling / 8000 * channels * 1000 / RTP_PACKETIZATION_PERIOD * nAudioBufferSecs);
 
-    drachtio::AudioPipe* ap = new drachtio::AudioPipe(tech_pvt->sessionId, host, port, path, sslFlags, 
+    AudioPipe* ap = new AudioPipe(tech_pvt->sessionId, host, port, path, sslFlags, 
       buflen, read_impl.decoded_bytes_per_packet, username, password, bugname, eventCallback);
     if (!ap) {
       switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error allocating AudioPipe\n");
@@ -374,17 +374,13 @@ extern "C" {
  
     int logs = LLL_ERR | LLL_WARN | LLL_NOTICE ;
      //LLL_INFO | LLL_PARSER | LLL_HEADER | LLL_EXT | LLL_CLIENT  | LLL_LATENCY | LLL_DEBUG ;
-    drachtio::AudioPipe::initialize(mySubProtocolName, logs, lws_logger);
-    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "mod_audio_fork successfully initialized\n");
-    return SWITCH_STATUS_SUCCESS;
+    AudioPipe::initialize(mySubProtocolName, logs, lws_logger);
+   return SWITCH_STATUS_SUCCESS;
   }
 
   switch_status_t fork_cleanup() {
     bool cleanup = false;
-    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "mod_audio_fork unloading..\n");
-
-    cleanup = drachtio::AudioPipe::deinitialize();
-    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "mod_audio_fork unloaded status %d\n", cleanup);
+    cleanup = AudioPipe::deinitialize();
     if (cleanup == true) {
         return SWITCH_STATUS_SUCCESS;
     }
@@ -424,7 +420,7 @@ extern "C" {
 
    switch_status_t fork_session_connect(void **ppUserData) {
     private_t *tech_pvt = static_cast<private_t *>(*ppUserData);
-    drachtio::AudioPipe *pAudioPipe = static_cast<drachtio::AudioPipe*>(tech_pvt->pAudioPipe);
+    AudioPipe *pAudioPipe = static_cast<AudioPipe*>(tech_pvt->pAudioPipe);
     pAudioPipe->connect();
     return SWITCH_STATUS_SUCCESS;
   }
@@ -442,7 +438,7 @@ extern "C" {
     switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "(%u) fork_session_cleanup\n", id);
 
     if (!tech_pvt) return SWITCH_STATUS_FALSE;
-    drachtio::AudioPipe *pAudioPipe = static_cast<drachtio::AudioPipe *>(tech_pvt->pAudioPipe);
+    AudioPipe *pAudioPipe = static_cast<AudioPipe *>(tech_pvt->pAudioPipe);
       
     switch_mutex_lock(tech_pvt->mutex);
 
@@ -485,7 +481,7 @@ extern "C" {
     private_t* tech_pvt = (private_t*) switch_core_media_bug_get_user_data(bug);
   
     if (!tech_pvt) return SWITCH_STATUS_FALSE;
-    drachtio::AudioPipe *pAudioPipe = static_cast<drachtio::AudioPipe *>(tech_pvt->pAudioPipe);
+    AudioPipe *pAudioPipe = static_cast<AudioPipe *>(tech_pvt->pAudioPipe);
     if (pAudioPipe && text) pAudioPipe->bufferForSending(text);
 
     return SWITCH_STATUS_SUCCESS;
@@ -520,7 +516,7 @@ extern "C" {
 
     tech_pvt->graceful_shutdown = 1;
 
-    drachtio::AudioPipe *pAudioPipe = static_cast<drachtio::AudioPipe *>(tech_pvt->pAudioPipe);
+    AudioPipe *pAudioPipe = static_cast<AudioPipe *>(tech_pvt->pAudioPipe);
     if (pAudioPipe) pAudioPipe->do_graceful_shutdown();
 
     return SWITCH_STATUS_SUCCESS;
@@ -539,8 +535,8 @@ extern "C" {
         switch_mutex_unlock(tech_pvt->mutex);
         return SWITCH_TRUE;
       }
-      drachtio::AudioPipe *pAudioPipe = static_cast<drachtio::AudioPipe *>(tech_pvt->pAudioPipe);
-      if (pAudioPipe->getLwsState() != drachtio::AudioPipe::LWS_CLIENT_CONNECTED) {
+      AudioPipe *pAudioPipe = static_cast<AudioPipe *>(tech_pvt->pAudioPipe);
+      if (pAudioPipe->getLwsState() != AudioPipe::LWS_CLIENT_CONNECTED) {
         switch_mutex_unlock(tech_pvt->mutex);
         return SWITCH_TRUE;
       }

mod_deepgram_transcribe/audio_pipe.cpp

@@ -71,7 +71,7 @@ int AudioPipe::lws_callback(struct lws *wsi,
         lwsl_err("AudioPipe::lws_service_thread LWS_CALLBACK_CLIENT_CONNECTION_ERROR: %s, response status %d\n", in ? (char *)in : "(null)", rc); 
         if (ap) {
           ap->m_state = LWS_CLIENT_FAILED;
-          ap->m_callback(ap->m_uuid.c_str(),  ap->m_bugname.c_str(), deepgram::AudioPipe::CONNECT_FAIL, (char *) in, ap->isFinished());
+          ap->m_callback(ap->m_uuid.c_str(), AudioPipe::CONNECT_FAIL, (char *) in, ap->isFinished());
         }
         else {
           lwsl_err("AudioPipe::lws_service_thread LWS_CALLBACK_CLIENT_CONNECTION_ERROR unable to find wsi %p..\n", wsi); 
@@ -82,12 +82,11 @@ int AudioPipe::lws_callback(struct lws *wsi,
     case LWS_CALLBACK_CLIENT_ESTABLISHED:
       {
         AudioPipe* ap = findAndRemovePendingConnect(wsi);
-
         if (ap) {
           *ppAp = ap;
           ap->m_vhd = vhd;
           ap->m_state = LWS_CLIENT_CONNECTED;
-          ap->m_callback(ap->m_uuid.c_str(), ap->m_bugname.c_str(), deepgram::AudioPipe::CONNECT_SUCCESS, NULL,  ap->isFinished());
+          ap->m_callback(ap->m_uuid.c_str(), AudioPipe::CONNECT_SUCCESS, NULL,  ap->isFinished());
         }
         else {
           lwsl_err("AudioPipe::lws_service_thread LWS_CALLBACK_CLIENT_ESTABLISHED %s unable to find wsi %p..\n", ap->m_uuid.c_str(), wsi); 
@@ -97,7 +96,6 @@ int AudioPipe::lws_callback(struct lws *wsi,
     case LWS_CALLBACK_CLIENT_CLOSED:
       {
         AudioPipe* ap = *ppAp;
-
         if (!ap) {
           lwsl_err("AudioPipe::lws_service_thread LWS_CALLBACK_CLIENT_CLOSED %s unable to find wsi %p..\n", ap->m_uuid.c_str(), wsi); 
           return 0;
@@ -106,12 +104,12 @@ int AudioPipe::lws_callback(struct lws *wsi,
           // closed by us
 
           lwsl_debug("%s socket closed by us\n", ap->m_uuid.c_str());
-          ap->m_callback(ap->m_uuid.c_str(),  ap->m_bugname.c_str(), deepgram::AudioPipe::CONNECTION_CLOSED_GRACEFULLY, NULL,  ap->isFinished());
+          ap->m_callback(ap->m_uuid.c_str(), AudioPipe::CONNECTION_CLOSED_GRACEFULLY, NULL,  ap->isFinished());
         }
         else if (ap->m_state == LWS_CLIENT_CONNECTED) {
           // closed by far end
           lwsl_info("%s socket closed by far end\n", ap->m_uuid.c_str());
-          ap->m_callback(ap->m_uuid.c_str(),  ap->m_bugname.c_str(), deepgram::AudioPipe::CONNECTION_DROPPED, NULL,  ap->isFinished());
+          ap->m_callback(ap->m_uuid.c_str(), AudioPipe::CONNECTION_DROPPED, NULL,  ap->isFinished());
         }
         ap->m_state = LWS_CLIENT_DISCONNECTED;
         ap->setClosed();
@@ -127,7 +125,6 @@ int AudioPipe::lws_callback(struct lws *wsi,
     case LWS_CALLBACK_CLIENT_RECEIVE:
       {
         AudioPipe* ap = *ppAp;
-
         if (!ap) {
           lwsl_err("AudioPipe::lws_service_thread LWS_CALLBACK_CLIENT_RECEIVE %s unable to find wsi %p..\n", ap->m_uuid.c_str(), wsi); 
           return 0;
@@ -174,7 +171,7 @@ int AudioPipe::lws_callback(struct lws *wsi,
           if (lws_is_final_fragment(wsi)) {
             if (nullptr != ap->m_recv_buf) {
               std::string msg((char *)ap->m_recv_buf, ap->m_recv_buf_ptr - ap->m_recv_buf);
-              ap->m_callback(ap->m_uuid.c_str(),  ap->m_bugname.c_str(), deepgram::AudioPipe::MESSAGE, msg.c_str(),  ap->isFinished());
+              ap->m_callback(ap->m_uuid.c_str(), AudioPipe::MESSAGE, msg.c_str(),  ap->isFinished());
               if (nullptr != ap->m_recv_buf) free(ap->m_recv_buf);
             }
             ap->m_recv_buf = ap->m_recv_buf_ptr = nullptr;
@@ -187,7 +184,6 @@ int AudioPipe::lws_callback(struct lws *wsi,
     case LWS_CALLBACK_CLIENT_WRITEABLE:
       {
         AudioPipe* ap = *ppAp;
-
         if (!ap) {
           lwsl_err("AudioPipe::lws_service_thread LWS_CALLBACK_CLIENT_WRITEABLE %s unable to find wsi %p..\n", ap->m_uuid.c_str(), wsi); 
           return 0;
@@ -255,7 +251,7 @@ static const lws_retry_bo_t retry = {
 };
 
 struct lws_context *AudioPipe::context = nullptr;
-std::thread AudioPipe::serviceThread;
+std::string AudioPipe::protocolName;
 std::mutex AudioPipe::mutex_connects;
 std::mutex AudioPipe::mutex_disconnects;
 std::mutex AudioPipe::mutex_writes;
@@ -424,29 +420,26 @@ bool AudioPipe::lws_service_thread() {
 
 void AudioPipe::initialize(int loglevel, log_emit_function logger) {
 
-  //lws_set_log_level(loglevel, logger);
+  lws_set_log_level(loglevel, logger);
 
   lwsl_notice("AudioPipe::initialize starting\n"); 
   std::lock_guard<std::mutex> lock(mapMutex);
+  std::thread t(&AudioPipe::lws_service_thread);
   stopFlag = false;
-  serviceThread = std::thread(&AudioPipe::lws_service_thread);
+  t.detach();
 }
 
 bool AudioPipe::deinitialize() {
   lwsl_notice("AudioPipe::deinitialize\n"); 
   std::lock_guard<std::mutex> lock(mapMutex);
   stopFlag = true;
-  if (serviceThread.joinable()) {
-    serviceThread.join();
-  }
-
   return true;
 }
 
 // instance members
-AudioPipe::AudioPipe(const char* uuid, const char* bugname, const char* host, unsigned int port, const char* path,
+AudioPipe::AudioPipe(const char* uuid, const char* host, unsigned int port, const char* path,
   size_t bufLen, size_t minFreespace, const char* apiKey, notifyHandler_t callback) :
-  m_uuid(uuid), m_host(host), m_port(port), m_path(path), m_finished(false), m_bugname(bugname),
+  m_uuid(uuid), m_host(host), m_port(port), m_path(path), m_finished(false),
   m_audio_buffer_min_freespace(minFreespace), m_audio_buffer_max_len(bufLen), m_gracefulShutdown(false),
   m_audio_buffer_write_offset(LWS_PRE), m_recv_buf(nullptr), m_recv_buf_ptr(nullptr), 
   m_state(LWS_CLIENT_IDLE), m_wsi(nullptr), m_vhd(nullptr), m_apiKey(apiKey), m_callback(callback) {
@@ -475,6 +468,7 @@ bool AudioPipe::connect_client(struct lws_per_vhost_data *vhd) {
   i.host = i.address;
   i.origin = i.address;
   i.ssl_connection = LCCSCF_USE_SSL;
+  //i.protocol = protocolName.c_str();
   i.pwsi = &(m_wsi);
 
   m_state = LWS_CLIENT_CONNECTING;

mod_deepgram_transcribe/audio_pipe.hpp

@@ -13,131 +13,133 @@
 
 namespace deepgram {
 
-  class AudioPipe {
-  public:
-    enum LwsState_t {
-      LWS_CLIENT_IDLE,
-      LWS_CLIENT_CONNECTING,
-      LWS_CLIENT_CONNECTED,
-      LWS_CLIENT_FAILED,
-      LWS_CLIENT_DISCONNECTING,
-      LWS_CLIENT_DISCONNECTED
-    };
-    enum NotifyEvent_t {
-      CONNECT_SUCCESS,
-      CONNECT_FAIL,
-      CONNECTION_DROPPED,
-      CONNECTION_CLOSED_GRACEFULLY,
-      MESSAGE
-    };
-    typedef void (*log_emit_function)(int level, const char *line);
-    typedef void (*notifyHandler_t)(const char *sessionId, const char* bugname, NotifyEvent_t event, const char* message, bool finished);
-
-    struct lws_per_vhost_data {
-      struct lws_context *context;
-      struct lws_vhost *vhost;
-      const struct lws_protocols *protocol;
-    };
-
-    static void initialize(int loglevel, log_emit_function logger);
-    static bool deinitialize();
-    static bool lws_service_thread();
-
-    // constructor
-    AudioPipe(const char* uuid, const char* bugname, const char* host, unsigned int port, const char* path, 
-      size_t bufLen, size_t minFreespace, const char* apiKey, notifyHandler_t callback);
-    ~AudioPipe();  
-
-    LwsState_t getLwsState(void) { return m_state; }
-    std::string& getApiKey(void) {
-      return m_apiKey;
-    }
-    void connect(void);
-    void bufferForSending(const char* text);
-    size_t binarySpaceAvailable(void) {
-      return m_audio_buffer_max_len - m_audio_buffer_write_offset;
-    }
-    size_t binaryMinSpace(void) {
-      return m_audio_buffer_min_freespace;
-    }
-    char * binaryWritePtr(void) { 
-      return (char *) m_audio_buffer + m_audio_buffer_write_offset;
-    }
-    void binaryWritePtrAdd(size_t len) {
-      m_audio_buffer_write_offset += len;
-    }
-    void binaryWritePtrResetToZero(void) {
-      m_audio_buffer_write_offset = 0;
-    }
-    void lockAudioBuffer(void) {
-      m_audio_mutex.lock();
-    }
-    void unlockAudioBuffer(void) ;
-
-    void close() ;
-    void finish();
-    void waitForClose();
-    void setClosed() { m_promise.set_value(); }
-    bool isFinished() { return m_finished;}
-
-    // no default constructor or copying
-    AudioPipe() = delete;
-    AudioPipe(const AudioPipe&) = delete;
-    void operator=(const AudioPipe&) = delete;
-
-  private:
-    static std::thread serviceThread;
-
-    static int lws_callback(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len); 
-    static struct lws_context *context;
-    static std::mutex mutex_connects;
-    static std::mutex mutex_disconnects;
-    static std::mutex mutex_writes;
-    static std::list<AudioPipe*> pendingConnects;
-    static std::list<AudioPipe*> pendingDisconnects;
-    static std::list<AudioPipe*> pendingWrites;
-    static log_emit_function logger;
-
-    static std::mutex mapMutex;
-    static bool stopFlag;
-
-    static AudioPipe* findAndRemovePendingConnect(struct lws *wsi);
-    static AudioPipe* findPendingConnect(struct lws *wsi);
-    static void addPendingConnect(AudioPipe* ap);
-    static void addPendingDisconnect(AudioPipe* ap);
-    static void addPendingWrite(AudioPipe* ap);
-    static void processPendingConnects(lws_per_vhost_data *vhd);
-    static void processPendingDisconnects(lws_per_vhost_data *vhd);
-    static void processPendingWrites(void);
-    
-    bool connect_client(struct lws_per_vhost_data *vhd);
-
-    LwsState_t m_state;
-    std::string m_uuid;
-    std::string m_host;
-    unsigned int m_port;
-    std::string m_path;
-    std::string m_metadata;
-    std::mutex m_text_mutex;
-    std::mutex m_audio_mutex;
-    int m_sslFlags;
-    struct lws *m_wsi;
-    uint8_t *m_audio_buffer;
-    size_t m_audio_buffer_max_len;
-    size_t m_audio_buffer_write_offset;
-    size_t m_audio_buffer_min_freespace;
-    uint8_t* m_recv_buf;
-    uint8_t* m_recv_buf_ptr;
-    size_t m_recv_buf_len;
-    struct lws_per_vhost_data* m_vhd;
-    notifyHandler_t m_callback;
-    log_emit_function m_logger;
-    std::string m_apiKey;
-    bool m_gracefulShutdown;
-    bool m_finished;
-    std::string m_bugname;
-    std::promise<void> m_promise;
+class AudioPipe {
+public:
+  enum LwsState_t {
+    LWS_CLIENT_IDLE,
+    LWS_CLIENT_CONNECTING,
+    LWS_CLIENT_CONNECTED,
+    LWS_CLIENT_FAILED,
+    LWS_CLIENT_DISCONNECTING,
+    LWS_CLIENT_DISCONNECTED
   };
+  enum NotifyEvent_t {
+    CONNECT_SUCCESS,
+    CONNECT_FAIL,
+    CONNECTION_DROPPED,
+    CONNECTION_CLOSED_GRACEFULLY,
+    MESSAGE
+  };
+  typedef void (*log_emit_function)(int level, const char *line);
+  typedef void (*notifyHandler_t)(const char *sessionId, NotifyEvent_t event, const char* message, bool finished);
+
+  struct lws_per_vhost_data {
+    struct lws_context *context;
+    struct lws_vhost *vhost;
+    const struct lws_protocols *protocol;
+  };
+
+  static void initialize(int loglevel, log_emit_function logger);
+  static bool deinitialize();
+  static bool lws_service_thread();
+
+  // constructor
+  AudioPipe(const char* uuid, const char* host, unsigned int port, const char* path, 
+    size_t bufLen, size_t minFreespace, const char* apiKey, notifyHandler_t callback);
+  ~AudioPipe();  
+
+  LwsState_t getLwsState(void) { return m_state; }
+  std::string& getApiKey(void) {
+    return m_apiKey;
+  }
+  void connect(void);
+  void bufferForSending(const char* text);
+  size_t binarySpaceAvailable(void) {
+    return m_audio_buffer_max_len - m_audio_buffer_write_offset;
+  }
+  size_t binaryMinSpace(void) {
+    return m_audio_buffer_min_freespace;
+  }
+  char * binaryWritePtr(void) { 
+    return (char *) m_audio_buffer + m_audio_buffer_write_offset;
+  }
+  void binaryWritePtrAdd(size_t len) {
+    m_audio_buffer_write_offset += len;
+  }
+  void binaryWritePtrResetToZero(void) {
+    m_audio_buffer_write_offset = 0;
+  }
+  void lockAudioBuffer(void) {
+    m_audio_mutex.lock();
+  }
+  void unlockAudioBuffer(void) ;
+
+  void close() ;
+  void finish();
+  void waitForClose();
+  void setClosed() { m_promise.set_value(); }
+  bool isFinished() { return m_finished;}
+
+  // no default constructor or copying
+  AudioPipe() = delete;
+  AudioPipe(const AudioPipe&) = delete;
+  void operator=(const AudioPipe&) = delete;
+
+private:
+
+  static int lws_callback(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len); 
+  static unsigned int nchild;
+  static struct lws_context *context;
+  static unsigned int numContexts;
+  static std::string protocolName;
+  static std::mutex mutex_connects;
+  static std::mutex mutex_disconnects;
+  static std::mutex mutex_writes;
+  static std::list<AudioPipe*> pendingConnects;
+  static std::list<AudioPipe*> pendingDisconnects;
+  static std::list<AudioPipe*> pendingWrites;
+  static log_emit_function logger;
+
+  static std::mutex mapMutex;
+  static bool stopFlag;
+
+  static AudioPipe* findAndRemovePendingConnect(struct lws *wsi);
+  static AudioPipe* findPendingConnect(struct lws *wsi);
+  static void addPendingConnect(AudioPipe* ap);
+  static void addPendingDisconnect(AudioPipe* ap);
+  static void addPendingWrite(AudioPipe* ap);
+  static void processPendingConnects(lws_per_vhost_data *vhd);
+  static void processPendingDisconnects(lws_per_vhost_data *vhd);
+  static void processPendingWrites(void);
+  
+  bool connect_client(struct lws_per_vhost_data *vhd);
+
+  LwsState_t m_state;
+  std::string m_uuid;
+  std::string m_host;
+  unsigned int m_port;
+  std::string m_path;
+  std::string m_metadata;
+  std::mutex m_text_mutex;
+  std::mutex m_audio_mutex;
+  int m_sslFlags;
+  struct lws *m_wsi;
+  uint8_t *m_audio_buffer;
+  size_t m_audio_buffer_max_len;
+  size_t m_audio_buffer_write_offset;
+  size_t m_audio_buffer_min_freespace;
+  uint8_t* m_recv_buf;
+  uint8_t* m_recv_buf_ptr;
+  size_t m_recv_buf_len;
+  struct lws_per_vhost_data* m_vhd;
+  notifyHandler_t m_callback;
+  log_emit_function m_logger;
+  std::string m_apiKey;
+  bool m_gracefulShutdown;
+  bool m_finished;
+  std::string m_bugname;
+  std::promise<void> m_promise;
+};
 
 } // namespace deepgram
 #endif

mod_deepgram_transcribe/dg_transcribe_glue.cpp

@@ -38,54 +38,50 @@ namespace {
       std::string model;
   };
 
-  static const std::unordered_map<std::string, std::string> languageLookupTable = {
-      {"zh", "base"},
-      {"zh-CN", "base"},
-      {"zh-TW", "base"},
-      {"da", "enhanced"},
-      {"en", "nova-2"},
-      {"en-US", "nova-2"},
-      {"en-AU", "nova-2"},
-      {"en-GB", "nova-2"},
-      {"en-IN", "nova-2"},
-      {"en-NZ", "nova-2"},
-      {"nl", "nova-2"},
-      {"fr", "nova-2"},
-      {"fr-CA", "nova-2"},
-      {"de", "nova-2"},
-      {"hi", "nova-2"},
-      {"hi-Latn", "nova-2"},
-      {"id", "base"},
-      {"it", "enhanced"},
-      {"ja", "enhanced"},
-      {"ko", "enhanced"},
-      {"no", "enhanced"},
-      {"pl", "enhanced"},
-      {"pt","nova-2"},
-      {"pt-BR", "nova-2"},
-      {"pt-PT", "enhanced"},
-      {"ru", "base"},
-      {"es","nova-2"},
-      {"es-419","nova-2"},
-      {"es-LATAM","enhanced"},
-      {"sv", "enhanced"},
-      {"ta", "enhanced"},
-      {"taq", "enhanced"},
-      {"tr", "base"},
-      {"uk", "base"}
+  static const std::unordered_map<std::string, LanguageInfo> languageLookupTable = {
+      {"zh", {"base", "general"}},
+      {"zh-CN", {"base", "general"}},
+      {"zh-TW", {"base", "general"}},
+      {"da", {"enhanced", "general"}},
+      {"en", {"nova", "phonecall"}},
+      {"en-US", {"nova", "phonecall"}},
+      {"en-AU", {"nova", "general"}},
+      {"en-GB", {"nova", "general"}},
+      {"en-IN", {"nova", "general"}},
+      {"en-NZ", {"nova", "general"}},
+      {"nl", {"enhanced", "general"}},
+      {"fr", {"enhanced", "general"}},
+      {"fr-CA", {"base", "general"}},
+      {"de", {"enhanced", "general"}},
+      {"hi", {"enhanced", "general"}},
+      {"hi-Latn", {"base", "general"}},
+      {"id", {"base", "general"}},
+      {"ja", {"enhanced", "general"}},
+      {"ko", {"enhanced", "general"}},
+      {"no", {"enhanced", "general"}},
+      {"pl", {"enhanced", "general"}},
+      {"pt", {"enhanced", "general"}},
+      {"pt-BR", {"enhanced", "general"}},
+      {"pt-PT", {"enhanced", "general"}},
+      {"ru", {"base", "general"}},
+      {"es", {"nova", "general"}},
+      {"es-419", {"nova", "general"}},
+      {"sv", {"enhanced", "general"}},
+      {"ta", {"enhanced", "general"}},
+      {"tr", {"base", "general"}},
+      {"uk", {"base", "general"}}
   };
 
-  static bool getLanguageInfo(const std::string& language, std::string& model) {
+  static bool getLanguageInfo(const std::string& language, LanguageInfo& info) {
       auto it = languageLookupTable.find(language);
       if (it != languageLookupTable.end()) {
-          model = it->second;
+          info = it->second;
           return true;
       }
       return false;
   }
 
-  static const char* emptyTranscript = 
-    "\"is_final\":false,\"speech_final\":false,\"channel\":{\"alternatives\":[{\"transcript\":\"\",\"confidence\":0.0,\"words\":[]}]}";
+  static const char* emptyTranscript = "{\"alternatives\":[{\"transcript\":\"\",\"confidence\":0.0,\"words\":[]}]}";
 
   static void reaper(private_t *tech_pvt) {
     std::shared_ptr<deepgram::AudioPipe> pAp;
@@ -150,21 +146,24 @@ namespace {
     const char *customModel = switch_channel_get_variable(channel, "DEEPGRAM_SPEECH_CUSTOM_MODEL");
     const char *tier = switch_channel_get_variable(channel, "DEEPGRAM_SPEECH_TIER") ;
     std::ostringstream oss;
+    LanguageInfo info;
 
     oss << "/v1/listen?";
 
-    /* make best choice by language if model not supplied*/
-    if (!model && !customModel) {
-      std::string defaultModel;
-      if (getLanguageInfo(language, defaultModel)) {
-        oss << "&model=" << defaultModel;
+    if (!tier && !model && !customModel) {
+      /* make best choice by language */
+      if (getLanguageInfo(language, info)) {
+        oss << "tier=" << info.tier << "&model=" << info.model;
       }
       else {
-        oss << "tier=base&model=base"; // most widely supported, though not ideal
+        oss << "tier=base&model=general"; // most widely supported, though not ideal
       }
     }
-    else if (model) oss << "&model=" << model;
-    else if (customModel) oss << "&model=" << customModel;
+    else {
+      if (tier) oss << "tier=" << tier;
+      if (model) oss << "&model=" << model;
+      if (customModel) oss << "&model=" << customModel;
+    }
 
     if (var = switch_channel_get_variable(channel, "DEEPGRAM_SPEECH_MODEL_VERSION")) {
      oss <<  "&version";
@@ -266,18 +265,17 @@ namespace {
    return path;
   }
 
-  static void eventCallback(const char* sessionId, const char* bugname, 
-    deepgram::AudioPipe::NotifyEvent_t event, const char* message, bool finished) {
+  static void eventCallback(const char* sessionId, deepgram::AudioPipe::NotifyEvent_t event, const char* message, bool finished) {
     switch_core_session_t* session = switch_core_session_locate(sessionId);
     if (session) {
       switch_channel_t *channel = switch_core_session_get_channel(session);
-      switch_media_bug_t *bug = (switch_media_bug_t*) switch_channel_get_private(channel, bugname);
+      switch_media_bug_t *bug = (switch_media_bug_t*) switch_channel_get_private(channel, MY_BUG_NAME);
       if (bug) {
         private_t* tech_pvt = (private_t*) switch_core_media_bug_get_user_data(bug);
         if (tech_pvt) {
           switch (event) {
             case deepgram::AudioPipe::CONNECT_SUCCESS:
-              switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "connection (%s) successful\n", tech_pvt->bugname);
+              switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "connection successful\n");
               tech_pvt->responseHandler(session, TRANSCRIBE_EVENT_CONNECT_SUCCESS, NULL, tech_pvt->bugname, finished);
             break;
             case deepgram::AudioPipe::CONNECT_FAIL:
@@ -287,19 +285,19 @@ namespace {
               json << "{\"reason\":\"" << message << "\"}";
               tech_pvt->pAudioPipe = nullptr;
               tech_pvt->responseHandler(session, TRANSCRIBE_EVENT_CONNECT_FAIL, (char *) json.str().c_str(), tech_pvt->bugname, finished);
-              switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "connection (%s) failed: %s\n", message, tech_pvt->bugname);
+              switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "connection failed: %s\n", message);
             }
             break;
             case deepgram::AudioPipe::CONNECTION_DROPPED:
               // first thing: we can no longer access the AudioPipe
               tech_pvt->pAudioPipe = nullptr;
               tech_pvt->responseHandler(session, TRANSCRIBE_EVENT_DISCONNECT, NULL, tech_pvt->bugname, finished);
-              switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "connection (%s) dropped from far end\n", tech_pvt->bugname);
+              switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "connection dropped from far end\n");
             break;
             case deepgram::AudioPipe::CONNECTION_CLOSED_GRACEFULLY:
               // first thing: we can no longer access the AudioPipe
               tech_pvt->pAudioPipe = nullptr;
-              switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "connection (%s) closed gracefully\n", tech_pvt->bugname);
+              switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "connection closed gracefully\n");
             break;
             case deepgram::AudioPipe::MESSAGE:
               if( strstr(message, emptyTranscript)) {
@@ -307,7 +305,7 @@ namespace {
               }
               else {
                 tech_pvt->responseHandler(session, TRANSCRIBE_EVENT_RESULTS, message, tech_pvt->bugname, finished);
-                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "deepgram message (%s): %s\n", tech_pvt->bugname, message);
+                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "deepgram message: %s\n", message);
               }
             break;
 
@@ -345,7 +343,6 @@ namespace {
     tech_pvt->channels = channels;
     tech_pvt->id = ++idxCallCount;
     tech_pvt->buffer_overrun_notified = 0;
-    strncpy(tech_pvt->bugname, bugname, MAX_BUG_LEN);
     
     size_t buflen = LWS_PRE + (FRAME_SIZE_8000 * desiredSampling / 8000 * channels * 1000 / RTP_PACKETIZATION_PERIOD * nAudioBufferSecs);
 
@@ -356,7 +353,7 @@ namespace {
       return SWITCH_STATUS_FALSE;
     }
 
-    deepgram::AudioPipe* ap = new deepgram::AudioPipe(tech_pvt->sessionId, bugname, tech_pvt->host, tech_pvt->port, tech_pvt->path, 
+    deepgram::AudioPipe* ap = new deepgram::AudioPipe(tech_pvt->sessionId, tech_pvt->host, tech_pvt->port, tech_pvt->path, 
       buflen, read_impl.decoded_bytes_per_packet, apiKey, eventCallback);
     if (!ap) {
       switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error allocating AudioPipe\n");
@@ -403,8 +400,7 @@ extern "C" {
   switch_status_t dg_transcribe_init() {
     switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "mod_deepgram_transcribe: audio buffer (in secs):    %d secs\n", nAudioBufferSecs);
  
-    int logs = LLL_ERR | LLL_WARN | LLL_NOTICE;
-    // | LLL_INFO | LLL_PARSER | LLL_HEADER | LLL_EXT | LLL_CLIENT  | LLL_LATENCY | LLL_DEBUG ;
+    int logs = LLL_ERR | LLL_WARN | LLL_NOTICE || LLL_INFO | LLL_PARSER | LLL_HEADER | LLL_EXT | LLL_CLIENT  | LLL_LATENCY | LLL_DEBUG ;
     
     deepgram::AudioPipe::initialize(logs, lws_logger);
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "AudioPipe::initialize completed\n");
@@ -459,7 +455,7 @@ extern "C" {
 
 	switch_status_t dg_transcribe_session_stop(switch_core_session_t *session,int channelIsClosing, char* bugname) {
     switch_channel_t *channel = switch_core_session_get_channel(session);
-    switch_media_bug_t *bug = (switch_media_bug_t*) switch_channel_get_private(channel, bugname);
+    switch_media_bug_t *bug = (switch_media_bug_t*) switch_channel_get_private(channel, MY_BUG_NAME);
     if (!bug) {
       switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "dg_transcribe_session_stop: no bug - websocket conection already closed\n");
       return SWITCH_STATUS_FALSE;

mod_deepgram_transcribe/mod_deepgram_transcribe.c

@@ -45,6 +45,7 @@ static switch_bool_t capture_callback(switch_media_bug_t *bug, void *user_data,
 		{
 			private_t *tech_pvt = (private_t*) switch_core_media_bug_get_user_data(bug);
 			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Got SWITCH_ABC_TYPE_CLOSE.\n");
+
 			dg_transcribe_session_stop(session, 1,  tech_pvt->bugname);
 			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Finished SWITCH_ABC_TYPE_CLOSE.\n");
 		}
@@ -73,7 +74,7 @@ static switch_status_t start_capture(switch_core_session_t *session, switch_medi
 	void *pUserData;
 	uint32_t samples_per_second;
 
-	if (switch_channel_get_private(channel, bugname)) {
+	if (switch_channel_get_private(channel, MY_BUG_NAME)) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "removing bug from previous transcribe\n");
 		do_stop(session, bugname);
 	}
@@ -93,7 +94,7 @@ static switch_status_t start_capture(switch_core_session_t *session, switch_medi
 	if ((status = switch_core_media_bug_add(session, "dg_transcribe", NULL, capture_callback, pUserData, 0, flags, &bug)) != SWITCH_STATUS_SUCCESS) {
 		return status;
 	}
-  switch_channel_set_private(channel, bugname, bug);
+  switch_channel_set_private(channel, MY_BUG_NAME, bug);
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "added media bug for dg transcribe\n");
 
 	return SWITCH_STATUS_SUCCESS;
@@ -104,16 +105,13 @@ static switch_status_t do_stop(switch_core_session_t *session,  char* bugname)
 	switch_status_t status = SWITCH_STATUS_SUCCESS;
 
 	switch_channel_t *channel = switch_core_session_get_channel(session);
-	switch_media_bug_t *bug = switch_channel_get_private(channel, bugname);
+	switch_media_bug_t *bug = switch_channel_get_private(channel, MY_BUG_NAME);
 
 	if (bug) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Received user command command to stop transcribe.\n");
 		status = dg_transcribe_session_stop(session, 0, bugname);
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "stopped transcribe.\n");
 	}
-  else {
-		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "do_stop: did not find bugname %s.\n", bugname);
-  }
 
 	return status;
 }
@@ -143,7 +141,7 @@ SWITCH_STANDARD_API(dg_transcribe_function)
 		if ((lsession = switch_core_session_locate(argv[0]))) {
 			if (!strcasecmp(argv[1], "stop")) {
 				char *bugname = argc > 2 ? argv[2] : MY_BUG_NAME;
-    		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "stop transcribing %s\n", bugname);
+    		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "stop transcribing\n");
 				status = do_stop(lsession, bugname);
 			} else if (!strcasecmp(argv[1], "start")) {
         char* lang = argv[2];
@@ -153,8 +151,7 @@ SWITCH_STANDARD_API(dg_transcribe_function)
           flags |= SMBF_WRITE_STREAM ;
           flags |= SMBF_STEREO;
 				}
-    		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "start transcribing %s %s %s\n", 
-          lang, interim ? "interim": "complete", bugname);
+    		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "start transcribing %s %s\n", lang, interim ? "interim": "complete");
 				status = start_capture(lsession, flags, lang, interim, bugname);
 			}
 			switch_core_session_rwunlock(lsession);

mod_ibm_transcribe/audio_pipe.cpp

@@ -48,7 +48,7 @@ int AudioPipe::lws_callback(struct lws *wsi,
         lwsl_err("AudioPipe::lws_service_thread LWS_CALLBACK_CLIENT_CONNECTION_ERROR: %s, response status %d\n", in ? (char *)in : "(null)", rc); 
         if (ap) {
           ap->m_state = LWS_CLIENT_FAILED;
-          ap->m_callback(ap->m_uuid.c_str(), ap->m_bugname.c_str(), AudioPipe::CONNECT_FAIL, (char *) in, ap->isFinished(), ap->isInterimTranscriptsEnabled());
+          ap->m_callback(ap->m_uuid.c_str(), AudioPipe::CONNECT_FAIL, (char *) in, ap->isFinished(), ap->isInterimTranscriptsEnabled(), ap->getBugname().c_str());
         }
         else {
           lwsl_err("AudioPipe::lws_service_thread LWS_CALLBACK_CLIENT_CONNECTION_ERROR unable to find wsi %p..\n", wsi); 
@@ -77,7 +77,7 @@ int AudioPipe::lws_callback(struct lws *wsi,
             oss << "}";
 
             ap->bufferForSending(oss.str().c_str());
-            ap->m_callback(ap->m_uuid.c_str(), ap->m_bugname.c_str(), AudioPipe::CONNECT_SUCCESS, NULL,  ap->isFinished(), ap->isInterimTranscriptsEnabled());
+            ap->m_callback(ap->m_uuid.c_str(), AudioPipe::CONNECT_SUCCESS, NULL,  ap->isFinished(), ap->isInterimTranscriptsEnabled(), ap->getBugname().c_str());
           }
 
         }
@@ -97,12 +97,12 @@ int AudioPipe::lws_callback(struct lws *wsi,
           // closed by us
 
           lwsl_debug("%s socket closed by us\n", ap->m_uuid.c_str());
-          ap->m_callback(ap->m_uuid.c_str(), ap->m_bugname.c_str(), AudioPipe::CONNECTION_CLOSED_GRACEFULLY, NULL,  ap->isFinished(), ap->isInterimTranscriptsEnabled());
+          ap->m_callback(ap->m_uuid.c_str(), AudioPipe::CONNECTION_CLOSED_GRACEFULLY, NULL,  ap->isFinished(), ap->isInterimTranscriptsEnabled(), ap->getBugname().c_str());
         }
         else if (ap->m_state == LWS_CLIENT_CONNECTED) {
           // closed by far end
           lwsl_info("%s socket closed by far end\n", ap->m_uuid.c_str());
-          ap->m_callback(ap->m_uuid.c_str(), ap->m_bugname.c_str(), AudioPipe::CONNECTION_DROPPED, NULL,  ap->isFinished(), ap->isInterimTranscriptsEnabled());
+          ap->m_callback(ap->m_uuid.c_str(), AudioPipe::CONNECTION_DROPPED, NULL,  ap->isFinished(), ap->isInterimTranscriptsEnabled(), ap->getBugname().c_str());
         }
         ap->m_state = LWS_CLIENT_DISCONNECTED;
         ap->setClosed();
@@ -166,7 +166,7 @@ int AudioPipe::lws_callback(struct lws *wsi,
               std::string msg((char *)ap->m_recv_buf, ap->m_recv_buf_ptr - ap->m_recv_buf);
               //std::cerr << "Recv: " << msg << std::endl;
 
-              ap->m_callback(ap->m_uuid.c_str(), ap->m_bugname.c_str(), AudioPipe::MESSAGE, msg.c_str(),  ap->isFinished(), ap->isInterimTranscriptsEnabled());
+              ap->m_callback(ap->m_uuid.c_str(), AudioPipe::MESSAGE, msg.c_str(),  ap->isFinished(), ap->isInterimTranscriptsEnabled(), ap->getBugname().c_str());
               if (nullptr != ap->m_recv_buf) free(ap->m_recv_buf);
             }
             ap->m_recv_buf = ap->m_recv_buf_ptr = nullptr;
@@ -251,7 +251,6 @@ static const lws_retry_bo_t retry = {
 };
 
 struct lws_context *AudioPipe::context = nullptr;
-std::thread AudioPipe::serviceThread;
 std::mutex AudioPipe::mutex_connects;
 std::mutex AudioPipe::mutex_disconnects;
 std::mutex AudioPipe::mutex_writes;
@@ -419,29 +418,26 @@ bool AudioPipe::lws_service_thread() {
 
 void AudioPipe::initialize(int loglevel, log_emit_function logger) {
 
-  //lws_set_log_level(loglevel, logger);
+  lws_set_log_level(loglevel, logger);
 
   lwsl_notice("AudioPipe::initialize starting\n"); 
   std::lock_guard<std::mutex> lock(mapMutex);
+  std::thread t(&AudioPipe::lws_service_thread);
   stopFlag = false;
-  serviceThread = std::thread(&AudioPipe::lws_service_thread);
+  t.detach();
 }
 
 bool AudioPipe::deinitialize() {
   lwsl_notice("AudioPipe::deinitialize\n"); 
   std::lock_guard<std::mutex> lock(mapMutex);
   stopFlag = true;
-  if (serviceThread.joinable()) {
-    serviceThread.join();
-  }
-
   return true;
 }
 
 // instance members
-AudioPipe::AudioPipe(const char* uuid, const char* bugname, const char* host, unsigned int port, const char* path,
+AudioPipe::AudioPipe(const char* uuid, const char* host, unsigned int port, const char* path,
   size_t bufLen, size_t minFreespace, notifyHandler_t callback) :
-  m_uuid(uuid), m_host(host), m_port(port), m_path(path), m_finished(false),  m_bugname(bugname),
+  m_uuid(uuid), m_host(host), m_port(port), m_path(path), m_finished(false),
   m_audio_buffer_min_freespace(minFreespace), m_audio_buffer_max_len(bufLen), m_gracefulShutdown(false),
   m_audio_buffer_write_offset(LWS_PRE), m_recv_buf(nullptr), m_recv_buf_ptr(nullptr), m_interim(false),
   m_state(LWS_CLIENT_IDLE), m_wsi(nullptr), m_vhd(nullptr), m_callback(callback) {

mod_ibm_transcribe/audio_pipe.hpp

@@ -31,7 +31,7 @@ public:
     MESSAGE
   };
   typedef void (*log_emit_function)(int level, const char *line);
-  typedef void (*notifyHandler_t)(const char *sessionId, const char* bugname, NotifyEvent_t event, const char* message, bool finished, bool wantsInterim);
+  typedef void (*notifyHandler_t)(const char *sessionId, NotifyEvent_t event, const char* message, bool finished, bool wantsInterim, const char* bugname);
 
   struct lws_per_vhost_data {
     struct lws_context *context;
@@ -44,7 +44,7 @@ public:
   static bool lws_service_thread();
 
   // constructor
-  AudioPipe(const char* uuid, const char* bugname, const char* host, unsigned int port, const char* path, 
+  AudioPipe(const char* uuid, const char* host, unsigned int port, const char* path, 
     size_t bufLen, size_t minFreespace, notifyHandler_t callback);
   ~AudioPipe();  
 
@@ -104,7 +104,6 @@ public:
   void operator=(const AudioPipe&) = delete;
 
 private:
-    static std::thread serviceThread;
 
   static int lws_callback(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len); 
   static struct lws_context *context;

mod_ibm_transcribe/ibm_transcribe_glue.cpp

@@ -82,8 +82,8 @@ namespace {
     }
   }
 
-  static void responseHandler(switch_core_session_t* session, const char* bugname,
-    const char* eventName, const char * json, int finished) {
+  static void responseHandler(switch_core_session_t* session, 
+    const char* eventName, const char * json, const char* bugname, int finished) {
     switch_event_t *event;
     switch_channel_t *channel = switch_core_session_get_channel(session);
 
@@ -162,7 +162,7 @@ namespace {
     return path;
   }
 
-  static void eventCallback(const char* sessionId, const char* bugname, ibm::AudioPipe::NotifyEvent_t event, const char* message, bool finished, bool wantsInterim) {
+  static void eventCallback(const char* sessionId, ibm::AudioPipe::NotifyEvent_t event, const char* message, bool finished, bool wantsInterim, const char* bugname) {
     switch_core_session_t* session = switch_core_session_locate(sessionId);
     if (session) {
       bool releaseAudioPipe = false;
@@ -256,11 +256,10 @@ namespace {
     tech_pvt->channels = channels;
     tech_pvt->id = ++idxCallCount;
     tech_pvt->buffer_overrun_notified = 0;
-    strncpy(tech_pvt->bugname, bugname, MAX_BUG_LEN);
-
+    
     size_t buflen = LWS_PRE + (FRAME_SIZE_8000 * desiredSampling / 8000 * channels * 1000 / RTP_PACKETIZATION_PERIOD * nAudioBufferSecs);
 
-    ibm::AudioPipe* ap = new ibm::AudioPipe(tech_pvt->sessionId, bugname, tech_pvt->host, tech_pvt->port, tech_pvt->path, 
+    ibm::AudioPipe* ap = new ibm::AudioPipe(tech_pvt->sessionId, tech_pvt->host, tech_pvt->port, tech_pvt->path, 
       buflen, read_impl.decoded_bytes_per_packet, eventCallback);
     if (!ap) {
       switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error allocating AudioPipe\n");
@@ -312,8 +311,7 @@ extern "C" {
   switch_status_t ibm_transcribe_init() {
     switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "mod_ibm_transcribe: audio buffer (in secs):    %d secs\n", nAudioBufferSecs);
  
-    int logs = LLL_ERR | LLL_WARN | LLL_NOTICE ;
-    // | LLL_INFO | LLL_PARSER | LLL_HEADER | LLL_EXT | LLL_CLIENT  | LLL_LATENCY | LLL_DEBUG ;
+    int logs = LLL_ERR | LLL_WARN | LLL_NOTICE || LLL_INFO | LLL_PARSER | LLL_HEADER | LLL_EXT | LLL_CLIENT  | LLL_LATENCY | LLL_DEBUG ;
     
     ibm::AudioPipe::initialize(logs, lws_logger);
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "AudioPipe::initialize completed\n");

mod_ibm_transcribe/mod_ibm_transcribe.c

@@ -56,7 +56,7 @@ static switch_status_t start_capture(switch_core_session_t *session, switch_medi
 	void *pUserData;
 	uint32_t samples_per_second;
 
-	if (switch_channel_get_private(channel, bugname)) {
+	if (switch_channel_get_private(channel, MY_BUG_NAME)) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "removing bug from previous transcribe\n");
 		do_stop(session, bugname);
 	}
@@ -76,7 +76,7 @@ static switch_status_t start_capture(switch_core_session_t *session, switch_medi
 	if ((status = switch_core_media_bug_add(session, "ibm_transcribe", NULL, capture_callback, pUserData, 0, flags, &bug)) != SWITCH_STATUS_SUCCESS) {
 		return status;
 	}
-  switch_channel_set_private(channel, bugname, bug);
+  switch_channel_set_private(channel, MY_BUG_NAME, bug);
 	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "added media bug for ibm transcribe\n");
 
 	return SWITCH_STATUS_SUCCESS;
@@ -87,7 +87,7 @@ static switch_status_t do_stop(switch_core_session_t *session,  char* bugname)
 	switch_status_t status = SWITCH_STATUS_SUCCESS;
 
 	switch_channel_t *channel = switch_core_session_get_channel(session);
-	switch_media_bug_t *bug = switch_channel_get_private(channel, bugname);
+	switch_media_bug_t *bug = switch_channel_get_private(channel, MY_BUG_NAME);
 
 	if (bug) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Received user command command to stop transcribe.\n");

mod_jambonz_transcribe/audio_pipe.cpp

@@ -240,7 +240,6 @@ static const lws_retry_bo_t retry = {
 };
 
 struct lws_context *AudioPipe::context = nullptr;
-std::thread AudioPipe::serviceThread;
 std::mutex AudioPipe::mutex_connects;
 std::mutex AudioPipe::mutex_disconnects;
 std::mutex AudioPipe::mutex_writes;
@@ -409,21 +408,19 @@ bool AudioPipe::lws_service_thread() {
 
 void AudioPipe::initialize(int loglevel, log_emit_function logger) {
 
-  //lws_set_log_level(loglevel, logger);
+  lws_set_log_level(loglevel, logger);
 
   lwsl_notice("AudioPipe::initialize starting\n"); 
   std::lock_guard<std::mutex> lock(mapMutex);
+  std::thread t(&AudioPipe::lws_service_thread);
   stopFlag = false;
-  serviceThread = std::thread(&AudioPipe::lws_service_thread);
+  t.detach();
 }
 
 bool AudioPipe::deinitialize() {
   lwsl_notice("AudioPipe::deinitialize\n"); 
   std::lock_guard<std::mutex> lock(mapMutex);
   stopFlag = true;
-  if (serviceThread.joinable()) {
-    serviceThread.join();
-  }
   return true;
 }
 

mod_jambonz_transcribe/audio_pipe.hpp

@@ -86,7 +86,6 @@ public:
   void operator=(const AudioPipe&) = delete;
 
 private:
-    static std::thread serviceThread;
 
   static int lws_callback(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len); 
   static struct lws_context *context;

mod_jambonz_transcribe/jb_transcribe_glue.cpp

@@ -256,6 +256,7 @@ namespace {
     switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "host: %s, port: %d, path: %s\n", host, port, path);
 
     strncpy(tech_pvt->sessionId, switch_core_session_get_uuid(session), MAX_SESSION_ID);
+    strncpy(tech_pvt->bugname, bugname, MAX_BUG_LEN);
     strncpy(tech_pvt->host, host, MAX_WS_URL_LEN);
     strncpy(tech_pvt->path, path, MAX_PATH_LEN); 
     tech_pvt->port = port;
@@ -267,7 +268,6 @@ namespace {
     tech_pvt->channels = channels;
     tech_pvt->id = ++idxCallCount;
     tech_pvt->buffer_overrun_notified = 0;
-    strncpy(tech_pvt->bugname, bugname, MAX_BUG_LEN);
     
     size_t buflen = LWS_PRE + (FRAME_SIZE_8000 * desiredSampling / 8000 * channels * 1000 / RTP_PACKETIZATION_PERIOD * nAudioBufferSecs);
 
@@ -325,8 +325,7 @@ extern "C" {
   switch_status_t jb_transcribe_init() {
     switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "mod_jambonz_transcribe: audio buffer (in secs):    %d secs\n", nAudioBufferSecs);
  
-    int logs = LLL_ERR | LLL_WARN | LLL_NOTICE ;
-    // | LLL_INFO | LLL_PARSER | LLL_HEADER | LLL_EXT | LLL_CLIENT  | LLL_LATENCY | LLL_DEBUG ;
+    int logs = LLL_ERR | LLL_WARN | LLL_NOTICE || LLL_INFO | LLL_PARSER | LLL_HEADER | LLL_EXT | LLL_CLIENT  | LLL_LATENCY | LLL_DEBUG ;
     
     jambonz::AudioPipe::initialize(logs, lws_logger);
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "AudioPipe::initialize completed\n");