rdpsnd_alsa.c

 
#include <freerdp/config.h>
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <winpr/crt.h>
#include <winpr/cmdline.h>
#include <winpr/sysinfo.h>
#include <winpr/collections.h>
 
#include <alsa/asoundlib.h>
 
#include <freerdp/types.h>
#include <freerdp/codec/dsp.h>
#include <freerdp/channels/log.h>
 
#include "rdpsnd_main.h"
 
typedef struct
{
  rdpsndDevicePlugin device;
 
  UINT32 latency;
  AUDIO_FORMAT aformat;
  char* device_name;
  snd_pcm_t* pcm_handle;
  snd_mixer_t* mixer_handle;
 
  UINT32 actual_rate;
  snd_pcm_format_t format;
  UINT32 actual_channels;
 
  snd_pcm_uframes_t buffer_size;
  snd_pcm_uframes_t period_size;
} rdpsndAlsaPlugin;
 
#define SND_PCM_CHECK(_func, _status)                      \
  do                                                     \
  {                                                      \
    if ((_status) < 0)                                 \
    {                                                  \
      WLog_ERR(TAG, "%s: %d\n", (_func), (_status)); \
      return -1;                                     \
    }                                                  \
  } while (0)
 
static int rdpsnd_alsa_set_hw_params(rdpsndAlsaPlugin* alsa)
{
  int status = 0;
  snd_pcm_hw_params_t* hw_params = nullptr;
  snd_pcm_uframes_t buffer_size_max = 0;
  status = snd_pcm_hw_params_malloc(&hw_params);
  SND_PCM_CHECK("snd_pcm_hw_params_malloc", status);
  status = snd_pcm_hw_params_any(alsa->pcm_handle, hw_params);
  SND_PCM_CHECK("snd_pcm_hw_params_any", status);
  /* Set interleaved read/write access */
  status =
      snd_pcm_hw_params_set_access(alsa->pcm_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
  SND_PCM_CHECK("snd_pcm_hw_params_set_access", status);
  /* Set sample format */
  status = snd_pcm_hw_params_set_format(alsa->pcm_handle, hw_params, alsa->format);
  SND_PCM_CHECK("snd_pcm_hw_params_set_format", status);
  /* Set sample rate */
  status =
      snd_pcm_hw_params_set_rate_near(alsa->pcm_handle, hw_params, &alsa->actual_rate, nullptr);
  SND_PCM_CHECK("snd_pcm_hw_params_set_rate_near", status);
  /* Set number of channels */
  status = snd_pcm_hw_params_set_channels(alsa->pcm_handle, hw_params, alsa->actual_channels);
  SND_PCM_CHECK("snd_pcm_hw_params_set_channels", status);
  /* Get maximum buffer size */
  status = snd_pcm_hw_params_get_buffer_size_max(hw_params, &buffer_size_max);
  SND_PCM_CHECK("snd_pcm_hw_params_get_buffer_size_max", status);
  const size_t interrupts_per_sec_near = 50;
  const size_t bytes_per_sec =
      (1ull * alsa->actual_rate * alsa->aformat.wBitsPerSample / 8 * alsa->actual_channels);
  alsa->buffer_size = buffer_size_max;
  alsa->period_size = (bytes_per_sec / interrupts_per_sec_near);
 
  if (alsa->period_size > buffer_size_max)
  {
    WLog_ERR(TAG, "Warning: requested sound buffer size %lu, got %lu instead\n",
             alsa->buffer_size, buffer_size_max);
    alsa->period_size = (buffer_size_max / 8);
  }
 
  /* Set buffer size */
  status =
      snd_pcm_hw_params_set_buffer_size_near(alsa->pcm_handle, hw_params, &alsa->buffer_size);
  SND_PCM_CHECK("snd_pcm_hw_params_set_buffer_size_near", status);
  /* Set period size */
  status = snd_pcm_hw_params_set_period_size_near(alsa->pcm_handle, hw_params, &alsa->period_size,
                                                  nullptr);
  SND_PCM_CHECK("snd_pcm_hw_params_set_period_size_near", status);
  status = snd_pcm_hw_params(alsa->pcm_handle, hw_params);
  SND_PCM_CHECK("snd_pcm_hw_params", status);
  snd_pcm_hw_params_free(hw_params);
  return 0;
}
 
static int rdpsnd_alsa_set_sw_params(rdpsndAlsaPlugin* alsa)
{
  int status = 0;
  snd_pcm_sw_params_t* sw_params = nullptr;
  status = snd_pcm_sw_params_malloc(&sw_params);
  SND_PCM_CHECK("snd_pcm_sw_params_malloc", status);
  status = snd_pcm_sw_params_current(alsa->pcm_handle, sw_params);
  SND_PCM_CHECK("snd_pcm_sw_params_current", status);
  status = snd_pcm_sw_params_set_avail_min(
      alsa->pcm_handle, sw_params, (1ULL * alsa->aformat.nChannels * alsa->actual_channels));
  SND_PCM_CHECK("snd_pcm_sw_params_set_avail_min", status);
  status = snd_pcm_sw_params_set_start_threshold(alsa->pcm_handle, sw_params,
                                                 alsa->aformat.nBlockAlign);
  SND_PCM_CHECK("snd_pcm_sw_params_set_start_threshold", status);
  status = snd_pcm_sw_params(alsa->pcm_handle, sw_params);
  SND_PCM_CHECK("snd_pcm_sw_params", status);
  snd_pcm_sw_params_free(sw_params);
  status = snd_pcm_prepare(alsa->pcm_handle);
  SND_PCM_CHECK("snd_pcm_prepare", status);
  return 0;
}
 
static int rdpsnd_alsa_validate_params(rdpsndAlsaPlugin* alsa)
{
  int status = 0;
  snd_pcm_uframes_t buffer_size = 0;
  snd_pcm_uframes_t period_size = 0;
  status = snd_pcm_get_params(alsa->pcm_handle, &buffer_size, &period_size);
  SND_PCM_CHECK("snd_pcm_get_params", status);
  return 0;
}
 
static int rdpsnd_alsa_set_params(rdpsndAlsaPlugin* alsa)
{
  snd_pcm_drop(alsa->pcm_handle);
 
  if (rdpsnd_alsa_set_hw_params(alsa) < 0)
    return -1;
 
  if (rdpsnd_alsa_set_sw_params(alsa) < 0)
    return -1;
 
  return rdpsnd_alsa_validate_params(alsa);
}
 
static BOOL rdpsnd_alsa_set_format(rdpsndDevicePlugin* device, const AUDIO_FORMAT* format,
                                   UINT32 latency)
{
  rdpsndAlsaPlugin* alsa = (rdpsndAlsaPlugin*)device;
 
  if (format)
  {
    alsa->aformat = *format;
    alsa->actual_rate = format->nSamplesPerSec;
    alsa->actual_channels = format->nChannels;
 
    switch (format->wFormatTag)
    {
      case WAVE_FORMAT_PCM:
        switch (format->wBitsPerSample)
        {
          case 8:
            alsa->format = SND_PCM_FORMAT_S8;
            break;
 
          case 16:
            alsa->format = SND_PCM_FORMAT_S16_LE;
            break;
 
          default:
            return FALSE;
        }
 
        break;
 
      default:
        return FALSE;
    }
  }
 
  alsa->latency = latency;
  return (rdpsnd_alsa_set_params(alsa) == 0);
}
 
static void rdpsnd_alsa_close_mixer(rdpsndAlsaPlugin* alsa)
{
  if (alsa && alsa->mixer_handle)
  {
    snd_mixer_close(alsa->mixer_handle);
    alsa->mixer_handle = nullptr;
  }
}
 
static BOOL rdpsnd_alsa_open_mixer(rdpsndAlsaPlugin* alsa)
{
  int status = 0;
 
  if (alsa->mixer_handle)
    return TRUE;
 
  status = snd_mixer_open(&alsa->mixer_handle, 0);
 
  if (status < 0)
  {
    WLog_ERR(TAG, "snd_mixer_open failed");
    goto fail;
  }
 
  status = snd_mixer_attach(alsa->mixer_handle, alsa->device_name);
 
  if (status < 0)
  {
    WLog_ERR(TAG, "snd_mixer_attach failed");
    goto fail;
  }
 
  status = snd_mixer_selem_register(alsa->mixer_handle, nullptr, nullptr);
 
  if (status < 0)
  {
    WLog_ERR(TAG, "snd_mixer_selem_register failed");
    goto fail;
  }
 
  status = snd_mixer_load(alsa->mixer_handle);
 
  if (status < 0)
  {
    WLog_ERR(TAG, "snd_mixer_load failed");
    goto fail;
  }
 
  return TRUE;
fail:
  rdpsnd_alsa_close_mixer(alsa);
  return FALSE;
}
 
static void rdpsnd_alsa_pcm_close(rdpsndAlsaPlugin* alsa)
{
  if (alsa && alsa->pcm_handle)
  {
    snd_pcm_drain(alsa->pcm_handle);
    snd_pcm_close(alsa->pcm_handle);
    alsa->pcm_handle = nullptr;
  }
}
 
static BOOL rdpsnd_alsa_open(rdpsndDevicePlugin* device, const AUDIO_FORMAT* format, UINT32 latency)
{
  int mode = 0;
  int status = 0;
  rdpsndAlsaPlugin* alsa = (rdpsndAlsaPlugin*)device;
 
  if (alsa->pcm_handle)
    return TRUE;
 
  mode = 0;
  /*mode |= SND_PCM_NONBLOCK;*/
  status = snd_pcm_open(&alsa->pcm_handle, alsa->device_name, SND_PCM_STREAM_PLAYBACK, mode);
 
  if (status < 0)
  {
    WLog_ERR(TAG, "snd_pcm_open failed");
    return FALSE;
  }
 
  return rdpsnd_alsa_set_format(device, format, latency) && rdpsnd_alsa_open_mixer(alsa);
}
 
static void rdpsnd_alsa_close(rdpsndDevicePlugin* device)
{
  rdpsndAlsaPlugin* alsa = (rdpsndAlsaPlugin*)device;
 
  if (!alsa)
    return;
 
  rdpsnd_alsa_close_mixer(alsa);
}
 
static void rdpsnd_alsa_free(rdpsndDevicePlugin* device)
{
  rdpsndAlsaPlugin* alsa = (rdpsndAlsaPlugin*)device;
  rdpsnd_alsa_pcm_close(alsa);
  rdpsnd_alsa_close_mixer(alsa);
  free(alsa->device_name);
  free(alsa);
}
 
static BOOL rdpsnd_alsa_format_supported(WINPR_ATTR_UNUSED rdpsndDevicePlugin* device,
                                         const AUDIO_FORMAT* format)
{
  switch (format->wFormatTag)
  {
    case WAVE_FORMAT_PCM:
      if (format->cbSize == 0 && format->nSamplesPerSec <= 48000 &&
          (format->wBitsPerSample == 8 || format->wBitsPerSample == 16) &&
          (format->nChannels == 1 || format->nChannels == 2))
      {
        return TRUE;
      }
 
      break;
    default:
      break;
  }
 
  return FALSE;
}
 
static UINT32 rdpsnd_alsa_get_volume(rdpsndDevicePlugin* device)
{
  long volume_min = 0;
  long volume_max = 0;
  long volume_left = 0;
  long volume_right = 0;
 
  rdpsndAlsaPlugin* alsa = (rdpsndAlsaPlugin*)device;
  UINT32 dwVolumeLeft = ((50 * 0xFFFF) / 100);  /* 50% */
  UINT32 dwVolumeRight = ((50 * 0xFFFF) / 100); /* 50% */
 
  if (!rdpsnd_alsa_open_mixer(alsa))
    return 0;
 
  for (snd_mixer_elem_t* elem = snd_mixer_first_elem(alsa->mixer_handle); elem;
       elem = snd_mixer_elem_next(elem))
  {
    if (snd_mixer_selem_has_playback_volume(elem))
    {
      snd_mixer_selem_get_playback_volume_range(elem, &volume_min, &volume_max);
      snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, &volume_left);
      snd_mixer_selem_get_playback_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT, &volume_right);
      dwVolumeLeft =
          (UINT16)(((volume_left * 0xFFFF) - volume_min) / (volume_max - volume_min));
      dwVolumeRight =
          (UINT16)(((volume_right * 0xFFFF) - volume_min) / (volume_max - volume_min));
      break;
    }
  }
 
  return (dwVolumeLeft << 16) | dwVolumeRight;
}
 
static BOOL rdpsnd_alsa_set_volume(rdpsndDevicePlugin* device, UINT32 value)
{
  long left = 0;
  long right = 0;
  long volume_min = 0;
  long volume_max = 0;
  long volume_left = 0;
  long volume_right = 0;
  rdpsndAlsaPlugin* alsa = (rdpsndAlsaPlugin*)device;
 
  if (!rdpsnd_alsa_open_mixer(alsa))
    return FALSE;
 
  left = (value & 0xFFFF);
  right = ((value >> 16) & 0xFFFF);
 
  for (snd_mixer_elem_t* elem = snd_mixer_first_elem(alsa->mixer_handle); elem;
       elem = snd_mixer_elem_next(elem))
  {
    if (snd_mixer_selem_has_playback_volume(elem))
    {
      snd_mixer_selem_get_playback_volume_range(elem, &volume_min, &volume_max);
      volume_left = volume_min + (left * (volume_max - volume_min)) / 0xFFFF;
      volume_right = volume_min + (right * (volume_max - volume_min)) / 0xFFFF;
 
      if ((snd_mixer_selem_set_playback_volume(elem, SND_MIXER_SCHN_FRONT_LEFT, volume_left) <
           0) ||
          (snd_mixer_selem_set_playback_volume(elem, SND_MIXER_SCHN_FRONT_RIGHT,
                                               volume_right) < 0))
      {
        WLog_ERR(TAG, "error setting the volume\n");
        return FALSE;
      }
    }
  }
 
  return TRUE;
}
 
static UINT rdpsnd_alsa_play(rdpsndDevicePlugin* device, const BYTE* data, size_t size)
{
  UINT latency = 0;
  size_t offset = 0;
  rdpsndAlsaPlugin* alsa = (rdpsndAlsaPlugin*)device;
  WINPR_ASSERT(alsa);
  WINPR_ASSERT(data || (size == 0));
  const size_t frame_size = 1ull * alsa->actual_channels * alsa->aformat.wBitsPerSample / 8;
  if (frame_size == 0)
    return 0;
 
  while (offset < size)
  {
    snd_pcm_sframes_t status =
        snd_pcm_writei(alsa->pcm_handle, &data[offset], (size - offset) / frame_size);
 
    if (status < 0)
      status = snd_pcm_recover(alsa->pcm_handle, (int)status, 0);
 
    if (status < 0)
    {
      WLog_ERR(TAG, "status: %ld\n", status);
      rdpsnd_alsa_close(device);
      rdpsnd_alsa_open(device, nullptr, alsa->latency);
      break;
    }
 
    offset += WINPR_ASSERTING_INT_CAST(size_t, status) * frame_size;
  }
 
  {
    snd_pcm_sframes_t available = 0;
    snd_pcm_sframes_t delay = 0;
    int rc = snd_pcm_avail_delay(alsa->pcm_handle, &available, &delay);
 
    if ((rc == 0) && (available == 0)) /* Get [ms] from number of samples */
      latency = (UINT32)MIN(UINT32_MAX, delay * 1000 / alsa->actual_rate);
  }
 
  return latency + alsa->latency;
}
 
static UINT rdpsnd_alsa_parse_addin_args(rdpsndDevicePlugin* device, const ADDIN_ARGV* args)
{
  int status = 0;
  DWORD flags = 0;
  const COMMAND_LINE_ARGUMENT_A* arg = nullptr;
  rdpsndAlsaPlugin* alsa = (rdpsndAlsaPlugin*)device;
  COMMAND_LINE_ARGUMENT_A rdpsnd_alsa_args[] = {
    { "dev", COMMAND_LINE_VALUE_REQUIRED, "<device>", nullptr, nullptr, -1, nullptr, "device" },
    { nullptr, 0, nullptr, nullptr, nullptr, -1, nullptr, nullptr }
  };
  flags =
      COMMAND_LINE_SIGIL_NONE | COMMAND_LINE_SEPARATOR_COLON | COMMAND_LINE_IGN_UNKNOWN_KEYWORD;
  status = CommandLineParseArgumentsA(args->argc, args->argv, rdpsnd_alsa_args, flags, alsa,
                                      nullptr, nullptr);
 
  if (status < 0)
  {
    WLog_ERR(TAG, "CommandLineParseArgumentsA failed!");
    return CHANNEL_RC_INITIALIZATION_ERROR;
  }
 
  arg = rdpsnd_alsa_args;
 
  do
  {
    if (!(arg->Flags & COMMAND_LINE_VALUE_PRESENT))
      continue;
 
    CommandLineSwitchStart(arg) CommandLineSwitchCase(arg, "dev")
    {
      alsa->device_name = _strdup(arg->Value);
 
      if (!alsa->device_name)
        return CHANNEL_RC_NO_MEMORY;
    }
    CommandLineSwitchEnd(arg)
  } while ((arg = CommandLineFindNextArgumentA(arg)) != nullptr);
 
  return CHANNEL_RC_OK;
}
 
FREERDP_ENTRY_POINT(UINT VCAPITYPE alsa_freerdp_rdpsnd_client_subsystem_entry(
    PFREERDP_RDPSND_DEVICE_ENTRY_POINTS pEntryPoints))
{
  const ADDIN_ARGV* args = nullptr;
  rdpsndAlsaPlugin* alsa = nullptr;
  UINT error = 0;
  alsa = (rdpsndAlsaPlugin*)calloc(1, sizeof(rdpsndAlsaPlugin));
 
  if (!alsa)
  {
    WLog_ERR(TAG, "calloc failed!");
    return CHANNEL_RC_NO_MEMORY;
  }
 
  alsa->device.Open = rdpsnd_alsa_open;
  alsa->device.FormatSupported = rdpsnd_alsa_format_supported;
  alsa->device.GetVolume = rdpsnd_alsa_get_volume;
  alsa->device.SetVolume = rdpsnd_alsa_set_volume;
  alsa->device.Play = rdpsnd_alsa_play;
  alsa->device.Close = rdpsnd_alsa_close;
  alsa->device.Free = rdpsnd_alsa_free;
  args = pEntryPoints->args;
 
  if (args->argc > 1)
  {
    if ((error = rdpsnd_alsa_parse_addin_args(&alsa->device, args)))
    {
      WLog_ERR(TAG, "rdpsnd_alsa_parse_addin_args failed with error %" PRIu32 "", error);
      goto error_parse_args;
    }
  }
 
  if (!alsa->device_name)
  {
    alsa->device_name = _strdup("default");
 
    if (!alsa->device_name)
    {
      WLog_ERR(TAG, "_strdup failed!");
      error = CHANNEL_RC_NO_MEMORY;
      goto error_strdup;
    }
  }
 
  alsa->pcm_handle = nullptr;
  alsa->actual_rate = 22050;
  alsa->format = SND_PCM_FORMAT_S16_LE;
  alsa->actual_channels = 2;
  pEntryPoints->pRegisterRdpsndDevice(pEntryPoints->rdpsnd, (rdpsndDevicePlugin*)alsa);
  return CHANNEL_RC_OK;
error_strdup:
  free(alsa->device_name);
error_parse_args:
  free(alsa);
  return error;
}