(Audio) SOme control flow changes (no functional changes) and some cleanups

Author: LibretroAdmin

audio/common/mmdevice_common.c

@@ -24,7 +24,7 @@
 
 #include "../../verbosity.h"
 
-static const char* mmdevice_data_flow_name(unsigned data_flow)
+static const char *mmdevice_data_flow_name(unsigned data_flow)
 {
    switch (data_flow)
    {

audio/drivers/alsathread.c

@@ -214,9 +214,10 @@ static void alsa_microphone_worker_thread(void *mic_context)
 
 static int alsa_thread_microphone_read(void *driver_context, void *mic_context, void *s, size_t len)
 {
+   snd_pcm_state_t state;
+   size_t _len = 0;
    alsa_thread_microphone_t       *alsa = (alsa_thread_microphone_t*)driver_context;
    alsa_thread_microphone_handle_t *mic = (alsa_thread_microphone_handle_t*)mic_context;
-   snd_pcm_state_t state;
 
    if (!alsa || !mic || !s) /* If any of the parameters were invalid... */
       return -1;
@@ -245,28 +246,23 @@ static int alsa_thread_microphone_read(void *driver_context, void *mic_context,
    if (alsa->nonblock)
    {
       size_t avail;
-      size_t write_amt;
 
       /* "Hey, I'm gonna borrow the queue." */
       slock_lock(mic->info.fifo_lock);
 
       avail           = FIFO_READ_AVAIL(mic->info.buffer);
-      write_amt       = MIN(avail, len);
+      _len            = MIN(avail, len);
 
       /* "It's okay if you don't have any new samples, I'll just check in on you later." */
-      fifo_read(mic->info.buffer, s, write_amt);
+      fifo_read(mic->info.buffer, s, _len);
 
       /* "Here, take this queue back." */
       slock_unlock(mic->info.fifo_lock);
-
-      return (int)write_amt;
    }
    else
    {
-      size_t read = 0;
-
       /* Until we've read all requested samples (or we're told to stop)... */
-      while (read < len && !mic->info.thread_dead)
+      while (_len < len && !mic->info.thread_dead)
       {
          size_t avail;
 
@@ -294,21 +290,20 @@ static int alsa_thread_microphone_read(void *driver_context, void *mic_context,
          }
          else
          {
-            size_t read_amt = MIN(len - read, avail);
+            size_t read_amt = MIN(len - _len, avail);
 
             /* "I'll just go ahead and consume all these samples..."
              * (As many as will fit in s, or as many as are available.) */
-            fifo_read(mic->info.buffer,s + read, read_amt);
+            fifo_read(mic->info.buffer,s + _len, read_amt);
 
             /* "I'm done, you can take the queue back now." */
             slock_unlock(mic->info.fifo_lock);
-            read += read_amt;
+            _len += read_amt;
          }
-
          /* "I'll be right back..." */
       }
-      return (int)read;
    }
+   return _len;
 }
 
 static bool alsa_thread_microphone_mic_alive(const void *driver_context, const void *mic_context);
@@ -475,8 +470,9 @@ static void alsa_worker_thread(void *data)
 
       frames = snd_pcm_writei(alsa->info.pcm, buf, alsa->info.stream_info.period_frames);
 
-      if (frames == -EPIPE || frames == -EINTR ||
-            frames == -ESTRPIPE)
+      if (     frames == -EPIPE
+            || frames == -EINTR
+            || frames == -ESTRPIPE)
       {
          if (snd_pcm_recover(alsa->info.pcm, frames, false) < 0)
          {
@@ -625,7 +621,6 @@ static bool alsa_thread_alive(void *data)
 static bool alsa_thread_stop(void *data)
 {
    alsa_thread_t *alsa = (alsa_thread_t*)data;
-
    if (alsa)
       alsa->is_paused = true;
    return true;

audio/drivers/audioio.c

@@ -36,26 +36,26 @@ static void *audioio_init(const char *device, unsigned rate, unsigned latency,
       unsigned block_frames, unsigned *new_out_rate)
 {
    struct audio_info info;
-   const char *audiodev = device ? device : DEFAULT_DEV;
-   int              *fd = (int*)calloc(1, sizeof(int));
+   const char *audiodev  = device ? device : DEFAULT_DEV;
+   int              *fd  = (int*)calloc(1, sizeof(int));
 
    if (!fd)
       return NULL;
 
    AUDIO_INITINFO(&info);
 
 #ifdef AUMODE_PLAY_ALL
-   info.mode = AUMODE_PLAY_ALL;
+   info.mode             = AUMODE_PLAY_ALL;
 #elif defined(AUMODE_PLAY)
-   info.mode = AUMODE_PLAY;
+   info.mode             = AUMODE_PLAY;
 #endif
    info.play.sample_rate = rate;
-   info.play.channels = 2;
-   info.play.precision = 16;
+   info.play.channels    = 2;
+   info.play.precision   = 16;
 #ifdef AUDIO_ENCODING_SLINEAR
-   info.play.encoding = AUDIO_ENCODING_SLINEAR;
+   info.play.encoding    = AUDIO_ENCODING_SLINEAR;
 #else
-   info.play.encoding = AUDIO_ENCODING_LINEAR;
+   info.play.encoding    = AUDIO_ENCODING_LINEAR;
 #endif
 
    if ((*fd = open(audiodev, O_WRONLY)) < 0)

audio/drivers/audioworklet.c

@@ -149,15 +149,15 @@ static void audioworklet_thread_inited_cb(EMSCRIPTEN_WEBAUDIO_T context, bool su
    audioworklet_data_t *audioworklet = (audioworklet_data_t*)data;
    WebAudioWorkletProcessorCreateOptions opts = { "retroarch", 0 };
 
-   if (!success)
+   if (success)
+      emscripten_create_wasm_audio_worklet_processor_async(context, &opts,
+            audioworklet_processor_inited_cb, audioworklet);
+   else
    {
       RARCH_ERR("[AudioWorklet] Failed to init worklet thread! Is the worklet file in the right place?\n");
       audioworklet->init_error = true;
       audioworklet->init_done = true;
-      return;
    }
-
-   emscripten_create_wasm_audio_worklet_processor_async(context, &opts, audioworklet_processor_inited_cb, audioworklet);
 }
 
 static void audioworklet_ctx_statechange_cb(void *data, bool state)
@@ -190,9 +190,9 @@ static void audioworklet_ctx_create(void *data)
 
 static void audioworklet_alloc_buffer(void *data)
 {
+   size_t buffer_size;
    audioworklet_data_t *audioworklet = (audioworklet_data_t*)data;
 
-   size_t buffer_size;
    audioworklet->visible_buffer_size = (audioworklet->latency * audioworklet->rate * 2 * sizeof(float)) / 1000;
    buffer_size = audioworklet->visible_buffer_size;
 #ifdef EMSCRIPTEN_AUDIO_EXTERNAL_WRITE_BLOCK
@@ -239,9 +239,9 @@ static void *audioworklet_init(const char *device, unsigned rate,
          return NULL;
       }
       RARCH_LOG("[AudioWorklet] Reusing old context.\n");
-      audioworklet = audioworklet_static_data;
+      audioworklet          = audioworklet_static_data;
       audioworklet->latency = latency;
-      *new_rate = audioworklet->rate;
+      *new_rate             = audioworklet->rate;
       RARCH_LOG("[AudioWorklet] Device rate: %d Hz.\n", *new_rate);
       audioworklet_alloc_buffer(audioworklet);
       audioworklet_resume_ctx(audioworklet);
@@ -259,7 +259,7 @@ static void *audioworklet_init(const char *device, unsigned rate,
 
    audioworklet->latency = latency;
    platform_emscripten_run_on_browser_thread_sync(audioworklet_ctx_create, audioworklet);
-   *new_rate = audioworklet->rate;
+   *new_rate             = audioworklet->rate;
    RARCH_LOG("[AudioWorklet] Device rate: %d Hz.\n", *new_rate);
    audioworklet->initing = true;
    audioworklet_alloc_buffer(audioworklet);
@@ -295,10 +295,10 @@ static ssize_t audioworklet_write(void *data, const void *s, size_t ss)
    size_t max_write;
    size_t to_write_frames;
    size_t to_write_bytes;
-   size_t _len = 0;
+   size_t _len          = 0;
    audioworklet_data_t *audioworklet = (audioworklet_data_t*)data;
    const float *samples = (const float*)s;
-   size_t num_frames = ss / 2 / sizeof(float);
+   size_t num_frames    = ss / 2 / sizeof(float);
 
    /* too early! might happen with external blocking */
    if (!audioworklet->driver_running)
@@ -382,51 +382,51 @@ bool audioworklet_external_block(void)
 {
    audioworklet_data_t *audioworklet = audioworklet_static_data;
 
-   if (!audioworklet)
-      return false;
-
+   if (audioworklet)
+   {
 #ifdef EMSCRIPTEN_AUDIO_FAKE_BLOCK
-   if (!audioworklet->block_requested)
-      return false;
+      if (!audioworklet->block_requested)
+         return false;
 #endif
 
-   while (audioworklet->initing && !audioworklet->init_done)
+      while (audioworklet->initing && !audioworklet->init_done)
 #ifdef EMSCRIPTEN_AUDIO_ASYNC_BLOCK
-      retro_sleep(1);
+         retro_sleep(1);
 #else
-      return true;
+         return true;
 #endif
-   if (audioworklet->init_done && !audioworklet->driver_running)
-   {
-      audioworklet->initing = false;
-      if (audioworklet->init_error)
+      if (audioworklet->init_done && !audioworklet->driver_running)
       {
-         audioworklet_init_error(audioworklet);
-         abort();
-         return false;
+         audioworklet->initing = false;
+         if (audioworklet->init_error)
+         {
+            audioworklet_init_error(audioworklet);
+            abort();
+            return false;
+         }
+         audioworklet->driver_running = true;
       }
-      audioworklet->driver_running = true;
-   }
 #ifdef EMSCRIPTEN_AUDIO_EXTERNAL_WRITE_BLOCK
-   if (!audioworklet->driver_running)
-      return false;
+      if (!audioworklet->driver_running)
+         return false;
 
-   while (emscripten_atomic_load_u32(&audioworklet->write_avail_bytes) < audioworklet->write_avail_diff)
-   {
-      audioworklet_resume_ctx(audioworklet);
+      while (emscripten_atomic_load_u32(&audioworklet->write_avail_bytes) < audioworklet->write_avail_diff)
+      {
+         audioworklet_resume_ctx(audioworklet);
 #ifdef EMSCRIPTEN_AUDIO_ASYNC_BLOCK
-      retro_sleep(1);
+         retro_sleep(1);
 #else
-      return true;
+         return true;
 #endif
-   }
+      }
 #endif
 
 #ifdef EMSCRIPTEN_AUDIO_FAKE_BLOCK
-   audioworklet->block_requested = false;
-   platform_emscripten_exit_fake_block();
-   return true; /* return to RAF if needed */
+      audioworklet->block_requested = false;
+      platform_emscripten_exit_fake_block();
+      return true; /* return to RAF if needed */
 #endif
+   }
    return false;
 }
 #endif