FreeRDP
Loading...
Searching...
No Matches
camera_android.c
1
20#include <stdlib.h>
21#include <string.h>
22
23#include <winpr/wtypes.h>
24
25#include <camera/NdkCameraDevice.h>
26#include <camera/NdkCameraManager.h>
27#include <camera/NdkCameraMetadata.h>
28#include <camera/NdkCameraCaptureSession.h>
29#include <media/NdkImage.h>
30#include <media/NdkImageReader.h>
31
32#include "../camera.h"
33
34#define TAG CHANNELS_TAG("rdpecam-android.client")
35
36#define ANDROID_CAMERA_PREFIX "android-camera-"
37#define ANDROID_CAMERA_PREFIX_LEN (sizeof(ANDROID_CAMERA_PREFIX) - 1)
38
39#define CAM_ANDROID_FPS 30
40
41/* The smallest frame that the H.264 encoder of MediaCodec takes (MEDIACODEC_MINIMUM_WIDTH and
42 * MEDIACODEC_MINIMUM_HEIGHT of libfreerdp/codec/h264_mediacodec.c): a smaller one would never be
43 * encoded. */
44#define CAM_ANDROID_MIN_WIDTH 320
45#define CAM_ANDROID_MIN_HEIGHT 240
46
47typedef struct
48{
49 ICamHal iHal;
50 ACameraManager* manager;
51 wHashTable* streams; /* key: deviceId, value: CamAndroidStream */
52} CamAndroidHal;
53
54typedef struct
55{
56 size_t streamIndex;
57
58 ACameraDevice* device;
59 ACameraCaptureSession* session;
60 ACaptureSessionOutputContainer* outputContainer;
61 ACaptureSessionOutput* sessionOutput;
62 ACameraOutputTarget* outputTarget;
63 ACaptureRequest* captureRequest;
64 AImageReader* imageReader;
65 ANativeWindow* window;
66
67 ICamHalSampleCapturedCallback sampleCallback;
68 CameraDevice* dev;
69 BOOL streaming;
70 BOOL deviceError;
72
73 BYTE* nv12Buffer;
74 size_t nv12BufferSize;
75} CamAndroidStream;
76
77static const char* cam_android_extract_camera_id(const char* deviceId)
78{
79 WINPR_ASSERT(deviceId);
80
81 if (strncmp(deviceId, ANDROID_CAMERA_PREFIX, ANDROID_CAMERA_PREFIX_LEN) != 0)
82 return nullptr;
83 return deviceId + ANDROID_CAMERA_PREFIX_LEN;
84}
85
86/* Tear down the capture session and its request objects. The ImageReader and device are kept. */
87static void cam_android_close_session(CamAndroidStream* stream)
88{
89 WINPR_ASSERT(stream);
90
91 if (stream->session)
92 {
93 ACameraCaptureSession_stopRepeating(stream->session);
94 ACameraCaptureSession_close(stream->session);
95 stream->session = nullptr;
96 }
97 if (stream->captureRequest)
98 {
99 if (stream->outputTarget)
100 ACaptureRequest_removeTarget(stream->captureRequest, stream->outputTarget);
101 ACaptureRequest_free(stream->captureRequest);
102 stream->captureRequest = nullptr;
103 }
104 if (stream->outputTarget)
105 {
106 ACameraOutputTarget_free(stream->outputTarget);
107 stream->outputTarget = nullptr;
108 }
109 if (stream->outputContainer)
110 {
111 ACaptureSessionOutputContainer_free(stream->outputContainer);
112 stream->outputContainer = nullptr;
113 }
114 if (stream->sessionOutput)
115 {
116 ACaptureSessionOutput_free(stream->sessionOutput);
117 stream->sessionOutput = nullptr;
118 }
119}
120
121/* Pack a YUV_420_888 frame into NV12 (handles NV12, NV21 and planar I420 layouts). */
122static void cam_android_yuv420_888_to_nv12(BYTE* dst, int width, int height, const uint8_t* yData,
123 int yRowStride, const uint8_t* uData, int uRowStride,
124 int uPixelStride, const uint8_t* vData, int vRowStride,
125 int vPixelStride)
126{
127 WINPR_ASSERT(dst);
128 WINPR_ASSERT(yData);
129 WINPR_ASSERT(uData);
130 WINPR_ASSERT(vData);
131
132 const size_t ySize = (size_t)width * height;
133
134 /* Y plane */
135 if (yRowStride == width)
136 memcpy(dst, yData, ySize);
137 else
138 {
139 for (int row = 0; row < height; row++)
140 memcpy(dst + (size_t)row * width, yData + (size_t)row * yRowStride, (size_t)width);
141 }
142
143 /* UV planes -> interleaved NV12 */
144 BYTE* uv = dst + ySize;
145 const int uvHeight = height / 2;
146 const int uvWidth = width / 2;
147 const size_t uvRowBytes = (size_t)(uvWidth * 2);
148
149 if (uPixelStride == 2 && vPixelStride == 2)
150 {
151 /* Semi-planar: NV12 (U first) or NV21 (V first). */
152 if (uData < vData)
153 {
154 /* NV12: copy the UV block directly. */
155 if (uRowStride == (int)uvRowBytes)
156 memcpy(uv, uData, (size_t)uvHeight * uvRowBytes);
157 else
158 {
159 for (int row = 0; row < uvHeight; row++)
160 memcpy(uv + (size_t)row * uvRowBytes, uData + (size_t)row * uRowStride,
161 uvRowBytes);
162 }
163 }
164 else
165 {
166 /* NV21: swap U and V bytes. */
167 for (int row = 0; row < uvHeight; row++)
168 {
169 const uint8_t* u = uData + (size_t)row * uRowStride;
170 const uint8_t* v = vData + (size_t)row * vRowStride;
171 BYTE* d = uv + (size_t)row * uvRowBytes;
172 for (int col = 0; col < uvWidth; col++, u += 2, v += 2, d += 2)
173 {
174 d[0] = u[0];
175 d[1] = v[0];
176 }
177 }
178 }
179 }
180 else
181 {
182 /* Planar I420: interleave U and V. */
183 for (int row = 0; row < uvHeight; row++)
184 {
185 const uint8_t* uRow = uData + (size_t)row * uRowStride;
186 const uint8_t* vRow = vData + (size_t)row * vRowStride;
187 BYTE* dstRow = uv + (size_t)row * uvRowBytes;
188 for (int col = 0; col < uvWidth; col++)
189 {
190 dstRow[col * 2] = uRow[col * uPixelStride];
191 dstRow[col * 2 + 1] = vRow[col * vPixelStride];
192 }
193 }
194 }
195}
196
197static void cam_android_deliver_frame(CamAndroidStream* stream, AImage* image)
198{
199 WINPR_ASSERT(stream);
200 WINPR_ASSERT(image);
201
202 int32_t width = 0;
203 int32_t height = 0;
204 if (AImage_getWidth(image, &width) != AMEDIA_OK ||
205 AImage_getHeight(image, &height) != AMEDIA_OK)
206 return;
207
208 const size_t ySize = (size_t)(width * height);
209 const size_t nv12Size = ySize + ySize / 2;
210
211 if (stream->nv12BufferSize < nv12Size)
212 {
213 BYTE* tmp = (BYTE*)realloc(stream->nv12Buffer, nv12Size);
214 if (!tmp)
215 return;
216 stream->nv12Buffer = tmp;
217 stream->nv12BufferSize = nv12Size;
218 }
219
220 /* Fetch the planes; the length out-param is required but unused. */
221 int dataLength = 0;
222 uint8_t* yData = nullptr;
223 uint8_t* uData = nullptr;
224 uint8_t* vData = nullptr;
225 if (AImage_getPlaneData(image, 0, &yData, &dataLength) != AMEDIA_OK ||
226 AImage_getPlaneData(image, 1, &uData, &dataLength) != AMEDIA_OK ||
227 AImage_getPlaneData(image, 2, &vData, &dataLength) != AMEDIA_OK)
228 return;
229
230 int yRowStride = 0;
231 int uRowStride = 0;
232 int uPixelStride = 0;
233 int vRowStride = 0;
234 int vPixelStride = 0;
235 AImage_getPlaneRowStride(image, 0, &yRowStride);
236 AImage_getPlaneRowStride(image, 1, &uRowStride);
237 AImage_getPlanePixelStride(image, 1, &uPixelStride);
238 AImage_getPlaneRowStride(image, 2, &vRowStride);
239 AImage_getPlanePixelStride(image, 2, &vPixelStride);
240
241 cam_android_yuv420_888_to_nv12(stream->nv12Buffer, width, height, yData, yRowStride, uData,
242 uRowStride, uPixelStride, vData, vRowStride, vPixelStride);
243
244 stream->sampleCallback(stream->dev, stream->streamIndex, stream->nv12Buffer, nv12Size);
245}
246
247static void cam_android_on_image_available(void* context, AImageReader* reader)
248{
249 CamAndroidStream* stream = (CamAndroidStream*)context;
250 WINPR_ASSERT(stream);
251 WINPR_ASSERT(reader);
252
253 EnterCriticalSection(&stream->lock);
254 const BOOL streaming = stream->streaming;
255 LeaveCriticalSection(&stream->lock);
256
257 if (!streaming)
258 return;
259
260 AImage* image = nullptr;
261 if (AImageReader_acquireLatestImage(reader, &image) == AMEDIA_OK && image)
262 {
263 cam_android_deliver_frame(stream, image);
264 AImage_delete(image);
265 }
266}
267
268/* Mark the device broken so it is reopened on next use. */
269static void cam_android_mark_device_error(CamAndroidStream* stream)
270{
271 if (!stream)
272 return;
273 EnterCriticalSection(&stream->lock);
274 stream->deviceError = TRUE;
275 stream->streaming = FALSE;
276 LeaveCriticalSection(&stream->lock);
277}
278
279static void cam_android_device_disconnected(void* context, ACameraDevice* device)
280{
281 WINPR_UNUSED(device);
282 WLog_WARN(TAG, "Camera device disconnected");
283 cam_android_mark_device_error((CamAndroidStream*)context);
284}
285
286static void cam_android_device_error(void* context, ACameraDevice* device, int error)
287{
288 WINPR_UNUSED(device);
289 WLog_ERR(TAG, "Camera device error %d", error);
290 cam_android_mark_device_error((CamAndroidStream*)context);
291}
292
293static void cam_android_session_active(void* context, ACameraCaptureSession* session)
294{
295 WINPR_UNUSED(context);
296 WINPR_UNUSED(session);
297 WLog_DBG(TAG, "Capture session active");
298}
299
300static void cam_android_session_closed(void* context, ACameraCaptureSession* session)
301{
302 WINPR_UNUSED(context);
303 WINPR_UNUSED(session);
304 WLog_DBG(TAG, "Capture session closed");
305}
306
307static void cam_android_session_ready(void* context, ACameraCaptureSession* session)
308{
309 WINPR_UNUSED(context);
310 WINPR_UNUSED(session);
311 WLog_DBG(TAG, "Capture session ready");
312}
313
314/* TRUE if the camera is BACKWARD_COMPATIBLE. Depth/IR/sub-sensor cameras lack this and cannot
315 * configure a normal YUV session, so they must not be offered to the server. */
316static BOOL cam_android_is_backward_compatible(ACameraMetadata* characteristics)
317{
318 WINPR_ASSERT(characteristics);
319
320 ACameraMetadata_const_entry caps;
321 if (ACameraMetadata_getConstEntry(characteristics, ACAMERA_REQUEST_AVAILABLE_CAPABILITIES,
322 &caps) != ACAMERA_OK)
323 return FALSE;
324
325 for (uint32_t i = 0; i < caps.count; i++)
326 {
327 if (caps.data.u8[i] == ACAMERA_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE)
328 return TRUE;
329 }
330 return FALSE;
331}
332
333static UINT cam_android_enumerate(ICamHal* ihal, ICamHalEnumCallback callback, CameraPlugin* ecam,
334 GENERIC_CHANNEL_CALLBACK* hchannel)
335{
336 CamAndroidHal* hal = (CamAndroidHal*)ihal;
337 WINPR_ASSERT(hal);
338
339 UINT count = 0;
340
341 /* The NV12 frames go to the server as H.264 (the first format of getSupportedFormats with NV12
342 * as its input): encoded by MediaCodec, or by FFmpeg with swscale. Without either, offer no
343 * cameras. */
344 if (!freerdp_video_conversion_supported(FREERDP_VIDEO_FORMAT_NV12, FREERDP_VIDEO_FORMAT_H264))
345 {
346 WLog_WARN(TAG, "Camera redirection unavailable: no conversion of NV12 frames to H.264");
347 return 0;
348 }
349
350 ACameraIdList* idList = nullptr;
351 if (ACameraManager_getCameraIdList(hal->manager, &idList) != ACAMERA_OK || !idList)
352 return 0;
353
354 /* Offer only the primary camera per facing direction: auxiliary back cameras (ultrawide/tele/
355 * macro/depth) advertise resolutions but fail to configure a YUV session and freeze the
356 * channel. Indexed by ACAMERA_LENS_FACING_* (FRONT=0, BACK=1, EXTERNAL=2). */
357 BOOL seenFacing[ACAMERA_LENS_FACING_EXTERNAL + 1] = WINPR_C_ARRAY_INIT;
358
359 for (int i = 0; i < idList->numCameras; i++)
360 {
361 const char* cameraId = idList->cameraIds[i];
362
363 ACameraMetadata* characteristics = nullptr;
364 if (ACameraManager_getCameraCharacteristics(hal->manager, cameraId, &characteristics) !=
365 ACAMERA_OK)
366 continue;
367
368 /* Skip depth/IR/sub-sensor cameras that can't configure a normal capture session. */
369 if (!cam_android_is_backward_compatible(characteristics))
370 {
371 WLog_DBG(TAG, "Skipping camera %s: not BACKWARD_COMPATIBLE", cameraId);
372 ACameraMetadata_free(characteristics);
373 continue;
374 }
375
376 ACameraMetadata_const_entry facingEntry;
377 const char* facingName = "Camera";
378 uint8_t facing = ACAMERA_LENS_FACING_EXTERNAL;
379 if (ACameraMetadata_getConstEntry(characteristics, ACAMERA_LENS_FACING, &facingEntry) ==
380 ACAMERA_OK)
381 {
382 facing = facingEntry.data.u8[0];
383 switch (facing)
384 {
385 case ACAMERA_LENS_FACING_FRONT:
386 facingName = "Front Camera";
387 break;
388 case ACAMERA_LENS_FACING_BACK:
389 facingName = "Back Camera";
390 break;
391 default:
392 facingName = "External Camera";
393 break;
394 }
395 }
396
397 /* Bounds-guard seenFacing[] against an out-of-range facing value. */
398 if (facing <= ACAMERA_LENS_FACING_EXTERNAL)
399 {
400 if (seenFacing[facing])
401 {
402 WLog_DBG(TAG, "Skipping camera %s: already have a %s", cameraId, facingName);
403 ACameraMetadata_free(characteristics);
404 continue;
405 }
406 seenFacing[facing] = TRUE;
407 }
408
409 char deviceId[64];
410 (void)_snprintf(deviceId, sizeof(deviceId), ANDROID_CAMERA_PREFIX "%s", cameraId);
411
412 IFCALL(callback, ecam, hchannel, deviceId, facingName);
413 count++;
414
415 ACameraMetadata_free(characteristics);
416 }
417
418 ACameraManager_deleteCameraIdList(idList);
419 return count;
420}
421
422/* Stop streaming and fully release the camera. Order matters: close the session and device before
423 * the ImageReader, or the camera service fails to unconfigure and leaves the device running. */
424static void cam_android_close_device(CamAndroidStream* stream)
425{
426 WINPR_ASSERT(stream);
427
428 EnterCriticalSection(&stream->lock);
429 stream->streaming = FALSE;
430 LeaveCriticalSection(&stream->lock);
431
432 if (stream->imageReader)
433 AImageReader_setImageListener(stream->imageReader, nullptr);
434
435 cam_android_close_session(stream);
436
437 if (stream->device)
438 {
439 ACameraDevice_close(stream->device);
440 stream->device = nullptr;
441 }
442
443 if (stream->imageReader)
444 {
445 AImageReader_delete(stream->imageReader);
446 stream->imageReader = nullptr;
447 stream->window = nullptr;
448 }
449 free(stream->nv12Buffer);
450 stream->nv12Buffer = nullptr;
451 stream->nv12BufferSize = 0;
452 stream->deviceError = FALSE;
453}
454
455/* Close every open camera except keepDeviceId. Phones share camera hardware, so holding more than
456 * one open makes the next openCamera fail with CAMERA_DISCONNECTED and freeze the channel. */
457static void cam_android_close_other_devices(CamAndroidHal* hal, const char* keepDeviceId)
458{
459 WINPR_ASSERT(hal);
460 WINPR_ASSERT(keepDeviceId);
461
462 ULONG_PTR* keys = nullptr;
463 const size_t count = HashTable_GetKeys(hal->streams, &keys);
464 for (size_t i = 0; i < count; i++)
465 {
466 const char* id = (const char*)keys[i];
467 if (strcmp(id, keepDeviceId) == 0)
468 continue;
469
470 CamAndroidStream* other = (CamAndroidStream*)HashTable_GetItemValue(hal->streams, id);
471 if (!other || !other->device)
472 continue;
473
474 WLog_DBG(TAG, "Closing camera %s to free resources for %s", id, keepDeviceId);
475 cam_android_close_device(other);
476 }
477 free(keys);
478}
479
480static CamAndroidStream* cam_android_get_or_create_stream(CamAndroidHal* hal, const char* deviceId,
481 CAM_ERROR_CODE* errorCode)
482{
483 WINPR_ASSERT(hal);
484 WINPR_ASSERT(deviceId);
485 WINPR_ASSERT(errorCode);
486
487 CamAndroidStream* stream = (CamAndroidStream*)HashTable_GetItemValue(hal->streams, deviceId);
488 if (stream)
489 return stream;
490
491 stream = (CamAndroidStream*)calloc(1, sizeof(CamAndroidStream));
492 if (!stream)
493 {
494 *errorCode = CAM_ERROR_CODE_OutOfMemory;
495 return nullptr;
496 }
497 if (!InitializeCriticalSectionEx(&stream->lock, 0, 0))
498 {
499 free(stream);
500 *errorCode = CAM_ERROR_CODE_UnexpectedError;
501 return nullptr;
502 }
503 if (!HashTable_Insert(hal->streams, deviceId, stream))
504 {
505 DeleteCriticalSection(&stream->lock);
506 free(stream);
507 *errorCode = CAM_ERROR_CODE_UnexpectedError;
508 return nullptr;
509 }
510 return stream;
511}
512
513/* Open the camera, closing any other open one first (phones keep only one open). Deferred from
514 * Activate to StartStream so media-type probing doesn't thrash the hardware. */
515static BOOL cam_android_open_device(CamAndroidHal* hal, CamAndroidStream* stream,
516 const char* deviceId, const char* cameraId,
517 CAM_ERROR_CODE* errorCode)
518{
519 WINPR_ASSERT(hal);
520 WINPR_ASSERT(stream);
521 WINPR_ASSERT(deviceId);
522 WINPR_ASSERT(cameraId);
523 WINPR_ASSERT(errorCode);
524
525 /* Reopen a device left broken by a previous error. */
526 EnterCriticalSection(&stream->lock);
527 const BOOL hadError = stream->deviceError;
528 LeaveCriticalSection(&stream->lock);
529 if (stream->device && hadError)
530 cam_android_close_device(stream);
531
532 if (stream->device)
533 return TRUE; /* already open */
534
535 cam_android_close_other_devices(hal, deviceId);
536
537 ACameraDevice_StateCallbacks deviceCallbacks = {
538 .context = stream,
539 .onDisconnected = cam_android_device_disconnected,
540 .onError = cam_android_device_error,
541 };
542
543 camera_status_t status =
544 ACameraManager_openCamera(hal->manager, cameraId, &deviceCallbacks, &stream->device);
545 if (status != ACAMERA_OK)
546 {
547 WLog_ERR(TAG, "ACameraManager_openCamera failed: %d", status);
548 *errorCode = CAM_ERROR_CODE_InvalidRequest;
549 return FALSE;
550 }
551
552 WLog_DBG(TAG, "Opened camera %s", cameraId);
553 return TRUE;
554}
555
556static BOOL cam_android_activate(ICamHal* ihal, const char* deviceId, CAM_ERROR_CODE* errorCode)
557{
558 CamAndroidHal* hal = (CamAndroidHal*)ihal;
559 WINPR_ASSERT(hal);
560 WINPR_ASSERT(deviceId);
561 WINPR_ASSERT(errorCode);
562
563 *errorCode = CAM_ERROR_CODE_None;
564
565 const char* cameraId = cam_android_extract_camera_id(deviceId);
566 if (!cameraId)
567 {
568 *errorCode = CAM_ERROR_CODE_InvalidRequest;
569 return FALSE;
570 }
571
572 /* Hardware is opened lazily in StartStream, not here. */
573 return cam_android_get_or_create_stream(hal, deviceId, errorCode) != nullptr;
574}
575
576static BOOL cam_android_deactivate(ICamHal* ihal, const char* deviceId, CAM_ERROR_CODE* errorCode)
577{
578 CamAndroidHal* hal = (CamAndroidHal*)ihal;
579 WINPR_ASSERT(hal);
580 WINPR_ASSERT(deviceId);
581 WINPR_ASSERT(errorCode);
582
583 *errorCode = CAM_ERROR_CODE_None;
584
585 CamAndroidStream* stream = (CamAndroidStream*)HashTable_GetItemValue(hal->streams, deviceId);
586 if (!stream || !stream->device)
587 return TRUE;
588
589 cam_android_close_device(stream);
590 return TRUE;
591}
592
593static INT16 cam_android_get_media_type_descriptions(ICamHal* ihal, const char* deviceId,
594 size_t streamIndex,
595 const CAM_MEDIA_FORMAT_INFO* supportedFormats,
596 size_t nSupportedFormats,
597 CAM_MEDIA_TYPE_DESCRIPTION* mediaTypes,
598 size_t* nMediaTypes)
599{
600 WINPR_UNUSED(streamIndex);
601 CamAndroidHal* hal = (CamAndroidHal*)ihal;
602 WINPR_ASSERT(hal);
603 WINPR_ASSERT(deviceId);
604 WINPR_ASSERT(supportedFormats || (nSupportedFormats == 0));
605 WINPR_ASSERT(mediaTypes);
606 WINPR_ASSERT(nMediaTypes);
607
608 size_t maxMediaTypes = *nMediaTypes;
609 *nMediaTypes = 0;
610
611 const char* cameraId = cam_android_extract_camera_id(deviceId);
612 if (!cameraId)
613 return -1;
614
615 /* Find the NV12 format index. */
616 INT16 formatIndex = -1;
617 for (size_t i = 0; i < nSupportedFormats; i++)
618 {
619 if (supportedFormats[i].inputFormat == CAM_MEDIA_FORMAT_NV12)
620 {
621 formatIndex = (INT16)i;
622 break;
623 }
624 }
625 if (formatIndex < 0)
626 {
627 WLog_WARN(TAG, "Server does not offer NV12 format");
628 return -1;
629 }
630
631 ACameraMetadata* characteristics = nullptr;
632 if (ACameraManager_getCameraCharacteristics(hal->manager, cameraId, &characteristics) !=
633 ACAMERA_OK)
634 return -1;
635
636 /* Stream configs: [format, width, height, isInput] tuples. */
637 ACameraMetadata_const_entry entry;
638 if (ACameraMetadata_getConstEntry(
639 characteristics, ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, &entry) != ACAMERA_OK)
640 {
641 ACameraMetadata_free(characteristics);
642 return -1;
643 }
644
645 size_t nTypes = 0;
646 for (uint32_t i = 0; i + 3 < entry.count; i += 4)
647 {
648 const int32_t fmt = entry.data.i32[i];
649 const int32_t w = entry.data.i32[i + 1];
650 const int32_t h = entry.data.i32[i + 2];
651 const int32_t isInput = entry.data.i32[i + 3];
652
653 if (isInput != 0)
654 continue;
655 if (fmt != AIMAGE_FORMAT_YUV_420_888)
656 continue;
657 /* Skip resolutions larger than 1080p to avoid saturating the RDP link */
658 if (w > 1920 || h > 1080)
659 continue;
660 /* Skip what the encoder would refuse: too small, or odd sides that NV12 cannot split */
661 if (w < CAM_ANDROID_MIN_WIDTH || h < CAM_ANDROID_MIN_HEIGHT || (w % 2) != 0 || (h % 2) != 0)
662 continue;
663
664 mediaTypes[nTypes].Format = CAM_MEDIA_FORMAT_NV12;
665 mediaTypes[nTypes].Width = (UINT32)w;
666 mediaTypes[nTypes].Height = (UINT32)h;
667 mediaTypes[nTypes].FrameRateNumerator = CAM_ANDROID_FPS;
668 mediaTypes[nTypes].FrameRateDenominator = 1;
669 mediaTypes[nTypes].PixelAspectRatioNumerator = 1;
670 mediaTypes[nTypes].PixelAspectRatioDenominator = 1;
671
672 WLog_DBG(TAG, "Camera format NV12 %dx%d @ %dfps", w, h, CAM_ANDROID_FPS);
673
674 if (++nTypes >= maxMediaTypes)
675 break;
676 }
677
678 *nMediaTypes = nTypes;
679 ACameraMetadata_free(characteristics);
680
681 if (nTypes == 0)
682 {
683 WLog_ERR(TAG, "No supported YUV resolutions found for camera %s", cameraId);
684 return -1;
685 }
686
687 return formatIndex;
688}
689
690static CAM_ERROR_CODE cam_android_start_stream(ICamHal* ihal, CameraDevice* dev, size_t streamIndex,
691 const CAM_MEDIA_TYPE_DESCRIPTION* mediaType,
692 ICamHalSampleCapturedCallback callback)
693{
694 CamAndroidHal* hal = (CamAndroidHal*)ihal;
695 WINPR_ASSERT(hal);
696 WINPR_ASSERT(dev);
697 WINPR_ASSERT(mediaType);
698 WINPR_ASSERT(callback);
699
700 const char* deviceId = dev->deviceId;
701
702 const char* cameraId = cam_android_extract_camera_id(deviceId);
703 if (!cameraId)
704 return CAM_ERROR_CODE_InvalidRequest;
705
706 CAM_ERROR_CODE errorCode = CAM_ERROR_CODE_None;
707 CamAndroidStream* stream = cam_android_get_or_create_stream(hal, deviceId, &errorCode);
708 if (!stream)
709 return errorCode;
710
711 if (!cam_android_open_device(hal, stream, deviceId, cameraId, &errorCode))
712 return errorCode;
713
714 stream->dev = dev;
715 stream->streamIndex = streamIndex;
716 stream->sampleCallback = callback;
717
718 const int32_t width = (int32_t)mediaType->Width;
719 const int32_t height = (int32_t)mediaType->Height;
720
721 if (AImageReader_new(width, height, AIMAGE_FORMAT_YUV_420_888, 4, &stream->imageReader) !=
722 AMEDIA_OK)
723 {
724 WLog_ERR(TAG, "AImageReader_new failed");
725 return CAM_ERROR_CODE_UnexpectedError;
726 }
727
728 AImageReader_ImageListener listener = {
729 .context = stream,
730 .onImageAvailable = cam_android_on_image_available,
731 };
732 AImageReader_setImageListener(stream->imageReader, &listener);
733
734 if (AImageReader_getWindow(stream->imageReader, &stream->window) != AMEDIA_OK)
735 {
736 WLog_ERR(TAG, "AImageReader_getWindow failed");
737 goto error;
738 }
739
740 ACaptureSessionOutput_create(stream->window, &stream->sessionOutput);
741 ACaptureSessionOutputContainer_create(&stream->outputContainer);
742 ACaptureSessionOutputContainer_add(stream->outputContainer, stream->sessionOutput);
743 ACameraOutputTarget_create(stream->window, &stream->outputTarget);
744 ACameraDevice_createCaptureRequest(stream->device, TEMPLATE_RECORD, &stream->captureRequest);
745 ACaptureRequest_addTarget(stream->captureRequest, stream->outputTarget);
746
747 ACameraCaptureSession_stateCallbacks sessionCallbacks = {
748 .context = stream,
749 .onActive = cam_android_session_active,
750 .onClosed = cam_android_session_closed,
751 .onReady = cam_android_session_ready,
752 };
753
754 if (ACameraDevice_createCaptureSession(stream->device, stream->outputContainer,
755 &sessionCallbacks, &stream->session) != ACAMERA_OK)
756 {
757 WLog_ERR(TAG, "ACameraDevice_createCaptureSession failed");
758 goto error;
759 }
760
761 if (ACameraCaptureSession_setRepeatingRequest(stream->session, nullptr, 1,
762 &stream->captureRequest, nullptr) != ACAMERA_OK)
763 {
764 WLog_ERR(TAG, "ACameraCaptureSession_setRepeatingRequest failed");
765 goto error;
766 }
767
768 EnterCriticalSection(&stream->lock);
769 stream->streaming = TRUE;
770 LeaveCriticalSection(&stream->lock);
771
772 WLog_DBG(TAG, "Camera stream started: %dx%d", width, height);
773 return CAM_ERROR_CODE_None;
774
775error:
776 cam_android_close_device(stream);
777 return CAM_ERROR_CODE_UnexpectedError;
778}
779
780static CAM_ERROR_CODE cam_android_stop_stream(ICamHal* ihal, const char* deviceId,
781 size_t streamIndex)
782{
783 WINPR_UNUSED(streamIndex);
784 CamAndroidHal* hal = (CamAndroidHal*)ihal;
785 WINPR_ASSERT(hal);
786 WINPR_ASSERT(deviceId);
787
788 CamAndroidStream* stream = (CamAndroidStream*)HashTable_GetItemValue(hal->streams, deviceId);
789 if (!stream)
790 return CAM_ERROR_CODE_None;
791
792 cam_android_close_device(stream);
793
794 WLog_DBG(TAG, "Camera stream stopped for %s", deviceId);
795 return CAM_ERROR_CODE_None;
796}
797
798static void cam_android_stream_free(void* obj)
799{
800 CamAndroidStream* stream = (CamAndroidStream*)obj;
801 if (!stream)
802 return;
803
804 cam_android_close_device(stream);
805 DeleteCriticalSection(&stream->lock);
806 free(stream);
807}
808
809static CAM_ERROR_CODE cam_android_free(ICamHal* ihal)
810{
811 CamAndroidHal* hal = (CamAndroidHal*)ihal;
812 if (!hal)
813 return CAM_ERROR_CODE_NotInitialized;
814
815 HashTable_Free(hal->streams);
816 if (hal->manager)
817 ACameraManager_delete(hal->manager);
818 free(hal);
819 return CAM_ERROR_CODE_None;
820}
821
822FREERDP_ENTRY_POINT(UINT VCAPITYPE android_freerdp_rdpecam_client_subsystem_entry(
824{
825 WINPR_ASSERT(pEntryPoints);
826
827 CamAndroidHal* hal = (CamAndroidHal*)calloc(1, sizeof(CamAndroidHal));
828 if (!hal)
829 return CHANNEL_RC_NO_MEMORY;
830
831 hal->manager = ACameraManager_create();
832 if (!hal->manager)
833 {
834 free(hal);
835 return ERROR_INTERNAL_ERROR;
836 }
837
838 hal->streams = HashTable_New(FALSE);
839 if (!hal->streams)
840 goto error;
841
842 if (!HashTable_SetupForStringData(hal->streams, FALSE))
843 goto error;
844
845 wObject* obj = HashTable_ValueObject(hal->streams);
846 WINPR_ASSERT(obj);
847 obj->fnObjectFree = cam_android_stream_free;
848
849 hal->iHal.Enumerate = cam_android_enumerate;
850 hal->iHal.Activate = cam_android_activate;
851 hal->iHal.Deactivate = cam_android_deactivate;
852 hal->iHal.GetMediaTypeDescriptions = cam_android_get_media_type_descriptions;
853 hal->iHal.StartStream = cam_android_start_stream;
854 hal->iHal.StopStream = cam_android_stop_stream;
855 hal->iHal.Free = cam_android_free;
856
857 UINT ret = pEntryPoints->pRegisterCameraHal(pEntryPoints->plugin, &hal->iHal);
858 if (ret != CHANNEL_RC_OK)
859 {
860 WLog_ERR(TAG, "RegisterCameraHal failed: %" PRIu32, ret);
861 goto error;
862 }
863
864 return ret;
865
866error:
867 cam_android_free(&hal->iHal);
868 return ERROR_INTERNAL_ERROR;
869}
Definition camera.h:237
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
OBJECT_FREE_FN fnObjectFree
Definition collections.h:59