mirror of
https://github.com/libsdl-org/SDL.git
synced 2025-09-27 21:48:29 +00:00
camera: Renamed "video_capture" files to "camera" and moved to own subdir.
This commit is contained in:
Ryan C. Gordon
713
src/camera/android/SDL_camera_android.c
Normal file
713
src/camera/android/SDL_camera_android.c
Normal file
@@ -0,0 +1,713 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2024 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_internal.h"
|
||||
|
||||
#include "SDL3/SDL.h"
|
||||
#include "SDL3/SDL_video_capture.h"
|
||||
#include "../SDL_sysvideocapture.h"
|
||||
#include "../SDL_video_capture_c.h"
|
||||
#include "../SDL_pixels_c.h"
|
||||
#include "../../thread/SDL_systhread.h"
|
||||
|
||||
#define DEBUG_VIDEO_CAPTURE_CAPTURE 0
|
||||
|
||||
#if defined(SDL_PLATFORM_ANDROID) && __ANDROID_API__ >= 24
|
||||
|
||||
/*
|
||||
* APP_PLATFORM=android-24
|
||||
* minSdkVersion=24
|
||||
*
|
||||
* link with: -lcamera2ndk -lmediandk
|
||||
*
|
||||
* AndroidManifest.xml:
|
||||
* <uses-permission android:name="android.permission.CAMERA"></uses-permission>
|
||||
* <uses-feature android:name="android.hardware.camera" />
|
||||
*
|
||||
*
|
||||
* Add: #define SDL_VIDEO_CAPTURE 1
|
||||
* in: include/build_config/SDL_build_config_android.h
|
||||
*
|
||||
*
|
||||
* Very likely SDL must be build with YUV support (done by default)
|
||||
*
|
||||
* https://developer.android.com/reference/android/hardware/camera2/CameraManager
|
||||
* "All camera devices intended to be operated concurrently, must be opened using openCamera(String, CameraDevice.StateCallback, Handler),
|
||||
* before configuring sessions on any of the camera devices. * "
|
||||
*/
|
||||
|
||||
#include <camera/NdkCameraDevice.h>
|
||||
#include <camera/NdkCameraManager.h>
|
||||
#include <media/NdkImage.h>
|
||||
#include <media/NdkImageReader.h>
|
||||
|
||||
#include "../../core/android/SDL_android.h"
|
||||
|
||||
|
||||
static ACameraManager *cameraMgr = NULL;
|
||||
static ACameraIdList *cameraIdList = NULL;
|
||||
|
||||
static void
|
||||
create_cameraMgr(void)
|
||||
{
|
||||
if (cameraMgr == NULL) {
|
||||
#if 0 // !!! FIXME: this is getting replaced in a different branch.
|
||||
if (!Android_JNI_RequestPermission("android.permission.CAMERA")) {
|
||||
SDL_SetError("This app doesn't have CAMERA permission");
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
cameraMgr = ACameraManager_create();
|
||||
if (cameraMgr == NULL) {
|
||||
SDL_Log("Error creating ACameraManager");
|
||||
} else {
|
||||
SDL_Log("Create ACameraManager");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
delete_cameraMgr(void)
|
||||
{
|
||||
if (cameraIdList) {
|
||||
ACameraManager_deleteCameraIdList(cameraIdList);
|
||||
cameraIdList = NULL;
|
||||
}
|
||||
|
||||
if (cameraMgr) {
|
||||
ACameraManager_delete(cameraMgr);
|
||||
cameraMgr = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
struct SDL_PrivateVideoCaptureData
|
||||
{
|
||||
ACameraDevice *device;
|
||||
ACameraCaptureSession *session;
|
||||
ACameraDevice_StateCallbacks dev_callbacks;
|
||||
ACameraCaptureSession_stateCallbacks capture_callbacks;
|
||||
ACaptureSessionOutputContainer *sessionOutputContainer;
|
||||
AImageReader *reader;
|
||||
int num_formats;
|
||||
int count_formats[6]; // see format_2_id
|
||||
};
|
||||
|
||||
|
||||
/**/
|
||||
#define FORMAT_SDL SDL_PIXELFORMAT_NV12
|
||||
|
||||
static int
|
||||
format_2_id(int fmt) {
|
||||
switch (fmt) {
|
||||
#define CASE(x, y) case x: return y
|
||||
CASE(FORMAT_SDL, 0);
|
||||
CASE(SDL_PIXELFORMAT_RGB565, 1);
|
||||
CASE(SDL_PIXELFORMAT_XRGB8888, 2);
|
||||
CASE(SDL_PIXELFORMAT_RGBA8888, 3);
|
||||
CASE(SDL_PIXELFORMAT_RGBX8888, 4);
|
||||
CASE(SDL_PIXELFORMAT_UNKNOWN, 5);
|
||||
#undef CASE
|
||||
default:
|
||||
return 5;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
id_2_format(int fmt) {
|
||||
switch (fmt) {
|
||||
#define CASE(x, y) case y: return x
|
||||
CASE(FORMAT_SDL, 0);
|
||||
CASE(SDL_PIXELFORMAT_RGB565, 1);
|
||||
CASE(SDL_PIXELFORMAT_XRGB8888, 2);
|
||||
CASE(SDL_PIXELFORMAT_RGBA8888, 3);
|
||||
CASE(SDL_PIXELFORMAT_RGBX8888, 4);
|
||||
CASE(SDL_PIXELFORMAT_UNKNOWN, 5);
|
||||
#undef CASE
|
||||
default:
|
||||
return SDL_PIXELFORMAT_UNKNOWN;
|
||||
}
|
||||
}
|
||||
|
||||
static Uint32
|
||||
format_android_2_sdl(Uint32 fmt)
|
||||
{
|
||||
switch (fmt) {
|
||||
#define CASE(x, y) case x: return y
|
||||
CASE(AIMAGE_FORMAT_YUV_420_888, FORMAT_SDL);
|
||||
CASE(AIMAGE_FORMAT_RGB_565, SDL_PIXELFORMAT_RGB565);
|
||||
CASE(AIMAGE_FORMAT_RGB_888, SDL_PIXELFORMAT_XRGB8888);
|
||||
CASE(AIMAGE_FORMAT_RGBA_8888, SDL_PIXELFORMAT_RGBA8888);
|
||||
CASE(AIMAGE_FORMAT_RGBX_8888, SDL_PIXELFORMAT_RGBX8888);
|
||||
|
||||
CASE(AIMAGE_FORMAT_RGBA_FP16, SDL_PIXELFORMAT_UNKNOWN); // 64bits
|
||||
CASE(AIMAGE_FORMAT_RAW_PRIVATE, SDL_PIXELFORMAT_UNKNOWN);
|
||||
CASE(AIMAGE_FORMAT_JPEG, SDL_PIXELFORMAT_UNKNOWN);
|
||||
#undef CASE
|
||||
default:
|
||||
SDL_Log("Unknown format AIMAGE_FORMAT '%d'", fmt);
|
||||
return SDL_PIXELFORMAT_UNKNOWN;
|
||||
}
|
||||
}
|
||||
|
||||
static Uint32
|
||||
format_sdl_2_android(Uint32 fmt)
|
||||
{
|
||||
switch (fmt) {
|
||||
#define CASE(x, y) case y: return x
|
||||
CASE(AIMAGE_FORMAT_YUV_420_888, FORMAT_SDL);
|
||||
CASE(AIMAGE_FORMAT_RGB_565, SDL_PIXELFORMAT_RGB565);
|
||||
CASE(AIMAGE_FORMAT_RGB_888, SDL_PIXELFORMAT_XRGB8888);
|
||||
CASE(AIMAGE_FORMAT_RGBA_8888, SDL_PIXELFORMAT_RGBA8888);
|
||||
CASE(AIMAGE_FORMAT_RGBX_8888, SDL_PIXELFORMAT_RGBX8888);
|
||||
#undef CASE
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
onDisconnected(void *context, ACameraDevice *device)
|
||||
{
|
||||
// SDL_VideoCaptureDevice *_this = (SDL_VideoCaptureDevice *) context;
|
||||
SDL_Log("CB onDisconnected");
|
||||
}
|
||||
|
||||
static void
|
||||
onError(void *context, ACameraDevice *device, int error)
|
||||
{
|
||||
// SDL_VideoCaptureDevice *_this = (SDL_VideoCaptureDevice *) context;
|
||||
SDL_Log("CB onError");
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
onClosed(void* context, ACameraCaptureSession *session)
|
||||
{
|
||||
// SDL_VideoCaptureDevice *_this = (SDL_VideoCaptureDevice *) context;
|
||||
SDL_Log("CB onClosed");
|
||||
}
|
||||
|
||||
static void
|
||||
onReady(void* context, ACameraCaptureSession *session)
|
||||
{
|
||||
// SDL_VideoCaptureDevice *_this = (SDL_VideoCaptureDevice *) context;
|
||||
SDL_Log("CB onReady");
|
||||
}
|
||||
|
||||
static void
|
||||
onActive(void* context, ACameraCaptureSession *session)
|
||||
{
|
||||
// SDL_VideoCaptureDevice *_this = (SDL_VideoCaptureDevice *) context;
|
||||
SDL_Log("CB onActive");
|
||||
}
|
||||
|
||||
int
|
||||
OpenDevice(SDL_VideoCaptureDevice *_this)
|
||||
{
|
||||
camera_status_t res;
|
||||
|
||||
/* Cannot open a second camera, while the first one is opened.
|
||||
* If you want to play several camera, they must all be opened first, then played.
|
||||
*
|
||||
* https://developer.android.com/reference/android/hardware/camera2/CameraManager
|
||||
* "All camera devices intended to be operated concurrently, must be opened using openCamera(String, CameraDevice.StateCallback, Handler),
|
||||
* before configuring sessions on any of the camera devices. * "
|
||||
*
|
||||
*/
|
||||
if (check_device_playing()) {
|
||||
return SDL_SetError("A camera is already playing");
|
||||
}
|
||||
|
||||
_this->hidden = (struct SDL_PrivateVideoCaptureData *) SDL_calloc(1, sizeof (struct SDL_PrivateVideoCaptureData));
|
||||
if (_this->hidden == NULL) {
|
||||
return SDL_OutOfMemory();
|
||||
}
|
||||
|
||||
create_cameraMgr();
|
||||
|
||||
_this->hidden->dev_callbacks.context = (void *) _this;
|
||||
_this->hidden->dev_callbacks.onDisconnected = onDisconnected;
|
||||
_this->hidden->dev_callbacks.onError = onError;
|
||||
|
||||
res = ACameraManager_openCamera(cameraMgr, _this->dev_name, &_this->hidden->dev_callbacks, &_this->hidden->device);
|
||||
if (res != ACAMERA_OK) {
|
||||
return SDL_SetError("Failed to open camera");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
CloseDevice(SDL_VideoCaptureDevice *_this)
|
||||
{
|
||||
if (_this && _this->hidden) {
|
||||
if (_this->hidden->session) {
|
||||
ACameraCaptureSession_close(_this->hidden->session);
|
||||
}
|
||||
|
||||
if (_this->hidden->sessionOutputContainer) {
|
||||
ACaptureSessionOutputContainer_free(_this->hidden->sessionOutputContainer);
|
||||
}
|
||||
|
||||
if (_this->hidden->reader) {
|
||||
AImageReader_delete(_this->hidden->reader);
|
||||
}
|
||||
|
||||
if (_this->hidden->device) {
|
||||
ACameraDevice_close(_this->hidden->device);
|
||||
}
|
||||
|
||||
SDL_free(_this->hidden);
|
||||
|
||||
_this->hidden = NULL;
|
||||
}
|
||||
|
||||
if (check_all_device_closed()) {
|
||||
delete_cameraMgr();
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
InitDevice(SDL_VideoCaptureDevice *_this)
|
||||
{
|
||||
size_t size, pitch;
|
||||
SDL_CalculateSize(_this->spec.format, _this->spec.width, _this->spec.height, &size, &pitch, SDL_FALSE);
|
||||
SDL_Log("Buffer size: %d x %d", _this->spec.width, _this->spec.height);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
GetDeviceSpec(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureSpec *spec)
|
||||
{
|
||||
if (spec) {
|
||||
*spec = _this->spec;
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
int
|
||||
StartCapture(SDL_VideoCaptureDevice *_this)
|
||||
{
|
||||
camera_status_t res;
|
||||
media_status_t res2;
|
||||
ANativeWindow *window = NULL;
|
||||
ACaptureSessionOutput *sessionOutput;
|
||||
ACameraOutputTarget *outputTarget;
|
||||
ACaptureRequest *request;
|
||||
|
||||
res2 = AImageReader_new(_this->spec.width, _this->spec.height, format_sdl_2_android(_this->spec.format), 10 /* nb buffers */, &_this->hidden->reader);
|
||||
if (res2 != AMEDIA_OK) {
|
||||
SDL_SetError("Error AImageReader_new");
|
||||
goto error;
|
||||
}
|
||||
res2 = AImageReader_getWindow(_this->hidden->reader, &window);
|
||||
if (res2 != AMEDIA_OK) {
|
||||
SDL_SetError("Error AImageReader_new");
|
||||
goto error;
|
||||
|
||||
}
|
||||
|
||||
|
||||
res = ACaptureSessionOutput_create(window, &sessionOutput);
|
||||
if (res != ACAMERA_OK) {
|
||||
SDL_SetError("Error ACaptureSessionOutput_create");
|
||||
goto error;
|
||||
}
|
||||
res = ACaptureSessionOutputContainer_create(&_this->hidden->sessionOutputContainer);
|
||||
if (res != ACAMERA_OK) {
|
||||
SDL_SetError("Error ACaptureSessionOutputContainer_create");
|
||||
goto error;
|
||||
}
|
||||
res = ACaptureSessionOutputContainer_add(_this->hidden->sessionOutputContainer, sessionOutput);
|
||||
if (res != ACAMERA_OK) {
|
||||
SDL_SetError("Error ACaptureSessionOutputContainer_add");
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
||||
res = ACameraOutputTarget_create(window, &outputTarget);
|
||||
if (res != ACAMERA_OK) {
|
||||
SDL_SetError("Error ACameraOutputTarget_create");
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
||||
res = ACameraDevice_createCaptureRequest(_this->hidden->device, TEMPLATE_RECORD, &request);
|
||||
if (res != ACAMERA_OK) {
|
||||
SDL_SetError("Error ACameraDevice_createCaptureRequest");
|
||||
goto error;
|
||||
}
|
||||
|
||||
res = ACaptureRequest_addTarget(request, outputTarget);
|
||||
if (res != ACAMERA_OK) {
|
||||
SDL_SetError("Error ACaptureRequest_addTarget");
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
||||
_this->hidden->capture_callbacks.context = (void *) _this;
|
||||
_this->hidden->capture_callbacks.onClosed = onClosed;
|
||||
_this->hidden->capture_callbacks.onReady = onReady;
|
||||
_this->hidden->capture_callbacks.onActive = onActive;
|
||||
|
||||
res = ACameraDevice_createCaptureSession(_this->hidden->device,
|
||||
_this->hidden->sessionOutputContainer,
|
||||
&_this->hidden->capture_callbacks,
|
||||
&_this->hidden->session);
|
||||
if (res != ACAMERA_OK) {
|
||||
SDL_SetError("Error ACameraDevice_createCaptureSession");
|
||||
goto error;
|
||||
}
|
||||
|
||||
res = ACameraCaptureSession_setRepeatingRequest(_this->hidden->session, NULL, 1, &request, NULL);
|
||||
if (res != ACAMERA_OK) {
|
||||
SDL_SetError("Error ACameraDevice_createCaptureSession");
|
||||
goto error;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
return -1;
|
||||
}
|
||||
|
||||
int
|
||||
StopCapture(SDL_VideoCaptureDevice *_this)
|
||||
{
|
||||
ACameraCaptureSession_close(_this->hidden->session);
|
||||
_this->hidden->session = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
|
||||
{
|
||||
media_status_t res;
|
||||
AImage *image;
|
||||
res = AImageReader_acquireNextImage(_this->hidden->reader, &image);
|
||||
/* We could also use this one:
|
||||
res = AImageReader_acquireLatestImage(_this->hidden->reader, &image);
|
||||
*/
|
||||
if (res == AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE ) {
|
||||
|
||||
SDL_Delay(20); // TODO fix some delay
|
||||
#if DEBUG_VIDEO_CAPTURE_CAPTURE
|
||||
// SDL_Log("AImageReader_acquireNextImage: AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE");
|
||||
#endif
|
||||
return 0;
|
||||
} else if (res == AMEDIA_OK ) {
|
||||
int i = 0;
|
||||
int32_t numPlanes = 0;
|
||||
AImage_getNumberOfPlanes(image, &numPlanes);
|
||||
|
||||
frame->timestampNS = SDL_GetTicksNS();
|
||||
|
||||
for (i = 0; i < numPlanes && i < 3; i++) {
|
||||
int dataLength = 0;
|
||||
int rowStride = 0;
|
||||
uint8_t *data = NULL;
|
||||
frame->num_planes += 1;
|
||||
AImage_getPlaneRowStride(image, i, &rowStride);
|
||||
res = AImage_getPlaneData(image, i, &data, &dataLength);
|
||||
if (res == AMEDIA_OK) {
|
||||
frame->data[i] = data;
|
||||
frame->pitch[i] = rowStride;
|
||||
}
|
||||
}
|
||||
|
||||
if (frame->num_planes == 3) {
|
||||
/* plane 2 and 3 are interleaved NV12. SDL only takes two planes for this format */
|
||||
int pixelStride = 0;
|
||||
AImage_getPlanePixelStride(image, 1, &pixelStride);
|
||||
if (pixelStride == 2) {
|
||||
frame->num_planes -= 1;
|
||||
}
|
||||
}
|
||||
|
||||
frame->internal = (void*)image;
|
||||
return 0;
|
||||
} else if (res == AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED) {
|
||||
SDL_SetError("AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED");
|
||||
} else {
|
||||
SDL_SetError("AImageReader_acquireNextImage: %d", res);
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
int
|
||||
ReleaseFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
|
||||
{
|
||||
if (frame->internal){
|
||||
AImage_delete((AImage *)frame->internal);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
GetNumFormats(SDL_VideoCaptureDevice *_this)
|
||||
{
|
||||
camera_status_t res;
|
||||
int i;
|
||||
int unknown = 0;
|
||||
ACameraMetadata *metadata;
|
||||
ACameraMetadata_const_entry entry;
|
||||
|
||||
if (_this->hidden->num_formats != 0) {
|
||||
return _this->hidden->num_formats;
|
||||
}
|
||||
|
||||
res = ACameraManager_getCameraCharacteristics(cameraMgr, _this->dev_name, &metadata);
|
||||
if (res != ACAMERA_OK) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
res = ACameraMetadata_getConstEntry(metadata, ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, &entry);
|
||||
if (res != ACAMERA_OK) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
SDL_Log("got entry ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS");
|
||||
|
||||
for (i = 0; i < entry.count; i += 4) {
|
||||
int32_t format = entry.data.i32[i + 0];
|
||||
int32_t type = entry.data.i32[i + 3];
|
||||
Uint32 fmt;
|
||||
|
||||
if (type == ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT) {
|
||||
continue;
|
||||
}
|
||||
|
||||
fmt = format_android_2_sdl(format);
|
||||
_this->hidden->count_formats[format_2_id(fmt)] += 1;
|
||||
|
||||
#if DEBUG_VIDEO_CAPTURE_CAPTURE
|
||||
if (fmt != SDL_PIXELFORMAT_UNKNOWN) {
|
||||
int w = entry.data.i32[i + 1];
|
||||
int h = entry.data.i32[i + 2];
|
||||
SDL_Log("Got format android 0x%08x -> %s %d x %d", format, SDL_GetPixelFormatName(fmt), w, h);
|
||||
} else {
|
||||
unknown += 1;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
#if DEBUG_VIDEO_CAPTURE_CAPTURE
|
||||
if (unknown) {
|
||||
SDL_Log("Got unknown android");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
if ( _this->hidden->count_formats[0]) _this->hidden->num_formats += 1;
|
||||
if ( _this->hidden->count_formats[1]) _this->hidden->num_formats += 1;
|
||||
if ( _this->hidden->count_formats[2]) _this->hidden->num_formats += 1;
|
||||
if ( _this->hidden->count_formats[3]) _this->hidden->num_formats += 1;
|
||||
if ( _this->hidden->count_formats[4]) _this->hidden->num_formats += 1;
|
||||
if ( _this->hidden->count_formats[5]) _this->hidden->num_formats += 1;
|
||||
|
||||
return _this->hidden->num_formats;
|
||||
}
|
||||
|
||||
int
|
||||
GetFormat(SDL_VideoCaptureDevice *_this, int index, Uint32 *format)
|
||||
{
|
||||
int i;
|
||||
int i2 = 0;
|
||||
|
||||
if (_this->hidden->num_formats == 0) {
|
||||
GetNumFormats(_this);
|
||||
}
|
||||
|
||||
if (index < 0 || index >= _this->hidden->num_formats) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (i = 0; i < SDL_arraysize(_this->hidden->count_formats); i++) {
|
||||
if (_this->hidden->count_formats[i] == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (i2 == index) {
|
||||
*format = id_2_format(i);
|
||||
}
|
||||
|
||||
i2++;
|
||||
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
GetNumFrameSizes(SDL_VideoCaptureDevice *_this, Uint32 format)
|
||||
{
|
||||
int i, i2 = 0, index;
|
||||
if (_this->hidden->num_formats == 0) {
|
||||
GetNumFormats(_this);
|
||||
}
|
||||
|
||||
index = format_2_id(format);
|
||||
|
||||
for (i = 0; i < SDL_arraysize(_this->hidden->count_formats); i++) {
|
||||
if (_this->hidden->count_formats[i] == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (i2 == index) {
|
||||
/* number of resolution for this format */
|
||||
return _this->hidden->count_formats[i];
|
||||
}
|
||||
|
||||
i2++;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
int
|
||||
GetFrameSize(SDL_VideoCaptureDevice *_this, Uint32 format, int index, int *width, int *height)
|
||||
{
|
||||
camera_status_t res;
|
||||
int i, i2 = 0;
|
||||
ACameraMetadata *metadata;
|
||||
ACameraMetadata_const_entry entry;
|
||||
|
||||
if (_this->hidden->num_formats == 0) {
|
||||
GetNumFormats(_this);
|
||||
}
|
||||
|
||||
res = ACameraManager_getCameraCharacteristics(cameraMgr, _this->dev_name, &metadata);
|
||||
if (res != ACAMERA_OK) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
res = ACameraMetadata_getConstEntry(metadata, ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS, &entry);
|
||||
if (res != ACAMERA_OK) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (i = 0; i < entry.count; i += 4) {
|
||||
int32_t f = entry.data.i32[i + 0];
|
||||
int w = entry.data.i32[i + 1];
|
||||
int h = entry.data.i32[i + 2];
|
||||
int32_t type = entry.data.i32[i + 3];
|
||||
Uint32 fmt;
|
||||
|
||||
if (type == ACAMERA_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_INPUT) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
fmt = format_android_2_sdl(f);
|
||||
if (fmt != format) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (i2 == index) {
|
||||
*width = w;
|
||||
*height = h;
|
||||
return 0;
|
||||
}
|
||||
|
||||
i2++;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int GetNumDevices(void);
|
||||
|
||||
int
|
||||
GetDeviceName(SDL_VideoCaptureDeviceID instance_id, char *buf, int size)
|
||||
{
|
||||
int index = instance_id - 1;
|
||||
create_cameraMgr();
|
||||
|
||||
if (cameraIdList == NULL) {
|
||||
GetNumDevices();
|
||||
}
|
||||
|
||||
if (cameraIdList) {
|
||||
if (index >= 0 && index < cameraIdList->numCameras) {
|
||||
SDL_snprintf(buf, size, "%s", cameraIdList->cameraIds[index]);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int
|
||||
GetNumDevices(void)
|
||||
{
|
||||
camera_status_t res;
|
||||
create_cameraMgr();
|
||||
|
||||
if (cameraIdList) {
|
||||
ACameraManager_deleteCameraIdList(cameraIdList);
|
||||
cameraIdList = NULL;
|
||||
}
|
||||
|
||||
res = ACameraManager_getCameraIdList(cameraMgr, &cameraIdList);
|
||||
|
||||
if (res == ACAMERA_OK) {
|
||||
if (cameraIdList) {
|
||||
return cameraIdList->numCameras;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
SDL_VideoCaptureDeviceID *GetVideoCaptureDevices(int *count)
|
||||
{
|
||||
/* hard-coded list of ID */
|
||||
int i;
|
||||
int num = GetNumDevices();
|
||||
SDL_VideoCaptureDeviceID *ret;
|
||||
|
||||
ret = (SDL_VideoCaptureDeviceID *)SDL_malloc((num + 1) * sizeof(*ret));
|
||||
|
||||
if (ret == NULL) {
|
||||
SDL_OutOfMemory();
|
||||
*count = 0;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (i = 0; i < num; i++) {
|
||||
ret[i] = i + 1;
|
||||
}
|
||||
ret[num] = 0;
|
||||
*count = num;
|
||||
return ret;
|
||||
}
|
||||
|
||||
int SDL_SYS_VideoCaptureInit(void) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int SDL_SYS_VideoCaptureQuit(void) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
Reference in New Issue
Block a user