FreeRDP
Loading...
Searching...
No Matches
client/camera_device_main.c
1
20#include <winpr/assert.h>
21#include <winpr/cast.h>
22#include <winpr/interlocked.h>
23#include <winpr/sysinfo.h>
24
25#include "camera.h"
26#include "rdpecam-utils.h"
27
28#define TAG CHANNELS_TAG("rdpecam-device.client")
29
39WINPR_ATTR_NODISCARD
40static const CAM_MEDIA_FORMAT_INFO* getSupportedFormats(size_t* pCount)
41{
42 WINPR_ASSERT(pCount);
43
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 };
48
50 formats[ARRAYSIZE(available) * ARRAYSIZE(available)]; /* Max possible formats */
51 static size_t count = 0;
52 static BOOL initialized = FALSE;
53
54 if (!initialized)
55 {
56 for (size_t dst = 0; dst < ARRAYSIZE(available); dst++)
57 {
58 const CAM_MEDIA_FORMAT dstFormat = available[dst];
59
60 for (size_t src = 0; src < ARRAYSIZE(available); src++)
61 {
62 const CAM_MEDIA_FORMAT srcFormat = available[src];
63 if (freerdp_video_conversion_supported(ecamToVideoFormat(srcFormat),
64 ecamToVideoFormat(dstFormat)))
65 {
66 formats[count++] = (CAM_MEDIA_FORMAT_INFO){ srcFormat, dstFormat };
67 }
68 }
69 }
70 initialized = TRUE;
71 }
72
73 *pCount = count;
74 return formats;
75}
76
77/* DecodingRequired describes the transmitted format: compressed H.264 and MJPEG
78 * samples need decoding on the server; raw samples do not. */
79WINPR_ATTR_NODISCARD
80static CAM_MEDIA_TYPE_DESCRIPTION_FLAGS ecam_media_type_flags(CAM_MEDIA_FORMAT format)
81{
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;
85}
86
87static void ecam_dev_write_media_type(wStream* s, const CAM_MEDIA_TYPE_DESCRIPTION* mediaType)
88{
89 WINPR_ASSERT(mediaType);
90
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));
99}
100
101static BOOL ecam_dev_read_media_type(wStream* s, CAM_MEDIA_TYPE_DESCRIPTION* mediaType)
102{
103 WINPR_ASSERT(mediaType);
104
105 const uint8_t format = Stream_Get_UINT8(s);
106 if (!rdpecam_valid_CamMediaFormat(format))
107 return FALSE;
108
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);
116
117 if (mediaType->FrameRateNumerator == 0)
118 return FALSE;
119 if (mediaType->FrameRateDenominator == 0)
120 return FALSE;
121 if (mediaType->PixelAspectRatioNumerator == 0)
122 return FALSE;
123 if (mediaType->PixelAspectRatioDenominator == 0)
124 return FALSE;
125
126 const uint8_t flags = Stream_Get_UINT8(s);
127 if (!rdpecam_valid_MediaTypeDescriptionFlags(flags))
128 return FALSE;
129 mediaType->Flags = WINPR_ASSERTING_INT_CAST(CAM_MEDIA_TYPE_DESCRIPTION_FLAGS, flags);
130 return TRUE;
131}
132
133static void ecam_dev_print_media_type(CAM_MEDIA_TYPE_DESCRIPTION* mediaType)
134{
135 WINPR_ASSERT(mediaType);
136
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);
139}
140
146WINPR_ATTR_NODISCARD
147static wStream* ecam_dev_prepare_sample_response(CameraDevice* dev, size_t streamIndex)
148{
149 WINPR_ASSERT(dev);
150
151 CameraDeviceStream* stream = &dev->streams[streamIndex];
152 CAM_MSG_ID msg = CAM_MSG_ID_SampleResponse;
153
154 Stream_ResetPosition(stream->sampleRespBuffer);
155 if (!Stream_EnsureRemainingCapacity(stream->sampleRespBuffer, 3))
156 return nullptr;
157
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));
162
163 return stream->sampleRespBuffer;
164}
165
166static BOOL mediaSupportDrops(CAM_MEDIA_FORMAT format)
167{
168 switch (format)
169 {
170 case CAM_MEDIA_FORMAT_H264:
171 return FALSE;
172 default:
173 return TRUE;
174 }
175}
176
177static UINT ecam_dev_send_sample_error_response(CameraDevice* dev,
178 GENERIC_CHANNEL_CALLBACK* hchannel,
179 size_t streamIndex, CAM_ERROR_CODE errorCode)
180{
181 WINPR_ASSERT(dev);
182
183 wStream* s = Stream_New(nullptr, CAM_HEADER_SIZE + 5);
184 if (!s)
185 return ERROR_NOT_ENOUGH_MEMORY;
186
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);
191
192 return ecam_channel_write(dev->ecam, hchannel, CAM_MSG_ID_SampleErrorResponse, s, TRUE);
193}
194
195static UINT ecam_dev_send_pending(CameraDevice* dev, size_t streamIndex, CameraDeviceStream* stream)
196{
197 WINPR_ASSERT(dev);
198 WINPR_ASSERT(stream);
199
200 if (stream->samplesRequested <= 0)
201 {
202 WLog_VRB(TAG, "Frame delayed: No sample requested");
203 return CHANNEL_RC_OK;
204 }
205
206 if (!stream->haveSample)
207 {
208 WLog_VRB(TAG, "Frame response delayed: No sample available");
209 return CHANNEL_RC_OK;
210 }
211
212 wStream* output = ecam_dev_prepare_sample_response(dev, streamIndex);
213 if (!output)
214 return CHANNEL_RC_OK;
215
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))
219 {
220 WLog_DBG(TAG, "Frame dropped: error in ecam_encoder_compress");
221 stream->haveSample = FALSE;
222 return CHANNEL_RC_OK;
223 }
224
225 if (!stream->streaming)
226 {
227 WLog_DBG(TAG, "Frame delayed/dropped: stream stopped");
228 return CHANNEL_RC_OK;
229 }
230
231 stream->samplesRequested--;
232 stream->haveSample = FALSE;
233
234 /* channel write is protected by critical section in dvcman_write_channel */
235 return ecam_channel_write(dev->ecam, stream->hSampleReqChannel, CAM_MSG_ID_SampleResponse,
236 output, FALSE /* don't free stream */);
237}
238
239static UINT ecam_dev_sample_captured_callback(CameraDevice* dev, size_t streamIndex,
240 const BYTE* sample, size_t size)
241{
242 WINPR_ASSERT(dev);
243
244 if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
245 return ERROR_INVALID_INDEX;
246
247 CameraDeviceStream* stream = &dev->streams[streamIndex];
248
249 if (!stream->streaming)
250 {
251 WLog_DBG(TAG, "Frame drop: stream not running");
252 return CHANNEL_RC_OK;
253 }
254
255 EnterCriticalSection(&stream->lock);
256 UINT ret = CHANNEL_RC_NO_MEMORY;
257 if (dev->ihal->RequestDrivenCapture && (stream->samplesRequested <= 0))
258 {
259 /* The server requests samples one at a time, so the count is zero between
260 * two requests. Keep capturing and only release the device once the server
261 * went quiet for a while, e.g. because the application closed the camera. */
262 const UINT64 idle = GetTickCount64() - stream->lastSampleRequestTime;
263 if (idle >= ECAM_CAPTURE_IDLE_TIMEOUT_MS)
264 {
265 WLog_DBG(TAG, "No sample requested for %" PRIu64 " ms, releasing capture device", idle);
266 stream->captureRunning = FALSE;
267 ret = ECAM_SAMPLE_CAPTURE_DRAINED;
268 goto out;
269 }
270 }
271
272 /* If we already have a waiting sample, let's see if the input format support dropping
273 * frames so that we could just "refresh" the pending sample, otherwise we must wait until
274 * a frame request flushes it
275 */
276
277 if (stream->haveSample && !mediaSupportDrops(stream->formats.inputFormat))
278 {
279 /* we can't drop samples, so we have to wait until the pending sample is
280 * sent, by a sample request.
281 *
282 * When we're here we already have a sample ready to be sent, the delay between 2 frames
283 * seems like a reasonable wait delay. For instance 60 FPS means a frame every 16ms.
284 * We also cap that wait delay to not spinloop and not get stuck for too long.
285 * */
286 DWORD waitDelay = (1000 * stream->currMediaType.FrameRateDenominator) /
287 stream->currMediaType.FrameRateNumerator;
288 if (waitDelay < 16)
289 waitDelay = 16;
290 if (waitDelay > 100)
291 waitDelay = 100;
292
293 while (stream->haveSample && stream->streaming)
294 {
295 LeaveCriticalSection(&stream->lock);
296
297 SleepEx(waitDelay, TRUE);
298
299 EnterCriticalSection(&stream->lock);
300 }
301
302 if (!stream->streaming)
303 {
304 WLog_DBG(TAG, "Frame drop: stream not running");
305 ret = CHANNEL_RC_OK;
306 goto out;
307 }
308 }
309
310 Stream_ResetPosition(stream->pendingSample);
311 if (!Stream_EnsureRemainingCapacity(stream->pendingSample, size))
312 goto out;
313
314 Stream_Write(stream->pendingSample, sample, size);
315 Stream_SealLength(stream->pendingSample);
316 stream->haveSample = TRUE;
317
318 ret = ecam_dev_send_pending(dev, streamIndex, stream);
319
320out:
321 LeaveCriticalSection(&stream->lock);
322 return ret;
323}
324
325static void ecam_dev_stop_stream(CameraDevice* dev, size_t streamIndex)
326{
327 WINPR_ASSERT(dev);
328
329 if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
330 return;
331
332 CameraDeviceStream* stream = &dev->streams[streamIndex];
333
334 if (stream->streaming)
335 {
336 stream->streaming = FALSE;
337 stream->captureRunning = FALSE;
338 dev->ihal->StopStream(dev->ihal, dev->deviceId, 0);
339 }
340
341 stream->haveSample = FALSE;
342 stream->samplesRequested = FALSE;
343 Stream_Free(stream->sampleRespBuffer, TRUE);
344 stream->sampleRespBuffer = nullptr;
345
346 Stream_Free(stream->pendingSample, TRUE);
347 stream->pendingSample = nullptr;
348
349 ecam_encoder_context_free(stream);
350}
351
357static UINT ecam_dev_process_stop_streams_request(CameraDevice* dev,
358 GENERIC_CHANNEL_CALLBACK* hchannel, wStream* s)
359{
360 WINPR_ASSERT(dev);
361 WINPR_UNUSED(s);
362
363 for (size_t i = 0; i < ECAM_DEVICE_MAX_STREAMS; i++)
364 ecam_dev_stop_stream(dev, i);
365
366 return ecam_channel_send_generic_msg(dev->ecam, hchannel, CAM_MSG_ID_SuccessResponse);
367}
368
369WINPR_ATTR_NODISCARD
370static BOOL media_type_valid(CameraDevice* dev, UINT8 streamIndex,
371 const CAM_MEDIA_TYPE_DESCRIPTION* type)
372{
373 WINPR_ASSERT(dev);
374 WINPR_ASSERT(type);
375
376 CAM_MEDIA_TYPE_DESCRIPTION supported[ECAM_MAX_MEDIA_TYPE_DESCRIPTORS] = WINPR_C_ARRAY_INIT;
377 size_t nMediaTypes = ARRAYSIZE(supported);
378
379 size_t nSupportedFormats = 0;
380 const CAM_MEDIA_FORMAT_INFO* supportedFormats = getSupportedFormats(&nSupportedFormats);
381 INT16 formatIndex =
382 dev->ihal->GetMediaTypeDescriptions(dev->ihal, dev->deviceId, streamIndex, supportedFormats,
383 nSupportedFormats, supported, &nMediaTypes);
384 if (formatIndex < 0)
385 return FALSE;
386
387 for (size_t x = 0; x < nMediaTypes; x++)
388 {
389 CAM_MEDIA_TYPE_DESCRIPTION cur = supported[x];
390 cur.Format = supportedFormats[formatIndex].outputFormat;
391 /* Validate the same wire-format flags advertised in the media type list. */
392 cur.Flags = ecam_media_type_flags(cur.Format);
393 if (memcmp(&cur, type, sizeof(CAM_MEDIA_TYPE_DESCRIPTION)) == 0)
394 return TRUE;
395 }
396 return FALSE;
397}
398
404static UINT ecam_dev_process_start_streams_request(CameraDevice* dev,
405 GENERIC_CHANNEL_CALLBACK* hchannel, wStream* s)
406{
407 BYTE streamIndex = 0;
408 CAM_MEDIA_TYPE_DESCRIPTION mediaType = WINPR_C_ARRAY_INIT;
409
410 WINPR_ASSERT(dev);
411
412 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1 + 26))
413 return ERROR_INVALID_DATA;
414
415 Stream_Read_UINT8(s, streamIndex);
416
417 if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
418 {
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;
422 }
423
424 if (!ecam_dev_read_media_type(s, &mediaType))
425 {
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;
429 }
430
431 ecam_dev_print_media_type(&mediaType);
432 if (!media_type_valid(dev, streamIndex, &mediaType))
433 {
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;
437 }
438
439 CameraDeviceStream* stream = &dev->streams[streamIndex];
440
441 if (stream->streaming)
442 {
443 WLog_ERR(TAG, "Streaming already in progress, device %s, streamIndex %u", dev->deviceId,
444 streamIndex);
445 return CAM_ERROR_CODE_UnexpectedError;
446 }
447
448 /* saving media type description for CurrentMediaTypeRequest,
449 * to be done before calling ecam_encoder_context_init
450 */
451 stream->currMediaType = mediaType;
452
453 if (!ecam_encoder_context_init(stream))
454 {
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;
458 }
459
460 stream->sampleRespBuffer = Stream_New(nullptr, ECAM_SAMPLE_RESPONSE_BUFFER_SIZE);
461 if (!stream->sampleRespBuffer)
462 {
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;
467 }
468
469 /* replacing outputFormat with inputFormat in mediaType before starting stream */
470 mediaType.Format = streamInputFormat(stream);
471
472 stream->samplesRequested = 0;
473 stream->lastSampleRequestTime = GetTickCount64();
474 stream->haveSample = FALSE;
475
476 stream->pendingSample = Stream_New(nullptr, 4ull * mediaType.Width * mediaType.Height);
477 if (!stream->pendingSample)
478 {
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;
483 }
484
485 stream->captureRunning = TRUE;
486 const CAM_ERROR_CODE error = dev->ihal->StartStream(dev->ihal, dev, streamIndex, &mediaType,
487 ecam_dev_sample_captured_callback);
488 if (error)
489 {
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;
495 }
496
497 stream->streaming = TRUE;
498 return ecam_channel_send_generic_msg(dev->ecam, hchannel, CAM_MSG_ID_SuccessResponse);
499}
500
506static UINT ecam_dev_process_property_list_request(CameraDevice* dev,
507 GENERIC_CHANNEL_CALLBACK* hchannel,
508 WINPR_ATTR_UNUSED wStream* s)
509{
510 WINPR_ASSERT(dev);
511 // TODO: supported properties implementation
512
513 return ecam_channel_send_generic_msg(dev->ecam, hchannel, CAM_MSG_ID_PropertyListResponse);
514}
515
521static UINT ecam_dev_send_current_media_type_response(CameraDevice* dev,
522 GENERIC_CHANNEL_CALLBACK* hchannel,
524{
525 CAM_MSG_ID msg = CAM_MSG_ID_CurrentMediaTypeResponse;
526
527 WINPR_ASSERT(dev);
528
529 wStream* s = Stream_New(nullptr, CAM_HEADER_SIZE + sizeof(CAM_MEDIA_TYPE_DESCRIPTION));
530 if (!s)
531 {
532 WLog_ERR(TAG, "Stream_New failed");
533 return ERROR_NOT_ENOUGH_MEMORY;
534 }
535
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));
538
539 ecam_dev_write_media_type(s, mediaType);
540
541 return ecam_channel_write(dev->ecam, hchannel, msg, s, TRUE);
542}
543
549static UINT ecam_dev_process_sample_request(CameraDevice* dev, GENERIC_CHANNEL_CALLBACK* hchannel,
550 wStream* s)
551{
552 BYTE streamIndex = 0;
553
554 WINPR_ASSERT(dev);
555
556 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
557 return ERROR_INVALID_DATA;
558
559 Stream_Read_UINT8(s, streamIndex);
560
561 if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
562 {
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;
566 }
567
568 CameraDeviceStream* stream = &dev->streams[streamIndex];
569 BOOL startCapture = FALSE;
570 CAM_MEDIA_TYPE_DESCRIPTION mediaType = WINPR_C_ARRAY_INIT;
571
572 /* MS-RDPECAM 2.2.3.13: each Sample Request gets a Sample Response or a Sample Error Response.
573 * A stream never started, refused or stopped has no sample to give. Only the requests of the
574 * server, handled on this thread, start and stop a stream while the channel is open. */
575 if (!stream->streaming)
576 {
577 WLog_WARN(TAG,
578 "Sample request for stream %" PRIu8
579 ", which is not started: sample error response",
580 streamIndex);
581 return ecam_dev_send_sample_error_response(dev, hchannel, streamIndex,
582 CAM_ERROR_CODE_NotInitialized);
583 }
584
585 EnterCriticalSection(&stream->lock);
586
587 /* need to save channel because responses are asynchronous and coming from capture thread */
588 if (stream->hSampleReqChannel != hchannel)
589 stream->hSampleReqChannel = hchannel;
590
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)
595 {
596 stream->captureRunning = TRUE;
597 mediaType = stream->currMediaType;
598 mediaType.Format = streamInputFormat(stream);
599 startCapture = TRUE;
600 }
601
602 LeaveCriticalSection(&stream->lock);
603
604 if (startCapture)
605 {
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);
609 if (error)
610 {
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;
619 }
620 }
621
622 return ret;
623}
624
630static UINT ecam_dev_process_current_media_type_request(CameraDevice* dev,
631 GENERIC_CHANNEL_CALLBACK* hchannel,
632 wStream* s)
633{
634 BYTE streamIndex = 0;
635
636 WINPR_ASSERT(dev);
637
638 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
639 return ERROR_INVALID_DATA;
640
641 Stream_Read_UINT8(s, streamIndex);
642
643 if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
644 {
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;
648 }
649
650 CameraDeviceStream* stream = &dev->streams[streamIndex];
651
652 if (stream->currMediaType.Format == 0)
653 {
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;
657 }
658
659 return ecam_dev_send_current_media_type_response(dev, hchannel, &stream->currMediaType);
660}
661
667static UINT ecam_dev_send_media_type_list_response(CameraDevice* dev,
668 GENERIC_CHANNEL_CALLBACK* hchannel,
669 CAM_MEDIA_TYPE_DESCRIPTION* mediaTypes,
670 size_t nMediaTypes)
671{
672 CAM_MSG_ID msg = CAM_MSG_ID_MediaTypeListResponse;
673
674 WINPR_ASSERT(dev);
675
676 wStream* s = Stream_New(nullptr, CAM_HEADER_SIZE + ECAM_MAX_MEDIA_TYPE_DESCRIPTORS *
678 if (!s)
679 {
680 WLog_ERR(TAG, "Stream_New failed");
681 return ERROR_NOT_ENOUGH_MEMORY;
682 }
683
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));
686
687 for (size_t i = 0; i < nMediaTypes; i++, mediaTypes++)
688 {
689 ecam_dev_write_media_type(s, mediaTypes);
690 }
691
692 return ecam_channel_write(dev->ecam, hchannel, msg, s, TRUE);
693}
694
700static UINT ecam_dev_process_media_type_list_request(CameraDevice* dev,
701 GENERIC_CHANNEL_CALLBACK* hchannel, wStream* s)
702{
703 UINT error = CHANNEL_RC_OK;
704 BYTE streamIndex = 0;
705 CAM_MEDIA_TYPE_DESCRIPTION* mediaTypes = nullptr;
706 size_t nMediaTypes = ECAM_MAX_MEDIA_TYPE_DESCRIPTORS;
707
708 WINPR_ASSERT(dev);
709
710 if (!Stream_CheckAndLogRequiredLength(TAG, s, 1))
711 return ERROR_INVALID_DATA;
712
713 Stream_Read_UINT8(s, streamIndex);
714
715 if (streamIndex >= ECAM_DEVICE_MAX_STREAMS)
716 {
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;
720 }
721 CameraDeviceStream* stream = &dev->streams[streamIndex];
722
723 mediaTypes =
724 (CAM_MEDIA_TYPE_DESCRIPTION*)calloc(nMediaTypes, sizeof(CAM_MEDIA_TYPE_DESCRIPTION));
725 if (!mediaTypes)
726 {
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;
730 }
731
732 size_t nSupportedFormats = 0;
733 const CAM_MEDIA_FORMAT_INFO* supportedFormats = getSupportedFormats(&nSupportedFormats);
734
735 INT16 formatIndex =
736 dev->ihal->GetMediaTypeDescriptions(dev->ihal, dev->deviceId, streamIndex, supportedFormats,
737 nSupportedFormats, mediaTypes, &nMediaTypes);
738 if (formatIndex == -1 || nMediaTypes == 0)
739 {
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;
743 goto error;
744 }
745
746 stream->formats = supportedFormats[formatIndex];
747
748 /* replacing inputFormat with outputFormat in mediaTypes before sending response */
749 for (size_t i = 0; i < nMediaTypes; i++)
750 {
751 mediaTypes[i].Format = streamOutputFormat(stream);
752 /* Set decoding requirements for the transmitted format, not the capture format. */
753 mediaTypes[i].Flags = ecam_media_type_flags(mediaTypes[i].Format);
754 }
755
756 if (stream->currMediaType.Format == 0)
757 {
758 /* saving 1st media type description for CurrentMediaTypeRequest */
759 stream->currMediaType = mediaTypes[0];
760 }
761
762 error = ecam_dev_send_media_type_list_response(dev, hchannel, mediaTypes, nMediaTypes);
763
764error:
765 free(mediaTypes);
766 return error;
767}
768
774static UINT ecam_dev_send_stream_list_response(CameraDevice* dev,
775 GENERIC_CHANNEL_CALLBACK* hchannel)
776{
777 CAM_MSG_ID msg = CAM_MSG_ID_StreamListResponse;
778
779 WINPR_ASSERT(dev);
780
781 wStream* s = Stream_New(nullptr, CAM_HEADER_SIZE + sizeof(CAM_STREAM_DESCRIPTION));
782 if (!s)
783 {
784 WLog_ERR(TAG, "Stream_New failed");
785 return ERROR_NOT_ENOUGH_MEMORY;
786 }
787
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));
790
791 /* single stream description */
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 /* Selected */);
795 Stream_Write_UINT8(s, FALSE /* CanBeShared */);
796
797 return ecam_channel_write(dev->ecam, hchannel, msg, s, TRUE);
798}
799
805static UINT ecam_dev_process_stream_list_request(CameraDevice* dev,
806 GENERIC_CHANNEL_CALLBACK* hchannel,
807 WINPR_ATTR_UNUSED wStream* s)
808{
809 return ecam_dev_send_stream_list_response(dev, hchannel);
810}
811
817static UINT ecam_dev_process_activate_device_request(CameraDevice* dev,
818 GENERIC_CHANNEL_CALLBACK* hchannel,
819 WINPR_ATTR_UNUSED wStream* s)
820{
821 WINPR_ASSERT(dev);
822 CAM_ERROR_CODE errorCode = CAM_ERROR_CODE_None;
823
824 if (dev->ihal->Activate(dev->ihal, dev->deviceId, &errorCode))
825 return ecam_channel_send_generic_msg(dev->ecam, hchannel, CAM_MSG_ID_SuccessResponse);
826
827 return ecam_channel_send_error_response(dev->ecam, hchannel, errorCode);
828}
829
835static UINT ecam_dev_process_deactivate_device_request(CameraDevice* dev,
836 GENERIC_CHANNEL_CALLBACK* hchannel,
837 wStream* s)
838{
839 WINPR_ASSERT(dev);
840 WINPR_UNUSED(s);
841
842 for (size_t i = 0; i < ECAM_DEVICE_MAX_STREAMS; i++)
843 ecam_dev_stop_stream(dev, i);
844
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);
848
849 return ecam_channel_send_error_response(dev->ecam, hchannel, errorCode);
850}
851
857static UINT ecam_dev_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream* data)
858{
859 UINT error = CHANNEL_RC_OK;
860 BYTE version = 0;
861 BYTE messageId = 0;
862 GENERIC_CHANNEL_CALLBACK* hchannel = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
863
864 if (!hchannel || !data)
865 return ERROR_INVALID_PARAMETER;
866
867 CameraDevice* dev = (CameraDevice*)hchannel->plugin;
868
869 if (!dev)
870 return ERROR_INTERNAL_ERROR;
871
872 if (!Stream_CheckAndLogRequiredLength(TAG, data, CAM_HEADER_SIZE))
873 return ERROR_NO_DATA;
874
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);
879
880 switch (messageId)
881 {
882 case CAM_MSG_ID_ActivateDeviceRequest:
883 error = ecam_dev_process_activate_device_request(dev, hchannel, data);
884 break;
885
886 case CAM_MSG_ID_DeactivateDeviceRequest:
887 error = ecam_dev_process_deactivate_device_request(dev, hchannel, data);
888 break;
889
890 case CAM_MSG_ID_StreamListRequest:
891 error = ecam_dev_process_stream_list_request(dev, hchannel, data);
892 break;
893
894 case CAM_MSG_ID_MediaTypeListRequest:
895 error = ecam_dev_process_media_type_list_request(dev, hchannel, data);
896 break;
897
898 case CAM_MSG_ID_CurrentMediaTypeRequest:
899 error = ecam_dev_process_current_media_type_request(dev, hchannel, data);
900 break;
901
902 case CAM_MSG_ID_PropertyListRequest:
903 error = ecam_dev_process_property_list_request(dev, hchannel, data);
904 break;
905
906 case CAM_MSG_ID_StartStreamsRequest:
907 error = ecam_dev_process_start_streams_request(dev, hchannel, data);
908 break;
909
910 case CAM_MSG_ID_StopStreamsRequest:
911 error = ecam_dev_process_stop_streams_request(dev, hchannel, data);
912 break;
913
914 case CAM_MSG_ID_SampleRequest:
915 error = ecam_dev_process_sample_request(dev, hchannel, data);
916 break;
917
918 default:
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);
923 break;
924 }
925
926 return error;
927}
928
934static UINT ecam_dev_on_open(WINPR_ATTR_UNUSED IWTSVirtualChannelCallback* pChannelCallback)
935{
936 WLog_DBG(TAG, "entered");
937 return CHANNEL_RC_OK;
938}
939
945static UINT ecam_dev_on_close(IWTSVirtualChannelCallback* pChannelCallback)
946{
947 GENERIC_CHANNEL_CALLBACK* hchannel = (GENERIC_CHANNEL_CALLBACK*)pChannelCallback;
948 WINPR_ASSERT(hchannel);
949
950 CameraDevice* dev = (CameraDevice*)hchannel->plugin;
951 WINPR_ASSERT(dev);
952
953 WLog_DBG(TAG, "entered");
954
955 for (size_t i = 0; i < ECAM_DEVICE_MAX_STREAMS; i++)
956 ecam_dev_stop_stream(dev, i);
957
958 /* make sure this channel is not used for sample responses */
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;
962
963 free(hchannel);
964 return CHANNEL_RC_OK;
965}
966
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)
977{
978 GENERIC_LISTENER_CALLBACK* hlistener = (GENERIC_LISTENER_CALLBACK*)pListenerCallback;
979
980 if (!hlistener || !hlistener->plugin)
981 return ERROR_INTERNAL_ERROR;
982
983 WLog_DBG(TAG, "entered");
984 GENERIC_CHANNEL_CALLBACK* hchannel =
986
987 if (!hchannel)
988 {
989 WLog_ERR(TAG, "calloc failed");
990 return CHANNEL_RC_NO_MEMORY;
991 }
992
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;
1001}
1002
1006static void ecam_dev_delete_locks(CameraDevice* dev, size_t nStreams)
1007{
1008 WINPR_ASSERT(dev);
1009
1010 for (size_t i = 0; i < nStreams; i++)
1011 DeleteCriticalSection(&dev->streams[i].lock);
1012}
1013
1019CameraDevice* ecam_dev_create(CameraPlugin* ecam, const char* deviceId,
1020 WINPR_ATTR_UNUSED const char* deviceName)
1021{
1022 WINPR_ASSERT(ecam);
1023 WINPR_ASSERT(ecam->hlistener);
1024
1025 IWTSVirtualChannelManager* pChannelMgr = ecam->hlistener->channel_mgr;
1026 WINPR_ASSERT(pChannelMgr);
1027
1028 WLog_DBG(TAG, "entered for %s", deviceId);
1029
1030 CameraDevice* dev = (CameraDevice*)calloc(1, sizeof(CameraDevice));
1031
1032 if (!dev)
1033 {
1034 WLog_ERR(TAG, "calloc failed");
1035 return nullptr;
1036 }
1037
1038 dev->ecam = ecam;
1039 dev->ihal = ecam->ihal;
1040 strncpy(dev->deviceId, deviceId, sizeof(dev->deviceId) - 1);
1041
1042 /* The lock of each stream lives as long as the device: a request of the server can take it
1043 * before the stream starts, or after it stopped */
1044 for (size_t i = 0; i < ECAM_DEVICE_MAX_STREAMS; i++)
1045 {
1046 if (!InitializeCriticalSectionEx(&dev->streams[i].lock, 0, 0))
1047 {
1048 ecam_dev_delete_locks(dev, i);
1049 free(dev);
1050 WLog_ERR(TAG, "InitializeCriticalSectionEx failed");
1051 return nullptr;
1052 }
1053 }
1054
1055 dev->hlistener = (GENERIC_LISTENER_CALLBACK*)calloc(1, sizeof(GENERIC_LISTENER_CALLBACK));
1056
1057 if (!dev->hlistener)
1058 {
1059 ecam_dev_delete_locks(dev, ECAM_DEVICE_MAX_STREAMS);
1060 free(dev);
1061 WLog_ERR(TAG, "calloc failed");
1062 return nullptr;
1063 }
1064
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))
1070 {
1071 free(dev->hlistener);
1072 ecam_dev_delete_locks(dev, ECAM_DEVICE_MAX_STREAMS);
1073 free(dev);
1074 WLog_ERR(TAG, "CreateListener failed");
1075 return nullptr;
1076 }
1077
1078 return dev;
1079}
1080
1087void ecam_dev_destroy(CameraDevice* dev)
1088{
1089 if (!dev)
1090 return;
1091
1092 WLog_DBG(TAG, "entered for %s", dev->deviceId);
1093
1094 if (dev->hlistener)
1095 {
1096 IWTSVirtualChannelManager* mgr = dev->hlistener->channel_mgr;
1097 if (mgr)
1098 IFCALL(mgr->DestroyListener, mgr, dev->listener);
1099 }
1100
1101 free(dev->hlistener);
1102
1103 for (size_t i = 0; i < ECAM_DEVICE_MAX_STREAMS; i++)
1104 ecam_dev_stop_stream(dev, i);
1105
1106 ecam_dev_delete_locks(dev, ECAM_DEVICE_MAX_STREAMS);
1107 free(dev);
1108}