ksmith/orbithub
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Milestone 5: deliver embedded RDP sessions and lifecycle hardening

Browse Source
This commit is contained in:
Keith Smith
2026-03-03 18:59:26 -07:00
parent 230a401386
commit 36006bd4aa
2941 changed files with 724359 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
third_party/FreeRDP/channels/rdpsnd/client/alsa/CMakeLists.txt vendored Normal file
View File

@@ -0,0 +1,30 @@
# FreeRDP: A Remote Desktop Protocol Implementation
# FreeRDP cmake build script
#
# Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
define_channel_client_subsystem("rdpsnd" "alsa" "")
find_package(ALSA REQUIRED)
freerdp_client_pc_add_requires_private("alsa")
set(${MODULE_PREFIX}_SRCS rdpsnd_alsa.c)
set(${MODULE_PREFIX}_LIBS winpr freerdp ${ALSA_LIBRARIES})
include_directories(..)
include_directories(SYSTEM ${ALSA_INCLUDE_DIRS})
add_channel_client_subsystem_library(${MODULE_PREFIX} ${MODULE_NAME} ${CHANNEL_NAME} "" TRUE "")

571
third_party/FreeRDP/channels/rdpsnd/client/alsa/rdpsnd_alsa.c vendored Normal file
View File

@@ -0,0 +1,571 @@
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Audio Output Virtual Channel
*
* Copyright 2009-2011 Jay Sorg
* Copyright 2010-2011 Vic Lee
* Copyright 2015 Thincast Technologies GmbH
* Copyright 2015 DI (FH) Martin Haimberger <martin.haimberger@thincast.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#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);
/**
* ALSA Parameters
*
* http://www.alsa-project.org/main/index.php/FramesPeriods
*
* buffer_size = period_size * periods
* period_bytes = period_size * bytes_per_frame
* bytes_per_frame = channels * bytes_per_sample
*
* A frame is equivalent of one sample being played,
* irrespective of the number of channels or the number of bits
*
* A period is the number of frames in between each hardware interrupt.
*
* The buffer size always has to be greater than one period size.
* Commonly this is (2 * period_size), but some hardware can do 8 periods per buffer.
* It is also possible for the buffer size to not be an integer multiple of the period size.
*/
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;
}
/**
* Function description
*
* @return 0 on success, otherwise a Win32 error code
*/
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;
}
/**
* Function description
*
* @return 0 on success, otherwise a Win32 error code
*/
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;
}