camera: Renamed everything from "video capture" to "camera", wired to CMake.

src/camera/SDL_camera.c

@@ -27,20 +27,18 @@
 #include "../video/SDL_pixels_c.h"
 #include "../thread/SDL_systhread.h"
 
-#define DEBUG_VIDEO_CAPTURE_CAPTURE 0
+#define DEBUG_CAMERA 1
 
-
-#ifdef SDL_VIDEO_CAPTURE
 /* list node entries to share frames between SDL and user app */
 typedef struct entry_t
 {
-    SDL_VideoCaptureFrame frame;
+    SDL_CameraFrame frame;
 } entry_t;
 
-static SDL_VideoCaptureDevice *open_devices[16];
+static SDL_CameraDevice *open_devices[16];
 
 static void
-close_device(SDL_VideoCaptureDevice *device)
+close_device(SDL_CameraDevice *device)
 {
     if (!device) {
         return;
@@ -73,7 +71,7 @@ close_device(SDL_VideoCaptureDevice *device)
         while (device->buffer_queue != NULL) {
             SDL_ListPop(&device->buffer_queue, (void**)&entry);
             if (entry) {
-                SDL_VideoCaptureFrame f = entry->frame;
+                SDL_CameraFrame f = entry->frame;
                 /* Release frames not acquired, if any */
                 if (f.timestampNS) {
                     ReleaseFrame(device, &f);
@@ -109,7 +107,7 @@ SDL_bool check_device_playing(void)
     int i, n = SDL_arraysize(open_devices);
     for (i = 0; i < n; i++) {
         if (open_devices[i]) {
-            if (SDL_GetVideoCaptureStatus(open_devices[i]) == SDL_VIDEO_CAPTURE_PLAYING) {
+            if (SDL_GetCameraStatus(open_devices[i]) == SDL_CAMERA_PLAYING) {
                 return SDL_TRUE;
             }
         }
@@ -117,26 +115,20 @@ SDL_bool check_device_playing(void)
     return SDL_FALSE;
 }
 
-
-#endif /* SDL_VIDEO_CAPTURE */
-
 void
-SDL_CloseVideoCapture(SDL_VideoCaptureDevice *device)
+SDL_CloseCamera(SDL_CameraDevice *device)
 {
-#ifdef SDL_VIDEO_CAPTURE
     if (!device) {
         SDL_InvalidParamError("device");
         return;
     }
     close_device(device);
-#endif
 }
 
 int
-SDL_StartVideoCapture(SDL_VideoCaptureDevice *device)
+SDL_StartCamera(SDL_CameraDevice *device)
 {
-#ifdef SDL_VIDEO_CAPTURE
-    SDL_VideoCaptureStatus status;
+    SDL_CameraStatus status;
     int result;
     if (!device) {
         return SDL_InvalidParamError("device");
@@ -146,12 +138,12 @@ SDL_StartVideoCapture(SDL_VideoCaptureDevice *device)
         return SDL_SetError("no spec set");
     }
 
-    status = SDL_GetVideoCaptureStatus(device);
-    if (status != SDL_VIDEO_CAPTURE_INIT) {
+    status = SDL_GetCameraStatus(device);
+    if (status != SDL_CAMERA_INIT) {
         return SDL_SetError("invalid state");
     }
 
-    result = StartCapture(device);
+    result = StartCamera(device);
     if (result < 0) {
         return result;
     }
@@ -159,15 +151,11 @@ SDL_StartVideoCapture(SDL_VideoCaptureDevice *device)
     SDL_AtomicSet(&device->enabled, 1);
 
     return 0;
-#else
-    return SDL_Unsupported();
-#endif
 }
 
 int
-SDL_GetVideoCaptureSpec(SDL_VideoCaptureDevice *device, SDL_VideoCaptureSpec *spec)
+SDL_GetCameraSpec(SDL_CameraDevice *device, SDL_CameraSpec *spec)
 {
-#ifdef SDL_VIDEO_CAPTURE
     if (!device) {
         return SDL_InvalidParamError("device");
     }
@@ -179,24 +167,20 @@ SDL_GetVideoCaptureSpec(SDL_VideoCaptureDevice *device, SDL_VideoCaptureSpec *sp
     SDL_zerop(spec);
 
     return GetDeviceSpec(device, spec);
-#else
-    return SDL_Unsupported();
-#endif
 }
 
 int
-SDL_StopVideoCapture(SDL_VideoCaptureDevice *device)
+SDL_StopCamera(SDL_CameraDevice *device)
 {
-#ifdef SDL_VIDEO_CAPTURE
-    SDL_VideoCaptureStatus status;
+    SDL_CameraStatus status;
     int ret;
     if (!device) {
         return SDL_InvalidParamError("device");
     }
 
-    status = SDL_GetVideoCaptureStatus(device);
+    status = SDL_GetCameraStatus(device);
 
-    if (status != SDL_VIDEO_CAPTURE_PLAYING) {
+    if (status != SDL_CAMERA_PLAYING) {
         return SDL_SetError("invalid state");
     }
 
@@ -204,7 +188,7 @@ SDL_StopVideoCapture(SDL_VideoCaptureDevice *device)
     SDL_AtomicSet(&device->shutdown, 1);
 
     SDL_LockMutex(device->acquiring_lock);
-    ret = StopCapture(device);
+    ret = StopCamera(device);
     SDL_UnlockMutex(device->acquiring_lock);
 
     if (ret < 0) {
@@ -212,25 +196,20 @@ SDL_StopVideoCapture(SDL_VideoCaptureDevice *device)
     }
 
     return 0;
-#else
-    return SDL_Unsupported();
-#endif
 }
 
-#ifdef SDL_VIDEO_CAPTURE
-
 /* Check spec has valid format and frame size */
 static int
-prepare_video_capturespec(SDL_VideoCaptureDevice *device, const SDL_VideoCaptureSpec *desired, SDL_VideoCaptureSpec *obtained, int allowed_changes)
+prepare_cameraspec(SDL_CameraDevice *device, const SDL_CameraSpec *desired, SDL_CameraSpec *obtained, int allowed_changes)
 {
     /* Check format */
     {
-        int i, num = SDL_GetNumVideoCaptureFormats(device);
+        int i, num = SDL_GetNumCameraFormats(device);
         int is_format_valid = 0;
 
         for (i = 0; i < num; i++) {
             Uint32 format;
-            if (SDL_GetVideoCaptureFormat(device, i, &format) == 0) {
+            if (SDL_GetCameraFormat(device, i, &format) == 0) {
                 if (format == desired->format && format != SDL_PIXELFORMAT_UNKNOWN) {
                     is_format_valid = 1;
                     obtained->format = format;
@@ -243,7 +222,7 @@ prepare_video_capturespec(SDL_VideoCaptureDevice *device, const SDL_VideoCapture
             if (allowed_changes) {
                 for (i = 0; i < num; i++) {
                     Uint32 format;
-                    if (SDL_GetVideoCaptureFormat(device, i, &format) == 0) {
+                    if (SDL_GetCameraFormat(device, i, &format) == 0) {
                         if (format != SDL_PIXELFORMAT_UNKNOWN) {
                             obtained->format = format;
                             is_format_valid = 1;
@@ -266,12 +245,12 @@ prepare_video_capturespec(SDL_VideoCaptureDevice *device, const SDL_VideoCapture
 
     /* Check frame size */
     {
-        int i, num = SDL_GetNumVideoCaptureFrameSizes(device, obtained->format);
+        int i, num = SDL_GetNumCameraFrameSizes(device, obtained->format);
         int is_framesize_valid = 0;
 
         for (i = 0; i < num; i++) {
             int w, h;
-            if (SDL_GetVideoCaptureFrameSize(device, obtained->format, i, &w, &h) == 0) {
+            if (SDL_GetCameraFrameSize(device, obtained->format, i, &w, &h) == 0) {
                 if (desired->width == w && desired->height == h) {
                     is_framesize_valid = 1;
                     obtained->width = w;
@@ -284,7 +263,7 @@ prepare_video_capturespec(SDL_VideoCaptureDevice *device, const SDL_VideoCapture
         if (!is_framesize_valid) {
             if (allowed_changes) {
                 int w, h;
-                if (SDL_GetVideoCaptureFrameSize(device, obtained->format, 0, &w, &h) == 0) {
+                if (SDL_GetCameraFrameSize(device, obtained->format, 0, &w, &h) == 0) {
                     is_framesize_valid = 1;
                     obtained->width = w;
                     obtained->height = h;
@@ -305,12 +284,9 @@ prepare_video_capturespec(SDL_VideoCaptureDevice *device, const SDL_VideoCapture
     return 0;
 }
 
-#endif /* SDL_VIDEO_CAPTURE */
-
 const char *
-SDL_GetVideoCaptureDeviceName(SDL_VideoCaptureDeviceID instance_id)
+SDL_GetCameraDeviceName(SDL_CameraDeviceID instance_id)
 {
-#ifdef SDL_VIDEO_CAPTURE
     static char buf[256];
     buf[0] = 0;
     buf[255] = 0;
@@ -320,26 +296,19 @@ SDL_GetVideoCaptureDeviceName(SDL_VideoCaptureDeviceID instance_id)
         return NULL;
     }
 
-    if (GetDeviceName(instance_id, buf, sizeof (buf)) < 0) {
+    if (GetCameraDeviceName(instance_id, buf, sizeof (buf)) < 0) {
         buf[0] = 0;
     }
     return buf;
-#else
-    SDL_Unsupported();
-    return NULL;
-#endif
 }
 
 
-SDL_VideoCaptureDeviceID *
-SDL_GetVideoCaptureDevices(int *count)
+SDL_CameraDeviceID *
+SDL_GetCameraDevices(int *count)
 {
 
     int num = 0;
-    SDL_VideoCaptureDeviceID *ret = NULL;
-#ifdef SDL_VIDEO_CAPTURE
-    ret = GetVideoCaptureDevices(&num);
-#endif
+    SDL_CameraDeviceID *ret = GetCameraDevices(&num);
 
     if (ret) {
         if (count) {
@@ -350,7 +319,7 @@ SDL_GetVideoCaptureDevices(int *count)
 
     /* return list of 0 ID, null terminated */
     num = 0;
-    ret = (SDL_VideoCaptureDeviceID *)SDL_malloc((num + 1) * sizeof(*ret));
+    ret = (SDL_CameraDeviceID *)SDL_malloc((num + 1) * sizeof(*ret));
 
     if (ret == NULL) {
         SDL_OutOfMemory();
@@ -368,17 +337,15 @@ SDL_GetVideoCaptureDevices(int *count)
     return ret;
 }
 
-#ifdef SDL_VIDEO_CAPTURE
-
-/* Video capture thread function */
+/* Camera thread function */
 static int SDLCALL
-SDL_CaptureVideoThread(void *devicep)
+SDL_CameraThread(void *devicep)
 {
     const int delay = 20;
-    SDL_VideoCaptureDevice *device = (SDL_VideoCaptureDevice *) devicep;
+    SDL_CameraDevice *device = (SDL_CameraDevice *) devicep;
 
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
-    SDL_Log("Start thread 'SDL_CaptureVideo'");
+#if DEBUG_CAMERA
+    SDL_Log("Start thread 'SDL_CameraThread'");
 #endif
 
 
@@ -387,11 +354,11 @@ SDL_CaptureVideoThread(void *devicep)
     /*
     {
         // Set thread priority to THREAD_PRIORITY_VIDEO
-        extern void Android_JNI_VideoCaptureSetThreadPriority(int, int);
-        Android_JNI_VideoCaptureSetThreadPriority(device->iscapture, device);
+        extern void Android_JNI_CameraSetThreadPriority(int, int);
+        Android_JNI_CameraSetThreadPriority(device->iscapture, device);
     }*/
 #else
-    /* The video_capture mixing is always a high priority thread */
+    /* The camera capture is always a high priority thread */
     SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);
 #endif
 
@@ -403,9 +370,9 @@ SDL_CaptureVideoThread(void *devicep)
         SDL_Delay(delay);
     }
 
-    /* Loop, filling the video_capture buffers */
+    /* Loop, filling the camera buffers */
     while (!SDL_AtomicGet(&device->shutdown)) {
-        SDL_VideoCaptureFrame f;
+        SDL_CameraFrame f;
         int ret;
         entry_t *entry;
 
@@ -423,7 +390,7 @@ SDL_CaptureVideoThread(void *devicep)
 
         if (ret < 0) {
             /* Flag it as an error */
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
+#if DEBUG_CAMERA
             SDL_Log("dev[%p] error AcquireFrame: %d %s", (void *)device, ret, SDL_GetError());
 #endif
             f.num_planes = 0;
@@ -447,28 +414,26 @@ SDL_CaptureVideoThread(void *devicep)
         }
     }
 
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
-    SDL_Log("dev[%p] End thread 'SDL_CaptureVideo'", (void *)device);
+#if DEBUG_CAMERA
+    SDL_Log("dev[%p] End thread 'SDL_CameraThread'", (void *)device);
 #endif
     return 0;
 
 error_mem:
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
-    SDL_Log("dev[%p] End thread 'SDL_CaptureVideo' with error: %s", (void *)device, SDL_GetError());
+#if DEBUG_CAMERA
+    SDL_Log("dev[%p] End thread 'SDL_CameraThread' with error: %s", (void *)device, SDL_GetError());
 #endif
     SDL_AtomicSet(&device->shutdown, 1);
     SDL_OutOfMemory();
     return 0;
 }
-#endif
 
-SDL_VideoCaptureDevice *
-SDL_OpenVideoCapture(SDL_VideoCaptureDeviceID instance_id)
+SDL_CameraDevice *
+SDL_OpenCamera(SDL_CameraDeviceID instance_id)
 {
-#ifdef SDL_VIDEO_CAPTURE
     int i, n = SDL_arraysize(open_devices);
     int id = -1;
-    SDL_VideoCaptureDevice *device = NULL;
+    SDL_CameraDevice *device = NULL;
     const char *device_name = NULL;
 
     if (!SDL_WasInit(SDL_INIT_VIDEO)) {
@@ -486,19 +451,19 @@ SDL_OpenVideoCapture(SDL_VideoCaptureDeviceID instance_id)
     }
 
     if (id == -1) {
-        SDL_SetError("Too many open video capture devices");
+        SDL_SetError("Too many open camera devices");
         goto error;
     }
 
     if (instance_id != 0) {
-        device_name = SDL_GetVideoCaptureDeviceName(instance_id);
+        device_name = SDL_GetCameraDeviceName(instance_id);
         if (device_name == NULL) {
             goto error;
         }
     } else {
-        SDL_VideoCaptureDeviceID *devices = SDL_GetVideoCaptureDevices(NULL);
+        SDL_CameraDeviceID *devices = SDL_GetCameraDevices(NULL);
         if (devices && devices[0]) {
-            device_name = SDL_GetVideoCaptureDeviceName(devices[0]);
+            device_name = SDL_GetCameraDeviceName(devices[0]);
             SDL_free(devices);
         }
     }
@@ -507,7 +472,7 @@ SDL_OpenVideoCapture(SDL_VideoCaptureDeviceID instance_id)
     // FIXME do we need this ?
     /* Let the user override. */
     {
-        const char *dev = SDL_getenv("SDL_VIDEO_CAPTURE_DEVICE_NAME");
+        const char *dev = SDL_getenv("SDL_CAMERA_DEVICE_NAME");
         if (dev && dev[0]) {
             device_name = dev;
         }
@@ -518,7 +483,7 @@ SDL_OpenVideoCapture(SDL_VideoCaptureDeviceID instance_id)
         goto error;
     }
 
-    device = (SDL_VideoCaptureDevice *) SDL_calloc(1, sizeof (SDL_VideoCaptureDevice));
+    device = (SDL_CameraDevice *) SDL_calloc(1, sizeof (SDL_CameraDevice));
     if (device == NULL) {
         SDL_OutOfMemory();
         goto error;
@@ -550,16 +515,16 @@ SDL_OpenVideoCapture(SDL_VideoCaptureDeviceID instance_id)
     open_devices[id] = device;  /* add it to our list of open devices. */
 
 
-    /* Start the video_capture thread */
+    /* Start the camera thread */
     {
         const size_t stacksize = 64 * 1024;
         char threadname[64];
 
-        SDL_snprintf(threadname, sizeof (threadname), "SDLVideoC%d", id);
-        device->thread = SDL_CreateThreadInternal(SDL_CaptureVideoThread, threadname, stacksize, device);
+        SDL_snprintf(threadname, sizeof (threadname), "SDLCamera%d", id);
+        device->thread = SDL_CreateThreadInternal(SDL_CameraThread, threadname, stacksize, device);
 
         if (device->thread == NULL) {
-            SDL_SetError("Couldn't create video_capture thread");
+            SDL_SetError("Couldn't create camera thread");
             goto error;
         }
     }
@@ -569,21 +534,16 @@ SDL_OpenVideoCapture(SDL_VideoCaptureDeviceID instance_id)
 error:
     close_device(device);
     return NULL;
-#else
-    SDL_Unsupported();
-    return NULL;
-#endif /* SDL_VIDEO_CAPTURE */
 }
 
 int
-SDL_SetVideoCaptureSpec(SDL_VideoCaptureDevice *device,
-        const SDL_VideoCaptureSpec *desired,
-        SDL_VideoCaptureSpec *obtained,
+SDL_SetCameraSpec(SDL_CameraDevice *device,
+        const SDL_CameraSpec *desired,
+        SDL_CameraSpec *obtained,
         int allowed_changes)
 {
-#ifdef SDL_VIDEO_CAPTURE
-    SDL_VideoCaptureSpec _obtained;
-    SDL_VideoCaptureSpec _desired;
+    SDL_CameraSpec _obtained;
+    SDL_CameraSpec _desired;
     int result;
 
     if (!device) {
@@ -597,7 +557,7 @@ SDL_SetVideoCaptureSpec(SDL_VideoCaptureDevice *device,
     if (!desired) {
         SDL_zero(_desired);
         desired = &_desired;
-        allowed_changes = SDL_VIDEO_CAPTURE_ALLOW_ANY_CHANGE;
+        allowed_changes = SDL_CAMERA_ALLOW_ANY_CHANGE;
     } else {
         /* in case desired == obtained */
         _desired = *desired;
@@ -610,7 +570,7 @@ SDL_SetVideoCaptureSpec(SDL_VideoCaptureDevice *device,
 
     SDL_zerop(obtained);
 
-    if (prepare_video_capturespec(device, desired, obtained, allowed_changes) < 0) {
+    if (prepare_cameraspec(device, desired, obtained, allowed_changes) < 0) {
         return -1;
     }
 
@@ -626,16 +586,11 @@ SDL_SetVideoCaptureSpec(SDL_VideoCaptureDevice *device,
     device->is_spec_set = SDL_TRUE;
 
     return 0;
-#else
-    SDL_zero(*obtained);
-    return SDL_Unsupported();
-#endif /* SDL_VIDEO_CAPTURE */
 }
 
 int
-SDL_AcquireVideoCaptureFrame(SDL_VideoCaptureDevice *device, SDL_VideoCaptureFrame *frame)
+SDL_AcquireCameraFrame(SDL_CameraDevice *device, SDL_CameraFrame *frame)
 {
-#ifdef SDL_VIDEO_CAPTURE
     if (!device) {
         return SDL_InvalidParamError("device");
     }
@@ -679,15 +634,11 @@ SDL_AcquireVideoCaptureFrame(SDL_VideoCaptureDevice *device, SDL_VideoCaptureFra
     }
 
     return 0;
-#else
-    return SDL_Unsupported();
-#endif /* SDL_VIDEO_CAPTURE */
 }
 
 int
-SDL_ReleaseVideoCaptureFrame(SDL_VideoCaptureDevice *device, SDL_VideoCaptureFrame *frame)
+SDL_ReleaseCameraFrame(SDL_CameraDevice *device, SDL_CameraFrame *frame)
 {
-#ifdef SDL_VIDEO_CAPTURE
     if (!device) {
         return SDL_InvalidParamError("device");
     }
@@ -703,28 +654,20 @@ SDL_ReleaseVideoCaptureFrame(SDL_VideoCaptureDevice *device, SDL_VideoCaptureFra
     SDL_zerop(frame);
 
     return 0;
-#else
-    return SDL_Unsupported();
-#endif /* SDL_VIDEO_CAPTURE */
 }
 
 int
-SDL_GetNumVideoCaptureFormats(SDL_VideoCaptureDevice *device)
+SDL_GetNumCameraFormats(SDL_CameraDevice *device)
 {
-#ifdef SDL_VIDEO_CAPTURE
     if (!device) {
         return SDL_InvalidParamError("device");
     }
     return GetNumFormats(device);
-#else
-    return 0;
-#endif /* SDL_VIDEO_CAPTURE */
 }
 
 int
-SDL_GetVideoCaptureFormat(SDL_VideoCaptureDevice *device, int index, Uint32 *format)
+SDL_GetCameraFormat(SDL_CameraDevice *device, int index, Uint32 *format)
 {
-#ifdef SDL_VIDEO_CAPTURE
     if (!device) {
         return SDL_InvalidParamError("device");
     }
@@ -733,28 +676,20 @@ SDL_GetVideoCaptureFormat(SDL_VideoCaptureDevice *device, int index, Uint32 *for
     }
     *format = 0;
     return GetFormat(device, index, format);
-#else
-    return SDL_Unsupported();
-#endif /* SDL_VIDEO_CAPTURE */
 }
 
 int
-SDL_GetNumVideoCaptureFrameSizes(SDL_VideoCaptureDevice *device, Uint32 format)
+SDL_GetNumCameraFrameSizes(SDL_CameraDevice *device, Uint32 format)
 {
-#ifdef SDL_VIDEO_CAPTURE
     if (!device) {
         return SDL_InvalidParamError("device");
     }
     return GetNumFrameSizes(device, format);
-#else
-    return 0;
-#endif /* SDL_VIDEO_CAPTURE */
 }
 
 int
-SDL_GetVideoCaptureFrameSize(SDL_VideoCaptureDevice *device, Uint32 format, int index, int *width, int *height)
+SDL_GetCameraFrameSize(SDL_CameraDevice *device, Uint32 format, int index, int *width, int *height)
 {
-#ifdef SDL_VIDEO_CAPTURE
     if (!device) {
         return SDL_InvalidParamError("device");
     }
@@ -767,79 +702,61 @@ SDL_GetVideoCaptureFrameSize(SDL_VideoCaptureDevice *device, Uint32 format, int
     *width = 0;
     *height = 0;
     return GetFrameSize(device, format, index, width, height);
-#else
-    return SDL_Unsupported();
-#endif
 }
 
-SDL_VideoCaptureDevice *
-SDL_OpenVideoCaptureWithSpec(
-        SDL_VideoCaptureDeviceID instance_id,
-        const SDL_VideoCaptureSpec *desired,
-        SDL_VideoCaptureSpec *obtained,
+SDL_CameraDevice *
+SDL_OpenCameraWithSpec(
+        SDL_CameraDeviceID instance_id,
+        const SDL_CameraSpec *desired,
+        SDL_CameraSpec *obtained,
         int allowed_changes)
 {
-#ifdef SDL_VIDEO_CAPTURE
-    SDL_VideoCaptureDevice *device;
+    SDL_CameraDevice *device;
 
-    if ((device = SDL_OpenVideoCapture(instance_id)) == NULL) {
+    if ((device = SDL_OpenCamera(instance_id)) == NULL) {
         return NULL;
     }
 
-    if (SDL_SetVideoCaptureSpec(device, desired, obtained, allowed_changes) < 0) {
-        SDL_CloseVideoCapture(device);
+    if (SDL_SetCameraSpec(device, desired, obtained, allowed_changes) < 0) {
+        SDL_CloseCamera(device);
         return NULL;
     }
     return device;
-#else
-    SDL_Unsupported();
-    return NULL;
-#endif
 }
 
-SDL_VideoCaptureStatus
-SDL_GetVideoCaptureStatus(SDL_VideoCaptureDevice *device)
+SDL_CameraStatus
+SDL_GetCameraStatus(SDL_CameraDevice *device)
 {
-#ifdef SDL_VIDEO_CAPTURE
     if (device == NULL) {
-        return SDL_VIDEO_CAPTURE_INIT;
+        return SDL_CAMERA_INIT;
     }
 
     if (device->is_spec_set == SDL_FALSE) {
-        return SDL_VIDEO_CAPTURE_INIT;
+        return SDL_CAMERA_INIT;
     }
 
     if (SDL_AtomicGet(&device->shutdown)) {
-        return SDL_VIDEO_CAPTURE_STOPPED;
+        return SDL_CAMERA_STOPPED;
     }
 
     if (SDL_AtomicGet(&device->enabled)) {
-        return SDL_VIDEO_CAPTURE_PLAYING;
+        return SDL_CAMERA_PLAYING;
     }
-    return SDL_VIDEO_CAPTURE_INIT;
-#else
-    SDL_Unsupported();
-    return SDL_VIDEO_CAPTURE_FAIL;
-#endif
+    return SDL_CAMERA_INIT;
 }
 
 int
-SDL_VideoCaptureInit(void)
+SDL_CameraInit(void)
 {
-#ifdef SDL_VIDEO_CAPTURE
     SDL_zeroa(open_devices);
 
-    SDL_SYS_VideoCaptureInit();
+    SDL_SYS_CameraInit();
     return 0;
-#else
-    return 0;
-#endif
 }
 
 void
-SDL_QuitVideoCapture(void)
+SDL_QuitCamera(void)
 {
-#ifdef SDL_VIDEO_CAPTURE
     int i, n = SDL_arraysize(open_devices);
     for (i = 0; i < n; i++) {
         close_device(open_devices[i]);
@@ -847,122 +764,6 @@ SDL_QuitVideoCapture(void)
 
     SDL_zeroa(open_devices);
 
-    SDL_SYS_VideoCaptureQuit();
-#endif
+    SDL_SYS_CameraQuit();
 }
 
-#ifdef SDL_VIDEO_CAPTURE
-
-#if defined(SDL_PLATFORM_LINUX) && !defined(SDL_PLATFORM_ANDROID)
-
-/* See SDL_video_capture_v4l2.c */
-
-#elif defined(SDL_PLATFORM_ANDROID) && __ANDROID_API__ >= 24
-
-/* See SDL_android_video_capture.c */
-
-#elif defined(SDL_PLATFORM_IOS) || defined(SDL_PLATFORM_MACOS)
-
-/* See SDL_video_capture_apple.m */
-#else
-
-int SDL_SYS_VideoCaptureInit(void)
-{
-    return 0;
-}
-
-int SDL_SYS_VideoCaptureQuit(void)
-{
-    return 0;
-}
-
-int
-OpenDevice(SDL_VideoCaptureDevice *_this)
-{
-    return SDL_SetError("not implemented");
-}
-
-void
-CloseDevice(SDL_VideoCaptureDevice *_this)
-{
-    return;
-}
-
-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 -1;
-}
-
-int
-GetDeviceSpec(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureSpec *spec)
-{
-    return SDL_Unsupported();
-}
-
-int
-StartCapture(SDL_VideoCaptureDevice *_this)
-{
-    return SDL_Unsupported();
-}
-
-int
-StopCapture(SDL_VideoCaptureDevice *_this)
-{
-    return -1;
-}
-
-int
-AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
-{
-    return -1;
-}
-
-int
-ReleaseFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
-{
-    return -1;
-}
-
-int
-GetNumFormats(SDL_VideoCaptureDevice *_this)
-{
-    return -1;
-}
-
-int
-GetFormat(SDL_VideoCaptureDevice *_this, int index, Uint32 *format)
-{
-    return -1;
-}
-
-int
-GetNumFrameSizes(SDL_VideoCaptureDevice *_this, Uint32 format)
-{
-    return -1;
-}
-
-int
-GetFrameSize(SDL_VideoCaptureDevice *_this, Uint32 format, int index, int *width, int *height)
-{
-    return -1;
-}
-
-int
-GetDeviceName(SDL_VideoCaptureDeviceID instance_id, char *buf, int size)
-{
-    return -1;
-}
-
-SDL_VideoCaptureDeviceID *
-GetVideoCaptureDevices(int *count)
-{
-    return NULL;
-}
-
-#endif
-
-#endif /* SDL_VIDEO_CAPTURE */

src/camera/SDL_camera_c.h

@@ -19,15 +19,14 @@
   3. This notice may not be removed or altered from any source distribution.
 */
 #include "../SDL_internal.h"
-#include "../../include/SDL3/SDL_camera.h"
 
-#ifndef SDL_video_capture_c_h_
-#define SDL_video_capture_c_h_
+#ifndef SDL_camera_c_h_
+#define SDL_camera_c_h_
 
-/* Initialize the video_capture subsystem */
-int SDL_VideoCaptureInit(void);
+/* Initialize the camera subsystem */
+int SDL_CameraInit(void);
 
-/* Shutdown the video_capture subsystem */
-void SDL_QuitVideoCapture(void);
+/* Shutdown the camera subsystem */
+void SDL_QuitCamera(void);
 
-#endif /* SDL_video_capture_c_h_ */
+#endif /* SDL_camera_c_h_ */

src/camera/SDL_syscamera.h

@@ -20,22 +20,22 @@
 */
 #include "../SDL_internal.h"
 
-#ifndef SDL_sysvideocapture_h_
-#define SDL_sysvideocapture_h_
+#ifndef SDL_syscamera_h_
+#define SDL_syscamera_h_
 
 #include "../SDL_list.h"
 
-/* The SDL video_capture driver */
-typedef struct SDL_VideoCaptureDevice SDL_VideoCaptureDevice;
+/* The SDL camera driver */
+typedef struct SDL_CameraDevice SDL_CameraDevice;
 
-/* Define the SDL video_capture driver structure */
-struct SDL_VideoCaptureDevice
+/* Define the SDL camera driver structure */
+struct SDL_CameraDevice
 {
     /* * * */
     /* Data common to all devices */
 
-    /* The device's current video_capture specification */
-    SDL_VideoCaptureSpec spec;
+    /* The device's current camera specification */
+    SDL_CameraSpec spec;
 
     /* Device name */
     char *dev_name;
@@ -49,7 +49,7 @@ struct SDL_VideoCaptureDevice
     SDL_Mutex *device_lock;
     SDL_Mutex *acquiring_lock;
 
-    /* A thread to feed the video_capture device */
+    /* A thread to feed the camera device */
     SDL_Thread *thread;
     SDL_ThreadID threadid;
 
@@ -58,35 +58,35 @@ struct SDL_VideoCaptureDevice
 
     /* * * */
     /* Data private to this driver */
-    struct SDL_PrivateVideoCaptureData *hidden;
+    struct SDL_PrivateCameraData *hidden;
 };
 
-extern int SDL_SYS_VideoCaptureInit(void);
-extern int SDL_SYS_VideoCaptureQuit(void);
+extern int SDL_SYS_CameraInit(void);
+extern int SDL_SYS_CameraQuit(void);
 
-extern int OpenDevice(SDL_VideoCaptureDevice *_this);
-extern void CloseDevice(SDL_VideoCaptureDevice *_this);
+extern int OpenDevice(SDL_CameraDevice *_this);
+extern void CloseDevice(SDL_CameraDevice *_this);
 
-extern int InitDevice(SDL_VideoCaptureDevice *_this);
+extern int InitDevice(SDL_CameraDevice *_this);
 
-extern int GetDeviceSpec(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureSpec *spec);
+extern int GetDeviceSpec(SDL_CameraDevice *_this, SDL_CameraSpec *spec);
 
-extern int StartCapture(SDL_VideoCaptureDevice *_this);
-extern int StopCapture(SDL_VideoCaptureDevice *_this);
+extern int StartCamera(SDL_CameraDevice *_this);
+extern int StopCamera(SDL_CameraDevice *_this);
 
-extern int AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame);
-extern int ReleaseFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame);
+extern int AcquireFrame(SDL_CameraDevice *_this, SDL_CameraFrame *frame);
+extern int ReleaseFrame(SDL_CameraDevice *_this, SDL_CameraFrame *frame);
 
-extern int GetNumFormats(SDL_VideoCaptureDevice *_this);
-extern int GetFormat(SDL_VideoCaptureDevice *_this, int index, Uint32 *format);
+extern int GetNumFormats(SDL_CameraDevice *_this);
+extern int GetFormat(SDL_CameraDevice *_this, int index, Uint32 *format);
 
-extern int GetNumFrameSizes(SDL_VideoCaptureDevice *_this, Uint32 format);
-extern int GetFrameSize(SDL_VideoCaptureDevice *_this, Uint32 format, int index, int *width, int *height);
+extern int GetNumFrameSizes(SDL_CameraDevice *_this, Uint32 format);
+extern int GetFrameSize(SDL_CameraDevice *_this, Uint32 format, int index, int *width, int *height);
 
-extern int GetDeviceName(SDL_VideoCaptureDeviceID instance_id, char *buf, int size);
-extern SDL_VideoCaptureDeviceID *GetVideoCaptureDevices(int *count);
+extern int GetCameraDeviceName(SDL_CameraDeviceID instance_id, char *buf, int size);
+extern SDL_CameraDeviceID *GetCameraDevices(int *count);
 
 extern SDL_bool check_all_device_closed(void);
 extern SDL_bool check_device_playing(void);
 
-#endif /* SDL_sysvideocapture_h_ */
+#endif /* SDL_syscamera_h_ */

src/camera/android/SDL_camera_android.c

@@ -20,16 +20,14 @@
 */
 #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 "../SDL_syscamera.h"
+#include "../SDL_camera_c.h"
+#include "../../video/SDL_pixels_c.h"
 #include "../../thread/SDL_systhread.h"
 
-#define DEBUG_VIDEO_CAPTURE_CAPTURE 0
+#define DEBUG_CAMERA 1
 
-#if defined(SDL_PLATFORM_ANDROID) && __ANDROID_API__ >= 24
+#if defined(SDL_CAMERA_ANDROID) && __ANDROID_API__ >= 24
 
 /*
  * APP_PLATFORM=android-24
@@ -42,7 +40,7 @@
  *   <uses-feature android:name="android.hardware.camera" />
  *
  *
- * Add: #define SDL_VIDEO_CAPTURE 1
+ * Add: #define SDL_CAMERA 1
  * in:  include/build_config/SDL_build_config_android.h
  *
  *
@@ -97,7 +95,7 @@ delete_cameraMgr(void)
     }
 }
 
-struct SDL_PrivateVideoCaptureData
+struct SDL_PrivateCameraData
 {
     ACameraDevice *device;
     ACameraCaptureSession *session;
@@ -186,14 +184,14 @@ format_sdl_2_android(Uint32 fmt)
 static void
 onDisconnected(void *context, ACameraDevice *device)
 {
-    // SDL_VideoCaptureDevice *_this = (SDL_VideoCaptureDevice *) context;
+    // SDL_CameraDevice *_this = (SDL_CameraDevice *) context;
     SDL_Log("CB onDisconnected");
 }
 
 static void
 onError(void *context, ACameraDevice *device, int error)
 {
-    // SDL_VideoCaptureDevice *_this = (SDL_VideoCaptureDevice *) context;
+    // SDL_CameraDevice *_this = (SDL_CameraDevice *) context;
     SDL_Log("CB onError");
 }
 
@@ -201,26 +199,26 @@ onError(void *context, ACameraDevice *device, int error)
 static void
 onClosed(void* context, ACameraCaptureSession *session)
 {
-    // SDL_VideoCaptureDevice *_this = (SDL_VideoCaptureDevice *) context;
+    // SDL_CameraDevice *_this = (SDL_CameraDevice *) context;
     SDL_Log("CB onClosed");
 }
 
 static void
 onReady(void* context, ACameraCaptureSession *session)
 {
-    // SDL_VideoCaptureDevice *_this = (SDL_VideoCaptureDevice *) context;
+    // SDL_CameraDevice *_this = (SDL_CameraDevice *) context;
     SDL_Log("CB onReady");
 }
 
 static void
 onActive(void* context, ACameraCaptureSession *session)
 {
-    // SDL_VideoCaptureDevice *_this = (SDL_VideoCaptureDevice *) context;
+    // SDL_CameraDevice *_this = (SDL_CameraDevice *) context;
     SDL_Log("CB onActive");
 }
 
 int
-OpenDevice(SDL_VideoCaptureDevice *_this)
+OpenDevice(SDL_CameraDevice *_this)
 {
     camera_status_t res;
 
@@ -236,7 +234,7 @@ OpenDevice(SDL_VideoCaptureDevice *_this)
         return SDL_SetError("A camera is already playing");
     }
 
-    _this->hidden = (struct SDL_PrivateVideoCaptureData *) SDL_calloc(1, sizeof (struct SDL_PrivateVideoCaptureData));
+    _this->hidden = (struct SDL_PrivateCameraData *) SDL_calloc(1, sizeof (struct SDL_PrivateCameraData));
     if (_this->hidden == NULL) {
         return SDL_OutOfMemory();
     }
@@ -256,7 +254,7 @@ OpenDevice(SDL_VideoCaptureDevice *_this)
 }
 
 void
-CloseDevice(SDL_VideoCaptureDevice *_this)
+CloseDevice(SDL_CameraDevice *_this)
 {
     if (_this && _this->hidden) {
         if (_this->hidden->session) {
@@ -286,7 +284,7 @@ CloseDevice(SDL_VideoCaptureDevice *_this)
 }
 
 int
-InitDevice(SDL_VideoCaptureDevice *_this)
+InitDevice(SDL_CameraDevice *_this)
 {
     size_t size, pitch;
     SDL_CalculateSize(_this->spec.format, _this->spec.width, _this->spec.height, &size, &pitch, SDL_FALSE);
@@ -295,7 +293,7 @@ InitDevice(SDL_VideoCaptureDevice *_this)
 }
 
 int
-GetDeviceSpec(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureSpec *spec)
+GetDeviceSpec(SDL_CameraDevice *_this, SDL_CameraSpec *spec)
 {
     if (spec) {
         *spec = _this->spec;
@@ -305,7 +303,7 @@ GetDeviceSpec(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureSpec *spec)
 }
 
 int
-StartCapture(SDL_VideoCaptureDevice *_this)
+StartCamera(SDL_CameraDevice *_this)
 {
     camera_status_t res;
     media_status_t res2;
@@ -391,7 +389,7 @@ error:
 }
 
 int
-StopCapture(SDL_VideoCaptureDevice *_this)
+StopCamera(SDL_CameraDevice *_this)
 {
     ACameraCaptureSession_close(_this->hidden->session);
     _this->hidden->session = NULL;
@@ -399,7 +397,7 @@ StopCapture(SDL_VideoCaptureDevice *_this)
 }
 
 int
-AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
+AcquireFrame(SDL_CameraDevice *_this, SDL_CameraFrame *frame)
 {
     media_status_t res;
     AImage *image;
@@ -410,7 +408,7 @@ AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
     if (res == AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE ) {
 
         SDL_Delay(20); // TODO fix some delay
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
+#if DEBUG_CAMERA
 //        SDL_Log("AImageReader_acquireNextImage: AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE");
 #endif
         return 0;
@@ -455,7 +453,7 @@ AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
 }
 
 int
-ReleaseFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
+ReleaseFrame(SDL_CameraDevice *_this, SDL_CameraFrame *frame)
 {
     if (frame->internal){
         AImage_delete((AImage *)frame->internal);
@@ -464,7 +462,7 @@ ReleaseFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
 }
 
 int
-GetNumFormats(SDL_VideoCaptureDevice *_this)
+GetNumFormats(SDL_CameraDevice *_this)
 {
     camera_status_t res;
     int i;
@@ -500,7 +498,7 @@ GetNumFormats(SDL_VideoCaptureDevice *_this)
         fmt = format_android_2_sdl(format);
         _this->hidden->count_formats[format_2_id(fmt)] += 1;
 
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
+#if DEBUG_CAMERA
         if (fmt != SDL_PIXELFORMAT_UNKNOWN) {
             int w = entry.data.i32[i + 1];
             int h = entry.data.i32[i + 2];
@@ -511,7 +509,7 @@ GetNumFormats(SDL_VideoCaptureDevice *_this)
 #endif
     }
 
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
+#if DEBUG_CAMERA
         if (unknown) {
             SDL_Log("Got unknown android");
         }
@@ -529,7 +527,7 @@ GetNumFormats(SDL_VideoCaptureDevice *_this)
 }
 
 int
-GetFormat(SDL_VideoCaptureDevice *_this, int index, Uint32 *format)
+GetFormat(SDL_CameraDevice *_this, int index, Uint32 *format)
 {
     int i;
     int i2 = 0;
@@ -558,7 +556,7 @@ GetFormat(SDL_VideoCaptureDevice *_this, int index, Uint32 *format)
 }
 
 int
-GetNumFrameSizes(SDL_VideoCaptureDevice *_this, Uint32 format)
+GetNumFrameSizes(SDL_CameraDevice *_this, Uint32 format)
 {
     int i, i2 = 0, index;
     if (_this->hidden->num_formats == 0) {
@@ -584,7 +582,7 @@ GetNumFrameSizes(SDL_VideoCaptureDevice *_this, Uint32 format)
 }
 
 int
-GetFrameSize(SDL_VideoCaptureDevice *_this, Uint32 format, int index, int *width, int *height)
+GetFrameSize(SDL_CameraDevice *_this, Uint32 format, int index, int *width, int *height)
 {
     camera_status_t res;
     int i, i2 = 0;
@@ -636,7 +634,7 @@ GetFrameSize(SDL_VideoCaptureDevice *_this, Uint32 format, int index, int *width
 static int GetNumDevices(void);
 
 int
-GetDeviceName(SDL_VideoCaptureDeviceID instance_id, char *buf, int size)
+GetCameraDeviceName(SDL_CameraDeviceID instance_id, char *buf, int size)
 {
     int index = instance_id - 1;
     create_cameraMgr();
@@ -676,14 +674,14 @@ GetNumDevices(void)
     return -1;
 }
 
-SDL_VideoCaptureDeviceID *GetVideoCaptureDevices(int *count)
+SDL_CameraDeviceID *GetCameraDevices(int *count)
 {
     /* hard-coded list of ID */
     int i;
     int num = GetNumDevices();
-    SDL_VideoCaptureDeviceID *ret;
+    SDL_CameraDeviceID *ret;
 
-    ret = (SDL_VideoCaptureDeviceID *)SDL_malloc((num + 1) * sizeof(*ret));
+    ret = (SDL_CameraDeviceID *)SDL_malloc((num + 1) * sizeof(*ret));
 
     if (ret == NULL) {
         SDL_OutOfMemory();
@@ -699,15 +697,14 @@ SDL_VideoCaptureDeviceID *GetVideoCaptureDevices(int *count)
     return ret;
 }
 
-int SDL_SYS_VideoCaptureInit(void) {
+int SDL_SYS_CameraInit(void) {
     return 0;
 }
 
-int SDL_SYS_VideoCaptureQuit(void) {
+int SDL_SYS_CameraQuit(void) {
     return 0;
 }
 
-
 #endif
 
 

src/camera/apple/SDL_camera_apple.m

@@ -20,12 +20,10 @@
 */
 #include "SDL_internal.h"
 
-#ifdef SDL_VIDEO_CAPTURE
+#ifdef SDL_CAMERA_APPLE
 
-#include "SDL3/SDL.h"
-#include "SDL3/SDL_video_capture.h"
-#include "SDL_sysvideocapture.h"
-#include "SDL_video_capture_c.h"
+#include "../SDL_syscamera.h"
+#include "../SDL_camera_c.h"
 #include "../thread/SDL_systhread.h"
 
 #if defined(HAVE_COREMEDIA) && defined(SDL_PLATFORM_MACOS) && (__MAC_OS_X_VERSION_MAX_ALLOWED < 101500)
@@ -37,52 +35,52 @@
 #undef HAVE_COREMEDIA
 #endif
 
-#ifndef HAVE_COREMEDIA
-int InitDevice(SDL_VideoCaptureDevice *_this) {
+#ifndef HAVE_COREMEDIA  /* !!! FIXME: use the dummy driver. */
+int InitDevice(SDL_CameraDevice *_this) {
     return -1;
 }
-int OpenDevice(SDL_VideoCaptureDevice *_this) {
+int OpenDevice(SDL_CameraDevice *_this) {
     return -1;
 }
-int AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame) {
+int AcquireFrame(SDL_CameraDevice *_this, SDL_CameraFrame *frame) {
     return -1;
 }
-void CloseDevice(SDL_VideoCaptureDevice *_this) {
+void CloseDevice(SDL_CameraDevice *_this) {
 }
-int GetDeviceName(SDL_VideoCaptureDeviceID instance_id, char *buf, int size) {
+int GetCameraDeviceName(SDL_CameraDeviceID instance_id, char *buf, int size) {
     return -1;
 }
-int GetDeviceSpec(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureSpec *spec) {
+int GetDeviceSpec(SDL_CameraDevice *_this, SDL_CameraSpec *spec) {
     return -1;
 }
-int GetFormat(SDL_VideoCaptureDevice *_this, int index, Uint32 *format) {
+int GetFormat(SDL_CameraDevice *_this, int index, Uint32 *format) {
     return -1;
 }
-int GetFrameSize(SDL_VideoCaptureDevice *_this, Uint32 format, int index, int *width, int *height) {
+int GetFrameSize(SDL_CameraDevice *_this, Uint32 format, int index, int *width, int *height) {
     return -1;
 }
-SDL_VideoCaptureDeviceID *GetVideoCaptureDevices(int *count) {
+SDL_CameraDeviceID *GetCameraDevices(int *count) {
     return NULL;
 }
-int GetNumFormats(SDL_VideoCaptureDevice *_this) {
+int GetNumFormats(SDL_CameraDevice *_this) {
     return 0;
 }
-int GetNumFrameSizes(SDL_VideoCaptureDevice *_this, Uint32 format) {
+int GetNumFrameSizes(SDL_CameraDevice *_this, Uint32 format) {
     return 0;
 }
-int ReleaseFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame) {
+int ReleaseFrame(SDL_CameraDevice *_this, SDL_CameraFrame *frame) {
     return 0;
 }
-int StartCapture(SDL_VideoCaptureDevice *_this) {
+int StartCapture(SDL_CameraDevice *_this) {
     return 0;
 }
-int StopCapture(SDL_VideoCaptureDevice *_this) {
+int StopCapture(SDL_CameraDevice *_this) {
     return 0;
 }
-int SDL_SYS_VideoCaptureInit(void) {
+int SDL_SYS_CameraInit(void) {
     return 0;
 }
-int SDL_SYS_VideoCaptureQuit(void) {
+int SDL_SYS_CameraQuit(void) {
     return 0;
 }
 
@@ -107,13 +105,13 @@ int SDL_SYS_VideoCaptureQuit(void) {
  * IOS:
  *
  * - Need to link with:: CoreMedia CoreVideo
- * - Add #define SDL_VIDEO_CAPTURE 1
+ * - Add #define SDL_CAMERA 1
  *   to SDL_build_config_ios.h
  */
 
 @class MySampleBufferDelegate;
 
-struct SDL_PrivateVideoCaptureData
+struct SDL_PrivateCameraData
 {
     dispatch_queue_t queue;
     MySampleBufferDelegate *delegate;
@@ -216,13 +214,13 @@ sdlformat_to_nsfourcc(Uint32 fmt)
 
 
 @interface MySampleBufferDelegate : NSObject<AVCaptureVideoDataOutputSampleBufferDelegate>
-    @property struct SDL_PrivateVideoCaptureData *hidden;
-    - (void) set: (struct SDL_PrivateVideoCaptureData *) val;
+    @property struct SDL_PrivateCameraData *hidden;
+    - (void) set: (struct SDL_PrivateCameraData *) val;
 @end
 
 @implementation MySampleBufferDelegate
 
-    - (void) set: (struct SDL_PrivateVideoCaptureData *) val {
+    - (void) set: (struct SDL_PrivateCameraData *) val {
         _hidden = val;
     }
 
@@ -241,9 +239,9 @@ sdlformat_to_nsfourcc(Uint32 fmt)
 @end
 
 int
-OpenDevice(SDL_VideoCaptureDevice *_this)
+OpenDevice(SDL_CameraDevice *_this)
 {
-    _this->hidden = (struct SDL_PrivateVideoCaptureData *) SDL_calloc(1, sizeof (struct SDL_PrivateVideoCaptureData));
+    _this->hidden = (struct SDL_PrivateCameraData *) SDL_calloc(1, sizeof (struct SDL_PrivateCameraData));
     if (_this->hidden == NULL) {
         SDL_OutOfMemory();
         goto error;
@@ -256,7 +254,7 @@ error:
 }
 
 void
-CloseDevice(SDL_VideoCaptureDevice *_this)
+CloseDevice(SDL_CameraDevice *_this)
 {
     if (!_this) {
         return;
@@ -285,7 +283,7 @@ CloseDevice(SDL_VideoCaptureDevice *_this)
 }
 
 int
-InitDevice(SDL_VideoCaptureDevice *_this)
+InitDevice(SDL_CameraDevice *_this)
 {
     NSString *fmt = sdlformat_to_nsfourcc(_this->spec.format);
     int w = _this->spec.width;
@@ -405,7 +403,7 @@ error:
 }
 
 int
-GetDeviceSpec(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureSpec *spec)
+GetDeviceSpec(SDL_CameraDevice *_this, SDL_CameraSpec *spec)
 {
     if (spec) {
         *spec = _this->spec;
@@ -415,21 +413,21 @@ GetDeviceSpec(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureSpec *spec)
 }
 
 int
-StartCapture(SDL_VideoCaptureDevice *_this)
+StartCamera(SDL_CameraDevice *_this)
 {
     [_this->hidden->session startRunning];
     return 0;
 }
 
 int
-StopCapture(SDL_VideoCaptureDevice *_this)
+StopCamera(SDL_CameraDevice *_this)
 {
     [_this->hidden->session stopRunning];
     return 0;
 }
 
 int
-AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
+AcquireFrame(SDL_CameraDevice *_this, SDL_CameraFrame *frame)
 {
     if (CMSimpleQueueGetCount(_this->hidden->frame_queue) > 0) {
         int i, numPlanes, planar;
@@ -482,7 +480,7 @@ AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
 }
 
 int
-ReleaseFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
+ReleaseFrame(SDL_CameraDevice *_this, SDL_CameraFrame *frame)
 {
     if (frame->internal){
         CMSampleBufferRef sampleBuffer = (CMSampleBufferRef) frame->internal;
@@ -496,7 +494,7 @@ ReleaseFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
 }
 
 int
-GetNumFormats(SDL_VideoCaptureDevice *_this)
+GetNumFormats(SDL_CameraDevice *_this)
 {
     AVCaptureDevice *device = get_device_by_name(_this->dev_name);
     if (device) {
@@ -517,7 +515,7 @@ GetNumFormats(SDL_VideoCaptureDevice *_this)
 }
 
 int
-GetFormat(SDL_VideoCaptureDevice *_this, int index, Uint32 *format)
+GetFormat(SDL_CameraDevice *_this, int index, Uint32 *format)
 {
     AVCaptureDevice *device = get_device_by_name(_this->dev_name);
     if (device) {
@@ -545,7 +543,7 @@ GetFormat(SDL_VideoCaptureDevice *_this, int index, Uint32 *format)
 }
 
 int
-GetNumFrameSizes(SDL_VideoCaptureDevice *_this, Uint32 format)
+GetNumFrameSizes(SDL_CameraDevice *_this, Uint32 format)
 {
     AVCaptureDevice *device = get_device_by_name(_this->dev_name);
     if (device) {
@@ -568,7 +566,7 @@ GetNumFrameSizes(SDL_VideoCaptureDevice *_this, Uint32 format)
 }
 
 int
-GetFrameSize(SDL_VideoCaptureDevice *_this, Uint32 format, int index, int *width, int *height)
+GetFrameSize(SDL_CameraDevice *_this, Uint32 format, int index, int *width, int *height)
 {
     AVCaptureDevice *device = get_device_by_name(_this->dev_name);
     if (device) {
@@ -596,7 +594,7 @@ GetFrameSize(SDL_VideoCaptureDevice *_this, Uint32 format, int index, int *width
 }
 
 int
-GetDeviceName(SDL_VideoCaptureDeviceID instance_id, char *buf, int size)
+GetCameraDeviceName(SDL_CameraDeviceID instance_id, char *buf, int size)
 {
     int index = instance_id - 1;
     NSArray<AVCaptureDevice *> *devices = discover_devices();
@@ -617,14 +615,14 @@ GetNumDevices(void)
     return [devices count];
 }
 
-SDL_VideoCaptureDeviceID *GetVideoCaptureDevices(int *count)
+SDL_CameraDeviceID *GetCameraDevices(int *count)
 {
     /* hard-coded list of ID */
     int i;
     int num = GetNumDevices();
-    SDL_VideoCaptureDeviceID *ret;
+    SDL_CameraDeviceID *ret;
 
-    ret = (SDL_VideoCaptureDeviceID *)SDL_malloc((num + 1) * sizeof(*ret));
+    ret = (SDL_CameraDeviceID *)SDL_malloc((num + 1) * sizeof(*ret));
 
     if (ret == NULL) {
         SDL_OutOfMemory();
@@ -640,20 +638,17 @@ SDL_VideoCaptureDeviceID *GetVideoCaptureDevices(int *count)
     return ret;
 }
 
-int SDL_SYS_VideoCaptureInit(void)
+int SDL_SYS_CameraInit(void)
 {
     return 0;
 }
 
-int SDL_SYS_VideoCaptureQuit(void)
+int SDL_SYS_CameraQuit(void)
 {
     return 0;
 }
 
-
-
-
 #endif /* HAVE_COREMEDIA */
 
-#endif /* SDL_VIDEO_CAPTURE */
+#endif /* SDL_CAMERA_APPLE */
 

src/camera/v4l2/SDL_camera_v4l2.c

@@ -20,46 +20,41 @@
 */
 #include "SDL_internal.h"
 
-#ifdef SDL_VIDEO_CAPTURE
+#ifdef SDL_CAMERA_V4L2
 
-#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"
+#include "../SDL_syscamera.h"
+#include "../SDL_camera_c.h"
+#include "../../video/SDL_pixels_c.h"
+#include "../../thread/SDL_systhread.h"
 #include "../../core/linux/SDL_evdev_capabilities.h"
 #include "../../core/linux/SDL_udev.h"
 #include <limits.h>      /* INT_MAX */
 
-#define DEBUG_VIDEO_CAPTURE_CAPTURE 0
+#define DEBUG_CAMERA 1
 
-#if defined(SDL_PLATFORM_LINUX) && !defined(SDL_PLATFORM_ANDROID)
-
-
-#define MAX_CAPTURE_DEVICES 128 /* It's doubtful someone has more than that */
+#define MAX_CAMERA_DEVICES 128 /* It's doubtful someone has more than that */
 
 static int MaybeAddDevice(const char *path);
 #ifdef SDL_USE_LIBUDEV
 static int MaybeRemoveDevice(const char *path);
-static void capture_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_class, const char *devpath);
+static void camera_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_class, const char *devpath);
 #endif /* SDL_USE_LIBUDEV */
 
 /*
- * List of available capture devices.
+ * List of available camera devices.
  */
-typedef struct SDL_capturelist_item
+typedef struct SDL_cameralist_item
 {
     char *fname;        /* Dev path name (like /dev/video0) */
     char *bus_info;     /* don't add two paths with same bus_info (eg /dev/video0 and /dev/video1 */
-    SDL_VideoCaptureDeviceID instance_id;
-    SDL_VideoCaptureDevice *device; /* Associated device */
-    struct SDL_capturelist_item *next;
-} SDL_capturelist_item;
+    SDL_CameraDeviceID instance_id;
+    SDL_CameraDevice *device; /* Associated device */
+    struct SDL_cameralist_item *next;
+} SDL_cameralist_item;
 
-static SDL_capturelist_item *SDL_capturelist = NULL;
-static SDL_capturelist_item *SDL_capturelist_tail = NULL;
-static int num_video_captures = 0;
+static SDL_cameralist_item *SDL_cameralist = NULL;
+static SDL_cameralist_item *SDL_cameralist_tail = NULL;
+static int num_cameras = 0;
 
 
 
@@ -75,7 +70,7 @@ struct buffer {
     int available; /* Is available in userspace */
 };
 
-struct SDL_PrivateVideoCaptureData
+struct SDL_PrivateCameraData
 {
     int fd;
     enum io_method io;
@@ -107,7 +102,7 @@ xioctl(int fh, int request, void *arg)
 
 /* -1:error  1:frame 0:no frame*/
 static int
-acquire_frame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
+acquire_frame(SDL_CameraDevice *_this, SDL_CameraFrame *frame)
 {
     struct v4l2_buffer buf;
     int i;
@@ -168,7 +163,7 @@ acquire_frame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
             frame->pitch[0] = _this->hidden->driver_pitch;
             _this->hidden->buffers[buf.index].available = 1;
 
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
+#if DEBUG_CAMERA
             SDL_Log("debug mmap: image %d/%d  num_planes:%d data[0]=%p", buf.index, _this->hidden->nb_buffers, frame->num_planes, (void*)frame->data[0]);
 #endif
             break;
@@ -208,7 +203,7 @@ acquire_frame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
             frame->data[0] = (void*)buf.m.userptr;
             frame->pitch[0] = _this->hidden->driver_pitch;
             _this->hidden->buffers[i].available = 1;
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
+#if DEBUG_CAMERA
             SDL_Log("debug userptr: image %d/%d  num_planes:%d data[0]=%p", buf.index, _this->hidden->nb_buffers, frame->num_planes, (void*)frame->data[0]);
 #endif
             break;
@@ -219,7 +214,7 @@ acquire_frame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
 
 
 int
-ReleaseFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
+ReleaseFrame(SDL_CameraDevice *_this, SDL_CameraFrame *frame)
 {
     struct v4l2_buffer buf;
     int i;
@@ -274,7 +269,7 @@ ReleaseFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
 
 
 int
-AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
+AcquireFrame(SDL_CameraDevice *_this, SDL_CameraFrame *frame)
 {
     fd_set fds;
     struct timeval tv;
@@ -293,7 +288,7 @@ AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
 
     if (ret == -1) {
         if (errno == EINTR) {
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
+#if DEBUG_CAMERA
             SDL_Log("continue ..");
 #endif
             return 0;
@@ -315,7 +310,7 @@ AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
     if (ret == 1){
         frame->timestampNS = SDL_GetTicksNS();
     } else if (ret == 0) {
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
+#if DEBUG_CAMERA
         SDL_Log("No frame continue: %s", SDL_GetError());
 #endif
     }
@@ -326,7 +321,7 @@ AcquireFrame(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureFrame *frame)
 
 
 int
-StopCapture(SDL_VideoCaptureDevice *_this)
+StopCamera(SDL_CameraDevice *_this)
 {
     enum v4l2_buf_type type;
     int fd = _this->hidden->fd;
@@ -349,7 +344,7 @@ StopCapture(SDL_VideoCaptureDevice *_this)
 }
 
 static int
-enqueue_buffers(SDL_VideoCaptureDevice *_this)
+enqueue_buffers(SDL_CameraDevice *_this)
 {
     int i;
     int fd = _this->hidden->fd;
@@ -398,7 +393,7 @@ enqueue_buffers(SDL_VideoCaptureDevice *_this)
 }
 
 static int
-pre_enqueue_buffers(SDL_VideoCaptureDevice *_this)
+pre_enqueue_buffers(SDL_CameraDevice *_this)
 {
     struct v4l2_requestbuffers req;
     int fd = _this->hidden->fd;
@@ -452,7 +447,7 @@ pre_enqueue_buffers(SDL_VideoCaptureDevice *_this)
 }
 
 int
-StartCapture(SDL_VideoCaptureDevice *_this)
+StartCamera(SDL_CameraDevice *_this)
 {
     enum v4l2_buf_type type;
 
@@ -498,7 +493,7 @@ StartCapture(SDL_VideoCaptureDevice *_this)
     return 0;
 }
 
-static int alloc_buffer_read(SDL_VideoCaptureDevice *_this, size_t buffer_size)
+static int alloc_buffer_read(SDL_CameraDevice *_this, size_t buffer_size)
 {
     _this->hidden->buffers[0].length = buffer_size;
     _this->hidden->buffers[0].start = SDL_calloc(1, buffer_size);
@@ -510,7 +505,7 @@ static int alloc_buffer_read(SDL_VideoCaptureDevice *_this, size_t buffer_size)
 }
 
 static int
-alloc_buffer_mmap(SDL_VideoCaptureDevice *_this)
+alloc_buffer_mmap(SDL_CameraDevice *_this)
 {
     int fd = _this->hidden->fd;
     int i;
@@ -543,7 +538,7 @@ alloc_buffer_mmap(SDL_VideoCaptureDevice *_this)
 }
 
 static int
-alloc_buffer_userp(SDL_VideoCaptureDevice *_this, size_t buffer_size)
+alloc_buffer_userp(SDL_CameraDevice *_this, size_t buffer_size)
 {
     int i;
     for (i = 0; i < _this->hidden->nb_buffers; ++i) {
@@ -585,7 +580,7 @@ format_sdl_2_v4l2(Uint32 fmt)
 }
 
 int
-GetNumFormats(SDL_VideoCaptureDevice *_this)
+GetNumFormats(SDL_CameraDevice *_this)
 {
     int fd = _this->hidden->fd;
     int i = 0;
@@ -601,7 +596,7 @@ GetNumFormats(SDL_VideoCaptureDevice *_this)
 }
 
 int
-GetFormat(SDL_VideoCaptureDevice *_this, int index, Uint32 *format)
+GetFormat(SDL_CameraDevice *_this, int index, Uint32 *format)
 {
     int fd = _this->hidden->fd;
     struct v4l2_fmtdesc fmtdesc;
@@ -612,7 +607,7 @@ GetFormat(SDL_VideoCaptureDevice *_this, int index, Uint32 *format)
     if (ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc) == 0) {
         *format = format_v4l2_2_sdl(fmtdesc.pixelformat);
 
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
+#if DEBUG_CAMERA
         if (fmtdesc.flags & V4L2_FMT_FLAG_EMULATED) {
             SDL_Log("%s format emulated", SDL_GetPixelFormatName(*format));
         }
@@ -627,7 +622,7 @@ GetFormat(SDL_VideoCaptureDevice *_this, int index, Uint32 *format)
 }
 
 int
-GetNumFrameSizes(SDL_VideoCaptureDevice *_this, Uint32 format)
+GetNumFrameSizes(SDL_CameraDevice *_this, Uint32 format)
 {
     int fd = _this->hidden->fd;
     int i = 0;
@@ -651,7 +646,7 @@ GetNumFrameSizes(SDL_VideoCaptureDevice *_this, Uint32 format)
 }
 
 int
-GetFrameSize(SDL_VideoCaptureDevice *_this, Uint32 format, int index, int *width, int *height)
+GetFrameSize(SDL_CameraDevice *_this, Uint32 format, int index, int *width, int *height)
 {
     int fd = _this->hidden->fd;
     struct v4l2_frmsizeenum frmsizeenum;
@@ -704,7 +699,7 @@ dbg_v4l2_pixelformat(const char *str, int f) {
 #endif
 
 int
-GetDeviceSpec(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureSpec *spec)
+GetDeviceSpec(SDL_CameraDevice *_this, SDL_CameraSpec *spec)
 {
     struct v4l2_format fmt;
     int fd = _this->hidden->fd;
@@ -737,7 +732,7 @@ GetDeviceSpec(SDL_VideoCaptureDevice *_this, SDL_VideoCaptureSpec *spec)
 }
 
 int
-InitDevice(SDL_VideoCaptureDevice *_this)
+InitDevice(SDL_CameraDevice *_this)
 {
     struct v4l2_cropcap cropcap;
     struct v4l2_crop crop;
@@ -783,7 +778,7 @@ InitDevice(SDL_VideoCaptureDevice *_this)
         //    fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;
         fmt.fmt.pix.field       = V4L2_FIELD_ANY;
 
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
+#if DEBUG_CAMERA
         SDL_Log("set SDL format %s", SDL_GetPixelFormatName(_this->spec.format));
         dbg_v4l2_pixelformat("set format", fmt.fmt.pix.pixelformat);
 #endif
@@ -833,7 +828,7 @@ InitDevice(SDL_VideoCaptureDevice *_this)
 }
 
 void
-CloseDevice(SDL_VideoCaptureDevice *_this)
+CloseDevice(SDL_CameraDevice *_this)
 {
     if (!_this) {
         return;
@@ -869,7 +864,7 @@ CloseDevice(SDL_VideoCaptureDevice *_this)
 
         if (_this->hidden->fd != -1) {
             if (close(_this->hidden->fd)) {
-                SDL_SetError("close video capture device");
+                SDL_SetError("close camera device");
             }
         }
         SDL_free(_this->hidden);
@@ -880,14 +875,14 @@ CloseDevice(SDL_VideoCaptureDevice *_this)
 
 
 int
-OpenDevice(SDL_VideoCaptureDevice *_this)
+OpenDevice(SDL_CameraDevice *_this)
 {
     struct stat st;
     struct v4l2_capability cap;
     int fd;
     enum io_method io;
 
-    _this->hidden = (struct SDL_PrivateVideoCaptureData *) SDL_calloc(1, sizeof (struct SDL_PrivateVideoCaptureData));
+    _this->hidden = (struct SDL_PrivateCameraData *) SDL_calloc(1, sizeof (struct SDL_PrivateCameraData));
     if (_this->hidden == NULL) {
         SDL_OutOfMemory();
         return -1;
@@ -966,10 +961,10 @@ OpenDevice(SDL_VideoCaptureDevice *_this)
 }
 
 int
-GetDeviceName(SDL_VideoCaptureDeviceID instance_id, char *buf, int size)
+GetCameraDeviceName(SDL_CameraDeviceID instance_id, char *buf, int size)
 {
-    SDL_capturelist_item *item;
-    for (item = SDL_capturelist; item; item = item->next) {
+    SDL_cameralist_item *item;
+    for (item = SDL_cameralist; item; item = item->next) {
         if (item->instance_id == instance_id) {
             SDL_snprintf(buf, size, "%s", item->fname);
             return 0;
@@ -981,15 +976,15 @@ GetDeviceName(SDL_VideoCaptureDeviceID instance_id, char *buf, int size)
 }
 
 
-SDL_VideoCaptureDeviceID *GetVideoCaptureDevices(int *count)
+SDL_CameraDeviceID *GetCameraDevices(int *count)
 {
     /* real list of ID */
     int i = 0;
-    int num = num_video_captures;
-    SDL_VideoCaptureDeviceID *ret;
-    SDL_capturelist_item *item;
+    int num = num_cameras;
+    SDL_CameraDeviceID *ret;
+    SDL_cameralist_item *item;
 
-    ret = (SDL_VideoCaptureDeviceID *)SDL_malloc((num + 1) * sizeof(*ret));
+    ret = (SDL_CameraDeviceID *)SDL_malloc((num + 1) * sizeof(*ret));
 
     if (ret == NULL) {
         SDL_OutOfMemory();
@@ -997,7 +992,7 @@ SDL_VideoCaptureDeviceID *GetVideoCaptureDevices(int *count)
         return NULL;
     }
 
-    for (item = SDL_capturelist; item; item = item->next) {
+    for (item = SDL_cameralist; item; item = item->next) {
         ret[i] = item->instance_id;
         i++;
     }
@@ -1011,18 +1006,18 @@ SDL_VideoCaptureDeviceID *GetVideoCaptureDevices(int *count)
 /*
  * Initializes the subsystem by finding available devices.
  */
-int SDL_SYS_VideoCaptureInit(void)
+int SDL_SYS_CameraInit(void)
 {
     const char pattern[] = "/dev/video%d";
     char path[PATH_MAX];
     int i, j;
 
     /*
-     * Limit amount of checks to MAX_CAPTURE_DEVICES since we may or may not have
+     * Limit amount of checks to MAX_CAMERA_DEVICES since we may or may not have
      * permission to some or all devices.
      */
     i = 0;
-    for (j = 0; j < MAX_CAPTURE_DEVICES; ++j) {
+    for (j = 0; j < MAX_CAMERA_DEVICES; ++j) {
         (void)SDL_snprintf(path, PATH_MAX, pattern, i++);
         if (MaybeAddDevice(path) == -2) {
             break;
@@ -1034,7 +1029,7 @@ int SDL_SYS_VideoCaptureInit(void)
         return SDL_SetError("Could not initialize UDEV");
     }
 
-    if (SDL_UDEV_AddCallback(capture_udev_callback) < 0) {
+    if (SDL_UDEV_AddCallback(camera_udev_callback) < 0) {
         SDL_UDEV_Quit();
         return SDL_SetError("Could not setup Video Capture <-> udev callback");
     }
@@ -1043,15 +1038,15 @@ int SDL_SYS_VideoCaptureInit(void)
     SDL_UDEV_Scan();
 #endif /* SDL_USE_LIBUDEV */
 
-    return num_video_captures;
+    return num_cameras;
 }
 
 
-int SDL_SYS_VideoCaptureQuit(void)
+int SDL_SYS_CameraQuit(void)
 {
-    SDL_capturelist_item *item;
-    for (item = SDL_capturelist; item; ) {
-        SDL_capturelist_item *tmp = item->next;
+    SDL_cameralist_item *item;
+    for (item = SDL_cameralist; item; ) {
+        SDL_cameralist_item *tmp = item->next;
 
         SDL_free(item->fname);
         SDL_free(item->bus_info);
@@ -1059,15 +1054,15 @@ int SDL_SYS_VideoCaptureQuit(void)
         item = tmp;
     }
 
-    num_video_captures = 0;
-    SDL_capturelist = NULL;
-    SDL_capturelist_tail = NULL;
+    num_cameras = 0;
+    SDL_cameralist = NULL;
+    SDL_cameralist_tail = NULL;
 
     return SDL_FALSE;
 }
 
 #ifdef SDL_USE_LIBUDEV
-static void capture_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_class, const char *devpath)
+static void camera_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_class, const char *devpath)
 {
     if (!devpath || !(udev_class & SDL_UDEV_DEVICE_VIDEO_CAPTURE)) {
         return;
@@ -1089,9 +1084,9 @@ static void capture_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_class
 #endif /* SDL_USE_LIBUDEV */
 
 static SDL_bool DeviceExists(const char *path, const char *bus_info) {
-    SDL_capturelist_item *item;
+    SDL_cameralist_item *item;
 
-    for (item = SDL_capturelist; item; item = item->next) {
+    for (item = SDL_cameralist; item; item = item->next) {
         /* found same dev name */
         if (SDL_strcmp(path, item->fname) == 0) {
             return SDL_TRUE;
@@ -1110,7 +1105,7 @@ static int MaybeAddDevice(const char *path)
     struct v4l2_capability vcap;
     int err;
     int fd;
-    SDL_capturelist_item *item;
+    SDL_cameralist_item *item;
 
     if (!path) {
         return -1;
@@ -1135,7 +1130,7 @@ static int MaybeAddDevice(const char *path)
 
 
     /* Add new item */
-    item = (SDL_capturelist_item *)SDL_calloc(1, sizeof(SDL_capturelist_item));
+    item = (SDL_cameralist_item *)SDL_calloc(1, sizeof(SDL_cameralist_item));
     if (!item) {
         SDL_free(bus_info);
         return -1;
@@ -1153,18 +1148,18 @@ static int MaybeAddDevice(const char *path)
     item->instance_id = SDL_GetNextObjectID();
 
 
-    if (!SDL_capturelist_tail) {
-        SDL_capturelist = SDL_capturelist_tail = item;
+    if (!SDL_cameralist_tail) {
+        SDL_cameralist = SDL_cameralist_tail = item;
     } else {
-        SDL_capturelist_tail->next = item;
-        SDL_capturelist_tail = item;
+        SDL_cameralist_tail->next = item;
+        SDL_cameralist_tail = item;
     }
 
-    ++num_video_captures;
+    ++num_cameras;
 
     /* !!! TODO: Send a add event? */
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
-    SDL_Log("Added video capture ID: %d %s (%s) (total: %d)", item->instance_id, path, bus_info, num_video_captures);
+#if DEBUG_CAMERA
+    SDL_Log("Added video camera ID: %d %s (%s) (total: %d)", item->instance_id, path, bus_info, num_cameras);
 #endif
     return 0;
 }
@@ -1173,30 +1168,30 @@ static int MaybeAddDevice(const char *path)
 static int MaybeRemoveDevice(const char *path)
 {
 
-    SDL_capturelist_item *item;
-    SDL_capturelist_item *prev = NULL;
-#if DEBUG_VIDEO_CAPTURE_CAPTURE
-    SDL_Log("Remove video capture %s", path);
+    SDL_cameralist_item *item;
+    SDL_cameralist_item *prev = NULL;
+#if DEBUG_CAMERA
+    SDL_Log("Remove video camera %s", path);
 #endif
     if (!path) {
         return -1;
     }
 
-    for (item = SDL_capturelist; item; item = item->next) {
+    for (item = SDL_cameralist; item; item = item->next) {
         /* found it, remove it. */
         if (SDL_strcmp(path, item->fname) == 0) {
             if (prev) {
                 prev->next = item->next;
             } else {
-                SDL_assert(SDL_capturelist == item);
-                SDL_capturelist = item->next;
+                SDL_assert(SDL_cameralist == item);
+                SDL_cameralist = item->next;
             }
-            if (item == SDL_capturelist_tail) {
-                SDL_capturelist_tail = prev;
+            if (item == SDL_cameralist_tail) {
+                SDL_cameralist_tail = prev;
             }
 
             /* Need to decrement the count */
-            --num_video_captures;
+            --num_cameras;
             /* !!! TODO: Send a remove event? */
 
             SDL_free(item->fname);
@@ -1210,8 +1205,4 @@ static int MaybeRemoveDevice(const char *path)
 }
 #endif /* SDL_USE_LIBUDEV */
 
-
-
-#endif
-
-#endif /* SDL_VIDEO_CAPTURE */
+#endif /* SDL_CAMERA_V4L2 */

src/dynapi/SDL_dynapi.sym

@@ -895,22 +895,6 @@ SDL3_0.0.0 {
     SDL_SetPropertyWithCleanup;
     SDL_SetX11EventHook;
     SDL_GetGlobalProperties;
-    SDL_OpenVideoCapture;
-    SDL_SetVideoCaptureSpec;
-    SDL_OpenVideoCaptureWithSpec;
-    SDL_GetVideoCaptureDeviceName;
-    SDL_GetVideoCaptureSpec;
-    SDL_GetVideoCaptureFormat;
-    SDL_GetNumVideoCaptureFormats;
-    SDL_GetVideoCaptureFrameSize;
-    SDL_GetNumVideoCaptureFrameSizes;
-    SDL_GetVideoCaptureStatus;
-    SDL_StartVideoCapture;
-    SDL_AcquireVideoCaptureFrame;
-    SDL_ReleaseVideoCaptureFrame;
-    SDL_StopVideoCapture;
-    SDL_CloseVideoCapture;
-    SDL_GetVideoCaptureDevices;
     SDL_GetGamepadButtonLabelForType;
     SDL_GetGamepadButtonLabel;
     SDL_GetPens;
@@ -973,6 +957,22 @@ SDL3_0.0.0 {
     SDL_SetWindowShape;
     SDL_RenderViewportSet;
     SDL_HasProperty;
+    SDL_GetCameraDevices;
+    SDL_OpenCamera;
+    SDL_SetCameraSpec;
+    SDL_OpenCameraWithSpec;
+    SDL_GetCameraDeviceName;
+    SDL_GetCameraSpec;
+    SDL_GetCameraFormat;
+    SDL_GetNumCameraFormats;
+    SDL_GetCameraFrameSize;
+    SDL_GetNumCameraFrameSizes;
+    SDL_GetCameraStatus;
+    SDL_StartCamera;
+    SDL_AcquireCameraFrame;
+    SDL_ReleaseCameraFrame;
+    SDL_StopCamera;
+    SDL_CloseCamera;
     # extra symbols go here (don't modify this line)
   local: *;
 };

src/dynapi/SDL_dynapi_overrides.h

@@ -920,22 +920,6 @@
 #define SDL_SetPropertyWithCleanup SDL_SetPropertyWithCleanup_REAL
 #define SDL_SetX11EventHook SDL_SetX11EventHook_REAL
 #define SDL_GetGlobalProperties SDL_GetGlobalProperties_REAL
-#define SDL_OpenVideoCapture SDL_OpenVideoCapture_REAL
-#define SDL_SetVideoCaptureSpec SDL_SetVideoCaptureSpec_REAL
-#define SDL_OpenVideoCaptureWithSpec SDL_OpenVideoCaptureWithSpec_REAL
-#define SDL_GetVideoCaptureDeviceName SDL_GetVideoCaptureDeviceName_REAL
-#define SDL_GetVideoCaptureSpec SDL_GetVideoCaptureSpec_REAL
-#define SDL_GetVideoCaptureFormat SDL_GetVideoCaptureFormat_REAL
-#define SDL_GetNumVideoCaptureFormats SDL_GetNumVideoCaptureFormats_REAL
-#define SDL_GetVideoCaptureFrameSize SDL_GetVideoCaptureFrameSize_REAL
-#define SDL_GetNumVideoCaptureFrameSizes SDL_GetNumVideoCaptureFrameSizes_REAL
-#define SDL_GetVideoCaptureStatus SDL_GetVideoCaptureStatus_REAL
-#define SDL_StartVideoCapture SDL_StartVideoCapture_REAL
-#define SDL_AcquireVideoCaptureFrame SDL_AcquireVideoCaptureFrame_REAL
-#define SDL_ReleaseVideoCaptureFrame SDL_ReleaseVideoCaptureFrame_REAL
-#define SDL_StopVideoCapture SDL_StopVideoCapture_REAL
-#define SDL_CloseVideoCapture SDL_CloseVideoCapture_REAL
-#define SDL_GetVideoCaptureDevices SDL_GetVideoCaptureDevices_REAL
 #define SDL_GetGamepadButtonLabelForType SDL_GetGamepadButtonLabelForType_REAL
 #define SDL_GetGamepadButtonLabel SDL_GetGamepadButtonLabel_REAL
 #define SDL_GetPens SDL_GetPens_REAL
@@ -998,3 +982,19 @@
 #define SDL_SetWindowShape SDL_SetWindowShape_REAL
 #define SDL_RenderViewportSet SDL_RenderViewportSet_REAL
 #define SDL_HasProperty SDL_HasProperty_REAL
+#define SDL_GetCameraDevices SDL_GetCameraDevices_REAL
+#define SDL_OpenCamera SDL_OpenCamera_REAL
+#define SDL_SetCameraSpec SDL_SetCameraSpec_REAL
+#define SDL_OpenCameraWithSpec SDL_OpenCameraWithSpec_REAL
+#define SDL_GetCameraDeviceName SDL_GetCameraDeviceName_REAL
+#define SDL_GetCameraSpec SDL_GetCameraSpec_REAL
+#define SDL_GetCameraFormat SDL_GetCameraFormat_REAL
+#define SDL_GetNumCameraFormats SDL_GetNumCameraFormats_REAL
+#define SDL_GetCameraFrameSize SDL_GetCameraFrameSize_REAL
+#define SDL_GetNumCameraFrameSizes SDL_GetNumCameraFrameSizes_REAL
+#define SDL_GetCameraStatus SDL_GetCameraStatus_REAL
+#define SDL_StartCamera SDL_StartCamera_REAL
+#define SDL_AcquireCameraFrame SDL_AcquireCameraFrame_REAL
+#define SDL_ReleaseCameraFrame SDL_ReleaseCameraFrame_REAL
+#define SDL_StopCamera SDL_StopCamera_REAL
+#define SDL_CloseCamera SDL_CloseCamera_REAL

src/dynapi/SDL_dynapi_procs.h

@@ -953,22 +953,6 @@ SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetDisplayProperties,(SDL_DisplayID a),(a),
 SDL_DYNAPI_PROC(int,SDL_SetPropertyWithCleanup,(SDL_PropertiesID a, const char *b, void *c, void (SDLCALL *d)(void *userdata, void *value), void *e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(void,SDL_SetX11EventHook,(SDL_X11EventHook a, void *b),(a,b),)
 SDL_DYNAPI_PROC(SDL_PropertiesID,SDL_GetGlobalProperties,(void),(),return)
-SDL_DYNAPI_PROC(SDL_VideoCaptureDevice*,SDL_OpenVideoCapture,(SDL_VideoCaptureDeviceID a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_SetVideoCaptureSpec,(SDL_VideoCaptureDevice *a, const SDL_VideoCaptureSpec *b, SDL_VideoCaptureSpec *c, int d),(a,b,c,d),return)
-SDL_DYNAPI_PROC(SDL_VideoCaptureDevice*,SDL_OpenVideoCaptureWithSpec,(SDL_VideoCaptureDeviceID a, const SDL_VideoCaptureSpec *b, SDL_VideoCaptureSpec *c, int d),(a,b,c,d),return)
-SDL_DYNAPI_PROC(const char*,SDL_GetVideoCaptureDeviceName,(SDL_VideoCaptureDeviceID a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_GetVideoCaptureSpec,(SDL_VideoCaptureDevice *a, SDL_VideoCaptureSpec *b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_GetVideoCaptureFormat,(SDL_VideoCaptureDevice *a, int b, Uint32 *c),(a,b,c),return)
-SDL_DYNAPI_PROC(int,SDL_GetNumVideoCaptureFormats,(SDL_VideoCaptureDevice *a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_GetVideoCaptureFrameSize,(SDL_VideoCaptureDevice *a, Uint32 b, int c, int *d, int *e),(a,b,c,d,e),return)
-SDL_DYNAPI_PROC(int,SDL_GetNumVideoCaptureFrameSizes,(SDL_VideoCaptureDevice *a, Uint32 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_VideoCaptureStatus,SDL_GetVideoCaptureStatus,(SDL_VideoCaptureDevice *a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_StartVideoCapture,(SDL_VideoCaptureDevice *a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_AcquireVideoCaptureFrame,(SDL_VideoCaptureDevice *a, SDL_VideoCaptureFrame *b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_ReleaseVideoCaptureFrame,(SDL_VideoCaptureDevice *a, SDL_VideoCaptureFrame *b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_StopVideoCapture,(SDL_VideoCaptureDevice *a),(a),return)
-SDL_DYNAPI_PROC(void,SDL_CloseVideoCapture,(SDL_VideoCaptureDevice *a),(a),)
-SDL_DYNAPI_PROC(SDL_VideoCaptureDeviceID*,SDL_GetVideoCaptureDevices,(int *a),(a),return)
 SDL_DYNAPI_PROC(SDL_GamepadButtonLabel,SDL_GetGamepadButtonLabelForType,(SDL_GamepadType a, SDL_GamepadButton b),(a,b),return)
 SDL_DYNAPI_PROC(SDL_GamepadButtonLabel,SDL_GetGamepadButtonLabel,(SDL_Gamepad *a, SDL_GamepadButton b),(a,b),return)
 SDL_DYNAPI_PROC(SDL_PenID*,SDL_GetPens,(int *a),(a),return)
@@ -1023,3 +1007,19 @@ SDL_DYNAPI_PROC(int,SDL_RenderGeometryRawFloat,(SDL_Renderer *a, SDL_Texture *b,
 SDL_DYNAPI_PROC(int,SDL_SetWindowShape,(SDL_Window *a, SDL_Surface *b),(a,b),return)
 SDL_DYNAPI_PROC(SDL_bool,SDL_RenderViewportSet,(SDL_Renderer *a),(a),return)
 SDL_DYNAPI_PROC(SDL_bool,SDL_HasProperty,(SDL_PropertiesID a, const char *b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_CameraDeviceID*,SDL_GetCameraDevices,(int *a),(a),return)
+SDL_DYNAPI_PROC(SDL_CameraDevice*,SDL_OpenCamera,(SDL_CameraDeviceID a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_SetCameraSpec,(SDL_CameraDevice *a, const SDL_CameraSpec *b, SDL_CameraSpec *c, int d),(a,b,c,d),return)
+SDL_DYNAPI_PROC(SDL_CameraDevice*,SDL_OpenCameraWithSpec,(SDL_CameraDeviceID a, const SDL_CameraSpec *b, SDL_CameraSpec *c, int d),(a,b,c,d),return)
+SDL_DYNAPI_PROC(const char*,SDL_GetCameraDeviceName,(SDL_CameraDeviceID a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_GetCameraSpec,(SDL_CameraDevice *a, SDL_CameraSpec *b),(a,b),return)
+SDL_DYNAPI_PROC(int,SDL_GetCameraFormat,(SDL_CameraDevice *a, int b, Uint32 *c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_GetNumCameraFormats,(SDL_CameraDevice *a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_GetCameraFrameSize,(SDL_CameraDevice *a, Uint32 b, int c, int *d, int *e),(a,b,c,d,e),return)
+SDL_DYNAPI_PROC(int,SDL_GetNumCameraFrameSizes,(SDL_CameraDevice *a, Uint32 b),(a,b),return)
+SDL_DYNAPI_PROC(SDL_CameraStatus,SDL_GetCameraStatus,(SDL_CameraDevice *a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_StartCamera,(SDL_CameraDevice *a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_AcquireCameraFrame,(SDL_CameraDevice *a, SDL_CameraFrame *b),(a,b),return)
+SDL_DYNAPI_PROC(int,SDL_ReleaseCameraFrame,(SDL_CameraDevice *a, SDL_CameraFrame *b),(a,b),return)
+SDL_DYNAPI_PROC(int,SDL_StopCamera,(SDL_CameraDevice *a),(a),return)
+SDL_DYNAPI_PROC(void,SDL_CloseCamera,(SDL_CameraDevice *a),(a),)

src/video/SDL_video.c

@@ -458,7 +458,7 @@ int SDL_VideoInit(const char *driver_name)
     SDL_bool init_keyboard = SDL_FALSE;
     SDL_bool init_mouse = SDL_FALSE;
     SDL_bool init_touch = SDL_FALSE;
-    SDL_bool init_video_capture = SDL_FALSE;
+    SDL_bool init_camera = SDL_FALSE;
     int i = 0;
 
     /* Check to make sure we don't overwrite '_this' */
@@ -485,10 +485,10 @@ int SDL_VideoInit(const char *driver_name)
         goto pre_driver_error;
     }
     init_touch = SDL_TRUE;
-    if (SDL_VideoCaptureInit() < 0) {
+    if (SDL_CameraInit() < 0) {
         goto pre_driver_error;
     }
-    init_video_capture = SDL_TRUE;
+    init_camera = SDL_TRUE;
 
     /* Select the proper video driver */
     video = NULL;
@@ -590,8 +590,8 @@ int SDL_VideoInit(const char *driver_name)
 
 pre_driver_error:
     SDL_assert(_this == NULL);
-    if (init_video_capture) {
-        SDL_QuitVideoCapture();
+    if (init_camera) {
+        SDL_QuitCamera();
     }
     if (init_touch) {
         SDL_QuitTouch();
@@ -3784,7 +3784,7 @@ void SDL_VideoQuit(void)
     SDL_ClearClipboardData();
 
     /* Halt event processing before doing anything else */
-    SDL_QuitVideoCapture();
+    SDL_QuitCamera();
     SDL_QuitTouch();
     SDL_QuitMouse();
     SDL_QuitKeyboard();