camera_device_enum_main.c

 
#include <winpr/assert.h>
#include <winpr/cast.h>
#include <winpr/string.h>
 
#include "camera.h"
 
#define TAG CHANNELS_TAG("rdpecam-enum.client")
 
UINT ecam_channel_send_error_response(CameraPlugin* ecam, GENERIC_CHANNEL_CALLBACK* hchannel,
                                      CAM_ERROR_CODE code)
{
  CAM_MSG_ID msg = CAM_MSG_ID_ErrorResponse;
 
  WINPR_ASSERT(ecam);
 
  wStream* s = Stream_New(nullptr, CAM_HEADER_SIZE + 4);
  if (!s)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return ERROR_NOT_ENOUGH_MEMORY;
  }
 
  Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, ecam->version));
  Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, msg));
  Stream_Write_UINT32(s, code);
 
  return ecam_channel_write(ecam, hchannel, msg, s, TRUE);
}
 
UINT ecam_channel_send_generic_msg(CameraPlugin* ecam, GENERIC_CHANNEL_CALLBACK* hchannel,
                                   CAM_MSG_ID msg)
{
  WINPR_ASSERT(ecam);
 
  wStream* s = Stream_New(nullptr, CAM_HEADER_SIZE);
  if (!s)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return ERROR_NOT_ENOUGH_MEMORY;
  }
 
  Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, ecam->version));
  Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, msg));
 
  return ecam_channel_write(ecam, hchannel, msg, s, TRUE);
}
 
UINT ecam_channel_write(WINPR_ATTR_UNUSED CameraPlugin* ecam, GENERIC_CHANNEL_CALLBACK* hchannel,
                        CAM_MSG_ID msg, wStream* out, BOOL freeStream)
{
  if (!hchannel || !out)
    return ERROR_INVALID_PARAMETER;
 
  Stream_SealLength(out);
 
  const ULONG len = WINPR_ASSERTING_INT_CAST(ULONG, Stream_Length(out));
 
  WLog_DBG(TAG, "ChannelId=%" PRIu32 ", MessageId=0x%02" PRIx8 ", Length=%" PRIu32,
           hchannel->channel_mgr->GetChannelId(hchannel->channel), msg, len);
 
  const UINT error =
      hchannel->channel->Write(hchannel->channel, len, Stream_Buffer(out), nullptr);
 
  if (freeStream)
    Stream_Free(out, TRUE);
 
  return error;
}
 
static UINT ecam_send_device_added_notification(CameraPlugin* ecam,
                                                GENERIC_CHANNEL_CALLBACK* hchannel,
                                                const char* deviceName, const char* channelName)
{
  CAM_MSG_ID msg = CAM_MSG_ID_DeviceAddedNotification;
 
  WINPR_ASSERT(ecam);
 
  wStream* s = Stream_New(nullptr, 256);
  if (!s)
  {
    WLog_ERR(TAG, "Stream_New failed!");
    return ERROR_NOT_ENOUGH_MEMORY;
  }
 
  Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, ecam->version));
  Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, msg));
 
  const size_t devNameLen = strlen(deviceName);
  const SSIZE_T devNameWLen = ConvertUtf8ToWChar(deviceName, nullptr, 0);
  if ((devNameWLen < 0) ||
      Stream_Write_UTF16_String_From_UTF8(s, WINPR_ASSERTING_INT_CAST(size_t, devNameWLen) + 1ull,
                                          deviceName, devNameLen, TRUE) < 0)
  {
    Stream_Free(s, TRUE);
    return ERROR_INTERNAL_ERROR;
  }
  Stream_Write(s, channelName, strlen(channelName) + 1);
 
  return ecam_channel_write(ecam, hchannel, msg, s, TRUE);
}
 
static UINT ecam_ihal_device_added_callback(CameraPlugin* ecam, GENERIC_CHANNEL_CALLBACK* hchannel,
                                            const char* deviceId, const char* deviceName)
{
  WLog_DBG(TAG, "deviceId=%s, deviceName=%s", deviceId, deviceName);
 
  if (!HashTable_ContainsKey(ecam->devices, deviceId))
  {
    CameraDevice* dev = ecam_dev_create(ecam, deviceId, deviceName);
    if (!HashTable_Insert(ecam->devices, deviceId, dev))
    {
      ecam_dev_destroy(dev);
      return ERROR_INTERNAL_ERROR;
    }
  }
  else
  {
    WLog_DBG(TAG, "Device %s already exists", deviceId);
  }
 
  ecam_send_device_added_notification(ecam, hchannel, deviceName, deviceId /*channelName*/);
 
  return CHANNEL_RC_OK;
}
 
static UINT ecam_enumerate_devices(CameraPlugin* ecam, GENERIC_CHANNEL_CALLBACK* hchannel)
{
  return ecam->ihal->Enumerate(ecam->ihal, ecam_ihal_device_added_callback, ecam, hchannel);
}
 
static UINT ecam_process_select_version_response(CameraPlugin* ecam,
                                                 GENERIC_CHANNEL_CALLBACK* hchannel,
                                                 WINPR_ATTR_UNUSED wStream* s, BYTE serverVersion)
{
  const BYTE clientVersion = ECAM_PROTO_VERSION;
 
  /* check remaining s capacity */
 
  WLog_DBG(TAG, "ServerVersion=%" PRIu8 ", ClientVersion=%" PRIu8, serverVersion, clientVersion);
 
  if (serverVersion > clientVersion)
  {
    WLog_ERR(TAG,
             "Incompatible protocol version server=%" PRIu8 ", client supports version=%" PRIu8,
             serverVersion, clientVersion);
    return CHANNEL_RC_OK;
  }
  ecam->version = serverVersion;
 
  if (ecam->ihal)
    ecam_enumerate_devices(ecam, hchannel);
  else
    WLog_ERR(TAG, "No HAL registered");
 
  return CHANNEL_RC_OK;
}
 
static UINT ecam_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data)
{
  UINT error = CHANNEL_RC_OK;
  BYTE version = 0;
  BYTE messageId = 0;
  GENERIC_CHANNEL_CALLBACK* hchannel = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
 
  if (!hchannel || !data)
    return ERROR_INVALID_PARAMETER;
 
  CameraPlugin* ecam = (CameraPlugin*)hchannel->plugin;
 
  if (!ecam)
    return ERROR_INTERNAL_ERROR;
 
  if (!Stream_CheckAndLogRequiredLength(TAG, data, CAM_HEADER_SIZE))
    return ERROR_NO_DATA;
 
  Stream_Read_UINT8(data, version);
  Stream_Read_UINT8(data, messageId);
  WLog_DBG(TAG, "ChannelId=%" PRIu32 ", MessageId=0x%02" PRIx8 ", Version=%d",
           hchannel->channel_mgr->GetChannelId(hchannel->channel), messageId, version);
 
  switch (messageId)
  {
    case CAM_MSG_ID_SelectVersionResponse:
      error = ecam_process_select_version_response(ecam, hchannel, data, version);
      break;
 
    default:
      WLog_WARN(TAG, "unknown MessageId=0x%02" PRIx8 "", messageId);
      error = ERROR_INVALID_DATA;
      ecam_channel_send_error_response(ecam, hchannel, CAM_ERROR_CODE_OperationNotSupported);
      break;
  }
 
  return error;
}
 
static UINT ecam_on_open(IWTSVirtualChannelCallback* pChannelCallback)
{
  GENERIC_CHANNEL_CALLBACK* hchannel = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
  WINPR_ASSERT(hchannel);
 
  CameraPlugin* ecam = (CameraPlugin*)hchannel->plugin;
  WINPR_ASSERT(ecam);
 
  WLog_DBG(TAG, "entered");
  return ecam_channel_send_generic_msg(ecam, hchannel, CAM_MSG_ID_SelectVersionRequest);
}
 
static UINT ecam_on_close(IWTSVirtualChannelCallback* pChannelCallback)
{
  GENERIC_CHANNEL_CALLBACK* hchannel = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
  WINPR_ASSERT(hchannel);
 
  WLog_DBG(TAG, "entered");
 
  free(hchannel);
  return CHANNEL_RC_OK;
}
 
static UINT ecam_on_new_channel_connection(IWTSListenerCallback* pListenerCallback,
                                           IWTSVirtualChannel* pChannel,
                                           WINPR_ATTR_UNUSED BYTE* Data,
                                           WINPR_ATTR_UNUSED BOOL* pbAccept,
                                           IWTSVirtualChannelCallback** ppCallback)
{
  GENERIC_LISTENER_CALLBACK* hlistener = (GENERIC_LISTENER_CALLBACK*)pListenerCallback;
 
  if (!hlistener || !hlistener->plugin)
    return ERROR_INTERNAL_ERROR;
 
  WLog_DBG(TAG, "entered");
  GENERIC_CHANNEL_CALLBACK* hchannel =
      (GENERIC_CHANNEL_CALLBACK*)calloc(1, sizeof(GENERIC_CHANNEL_CALLBACK));
 
  if (!hchannel)
  {
    WLog_ERR(TAG, "calloc failed!");
    return CHANNEL_RC_NO_MEMORY;
  }
 
  hchannel->iface.OnDataReceived = ecam_on_data_received;
  hchannel->iface.OnOpen = ecam_on_open;
  hchannel->iface.OnClose = ecam_on_close;
  hchannel->plugin = hlistener->plugin;
  hchannel->channel_mgr = hlistener->channel_mgr;
  hchannel->channel = pChannel;
  *ppCallback = (IWTSVirtualChannelCallback*)hchannel;
  return CHANNEL_RC_OK;
}
 
static void ecam_dev_destroy_pv(void* obj)
{
  CameraDevice* dev = obj;
  ecam_dev_destroy(dev);
}
 
static UINT ecam_plugin_initialize(IWTSPlugin* pPlugin, IWTSVirtualChannelManager* pChannelMgr)
{
  CameraPlugin* ecam = (CameraPlugin*)pPlugin;
 
  WLog_DBG(TAG, "entered");
 
  if (!ecam || !pChannelMgr)
    return ERROR_INVALID_PARAMETER;
 
  if (ecam->initialized)
  {
    WLog_ERR(TAG, "[%s] plugin initialized twice, aborting", RDPECAM_CONTROL_DVC_CHANNEL_NAME);
    return ERROR_INVALID_DATA;
  }
 
  ecam->version = ECAM_PROTO_VERSION;
 
  ecam->devices = HashTable_New(FALSE);
  if (!ecam->devices)
  {
    WLog_ERR(TAG, "HashTable_New failed!");
    return CHANNEL_RC_NO_MEMORY;
  }
 
  if (!HashTable_SetupForStringData(ecam->devices, FALSE))
  {
    HashTable_Free(ecam->devices);
    ecam->devices = nullptr;
    return ERROR_INTERNAL_ERROR;
  }
 
  wObject* obj = HashTable_ValueObject(ecam->devices);
  WINPR_ASSERT(obj);
  obj->fnObjectFree = ecam_dev_destroy_pv;
 
  ecam->hlistener = (GENERIC_LISTENER_CALLBACK*)calloc(1, sizeof(GENERIC_LISTENER_CALLBACK));
 
  if (!ecam->hlistener)
  {
    WLog_ERR(TAG, "calloc failed!");
    return CHANNEL_RC_NO_MEMORY;
  }
 
  ecam->hlistener->iface.OnNewChannelConnection = ecam_on_new_channel_connection;
  ecam->hlistener->plugin = pPlugin;
  ecam->hlistener->channel_mgr = pChannelMgr;
  const UINT rc = pChannelMgr->CreateListener(pChannelMgr, RDPECAM_CONTROL_DVC_CHANNEL_NAME, 0,
                                              &ecam->hlistener->iface, &ecam->listener);
 
  ecam->initialized = (rc == CHANNEL_RC_OK);
  return rc;
}
 
static UINT ecam_plugin_terminated(IWTSPlugin* pPlugin)
{
  CameraPlugin* ecam = (CameraPlugin*)pPlugin;
 
  if (!ecam)
    return ERROR_INVALID_DATA;
 
  WLog_DBG(TAG, "entered");
 
  if (ecam->hlistener)
  {
    IWTSVirtualChannelManager* mgr = ecam->hlistener->channel_mgr;
    if (mgr)
      IFCALL(mgr->DestroyListener, mgr, ecam->listener);
  }
 
  free(ecam->hlistener);
 
  HashTable_Free(ecam->devices);
 
  UINT rc = CHANNEL_RC_OK;
  if (ecam->ihal)
    rc = ecam->ihal->Free(ecam->ihal);
 
  free(ecam);
  return rc;
}
 
static UINT ecam_plugin_attached(IWTSPlugin* pPlugin)
{
  CameraPlugin* ecam = (CameraPlugin*)pPlugin;
  UINT error = CHANNEL_RC_OK;
 
  if (!ecam)
    return ERROR_INVALID_PARAMETER;
 
  ecam->attached = TRUE;
  return error;
}
 
static UINT ecam_plugin_detached(IWTSPlugin* pPlugin)
{
  CameraPlugin* ecam = (CameraPlugin*)pPlugin;
  UINT error = CHANNEL_RC_OK;
 
  if (!ecam)
    return ERROR_INVALID_PARAMETER;
 
  ecam->attached = FALSE;
  return error;
}
 
static UINT ecam_register_hal_plugin(IWTSPlugin* pPlugin, ICamHal* ihal)
{
  CameraPlugin* ecam = (CameraPlugin*)pPlugin;
 
  WINPR_ASSERT(ecam);
 
  if (ecam->ihal)
  {
    WLog_DBG(TAG, "already registered");
    return ERROR_ALREADY_EXISTS;
  }
 
  WLog_DBG(TAG, "HAL registered");
  ecam->ihal = ihal;
  return CHANNEL_RC_OK;
}
 
static UINT ecam_load_hal_plugin(CameraPlugin* ecam, const char* name, const ADDIN_ARGV* args)
{
  WINPR_ASSERT(ecam);
 
  FREERDP_CAMERA_HAL_ENTRY_POINTS entryPoints = WINPR_C_ARRAY_INIT;
  UINT error = ERROR_INTERNAL_ERROR;
  union
  {
    PVIRTUALCHANNELENTRY pvce;
    const PFREERDP_CAMERA_HAL_ENTRY entry;
  } cnv;
  cnv.pvce = freerdp_load_channel_addin_entry(RDPECAM_CHANNEL_NAME, name, nullptr, 0);
 
  if (cnv.entry == nullptr)
  {
    WLog_ERR(TAG,
             "freerdp_load_channel_addin_entry did not return any function pointers for %s ",
             name);
    return ERROR_INVALID_FUNCTION;
  }
 
  entryPoints.plugin = &ecam->iface;
  entryPoints.pRegisterCameraHal = ecam_register_hal_plugin;
  entryPoints.args = args;
  entryPoints.ecam = ecam;
 
  error = cnv.entry(&entryPoints);
  if (error)
  {
    WLog_ERR(TAG, "%s entry returned error %" PRIu32 ".", name, error);
    return error;
  }
 
  WLog_INFO(TAG, "Loaded %s HAL for ecam", name);
  return CHANNEL_RC_OK;
}
 
FREERDP_ENTRY_POINT(UINT VCAPITYPE rdpecam_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints))
{
  UINT error = CHANNEL_RC_INITIALIZATION_ERROR;
 
  WINPR_ASSERT(pEntryPoints);
  WINPR_ASSERT(pEntryPoints->GetPlugin);
  CameraPlugin* ecam = (CameraPlugin*)pEntryPoints->GetPlugin(pEntryPoints, RDPECAM_CHANNEL_NAME);
 
  if (ecam != nullptr)
    return CHANNEL_RC_ALREADY_INITIALIZED;
 
  ecam = (CameraPlugin*)calloc(1, sizeof(CameraPlugin));
 
  if (!ecam)
  {
    WLog_ERR(TAG, "calloc failed!");
    return CHANNEL_RC_NO_MEMORY;
  }
 
  ecam->attached = TRUE;
  ecam->iface.Initialize = ecam_plugin_initialize;
  ecam->iface.Connected = nullptr; /* server connects to client */
  ecam->iface.Disconnected = nullptr;
  ecam->iface.Terminated = ecam_plugin_terminated;
  ecam->iface.Attached = ecam_plugin_attached;
  ecam->iface.Detached = ecam_plugin_detached;
 
  /* TODO: camera redirect only supported for platforms with Video4Linux or Android */
#if defined(WITH_V4L)
  ecam->subsystem = "v4l";
#elif defined(__ANDROID__)
  ecam->subsystem = "android";
#else
  ecam->subsystem = nullptr;
#endif
 
  if (ecam->subsystem)
  {
    if ((error = ecam_load_hal_plugin(ecam, ecam->subsystem, nullptr /*args*/)))
    {
      WLog_ERR(TAG,
               "Unable to load camera redirection subsystem %s because of error %" PRIu32 "",
               ecam->subsystem, error);
      goto out;
    }
  }
 
  error = pEntryPoints->RegisterPlugin(pEntryPoints, RDPECAM_CHANNEL_NAME, &ecam->iface);
  if (error == CHANNEL_RC_OK)
    return error;
 
out:
  ecam_plugin_terminated(&ecam->iface);
  return error;
}