opera_lr_dsp_threaded.ic

#include "libopera/opera_dsp.h"

#include "opera_lr_callbacks.h"

#include "boolean.h"

#include <rthreads/rthreads.h>

#include <stdint.h>

/* FORWARD DECLARATIONS */
static void dsp_process(void);
static void dsp_upload_unlocked(void);

/* MACROS */
#define DSP_BUF_SIZE      (1 << 12)
#define DSP_BUF_SIZE_MASK (DSP_BUF_SIZE - 1)

/* GLOBAL VARIABLES */
static bool g_DSP_THREADED = false;

static uint32_t g_DSP_BUF_IDX     = 0;
static uint32_t g_DSP_BUF_PENDING = 0;
static int32_t  g_DSP_BUF[DSP_BUF_SIZE];

static scond_t *g_DSP_COND         = NULL;
static slock_t *g_DSP_COND_MUTEX   = NULL;
static sthread_t *g_DSP_THREAD     = NULL;
static bool g_DSP_THREAD_RUNNING   = false;
static slock_t *g_DSP_THREAD_MUTEX = NULL;

static void (*g_DSP_UPLOAD)(void)  = dsp_upload_unlocked;
static void (*g_DSP_PROCESS)(void) = dsp_process;


/* PRIVATE FUNCTIONS */

static
void
dsp_thread_loop(void *handle_)
{
  int32_t sample;
  uint32_t pending;
  bool running = true;

  while(running)
    {
      slock_lock(g_DSP_THREAD_MUTEX);
      running           = g_DSP_THREAD_RUNNING;
      pending           = g_DSP_BUF_PENDING;
      g_DSP_BUF_PENDING = 0;
      slock_unlock(g_DSP_THREAD_MUTEX);

      if (running)
        scond_wait(g_DSP_COND, g_DSP_COND_MUTEX);

      while (pending > 0)
        {
          sample = opera_dsp_loop();
          pending--;

          slock_lock(g_DSP_THREAD_MUTEX);
          g_DSP_BUF[g_DSP_BUF_IDX++]  = sample;
          g_DSP_BUF_IDX              &= DSP_BUF_SIZE_MASK;
          running                     = g_DSP_THREAD_RUNNING;
          pending                    += g_DSP_BUF_PENDING;
          g_DSP_BUF_PENDING           = 0;
          slock_unlock(g_DSP_THREAD_MUTEX);
        }
    }
}

static
void
dsp_upload_unlocked(void)
{
  retro_audio_sample_batch_cb((int16_t*)g_DSP_BUF,g_DSP_BUF_IDX);
  g_DSP_BUF_IDX = 0;
}

static
void
dsp_upload_locked(void)
{
  slock_lock(g_DSP_THREAD_MUTEX);
  dsp_upload_unlocked();
  slock_unlock(g_DSP_THREAD_MUTEX);
}

static
void
dsp_process(void)
{
  g_DSP_BUF[g_DSP_BUF_IDX++] = opera_dsp_loop();
  g_DSP_BUF_IDX &= DSP_BUF_SIZE_MASK;
}

static
void
dsp_process_threaded(void)
{
  slock_lock(g_DSP_THREAD_MUTEX);
  g_DSP_BUF_PENDING++;
  slock_unlock(g_DSP_THREAD_MUTEX);

  scond_signal(g_DSP_COND);
}


/* PUBLIC FUNCTIONS */

void
opera_lr_dsp_process(void)
{
  (*g_DSP_PROCESS)();
}

void
opera_lr_dsp_upload(void)
{
  (*g_DSP_UPLOAD)();
}

void
opera_lr_dsp_destroy(void)
{
  if(g_DSP_THREADED)
    {
      slock_lock(g_DSP_THREAD_MUTEX);
      g_DSP_THREAD_RUNNING = false;
      g_DSP_BUF_PENDING    = 0;
      g_DSP_BUF_IDX        = 0;
      slock_unlock(g_DSP_THREAD_MUTEX);

      scond_signal(g_DSP_COND);
      sthread_join(g_DSP_THREAD);

      scond_free(g_DSP_COND);
      slock_free(g_DSP_COND_MUTEX);
      slock_free(g_DSP_THREAD_MUTEX);

      g_DSP_THREAD       = NULL;
      g_DSP_COND         = NULL;
      g_DSP_COND_MUTEX   = NULL;
      g_DSP_THREAD_MUTEX = NULL;
      g_DSP_THREADED     = false;
    }
}

void
opera_lr_dsp_init(const bool threaded_)
{
  if(g_DSP_THREADED == threaded_)
    return;

  opera_lr_dsp_destroy();

  g_DSP_BUF_IDX = 0;

  g_DSP_THREADED = threaded_;
  if(g_DSP_THREADED)
    {
      g_DSP_COND           = scond_new();
      g_DSP_COND_MUTEX     = slock_new();
      g_DSP_THREAD_MUTEX   = slock_new();
      g_DSP_THREAD_RUNNING = true;
      g_DSP_THREAD         = sthread_create(dsp_thread_loop, NULL);

      g_DSP_UPLOAD         = dsp_upload_locked;
      g_DSP_PROCESS        = dsp_process_threaded;
    }
  else
    {
      g_DSP_UPLOAD  = dsp_upload_unlocked;
      g_DSP_PROCESS = dsp_process;
    }
}