20#include <winpr/assert.h>
21#include <winpr/cast.h>
22#include <winpr/interlocked.h>
23#include <winpr/sysinfo.h>
26#include "rdpecam-utils.h"
28#define TAG CHANNELS_TAG("rdpecam-device.client")
44 const CAM_MEDIA_FORMAT available[] = { CAM_MEDIA_FORMAT_H264, CAM_MEDIA_FORMAT_MJPG,
45 CAM_MEDIA_FORMAT_YUY2, CAM_MEDIA_FORMAT_NV12,
46 CAM_MEDIA_FORMAT_I420, CAM_MEDIA_FORMAT_RGB24,
47 CAM_MEDIA_FORMAT_RGB32 };
50 formats[ARRAYSIZE(available) * ARRAYSIZE(available)];
51 static size_t count = 0;
52 static BOOL initialized = FALSE;
56 for (
size_t dst = 0; dst < ARRAYSIZE(available); dst++)
58 const CAM_MEDIA_FORMAT dstFormat = available[dst];
60 for (
size_t src = 0; src < ARRAYSIZE(available); src++)
62 const CAM_MEDIA_FORMAT srcFormat = available[src];
63 if (freerdp_video_conversion_supported(ecamToVideoFormat(srcFormat),
64 ecamToVideoFormat(dstFormat)))
80static CAM_MEDIA_TYPE_DESCRIPTION_FLAGS ecam_media_type_flags(CAM_MEDIA_FORMAT format)
82 if ((format == CAM_MEDIA_FORMAT_H264) || (format == CAM_MEDIA_FORMAT_MJPG))
83 return CAM_MEDIA_TYPE_DESCRIPTION_FLAG_DecodingRequired;
84 return AM_MEDIA_TYPE_DESCRIPTION_FLAG_Invalid;
89 WINPR_ASSERT(mediaType);
91 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, mediaType->Format));
92 Stream_Write_UINT32(s, mediaType->Width);
93 Stream_Write_UINT32(s, mediaType->Height);
94 Stream_Write_UINT32(s, mediaType->FrameRateNumerator);
95 Stream_Write_UINT32(s, mediaType->FrameRateDenominator);
96 Stream_Write_UINT32(s, mediaType->PixelAspectRatioNumerator);
97 Stream_Write_UINT32(s, mediaType->PixelAspectRatioDenominator);
98 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, mediaType->Flags));
103 WINPR_ASSERT(mediaType);
105 const uint8_t format = Stream_Get_UINT8(s);
106 if (!rdpecam_valid_CamMediaFormat(format))
109 mediaType->Format = WINPR_ASSERTING_INT_CAST(CAM_MEDIA_FORMAT, format);
110 mediaType->Width = Stream_Get_UINT32(s);
111 mediaType->Height = Stream_Get_UINT32(s);
112 mediaType->FrameRateNumerator = Stream_Get_UINT32(s);
113 mediaType->FrameRateDenominator = Stream_Get_UINT32(s);
114 mediaType->PixelAspectRatioNumerator = Stream_Get_UINT32(s);
115 mediaType->PixelAspectRatioDenominator = Stream_Get_UINT32(s);
117 if (mediaType->FrameRateNumerator == 0)
119 if (mediaType->FrameRateDenominator == 0)
121 if (mediaType->PixelAspectRatioNumerator == 0)
123 if (mediaType->PixelAspectRatioDenominator == 0)
126 const uint8_t flags = Stream_Get_UINT8(s);
127 if (!rdpecam_valid_MediaTypeDescriptionFlags(flags))
129 mediaType->Flags = WINPR_ASSERTING_INT_CAST(CAM_MEDIA_TYPE_DESCRIPTION_FLAGS, flags);
135 WINPR_ASSERT(mediaType);
137 WLog_DBG(TAG,
"Format: %u, width: %u, height: %u, fps: %u, flags: %u", mediaType->Format,
138 mediaType->Width, mediaType->Height, mediaType->FrameRateNumerator, mediaType->Flags);
152 CAM_MSG_ID msg = CAM_MSG_ID_SampleResponse;
154 Stream_ResetPosition(stream->sampleRespBuffer);
155 if (!Stream_EnsureRemainingCapacity(stream->sampleRespBuffer, 3))
158 Stream_Write_UINT8(stream->sampleRespBuffer,
159 WINPR_ASSERTING_INT_CAST(uint8_t, dev->ecam->version));
160 Stream_Write_UINT8(stream->sampleRespBuffer, WINPR_ASSERTING_INT_CAST(uint8_t, msg));
161 Stream_Write_UINT8(stream->sampleRespBuffer, WINPR_ASSERTING_INT_CAST(uint8_t, streamIndex));
163 return stream->sampleRespBuffer;
166static BOOL mediaSupportDrops(CAM_MEDIA_FORMAT format)
170 case CAM_MEDIA_FORMAT_H264:
177static UINT ecam_dev_send_sample_error_response(
CameraDevice* dev,
179 size_t streamIndex, CAM_ERROR_CODE errorCode)
183 wStream* s = Stream_New(
nullptr, CAM_HEADER_SIZE + 5);
185 return ERROR_NOT_ENOUGH_MEMORY;
187 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, dev->ecam->version));
188 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, CAM_MSG_ID_SampleErrorResponse));
189 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, streamIndex));
190 Stream_Write_UINT32(s, (UINT32)errorCode);
192 return ecam_channel_write(dev->ecam, hchannel, CAM_MSG_ID_SampleErrorResponse, s, TRUE);
198 WINPR_ASSERT(stream);
200 if (stream->samplesRequested <= 0)
202 WLog_VRB(TAG,
"Frame delayed: No sample requested");
203 return CHANNEL_RC_OK;
206 if (!stream->haveSample)
208 WLog_VRB(TAG,
"Frame response delayed: No sample available");
209 return CHANNEL_RC_OK;
212 wStream* output = ecam_dev_prepare_sample_response(dev, streamIndex);
214 return CHANNEL_RC_OK;
216 const BYTE* encodedSample = Stream_Buffer(stream->pendingSample);
217 const size_t encodedSize = Stream_Length(stream->pendingSample);
218 if (!ecam_encoder_compress(stream, encodedSample, encodedSize, output))
220 WLog_DBG(TAG,
"Frame dropped: error in ecam_encoder_compress");
221 stream->haveSample = FALSE;
222 return CHANNEL_RC_OK;
225 if (!stream->streaming)
227 WLog_DBG(TAG,
"Frame delayed/dropped: stream stopped");
228 return CHANNEL_RC_OK;
231 stream->samplesRequested--;
232 stream->haveSample = FALSE;
235 return ecam_channel_write(dev->ecam, stream->hSampleReqChannel, CAM_MSG_ID_SampleResponse,
239static UINT ecam_dev_sample_captured_callback(
CameraDevice* dev,
size_t streamIndex,
240 const BYTE* sample,
size_t size)
244 if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
245 return ERROR_INVALID_INDEX;
249 if (!stream->streaming)
251 WLog_DBG(TAG,
"Frame drop: stream not running");
252 return CHANNEL_RC_OK;
255 EnterCriticalSection(&stream->lock);
256 UINT ret = CHANNEL_RC_NO_MEMORY;
257 if (dev->ihal->RequestDrivenCapture && (stream->samplesRequested <= 0))
262 const UINT64 idle = GetTickCount64() - stream->lastSampleRequestTime;
263 if (idle >= ECAM_CAPTURE_IDLE_TIMEOUT_MS)
265 WLog_DBG(TAG,
"No sample requested for %" PRIu64
" ms, releasing capture device", idle);
266 stream->captureRunning = FALSE;
267 ret = ECAM_SAMPLE_CAPTURE_DRAINED;
277 if (stream->haveSample && !mediaSupportDrops(stream->formats.inputFormat))
286 DWORD waitDelay = (1000 * stream->currMediaType.FrameRateDenominator) /
287 stream->currMediaType.FrameRateNumerator;
293 while (stream->haveSample && stream->streaming)
295 LeaveCriticalSection(&stream->lock);
297 SleepEx(waitDelay, TRUE);
299 EnterCriticalSection(&stream->lock);
302 if (!stream->streaming)
304 WLog_DBG(TAG,
"Frame drop: stream not running");
310 Stream_ResetPosition(stream->pendingSample);
311 if (!Stream_EnsureRemainingCapacity(stream->pendingSample, size))
314 Stream_Write(stream->pendingSample, sample, size);
315 Stream_SealLength(stream->pendingSample);
316 stream->haveSample = TRUE;
318 ret = ecam_dev_send_pending(dev, streamIndex, stream);
321 LeaveCriticalSection(&stream->lock);
325static void ecam_dev_stop_stream(
CameraDevice* dev,
size_t streamIndex)
329 if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
334 if (stream->streaming)
336 stream->streaming = FALSE;
337 stream->captureRunning = FALSE;
338 dev->ihal->StopStream(dev->ihal, dev->deviceId, 0);
341 stream->haveSample = FALSE;
342 stream->samplesRequested = FALSE;
343 Stream_Free(stream->sampleRespBuffer, TRUE);
344 stream->sampleRespBuffer =
nullptr;
346 Stream_Free(stream->pendingSample, TRUE);
347 stream->pendingSample =
nullptr;
349 ecam_encoder_context_free(stream);
357static UINT ecam_dev_process_stop_streams_request(
CameraDevice* dev,
363 for (
size_t i = 0; i < ECAM_DEVICE_MAX_STREAMS; i++)
364 ecam_dev_stop_stream(dev, i);
366 return ecam_channel_send_generic_msg(dev->ecam, hchannel, CAM_MSG_ID_SuccessResponse);
370static BOOL media_type_valid(
CameraDevice* dev, UINT8 streamIndex,
377 size_t nMediaTypes = ARRAYSIZE(supported);
379 size_t nSupportedFormats = 0;
382 dev->ihal->GetMediaTypeDescriptions(dev->ihal, dev->deviceId, streamIndex, supportedFormats,
383 nSupportedFormats, supported, &nMediaTypes);
387 for (
size_t x = 0; x < nMediaTypes; x++)
390 cur.Format = supportedFormats[formatIndex].outputFormat;
392 cur.Flags = ecam_media_type_flags(cur.Format);
404static UINT ecam_dev_process_start_streams_request(
CameraDevice* dev,
407 BYTE streamIndex = 0;
412 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1 + 26))
413 return ERROR_INVALID_DATA;
415 Stream_Read_UINT8(s, streamIndex);
417 if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
419 WLog_ERR(TAG,
"Incorrect streamIndex %" PRIu8, streamIndex);
420 ecam_channel_send_error_response(dev->ecam, hchannel, CAM_ERROR_CODE_InvalidStreamNumber);
421 return ERROR_INVALID_INDEX;
424 if (!ecam_dev_read_media_type(s, &mediaType))
426 WLog_ERR(TAG,
"Unable to read MEDIA_TYPE_DESCRIPTION");
427 ecam_channel_send_error_response(dev->ecam, hchannel, CAM_ERROR_CODE_InvalidMessage);
428 return ERROR_INVALID_DATA;
431 ecam_dev_print_media_type(&mediaType);
432 if (!media_type_valid(dev, streamIndex, &mediaType))
434 WLog_ERR(TAG,
"Unannounced MEDIA_TYPE_DESCRIPTION");
435 ecam_channel_send_error_response(dev->ecam, hchannel, CAM_ERROR_CODE_InvalidMessage);
436 return ERROR_INVALID_DATA;
441 if (stream->streaming)
443 WLog_ERR(TAG,
"Streaming already in progress, device %s, streamIndex %u", dev->deviceId,
445 return CAM_ERROR_CODE_UnexpectedError;
451 stream->currMediaType = mediaType;
453 if (!ecam_encoder_context_init(stream))
455 WLog_ERR(TAG,
"stream_ecam_encoder_init failed");
456 ecam_channel_send_error_response(dev->ecam, hchannel, CAM_ERROR_CODE_UnexpectedError);
457 return ERROR_INVALID_DATA;
460 stream->sampleRespBuffer = Stream_New(
nullptr, ECAM_SAMPLE_RESPONSE_BUFFER_SIZE);
461 if (!stream->sampleRespBuffer)
463 WLog_ERR(TAG,
"Stream_New failed");
464 ecam_dev_stop_stream(dev, streamIndex);
465 ecam_channel_send_error_response(dev->ecam, hchannel, CAM_ERROR_CODE_OutOfMemory);
466 return ERROR_INVALID_DATA;
470 mediaType.Format = streamInputFormat(stream);
472 stream->samplesRequested = 0;
473 stream->lastSampleRequestTime = GetTickCount64();
474 stream->haveSample = FALSE;
476 stream->pendingSample = Stream_New(
nullptr, 4ull * mediaType.Width * mediaType.Height);
477 if (!stream->pendingSample)
479 WLog_ERR(TAG,
"pending stream failed");
480 ecam_dev_stop_stream(dev, streamIndex);
481 ecam_channel_send_error_response(dev->ecam, hchannel, CAM_ERROR_CODE_OutOfMemory);
482 return ERROR_INVALID_DATA;
485 stream->captureRunning = TRUE;
486 const CAM_ERROR_CODE error = dev->ihal->StartStream(dev->ihal, dev, streamIndex, &mediaType,
487 ecam_dev_sample_captured_callback);
490 stream->captureRunning = FALSE;
491 WLog_ERR(TAG,
"StartStream failure");
492 ecam_dev_stop_stream(dev, streamIndex);
493 ecam_channel_send_error_response(dev->ecam, hchannel, error);
494 return ERROR_INVALID_DATA;
497 stream->streaming = TRUE;
498 return ecam_channel_send_generic_msg(dev->ecam, hchannel, CAM_MSG_ID_SuccessResponse);
506static UINT ecam_dev_process_property_list_request(
CameraDevice* dev,
513 return ecam_channel_send_generic_msg(dev->ecam, hchannel, CAM_MSG_ID_PropertyListResponse);
521static UINT ecam_dev_send_current_media_type_response(
CameraDevice* dev,
525 CAM_MSG_ID msg = CAM_MSG_ID_CurrentMediaTypeResponse;
532 WLog_ERR(TAG,
"Stream_New failed");
533 return ERROR_NOT_ENOUGH_MEMORY;
536 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, dev->ecam->version));
537 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, msg));
539 ecam_dev_write_media_type(s, mediaType);
541 return ecam_channel_write(dev->ecam, hchannel, msg, s, TRUE);
552 BYTE streamIndex = 0;
556 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
557 return ERROR_INVALID_DATA;
559 Stream_Read_UINT8(s, streamIndex);
561 if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
563 WLog_ERR(TAG,
"Incorrect streamIndex %u", streamIndex);
564 ecam_channel_send_error_response(dev->ecam, hchannel, CAM_ERROR_CODE_InvalidStreamNumber);
565 return ERROR_INVALID_INDEX;
569 BOOL startCapture = FALSE;
575 if (!stream->streaming)
578 "Sample request for stream %" PRIu8
579 ", which is not started: sample error response",
581 return ecam_dev_send_sample_error_response(dev, hchannel, streamIndex,
582 CAM_ERROR_CODE_NotInitialized);
585 EnterCriticalSection(&stream->lock);
588 if (stream->hSampleReqChannel != hchannel)
589 stream->hSampleReqChannel = hchannel;
591 stream->samplesRequested++;
592 stream->lastSampleRequestTime = GetTickCount64();
593 const UINT ret = ecam_dev_send_pending(dev, streamIndex, stream);
594 if (dev->ihal->RequestDrivenCapture && (ret == CHANNEL_RC_OK) && !stream->captureRunning)
596 stream->captureRunning = TRUE;
597 mediaType = stream->currMediaType;
598 mediaType.Format = streamInputFormat(stream);
602 LeaveCriticalSection(&stream->lock);
606 WLog_DBG(TAG,
"Sample requested, restarting capture device");
607 const CAM_ERROR_CODE error = dev->ihal->StartStream(dev->ihal, dev, streamIndex, &mediaType,
608 ecam_dev_sample_captured_callback);
611 WLog_ERR(TAG,
"StartStream failure");
612 EnterCriticalSection(&stream->lock);
613 stream->captureRunning = FALSE;
614 if (stream->samplesRequested > 0)
615 stream->samplesRequested--;
616 LeaveCriticalSection(&stream->lock);
617 ecam_dev_send_sample_error_response(dev, hchannel, streamIndex, error);
618 return ERROR_INVALID_DATA;
630static UINT ecam_dev_process_current_media_type_request(
CameraDevice* dev,
634 BYTE streamIndex = 0;
638 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
639 return ERROR_INVALID_DATA;
641 Stream_Read_UINT8(s, streamIndex);
643 if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
645 WLog_ERR(TAG,
"Incorrect streamIndex %u", streamIndex);
646 ecam_channel_send_error_response(dev->ecam, hchannel, CAM_ERROR_CODE_InvalidStreamNumber);
647 return ERROR_INVALID_INDEX;
652 if (stream->currMediaType.Format == 0)
654 WLog_ERR(TAG,
"Current media type unknown for streamIndex %u", streamIndex);
655 ecam_channel_send_error_response(dev->ecam, hchannel, CAM_ERROR_CODE_NotInitialized);
656 return ERROR_DEVICE_REINITIALIZATION_NEEDED;
659 return ecam_dev_send_current_media_type_response(dev, hchannel, &stream->currMediaType);
667static UINT ecam_dev_send_media_type_list_response(
CameraDevice* dev,
672 CAM_MSG_ID msg = CAM_MSG_ID_MediaTypeListResponse;
676 wStream* s = Stream_New(
nullptr, CAM_HEADER_SIZE + ECAM_MAX_MEDIA_TYPE_DESCRIPTORS *
680 WLog_ERR(TAG,
"Stream_New failed");
681 return ERROR_NOT_ENOUGH_MEMORY;
684 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, dev->ecam->version));
685 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, msg));
687 for (
size_t i = 0; i < nMediaTypes; i++, mediaTypes++)
689 ecam_dev_write_media_type(s, mediaTypes);
692 return ecam_channel_write(dev->ecam, hchannel, msg, s, TRUE);
700static UINT ecam_dev_process_media_type_list_request(
CameraDevice* dev,
703 UINT error = CHANNEL_RC_OK;
704 BYTE streamIndex = 0;
706 size_t nMediaTypes = ECAM_MAX_MEDIA_TYPE_DESCRIPTORS;
710 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
711 return ERROR_INVALID_DATA;
713 Stream_Read_UINT8(s, streamIndex);
715 if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
717 WLog_ERR(TAG,
"Incorrect streamIndex %u", streamIndex);
718 ecam_channel_send_error_response(dev->ecam, hchannel, CAM_ERROR_CODE_InvalidStreamNumber);
719 return ERROR_INVALID_INDEX;
727 WLog_ERR(TAG,
"calloc failed");
728 ecam_channel_send_error_response(dev->ecam, hchannel, CAM_ERROR_CODE_OutOfMemory);
729 return CHANNEL_RC_NO_MEMORY;
732 size_t nSupportedFormats = 0;
736 dev->ihal->GetMediaTypeDescriptions(dev->ihal, dev->deviceId, streamIndex, supportedFormats,
737 nSupportedFormats, mediaTypes, &nMediaTypes);
738 if (formatIndex == -1 || nMediaTypes == 0)
740 WLog_ERR(TAG,
"Camera doesn't support any compatible video formats");
741 ecam_channel_send_error_response(dev->ecam, hchannel, CAM_ERROR_CODE_ItemNotFound);
742 error = ERROR_DEVICE_FEATURE_NOT_SUPPORTED;
746 stream->formats = supportedFormats[formatIndex];
749 for (
size_t i = 0; i < nMediaTypes; i++)
751 mediaTypes[i].Format = streamOutputFormat(stream);
753 mediaTypes[i].Flags = ecam_media_type_flags(mediaTypes[i].Format);
756 if (stream->currMediaType.Format == 0)
759 stream->currMediaType = mediaTypes[0];
762 error = ecam_dev_send_media_type_list_response(dev, hchannel, mediaTypes, nMediaTypes);
774static UINT ecam_dev_send_stream_list_response(
CameraDevice* dev,
777 CAM_MSG_ID msg = CAM_MSG_ID_StreamListResponse;
784 WLog_ERR(TAG,
"Stream_New failed");
785 return ERROR_NOT_ENOUGH_MEMORY;
788 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, dev->ecam->version));
789 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(uint8_t, msg));
792 Stream_Write_UINT16(s, CAM_STREAM_FRAME_SOURCE_TYPE_Color);
793 Stream_Write_UINT8(s, CAM_STREAM_CATEGORY_Capture);
794 Stream_Write_UINT8(s, TRUE );
795 Stream_Write_UINT8(s, FALSE );
797 return ecam_channel_write(dev->ecam, hchannel, msg, s, TRUE);
805static UINT ecam_dev_process_stream_list_request(
CameraDevice* dev,
809 return ecam_dev_send_stream_list_response(dev, hchannel);
817static UINT ecam_dev_process_activate_device_request(
CameraDevice* dev,
822 CAM_ERROR_CODE errorCode = CAM_ERROR_CODE_None;
824 if (dev->ihal->Activate(dev->ihal, dev->deviceId, &errorCode))
825 return ecam_channel_send_generic_msg(dev->ecam, hchannel, CAM_MSG_ID_SuccessResponse);
827 return ecam_channel_send_error_response(dev->ecam, hchannel, errorCode);
835static UINT ecam_dev_process_deactivate_device_request(
CameraDevice* dev,
842 for (
size_t i = 0; i < ECAM_DEVICE_MAX_STREAMS; i++)
843 ecam_dev_stop_stream(dev, i);
845 CAM_ERROR_CODE errorCode = CAM_ERROR_CODE_None;
846 if (dev->ihal->Deactivate(dev->ihal, dev->deviceId, &errorCode))
847 return ecam_channel_send_generic_msg(dev->ecam, hchannel, CAM_MSG_ID_SuccessResponse);
849 return ecam_channel_send_error_response(dev->ecam, hchannel, errorCode);
857static UINT ecam_dev_on_data_received(IWTSVirtualChannelCallback* pChannelCallback,
wStream* data)
859 UINT error = CHANNEL_RC_OK;
864 if (!hchannel || !data)
865 return ERROR_INVALID_PARAMETER;
870 return ERROR_INTERNAL_ERROR;
872 if (!Stream_CheckAndLogRequiredLength(TAG, data, CAM_HEADER_SIZE))
873 return ERROR_NO_DATA;
875 Stream_Read_UINT8(data, version);
876 Stream_Read_UINT8(data, messageId);
877 WLog_DBG(TAG,
"ChannelId=%" PRIu32
", MessageId=0x%02" PRIx8
", Version=%d",
878 hchannel->channel_mgr->GetChannelId(hchannel->channel), messageId, version);
882 case CAM_MSG_ID_ActivateDeviceRequest:
883 error = ecam_dev_process_activate_device_request(dev, hchannel, data);
886 case CAM_MSG_ID_DeactivateDeviceRequest:
887 error = ecam_dev_process_deactivate_device_request(dev, hchannel, data);
890 case CAM_MSG_ID_StreamListRequest:
891 error = ecam_dev_process_stream_list_request(dev, hchannel, data);
894 case CAM_MSG_ID_MediaTypeListRequest:
895 error = ecam_dev_process_media_type_list_request(dev, hchannel, data);
898 case CAM_MSG_ID_CurrentMediaTypeRequest:
899 error = ecam_dev_process_current_media_type_request(dev, hchannel, data);
902 case CAM_MSG_ID_PropertyListRequest:
903 error = ecam_dev_process_property_list_request(dev, hchannel, data);
906 case CAM_MSG_ID_StartStreamsRequest:
907 error = ecam_dev_process_start_streams_request(dev, hchannel, data);
910 case CAM_MSG_ID_StopStreamsRequest:
911 error = ecam_dev_process_stop_streams_request(dev, hchannel, data);
914 case CAM_MSG_ID_SampleRequest:
915 error = ecam_dev_process_sample_request(dev, hchannel, data);
919 WLog_WARN(TAG,
"unknown MessageId=0x%02" PRIx8
"", messageId);
920 error = ERROR_INVALID_DATA;
921 ecam_channel_send_error_response(dev->ecam, hchannel,
922 CAM_ERROR_CODE_OperationNotSupported);
934static UINT ecam_dev_on_open(WINPR_ATTR_UNUSED IWTSVirtualChannelCallback* pChannelCallback)
936 WLog_DBG(TAG,
"entered");
937 return CHANNEL_RC_OK;
945static UINT ecam_dev_on_close(IWTSVirtualChannelCallback* pChannelCallback)
948 WINPR_ASSERT(hchannel);
953 WLog_DBG(TAG,
"entered");
955 for (
size_t i = 0; i < ECAM_DEVICE_MAX_STREAMS; i++)
956 ecam_dev_stop_stream(dev, i);
959 for (
size_t i = 0; i < ECAM_DEVICE_MAX_STREAMS; i++)
960 if (dev->streams[i].hSampleReqChannel == hchannel)
961 dev->streams[i].hSampleReqChannel =
nullptr;
964 return CHANNEL_RC_OK;
972static UINT ecam_dev_on_new_channel_connection(IWTSListenerCallback* pListenerCallback,
973 IWTSVirtualChannel* pChannel,
974 WINPR_ATTR_UNUSED BYTE* Data,
975 WINPR_ATTR_UNUSED BOOL* pbAccept,
976 IWTSVirtualChannelCallback** ppCallback)
980 if (!hlistener || !hlistener->plugin)
981 return ERROR_INTERNAL_ERROR;
983 WLog_DBG(TAG,
"entered");
989 WLog_ERR(TAG,
"calloc failed");
990 return CHANNEL_RC_NO_MEMORY;
993 hchannel->iface.OnDataReceived = ecam_dev_on_data_received;
994 hchannel->iface.OnOpen = ecam_dev_on_open;
995 hchannel->iface.OnClose = ecam_dev_on_close;
996 hchannel->plugin = hlistener->plugin;
997 hchannel->channel_mgr = hlistener->channel_mgr;
998 hchannel->channel = pChannel;
999 *ppCallback = (IWTSVirtualChannelCallback*)hchannel;
1000 return CHANNEL_RC_OK;
1006static void ecam_dev_delete_locks(
CameraDevice* dev,
size_t nStreams)
1010 for (
size_t i = 0; i < nStreams; i++)
1011 DeleteCriticalSection(&dev->streams[i].lock);
1020 WINPR_ATTR_UNUSED
const char* deviceName)
1023 WINPR_ASSERT(ecam->hlistener);
1025 IWTSVirtualChannelManager* pChannelMgr = ecam->hlistener->channel_mgr;
1026 WINPR_ASSERT(pChannelMgr);
1028 WLog_DBG(TAG,
"entered for %s", deviceId);
1034 WLog_ERR(TAG,
"calloc failed");
1039 dev->ihal = ecam->ihal;
1040 strncpy(dev->deviceId, deviceId,
sizeof(dev->deviceId) - 1);
1044 for (
size_t i = 0; i < ECAM_DEVICE_MAX_STREAMS; i++)
1046 if (!InitializeCriticalSectionEx(&dev->streams[i].lock, 0, 0))
1048 ecam_dev_delete_locks(dev, i);
1050 WLog_ERR(TAG,
"InitializeCriticalSectionEx failed");
1057 if (!dev->hlistener)
1059 ecam_dev_delete_locks(dev, ECAM_DEVICE_MAX_STREAMS);
1061 WLog_ERR(TAG,
"calloc failed");
1065 dev->hlistener->iface.OnNewChannelConnection = ecam_dev_on_new_channel_connection;
1066 dev->hlistener->plugin = (IWTSPlugin*)dev;
1067 dev->hlistener->channel_mgr = pChannelMgr;
1068 if (CHANNEL_RC_OK != pChannelMgr->CreateListener(pChannelMgr, deviceId, 0,
1069 &dev->hlistener->iface, &dev->listener))
1071 free(dev->hlistener);
1072 ecam_dev_delete_locks(dev, ECAM_DEVICE_MAX_STREAMS);
1074 WLog_ERR(TAG,
"CreateListener failed");
1092 WLog_DBG(TAG,
"entered for %s", dev->deviceId);
1096 IWTSVirtualChannelManager* mgr = dev->hlistener->channel_mgr;
1098 IFCALL(mgr->DestroyListener, mgr, dev->listener);
1101 free(dev->hlistener);
1103 for (
size_t i = 0; i < ECAM_DEVICE_MAX_STREAMS; i++)
1104 ecam_dev_stop_stream(dev, i);
1106 ecam_dev_delete_locks(dev, ECAM_DEVICE_MAX_STREAMS);