audin.c

 
#include <freerdp/config.h>
 
#include <winpr/crt.h>
#include <winpr/assert.h>
#include <winpr/synch.h>
#include <winpr/thread.h>
#include <winpr/stream.h>
 
#include <freerdp/freerdp.h>
#include <freerdp/server/server-common.h>
#include <freerdp/server/audin.h>
#include <freerdp/channels/log.h>
 
#define AUDIN_TAG CHANNELS_TAG("audin.server")
 
#define SNDIN_HEADER_SIZE 1
 
typedef enum
{
  MSG_SNDIN_VERSION = 0x01,
  MSG_SNDIN_FORMATS = 0x02,
  MSG_SNDIN_OPEN = 0x03,
  MSG_SNDIN_OPEN_REPLY = 0x04,
  MSG_SNDIN_DATA_INCOMING = 0x05,
  MSG_SNDIN_DATA = 0x06,
  MSG_SNDIN_FORMATCHANGE = 0x07,
} MSG_SNDIN;
 
typedef struct
{
  audin_server_context context;
 
  HANDLE stopEvent;
 
  HANDLE thread;
  void* audin_channel;
 
  DWORD SessionId;
 
  AUDIO_FORMAT* audin_server_formats;
  UINT32 audin_n_server_formats;
  AUDIO_FORMAT* audin_negotiated_format;
  UINT32 audin_client_format_idx;
  wLog* log;
} audin_server;
 
static UINT audin_server_recv_version(audin_server_context* context, wStream* s,
                                      const SNDIN_PDU* header)
{
  audin_server* audin = (audin_server*)context;
  SNDIN_VERSION pdu = WINPR_C_ARRAY_INIT;
  UINT error = CHANNEL_RC_OK;
 
  WINPR_ASSERT(context);
  WINPR_ASSERT(header);
 
  pdu.Header = *header;
 
  if (!Stream_CheckAndLogRequiredLengthWLog(audin->log, s, 4))
    return ERROR_NO_DATA;
 
  {
    const UINT32 version = Stream_Get_UINT32(s);
    switch (version)
    {
      case SNDIN_VERSION_Version_1:
        pdu.Version = SNDIN_VERSION_Version_1;
        break;
      case SNDIN_VERSION_Version_2:
        pdu.Version = SNDIN_VERSION_Version_2;
        break;
      default:
        pdu.Version = SNDIN_VERSION_Version_2;
        WLog_Print(audin->log, WLOG_WARN,
                   "Received unsupported channel version %" PRIu32
                   ", using highest supported version %u",
                   version, pdu.Version);
        break;
    }
  }
 
  IFCALLRET(context->ReceiveVersion, error, context, &pdu);
  if (error)
    WLog_Print(audin->log, WLOG_ERROR, "context->ReceiveVersion failed with error %" PRIu32 "",
               error);
 
  return error;
}
 
static UINT audin_server_recv_formats(audin_server_context* context, wStream* s,
                                      const SNDIN_PDU* header)
{
  audin_server* audin = (audin_server*)context;
  SNDIN_FORMATS pdu = WINPR_C_ARRAY_INIT;
  UINT error = CHANNEL_RC_OK;
 
  WINPR_ASSERT(context);
  WINPR_ASSERT(header);
 
  pdu.Header = *header;
 
  /* Implementations MUST, at a minimum, support WAVE_FORMAT_PCM (0x0001) */
  if (!Stream_CheckAndLogRequiredLengthWLog(audin->log, s, 4 + 4 + 18))
    return ERROR_NO_DATA;
 
  Stream_Read_UINT32(s, pdu.NumFormats);
  Stream_Read_UINT32(s, pdu.cbSizeFormatsPacket);
 
  if (pdu.NumFormats == 0)
  {
    WLog_Print(audin->log, WLOG_ERROR, "Sound Formats PDU contains no formats");
    return ERROR_INVALID_DATA;
  }
 
  /* basic sanity check, we need at least pdu.NumFormats * sizeof(AUDIO_FORMAT) bytes of data */
  if (!Stream_CheckAndLogRequiredCapacityOfSizeWLog(audin->log, s, pdu.NumFormats,
                                                    sizeof(AUDIO_FORMAT)))
    return ERROR_INVALID_DATA;
 
  if (pdu.NumFormats > 512)
  {
    WLog_Print(audin->log, WLOG_ERROR,
               "Sound Formats PDU contains %" PRIu32 " formats, implausible so discarding",
               pdu.NumFormats);
    return ERROR_INVALID_DATA;
  }
 
  pdu.SoundFormats = audio_formats_new(pdu.NumFormats);
  if (!pdu.SoundFormats)
  {
    WLog_Print(audin->log, WLOG_ERROR, "Failed to allocate %u SoundFormats", pdu.NumFormats);
    return ERROR_NOT_ENOUGH_MEMORY;
  }
 
  for (UINT32 i = 0; i < pdu.NumFormats; ++i)
  {
    AUDIO_FORMAT* format = &pdu.SoundFormats[i];
 
    if (!audio_format_read(s, format))
    {
      WLog_Print(audin->log, WLOG_ERROR, "Failed to read audio format");
      error = ERROR_INVALID_DATA;
      goto fail;
    }
 
    audio_format_print(audin->log, WLOG_DEBUG, format);
  }
 
  if (pdu.cbSizeFormatsPacket != Stream_GetPosition(s))
  {
    WLog_Print(audin->log, WLOG_WARN,
               "cbSizeFormatsPacket is invalid! Expected: %u Got: %zu. Fixing size",
               pdu.cbSizeFormatsPacket, Stream_GetPosition(s));
    const size_t pos = Stream_GetPosition(s);
    if (pos > UINT32_MAX)
    {
      WLog_Print(audin->log, WLOG_ERROR, "Stream too long, %" PRIuz " exceeds UINT32_MAX",
                 pos);
      error = ERROR_INVALID_PARAMETER;
      goto fail;
    }
    pdu.cbSizeFormatsPacket = (UINT32)pos;
  }
 
  pdu.ExtraDataSize = Stream_GetRemainingLength(s);
 
  IFCALLRET(context->ReceiveFormats, error, context, &pdu);
  if (error)
    WLog_Print(audin->log, WLOG_ERROR, "context->ReceiveFormats failed with error %" PRIu32 "",
               error);
 
fail:
  audio_formats_free(pdu.SoundFormats, pdu.NumFormats);
 
  return error;
}
 
static UINT audin_server_recv_open_reply(audin_server_context* context, wStream* s,
                                         const SNDIN_PDU* header)
{
  audin_server* audin = (audin_server*)context;
  SNDIN_OPEN_REPLY pdu = WINPR_C_ARRAY_INIT;
  UINT error = CHANNEL_RC_OK;
 
  WINPR_ASSERT(context);
  WINPR_ASSERT(header);
 
  pdu.Header = *header;
 
  if (!Stream_CheckAndLogRequiredLengthWLog(audin->log, s, 4))
    return ERROR_NO_DATA;
 
  Stream_Read_UINT32(s, pdu.Result);
 
  IFCALLRET(context->OpenReply, error, context, &pdu);
  if (error)
    WLog_Print(audin->log, WLOG_ERROR, "context->OpenReply failed with error %" PRIu32 "",
               error);
 
  return error;
}
 
static UINT audin_server_recv_data_incoming(audin_server_context* context,
                                            WINPR_ATTR_UNUSED wStream* s, const SNDIN_PDU* header)
{
  audin_server* audin = (audin_server*)context;
  SNDIN_DATA_INCOMING pdu = WINPR_C_ARRAY_INIT;
  UINT error = CHANNEL_RC_OK;
 
  WINPR_ASSERT(context);
  WINPR_ASSERT(header);
 
  pdu.Header = *header;
 
  IFCALLRET(context->IncomingData, error, context, &pdu);
  if (error)
    WLog_Print(audin->log, WLOG_ERROR, "context->IncomingData failed with error %" PRIu32 "",
               error);
 
  return error;
}
 
static UINT audin_server_recv_data(audin_server_context* context, wStream* s,
                                   const SNDIN_PDU* header)
{
  audin_server* audin = (audin_server*)context;
  SNDIN_DATA pdu = WINPR_C_ARRAY_INIT;
  wStream dataBuffer = WINPR_C_ARRAY_INIT;
  UINT error = CHANNEL_RC_OK;
 
  WINPR_ASSERT(context);
  WINPR_ASSERT(header);
 
  pdu.Header = *header;
 
  pdu.Data = Stream_StaticInit(&dataBuffer, Stream_Pointer(s), Stream_GetRemainingLength(s));
 
  IFCALLRET(context->Data, error, context, &pdu);
  if (error)
    WLog_Print(audin->log, WLOG_ERROR, "context->Data failed with error %" PRIu32 "", error);
 
  return error;
}
 
static UINT audin_server_recv_format_change(audin_server_context* context, wStream* s,
                                            const SNDIN_PDU* header)
{
  audin_server* audin = (audin_server*)context;
  SNDIN_FORMATCHANGE pdu = WINPR_C_ARRAY_INIT;
  UINT error = CHANNEL_RC_OK;
 
  WINPR_ASSERT(context);
  WINPR_ASSERT(header);
 
  pdu.Header = *header;
 
  if (!Stream_CheckAndLogRequiredLengthWLog(audin->log, s, 4))
    return ERROR_NO_DATA;
 
  Stream_Read_UINT32(s, pdu.NewFormat);
 
  IFCALLRET(context->ReceiveFormatChange, error, context, &pdu);
  if (error)
    WLog_Print(audin->log, WLOG_ERROR,
               "context->ReceiveFormatChange failed with error %" PRIu32 "", error);
 
  return error;
}
 
static DWORD WINAPI audin_server_thread_func(LPVOID arg)
{
  wStream* s = nullptr;
  void* buffer = nullptr;
  DWORD nCount = 0;
  HANDLE events[8] = WINPR_C_ARRAY_INIT;
  BOOL ready = FALSE;
  HANDLE ChannelEvent = nullptr;
  DWORD BytesReturned = 0;
  audin_server* audin = (audin_server*)arg;
  UINT error = CHANNEL_RC_OK;
  DWORD status = ERROR_INTERNAL_ERROR;
 
  WINPR_ASSERT(audin);
 
  if (WTSVirtualChannelQuery(audin->audin_channel, WTSVirtualEventHandle, &buffer,
                             &BytesReturned) == TRUE)
  {
    if (BytesReturned == sizeof(HANDLE))
      ChannelEvent = *(HANDLE*)buffer;
 
    WTSFreeMemory(buffer);
  }
  else
  {
    WLog_Print(audin->log, WLOG_ERROR, "WTSVirtualChannelQuery failed");
    error = ERROR_INTERNAL_ERROR;
    goto out;
  }
 
  nCount = 0;
  events[nCount++] = audin->stopEvent;
  events[nCount++] = ChannelEvent;
 
  /* Wait for the client to confirm that the Audio Input dynamic channel is ready */
 
  while (1)
  {
    status = WaitForMultipleObjects(nCount, events, FALSE, 100);
 
    if (status == WAIT_FAILED)
    {
      error = GetLastError();
      WLog_Print(audin->log, WLOG_ERROR,
                 "WaitForMultipleObjects failed with error %" PRIu32 "", error);
      goto out;
    }
    if (status == WAIT_OBJECT_0)
      goto out;
 
    if (WTSVirtualChannelQuery(audin->audin_channel, WTSVirtualChannelReady, &buffer,
                               &BytesReturned) == FALSE)
    {
      WLog_Print(audin->log, WLOG_ERROR, "WTSVirtualChannelQuery failed");
      error = ERROR_INTERNAL_ERROR;
      goto out;
    }
 
    ready = *((BOOL*)buffer);
    WTSFreeMemory(buffer);
 
    if (ready)
      break;
  }
 
  s = Stream_New(nullptr, 4096);
 
  if (!s)
  {
    WLog_Print(audin->log, WLOG_ERROR, "Stream_New failed!");
    error = CHANNEL_RC_NO_MEMORY;
    goto out;
  }
 
  if (ready)
  {
    SNDIN_VERSION version = WINPR_C_ARRAY_INIT;
 
    version.Version = audin->context.serverVersion;
 
    if ((error = audin->context.SendVersion(&audin->context, &version)))
    {
      WLog_Print(audin->log, WLOG_ERROR, "SendVersion failed with error %" PRIu32 "!", error);
      goto out_capacity;
    }
  }
 
  while (ready)
  {
    SNDIN_PDU header = WINPR_C_ARRAY_INIT;
 
    if ((status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE)) == WAIT_OBJECT_0)
      break;
 
    if (status == WAIT_FAILED)
    {
      error = GetLastError();
      WLog_Print(audin->log, WLOG_ERROR,
                 "WaitForMultipleObjects failed with error %" PRIu32 "", error);
      break;
    }
    if (status == WAIT_OBJECT_0)
      break;
 
    Stream_ResetPosition(s);
 
    if (!WTSVirtualChannelRead(audin->audin_channel, 0, nullptr, 0, &BytesReturned))
    {
      WLog_Print(audin->log, WLOG_ERROR, "WTSVirtualChannelRead failed!");
      error = ERROR_INTERNAL_ERROR;
      break;
    }
 
    if (BytesReturned < 1)
      continue;
 
    if (!Stream_EnsureRemainingCapacity(s, BytesReturned))
      break;
 
    const ULONG len = WINPR_ASSERTING_INT_CAST(ULONG, Stream_Capacity(s));
    if (WTSVirtualChannelRead(audin->audin_channel, 0, Stream_BufferAs(s, char), len,
                              &BytesReturned) == FALSE)
    {
      WLog_Print(audin->log, WLOG_ERROR, "WTSVirtualChannelRead failed!");
      error = ERROR_INTERNAL_ERROR;
      break;
    }
 
    if (BytesReturned > len)
    {
      WLog_Print(audin->log, WLOG_ERROR,
                 "WTSVirtualChannelRead returned an invalid length, got %" PRIu32
                 ", but limit is %" PRIu32,
                 BytesReturned, len);
      error = ERROR_INTERNAL_ERROR;
      break;
    }
 
    if (!Stream_SetLength(s, BytesReturned))
    {
      error = ERROR_INTERNAL_ERROR;
      break;
    }
 
    if (!Stream_CheckAndLogRequiredLengthWLog(audin->log, s, SNDIN_HEADER_SIZE))
    {
      error = ERROR_INTERNAL_ERROR;
      break;
    }
 
    Stream_Read_UINT8(s, header.MessageId);
 
    switch (header.MessageId)
    {
      case MSG_SNDIN_VERSION:
        error = audin_server_recv_version(&audin->context, s, &header);
        break;
      case MSG_SNDIN_FORMATS:
        error = audin_server_recv_formats(&audin->context, s, &header);
        break;
      case MSG_SNDIN_OPEN_REPLY:
        error = audin_server_recv_open_reply(&audin->context, s, &header);
        break;
      case MSG_SNDIN_DATA_INCOMING:
        error = audin_server_recv_data_incoming(&audin->context, s, &header);
        break;
      case MSG_SNDIN_DATA:
        error = audin_server_recv_data(&audin->context, s, &header);
        break;
      case MSG_SNDIN_FORMATCHANGE:
        error = audin_server_recv_format_change(&audin->context, s, &header);
        break;
      default:
        WLog_Print(audin->log, WLOG_ERROR,
                   "audin_server_thread_func: unknown or invalid MessageId %" PRIu8 "",
                   header.MessageId);
        error = ERROR_INVALID_DATA;
        break;
    }
    if (error)
      break;
  }
 
out_capacity:
  Stream_Free(s, TRUE);
out:
  (void)WTSVirtualChannelClose(audin->audin_channel);
  audin->audin_channel = nullptr;
 
  if (error && audin->context.rdpcontext)
    setChannelError(audin->context.rdpcontext, error,
                    "audin_server_thread_func reported an error");
 
  ExitThread(error);
  return error;
}
 
static BOOL audin_server_open(audin_server_context* context)
{
  audin_server* audin = (audin_server*)context;
 
  WINPR_ASSERT(audin);
  if (!audin->thread)
  {
    PULONG pSessionId = nullptr;
    DWORD BytesReturned = 0;
    audin->SessionId = WTS_CURRENT_SESSION;
    UINT32 channelId = 0;
    BOOL status = TRUE;
 
    if (WTSQuerySessionInformationA(context->vcm, WTS_CURRENT_SESSION, WTSSessionId,
                                    (LPSTR*)&pSessionId, &BytesReturned))
    {
      audin->SessionId = (DWORD)*pSessionId;
      WTSFreeMemory(pSessionId);
    }
 
    audin->audin_channel = WTSVirtualChannelOpenEx(audin->SessionId, AUDIN_DVC_CHANNEL_NAME,
                                                   WTS_CHANNEL_OPTION_DYNAMIC);
 
    if (!audin->audin_channel)
    {
      WLog_Print(audin->log, WLOG_ERROR, "WTSVirtualChannelOpenEx failed!");
      return FALSE;
    }
 
    channelId = WTSChannelGetIdByHandle(audin->audin_channel);
 
    IFCALLRET(context->ChannelIdAssigned, status, context, channelId);
    if (!status)
    {
      WLog_Print(audin->log, WLOG_ERROR, "context->ChannelIdAssigned failed!");
      return FALSE;
    }
 
    if (!(audin->stopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr)))
    {
      WLog_Print(audin->log, WLOG_ERROR, "CreateEvent failed!");
      return FALSE;
    }
 
    if (!(audin->thread =
              CreateThread(nullptr, 0, audin_server_thread_func, (void*)audin, 0, nullptr)))
    {
      WLog_Print(audin->log, WLOG_ERROR, "CreateThread failed!");
      (void)CloseHandle(audin->stopEvent);
      audin->stopEvent = nullptr;
      return FALSE;
    }
 
    return TRUE;
  }
 
  WLog_Print(audin->log, WLOG_ERROR, "thread already running!");
  return FALSE;
}
 
static BOOL audin_server_is_open(audin_server_context* context)
{
  audin_server* audin = (audin_server*)context;
 
  WINPR_ASSERT(audin);
  return audin->thread != nullptr;
}
 
static BOOL audin_server_close(audin_server_context* context)
{
  audin_server* audin = (audin_server*)context;
  WINPR_ASSERT(audin);
 
  if (audin->thread)
  {
    (void)SetEvent(audin->stopEvent);
 
    if (WaitForSingleObject(audin->thread, INFINITE) == WAIT_FAILED)
    {
      WLog_Print(audin->log, WLOG_ERROR, "WaitForSingleObject failed with error %" PRIu32 "",
                 GetLastError());
      return FALSE;
    }
 
    (void)CloseHandle(audin->thread);
    (void)CloseHandle(audin->stopEvent);
    audin->thread = nullptr;
    audin->stopEvent = nullptr;
  }
 
  if (audin->audin_channel)
  {
    (void)WTSVirtualChannelClose(audin->audin_channel);
    audin->audin_channel = nullptr;
  }
 
  audin->audin_negotiated_format = nullptr;
 
  return TRUE;
}
 
static wStream* audin_server_packet_new(wLog* log, size_t size, BYTE MessageId)
{
  WINPR_ASSERT(log);
 
  /* Allocate what we need plus header bytes */
  wStream* s = Stream_New(nullptr, size + SNDIN_HEADER_SIZE);
  if (!s)
  {
    WLog_Print(log, WLOG_ERROR, "Stream_New failed!");
    return nullptr;
  }
 
  Stream_Write_UINT8(s, MessageId);
 
  return s;
}
 
static UINT audin_server_packet_send(audin_server_context* context, wStream* s)
{
  audin_server* audin = (audin_server*)context;
  UINT error = CHANNEL_RC_OK;
  ULONG written = 0;
 
  WINPR_ASSERT(context);
  WINPR_ASSERT(s);
 
  const size_t pos = Stream_GetPosition(s);
  WINPR_ASSERT(pos <= UINT32_MAX);
  if (!WTSVirtualChannelWrite(audin->audin_channel, Stream_BufferAs(s, char), (UINT32)pos,
                              &written))
  {
    WLog_Print(audin->log, WLOG_ERROR, "WTSVirtualChannelWrite failed!");
    error = ERROR_INTERNAL_ERROR;
    goto out;
  }
 
  if (written < Stream_GetPosition(s))
  {
    WLog_Print(audin->log, WLOG_WARN, "Unexpected bytes written: %" PRIu32 "/%" PRIuz "",
               written, Stream_GetPosition(s));
  }
 
out:
  Stream_Free(s, TRUE);
  return error;
}
 
static UINT audin_server_send_version(audin_server_context* context, const SNDIN_VERSION* version)
{
  audin_server* audin = (audin_server*)context;
 
  WINPR_ASSERT(context);
  WINPR_ASSERT(version);
 
  wStream* s = audin_server_packet_new(audin->log, 4, MSG_SNDIN_VERSION);
  if (!s)
    return ERROR_NOT_ENOUGH_MEMORY;
 
  Stream_Write_UINT32(s, version->Version);
 
  return audin_server_packet_send(context, s);
}
 
static UINT audin_server_send_formats(audin_server_context* context, const SNDIN_FORMATS* formats)
{
  audin_server* audin = (audin_server*)context;
 
  WINPR_ASSERT(audin);
  WINPR_ASSERT(formats);
 
  wStream* s = audin_server_packet_new(audin->log, 4 + 4 + 18, MSG_SNDIN_FORMATS);
  if (!s)
    return ERROR_NOT_ENOUGH_MEMORY;
 
  Stream_Write_UINT32(s, formats->NumFormats);
  Stream_Write_UINT32(s, formats->cbSizeFormatsPacket);
 
  for (UINT32 i = 0; i < formats->NumFormats; ++i)
  {
    AUDIO_FORMAT* format = &formats->SoundFormats[i];
 
    if (!audio_format_write(s, format))
    {
      WLog_Print(audin->log, WLOG_ERROR, "Failed to write audio format");
      Stream_Free(s, TRUE);
      return CHANNEL_RC_NO_MEMORY;
    }
  }
 
  return audin_server_packet_send(context, s);
}
 
static UINT audin_server_send_open(audin_server_context* context, const SNDIN_OPEN* open)
{
  audin_server* audin = (audin_server*)context;
  WINPR_ASSERT(audin);
  WINPR_ASSERT(open);
 
  wStream* s = audin_server_packet_new(audin->log, 4 + 4 + 18 + 22, MSG_SNDIN_OPEN);
  if (!s)
    return ERROR_NOT_ENOUGH_MEMORY;
 
  Stream_Write_UINT32(s, open->FramesPerPacket);
  Stream_Write_UINT32(s, open->initialFormat);
 
  Stream_Write_UINT16(s, open->captureFormat.wFormatTag);
  Stream_Write_UINT16(s, open->captureFormat.nChannels);
  Stream_Write_UINT32(s, open->captureFormat.nSamplesPerSec);
  Stream_Write_UINT32(s, open->captureFormat.nAvgBytesPerSec);
  Stream_Write_UINT16(s, open->captureFormat.nBlockAlign);
  Stream_Write_UINT16(s, open->captureFormat.wBitsPerSample);
 
  if (open->ExtraFormatData)
  {
    Stream_Write_UINT16(s, 22); /* cbSize */
 
    Stream_Write_UINT16(s, open->ExtraFormatData->Samples.wReserved);
    Stream_Write_UINT32(s, open->ExtraFormatData->dwChannelMask);
 
    Stream_Write_UINT32(s, open->ExtraFormatData->SubFormat.Data1);
    Stream_Write_UINT16(s, open->ExtraFormatData->SubFormat.Data2);
    Stream_Write_UINT16(s, open->ExtraFormatData->SubFormat.Data3);
    Stream_Write_UINT8(s, open->ExtraFormatData->SubFormat.Data4[0]);
    Stream_Write_UINT8(s, open->ExtraFormatData->SubFormat.Data4[1]);
    Stream_Write_UINT8(s, open->ExtraFormatData->SubFormat.Data4[2]);
    Stream_Write_UINT8(s, open->ExtraFormatData->SubFormat.Data4[3]);
    Stream_Write_UINT8(s, open->ExtraFormatData->SubFormat.Data4[4]);
    Stream_Write_UINT8(s, open->ExtraFormatData->SubFormat.Data4[5]);
    Stream_Write_UINT8(s, open->ExtraFormatData->SubFormat.Data4[6]);
    Stream_Write_UINT8(s, open->ExtraFormatData->SubFormat.Data4[7]);
  }
  else
  {
    WINPR_ASSERT(open->captureFormat.wFormatTag != WAVE_FORMAT_EXTENSIBLE);
 
    Stream_Write_UINT16(s, 0); /* cbSize */
  }
 
  return audin_server_packet_send(context, s);
}
 
static UINT audin_server_send_format_change(audin_server_context* context,
                                            const SNDIN_FORMATCHANGE* format_change)
{
  audin_server* audin = (audin_server*)context;
 
  WINPR_ASSERT(context);
  WINPR_ASSERT(format_change);
 
  wStream* s = audin_server_packet_new(audin->log, 4, MSG_SNDIN_FORMATCHANGE);
  if (!s)
    return ERROR_NOT_ENOUGH_MEMORY;
 
  Stream_Write_UINT32(s, format_change->NewFormat);
 
  return audin_server_packet_send(context, s);
}
 
static UINT audin_server_receive_version_default(audin_server_context* audin_ctx,
                                                 const SNDIN_VERSION* version)
{
  audin_server* audin = (audin_server*)audin_ctx;
  SNDIN_FORMATS formats = WINPR_C_ARRAY_INIT;
 
  WINPR_ASSERT(audin);
  WINPR_ASSERT(version);
 
  if (version->Version == 0)
  {
    WLog_Print(audin->log, WLOG_ERROR, "Received invalid AUDIO_INPUT version from client");
    return ERROR_INVALID_DATA;
  }
 
  WLog_Print(audin->log, WLOG_DEBUG, "AUDIO_INPUT version of client: %u", version->Version);
 
  formats.NumFormats = audin->audin_n_server_formats;
  formats.SoundFormats = audin->audin_server_formats;
 
  return audin->context.SendFormats(&audin->context, &formats);
}
 
static UINT send_open(audin_server* audin)
{
  SNDIN_OPEN open = WINPR_C_ARRAY_INIT;
 
  WINPR_ASSERT(audin);
 
  open.FramesPerPacket = 441;
  open.initialFormat = audin->audin_client_format_idx;
  open.captureFormat.wFormatTag = WAVE_FORMAT_PCM;
  open.captureFormat.nChannels = 2;
  open.captureFormat.nSamplesPerSec = 44100;
  open.captureFormat.nAvgBytesPerSec = 44100 * 2 * 2;
  open.captureFormat.nBlockAlign = 4;
  open.captureFormat.wBitsPerSample = 16;
 
  WINPR_ASSERT(audin->context.SendOpen);
  return audin->context.SendOpen(&audin->context, &open);
}
 
static UINT audin_server_receive_formats_default(audin_server_context* context,
                                                 const SNDIN_FORMATS* formats)
{
  audin_server* audin = (audin_server*)context;
  WINPR_ASSERT(audin);
  WINPR_ASSERT(formats);
 
  if (audin->audin_negotiated_format)
  {
    WLog_Print(audin->log, WLOG_ERROR,
               "Received client formats, but negotiation was already done");
    return ERROR_INVALID_DATA;
  }
 
  for (UINT32 i = 0; i < audin->audin_n_server_formats; ++i)
  {
    for (UINT32 j = 0; j < formats->NumFormats; ++j)
    {
      if (audio_format_compatible(&audin->audin_server_formats[i], &formats->SoundFormats[j]))
      {
        audin->audin_negotiated_format = &audin->audin_server_formats[i];
        audin->audin_client_format_idx = i;
        return send_open(audin);
      }
    }
  }
 
  WLog_Print(audin->log, WLOG_ERROR, "Could not agree on a audio format with the server");
 
  return ERROR_INVALID_DATA;
}
 
static UINT audin_server_receive_format_change_default(audin_server_context* context,
                                                       const SNDIN_FORMATCHANGE* format_change)
{
  audin_server* audin = (audin_server*)context;
 
  WINPR_ASSERT(audin);
  WINPR_ASSERT(format_change);
 
  if (format_change->NewFormat != audin->audin_client_format_idx)
  {
    WLog_Print(audin->log, WLOG_ERROR,
               "NewFormat in FormatChange differs from requested format");
    return ERROR_INVALID_DATA;
  }
 
  WLog_Print(audin->log, WLOG_DEBUG, "Received Format Change PDU: %u", format_change->NewFormat);
 
  return CHANNEL_RC_OK;
}
 
static UINT
audin_server_incoming_data_default(audin_server_context* context,
                                   WINPR_ATTR_UNUSED const SNDIN_DATA_INCOMING* data_incoming)
{
  audin_server* audin = (audin_server*)context;
  WINPR_ASSERT(audin);
  WINPR_ASSERT(data_incoming);
 
  /* TODO: Implement bandwidth measure of clients uplink */
  WLog_Print(audin->log, WLOG_DEBUG, "Received Incoming Data PDU");
  return CHANNEL_RC_OK;
}
 
static UINT audin_server_open_reply_default(audin_server_context* context,
                                            const SNDIN_OPEN_REPLY* open_reply)
{
  audin_server* audin = (audin_server*)context;
  WINPR_ASSERT(audin);
  WINPR_ASSERT(open_reply);
 
  /* TODO: Implement failure handling */
  WLog_Print(audin->log, WLOG_DEBUG, "Open Reply PDU: Result: %" PRIu32, open_reply->Result);
  return CHANNEL_RC_OK;
}
 
audin_server_context* audin_server_context_new(HANDLE vcm)
{
  audin_server* audin = (audin_server*)calloc(1, sizeof(audin_server));
 
  if (!audin)
  {
    WLog_ERR(AUDIN_TAG, "calloc failed!");
    return nullptr;
  }
  audin->log = WLog_Get(AUDIN_TAG);
  audin->context.vcm = vcm;
  audin->context.Open = audin_server_open;
  audin->context.IsOpen = audin_server_is_open;
  audin->context.Close = audin_server_close;
 
  audin->context.SendVersion = audin_server_send_version;
  audin->context.SendFormats = audin_server_send_formats;
  audin->context.SendOpen = audin_server_send_open;
  audin->context.SendFormatChange = audin_server_send_format_change;
 
  /* Default values */
  audin->context.serverVersion = SNDIN_VERSION_Version_2;
  audin->context.ReceiveVersion = audin_server_receive_version_default;
  audin->context.ReceiveFormats = audin_server_receive_formats_default;
  audin->context.ReceiveFormatChange = audin_server_receive_format_change_default;
  audin->context.IncomingData = audin_server_incoming_data_default;
  audin->context.OpenReply = audin_server_open_reply_default;
 
  return &audin->context;
}
 
void audin_server_context_free(audin_server_context* context)
{
  audin_server* audin = (audin_server*)context;
 
  if (!audin)
    return;
 
  audin_server_close(context);
  audio_formats_free(audin->audin_server_formats, audin->audin_n_server_formats);
  audin->audin_server_formats = nullptr;
  free(audin);
}
 
BOOL audin_server_set_formats(audin_server_context* context, SSIZE_T count,
                              const AUDIO_FORMAT* formats)
{
  audin_server* audin = (audin_server*)context;
  WINPR_ASSERT(audin);
 
  audio_formats_free(audin->audin_server_formats, audin->audin_n_server_formats);
  audin->audin_n_server_formats = 0;
  audin->audin_server_formats = nullptr;
  audin->audin_negotiated_format = nullptr;
 
  if (count < 0)
  {
    const size_t audin_n_server_formats =
        server_audin_get_formats(&audin->audin_server_formats);
    WINPR_ASSERT(audin_n_server_formats <= UINT32_MAX);
 
    audin->audin_n_server_formats = (UINT32)audin_n_server_formats;
  }
  else
  {
    const size_t scount = (size_t)count;
    AUDIO_FORMAT* audin_server_formats = audio_formats_new(scount);
    if (!audin_server_formats)
      return count == 0;
 
    for (SSIZE_T x = 0; x < count; x++)
    {
      if (!audio_format_copy(&formats[x], &audin_server_formats[x]))
      {
        audio_formats_free(audin_server_formats, scount);
        return FALSE;
      }
    }
 
    WINPR_ASSERT(count <= UINT32_MAX);
    audin->audin_server_formats = audin_server_formats;
    audin->audin_n_server_formats = (UINT32)count;
  }
  return audin->audin_n_server_formats > 0;
}
 
const AUDIO_FORMAT* audin_server_get_negotiated_format(const audin_server_context* context)
{
  const audin_server* audin = (const audin_server*)context;
  WINPR_ASSERT(audin);
 
  return audin->audin_negotiated_format;
}