camera: Renamed "video_capture" files to "camera" and moved to own subdir.

src/camera/SDL_camera.c

@@ -0,0 +1,968 @@
+/*
+  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_camera.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
+
+
+#ifdef SDL_VIDEO_CAPTURE
+/* list node entries to share frames between SDL and user app */
+typedef struct entry_t
+{
+    SDL_VideoCaptureFrame frame;
+} entry_t;
+
+static SDL_VideoCaptureDevice *open_devices[16];
+
+static void
+close_device(SDL_VideoCaptureDevice *device)
+{
+    if (!device) {
+        return;
+    }
+
+    SDL_AtomicSet(&device->shutdown, 1);
+    SDL_AtomicSet(&device->enabled, 1);
+
+    if (device->thread != NULL) {
+        SDL_WaitThread(device->thread, NULL);
+    }
+    if (device->device_lock != NULL) {
+        SDL_DestroyMutex(device->device_lock);
+    }
+    if (device->acquiring_lock != NULL) {
+        SDL_DestroyMutex(device->acquiring_lock);
+    }
+
+    {
+        int i, n = SDL_arraysize(open_devices);
+        for (i = 0; i < n; i++) {
+            if (open_devices[i] == device) {
+                open_devices[i] = NULL;
+            }
+        }
+    }
+
+    {
+        entry_t *entry = NULL;
+        while (device->buffer_queue != NULL) {
+            SDL_ListPop(&device->buffer_queue, (void**)&entry);
+            if (entry) {
+                SDL_VideoCaptureFrame f = entry->frame;
+                /* Release frames not acquired, if any */
+                if (f.timestampNS) {
+                    ReleaseFrame(device, &f);
+                }
+                SDL_free(entry);
+            }
+        }
+    }
+
+    CloseDevice(device);
+
+    SDL_free(device->dev_name);
+    SDL_free(device);
+}
+
+/* Tell if all device are closed */
+SDL_bool check_all_device_closed(void)
+{
+    int i, n = SDL_arraysize(open_devices);
+    int all_closed = SDL_TRUE;
+    for (i = 0; i < n; i++) {
+        if (open_devices[i]) {
+            all_closed = SDL_FALSE;
+            break;
+        }
+    }
+    return all_closed;
+}
+
+/* Tell if at least one device is in playing state */
+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) {
+                return SDL_TRUE;
+            }
+        }
+    }
+    return SDL_FALSE;
+}
+
+
+#endif /* SDL_VIDEO_CAPTURE */
+
+void
+SDL_CloseVideoCapture(SDL_VideoCaptureDevice *device)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    if (!device) {
+        SDL_InvalidParamError("device");
+        return;
+    }
+    close_device(device);
+#endif
+}
+
+int
+SDL_StartVideoCapture(SDL_VideoCaptureDevice *device)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    SDL_VideoCaptureStatus status;
+    int result;
+    if (!device) {
+        return SDL_InvalidParamError("device");
+    }
+
+    if (device->is_spec_set == SDL_FALSE) {
+        return SDL_SetError("no spec set");
+    }
+
+    status = SDL_GetVideoCaptureStatus(device);
+    if (status != SDL_VIDEO_CAPTURE_INIT) {
+        return SDL_SetError("invalid state");
+    }
+
+    result = StartCapture(device);
+    if (result < 0) {
+        return result;
+    }
+
+    SDL_AtomicSet(&device->enabled, 1);
+
+    return 0;
+#else
+    return SDL_Unsupported();
+#endif
+}
+
+int
+SDL_GetVideoCaptureSpec(SDL_VideoCaptureDevice *device, SDL_VideoCaptureSpec *spec)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    if (!device) {
+        return SDL_InvalidParamError("device");
+    }
+
+    if (!spec) {
+        return SDL_InvalidParamError("spec");
+    }
+
+    SDL_zerop(spec);
+
+    return GetDeviceSpec(device, spec);
+#else
+    return SDL_Unsupported();
+#endif
+}
+
+int
+SDL_StopVideoCapture(SDL_VideoCaptureDevice *device)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    SDL_VideoCaptureStatus status;
+    int ret;
+    if (!device) {
+        return SDL_InvalidParamError("device");
+    }
+
+    status = SDL_GetVideoCaptureStatus(device);
+
+    if (status != SDL_VIDEO_CAPTURE_PLAYING) {
+        return SDL_SetError("invalid state");
+    }
+
+    SDL_AtomicSet(&device->enabled, 0);
+    SDL_AtomicSet(&device->shutdown, 1);
+
+    SDL_LockMutex(device->acquiring_lock);
+    ret = StopCapture(device);
+    SDL_UnlockMutex(device->acquiring_lock);
+
+    if (ret < 0) {
+        return -1;
+    }
+
+    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)
+{
+    /* Check format */
+    {
+        int i, num = SDL_GetNumVideoCaptureFormats(device);
+        int is_format_valid = 0;
+
+        for (i = 0; i < num; i++) {
+            Uint32 format;
+            if (SDL_GetVideoCaptureFormat(device, i, &format) == 0) {
+                if (format == desired->format && format != SDL_PIXELFORMAT_UNKNOWN) {
+                    is_format_valid = 1;
+                    obtained->format = format;
+                    break;
+                }
+            }
+        }
+
+        if (!is_format_valid) {
+            if (allowed_changes) {
+                for (i = 0; i < num; i++) {
+                    Uint32 format;
+                    if (SDL_GetVideoCaptureFormat(device, i, &format) == 0) {
+                        if (format != SDL_PIXELFORMAT_UNKNOWN) {
+                            obtained->format = format;
+                            is_format_valid = 1;
+                            break;
+                        }
+                    }
+                }
+
+            } else {
+                SDL_SetError("Not allowed to change the format");
+                return -1;
+            }
+        }
+
+        if (!is_format_valid) {
+            SDL_SetError("Invalid format");
+            return -1;
+        }
+    }
+
+    /* Check frame size */
+    {
+        int i, num = SDL_GetNumVideoCaptureFrameSizes(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 (desired->width == w && desired->height == h) {
+                    is_framesize_valid = 1;
+                    obtained->width = w;
+                    obtained->height = h;
+                    break;
+                }
+            }
+        }
+
+        if (!is_framesize_valid) {
+            if (allowed_changes) {
+                int w, h;
+                if (SDL_GetVideoCaptureFrameSize(device, obtained->format, 0, &w, &h) == 0) {
+                    is_framesize_valid = 1;
+                    obtained->width = w;
+                    obtained->height = h;
+                }
+            } else {
+                SDL_SetError("Not allowed to change the frame size");
+                return -1;
+            }
+        }
+
+        if (!is_framesize_valid) {
+            SDL_SetError("Invalid frame size");
+            return -1;
+        }
+
+    }
+
+    return 0;
+}
+
+#endif /* SDL_VIDEO_CAPTURE */
+
+const char *
+SDL_GetVideoCaptureDeviceName(SDL_VideoCaptureDeviceID instance_id)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    static char buf[256];
+    buf[0] = 0;
+    buf[255] = 0;
+
+    if (instance_id == 0) {
+        SDL_InvalidParamError("instance_id");
+        return NULL;
+    }
+
+    if (GetDeviceName(instance_id, buf, sizeof (buf)) < 0) {
+        buf[0] = 0;
+    }
+    return buf;
+#else
+    SDL_Unsupported();
+    return NULL;
+#endif
+}
+
+
+SDL_VideoCaptureDeviceID *
+SDL_GetVideoCaptureDevices(int *count)
+{
+
+    int num = 0;
+    SDL_VideoCaptureDeviceID *ret = NULL;
+#ifdef SDL_VIDEO_CAPTURE
+    ret = GetVideoCaptureDevices(&num);
+#endif
+
+    if (ret) {
+        if (count) {
+            *count = num;
+        }
+        return ret;
+    }
+
+    /* return list of 0 ID, null terminated */
+    num = 0;
+    ret = (SDL_VideoCaptureDeviceID *)SDL_malloc((num + 1) * sizeof(*ret));
+
+    if (ret == NULL) {
+        SDL_OutOfMemory();
+        if (count) {
+            *count = 0;
+        }
+        return NULL;
+    }
+
+    ret[num] = 0;
+    if (count) {
+        *count = num;
+    }
+
+    return ret;
+}
+
+#ifdef SDL_VIDEO_CAPTURE
+
+/* Video capture thread function */
+static int SDLCALL
+SDL_CaptureVideoThread(void *devicep)
+{
+    const int delay = 20;
+    SDL_VideoCaptureDevice *device = (SDL_VideoCaptureDevice *) devicep;
+
+#if DEBUG_VIDEO_CAPTURE_CAPTURE
+    SDL_Log("Start thread 'SDL_CaptureVideo'");
+#endif
+
+
+#ifdef SDL_VIDEO_DRIVER_ANDROID
+    // TODO
+    /*
+    {
+        // Set thread priority to THREAD_PRIORITY_VIDEO
+        extern void Android_JNI_VideoCaptureSetThreadPriority(int, int);
+        Android_JNI_VideoCaptureSetThreadPriority(device->iscapture, device);
+    }*/
+#else
+    /* The video_capture mixing is always a high priority thread */
+    SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);
+#endif
+
+    /* Perform any thread setup */
+    device->threadid = SDL_GetCurrentThreadID();
+
+    /* Init state */
+    while (!SDL_AtomicGet(&device->enabled)) {
+        SDL_Delay(delay);
+    }
+
+    /* Loop, filling the video_capture buffers */
+    while (!SDL_AtomicGet(&device->shutdown)) {
+        SDL_VideoCaptureFrame f;
+        int ret;
+        entry_t *entry;
+
+        SDL_zero(f);
+
+        SDL_LockMutex(device->acquiring_lock);
+        ret = AcquireFrame(device, &f);
+        SDL_UnlockMutex(device->acquiring_lock);
+
+        if (ret == 0) {
+            if (f.num_planes == 0) {
+                continue;
+            }
+        }
+
+        if (ret < 0) {
+            /* Flag it as an error */
+#if DEBUG_VIDEO_CAPTURE_CAPTURE
+            SDL_Log("dev[%p] error AcquireFrame: %d %s", (void *)device, ret, SDL_GetError());
+#endif
+            f.num_planes = 0;
+        }
+
+
+        entry = SDL_malloc(sizeof (entry_t));
+        if (entry == NULL) {
+            goto error_mem;
+        }
+
+        entry->frame = f;
+
+        SDL_LockMutex(device->device_lock);
+        ret = SDL_ListAdd(&device->buffer_queue, entry);
+        SDL_UnlockMutex(device->device_lock);
+
+        if (ret < 0) {
+            SDL_free(entry);
+            goto error_mem;
+        }
+    }
+
+#if DEBUG_VIDEO_CAPTURE_CAPTURE
+    SDL_Log("dev[%p] End thread 'SDL_CaptureVideo'", (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());
+#endif
+    SDL_AtomicSet(&device->shutdown, 1);
+    SDL_OutOfMemory();
+    return 0;
+}
+#endif
+
+SDL_VideoCaptureDevice *
+SDL_OpenVideoCapture(SDL_VideoCaptureDeviceID instance_id)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    int i, n = SDL_arraysize(open_devices);
+    int id = -1;
+    SDL_VideoCaptureDevice *device = NULL;
+    const char *device_name = NULL;
+
+    if (!SDL_WasInit(SDL_INIT_VIDEO)) {
+        SDL_SetError("Video subsystem is not initialized");
+        goto error;
+    }
+
+    /* !!! FIXME: there is a race condition here if two devices open from two threads at once. */
+    /* Find an available device ID... */
+    for (i = 0; i < n; i++) {
+        if (open_devices[i] == NULL) {
+            id = i;
+            break;
+        }
+    }
+
+    if (id == -1) {
+        SDL_SetError("Too many open video capture devices");
+        goto error;
+    }
+
+    if (instance_id != 0) {
+        device_name = SDL_GetVideoCaptureDeviceName(instance_id);
+        if (device_name == NULL) {
+            goto error;
+        }
+    } else {
+        SDL_VideoCaptureDeviceID *devices = SDL_GetVideoCaptureDevices(NULL);
+        if (devices && devices[0]) {
+            device_name = SDL_GetVideoCaptureDeviceName(devices[0]);
+            SDL_free(devices);
+        }
+    }
+
+#if 0
+    // FIXME do we need this ?
+    /* Let the user override. */
+    {
+        const char *dev = SDL_getenv("SDL_VIDEO_CAPTURE_DEVICE_NAME");
+        if (dev && dev[0]) {
+            device_name = dev;
+        }
+    }
+#endif
+
+    if (device_name == NULL) {
+        goto error;
+    }
+
+    device = (SDL_VideoCaptureDevice *) SDL_calloc(1, sizeof (SDL_VideoCaptureDevice));
+    if (device == NULL) {
+        SDL_OutOfMemory();
+        goto error;
+    }
+    device->dev_name = SDL_strdup(device_name);
+
+
+    SDL_AtomicSet(&device->shutdown, 0);
+    SDL_AtomicSet(&device->enabled, 0);
+
+    device->device_lock = SDL_CreateMutex();
+    if (device->device_lock == NULL) {
+        SDL_SetError("Couldn't create acquiring_lock");
+        goto error;
+    }
+
+    device->acquiring_lock = SDL_CreateMutex();
+    if (device->acquiring_lock == NULL) {
+        SDL_SetError("Couldn't create acquiring_lock");
+        goto error;
+    }
+
+    if (OpenDevice(device) < 0) {
+        goto error;
+    }
+
+    /* empty */
+    device->buffer_queue = NULL;
+    open_devices[id] = device;  /* add it to our list of open devices. */
+
+
+    /* Start the video_capture 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);
+
+        if (device->thread == NULL) {
+            SDL_SetError("Couldn't create video_capture thread");
+            goto error;
+        }
+    }
+
+    return device;
+
+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,
+        int allowed_changes)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    SDL_VideoCaptureSpec _obtained;
+    SDL_VideoCaptureSpec _desired;
+    int result;
+
+    if (!device) {
+        return SDL_InvalidParamError("device");
+    }
+
+    if (device->is_spec_set == SDL_TRUE) {
+        return SDL_SetError("already configured");
+    }
+
+    if (!desired) {
+        SDL_zero(_desired);
+        desired = &_desired;
+        allowed_changes = SDL_VIDEO_CAPTURE_ALLOW_ANY_CHANGE;
+    } else {
+        /* in case desired == obtained */
+        _desired = *desired;
+        desired = &_desired;
+    }
+
+    if (!obtained) {
+        obtained = &_obtained;
+    }
+
+    SDL_zerop(obtained);
+
+    if (prepare_video_capturespec(device, desired, obtained, allowed_changes) < 0) {
+        return -1;
+    }
+
+    device->spec = *obtained;
+
+    result = InitDevice(device);
+    if (result < 0) {
+        return result;
+    }
+
+    *obtained = device->spec;
+
+    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)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    if (!device) {
+        return SDL_InvalidParamError("device");
+    }
+
+    if (!frame) {
+        return SDL_InvalidParamError("frame");
+    }
+
+    SDL_zerop(frame);
+
+    if (device->thread == NULL) {
+        int ret;
+
+        /* Wait for a frame */
+        while ((ret = AcquireFrame(device, frame)) == 0) {
+            if (frame->num_planes) {
+                return 0;
+            }
+        }
+        return -1;
+    } else {
+        entry_t *entry = NULL;
+
+        SDL_LockMutex(device->device_lock);
+        SDL_ListPop(&device->buffer_queue, (void**)&entry);
+        SDL_UnlockMutex(device->device_lock);
+
+        if (entry) {
+            *frame = entry->frame;
+            SDL_free(entry);
+
+            /* Error from thread */
+            if (frame->num_planes == 0 && frame->timestampNS == 0) {
+                return SDL_SetError("error from acquisition thread");
+            }
+
+
+        } else {
+            /* Queue is empty. Not an error. */
+        }
+    }
+
+    return 0;
+#else
+    return SDL_Unsupported();
+#endif /* SDL_VIDEO_CAPTURE */
+}
+
+int
+SDL_ReleaseVideoCaptureFrame(SDL_VideoCaptureDevice *device, SDL_VideoCaptureFrame *frame)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    if (!device) {
+        return SDL_InvalidParamError("device");
+    }
+
+    if (frame == NULL) {
+        return SDL_InvalidParamError("frame");
+    }
+
+    if (ReleaseFrame(device, frame) < 0) {
+        return -1;
+    }
+
+    SDL_zerop(frame);
+
+    return 0;
+#else
+    return SDL_Unsupported();
+#endif /* SDL_VIDEO_CAPTURE */
+}
+
+int
+SDL_GetNumVideoCaptureFormats(SDL_VideoCaptureDevice *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)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    if (!device) {
+        return SDL_InvalidParamError("device");
+    }
+    if (!format) {
+        return SDL_InvalidParamError("format");
+    }
+    *format = 0;
+    return GetFormat(device, index, format);
+#else
+    return SDL_Unsupported();
+#endif /* SDL_VIDEO_CAPTURE */
+}
+
+int
+SDL_GetNumVideoCaptureFrameSizes(SDL_VideoCaptureDevice *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)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    if (!device) {
+        return SDL_InvalidParamError("device");
+    }
+    if (!width) {
+        return SDL_InvalidParamError("width");
+    }
+    if (!height) {
+        return SDL_InvalidParamError("height");
+    }
+    *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,
+        int allowed_changes)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    SDL_VideoCaptureDevice *device;
+
+    if ((device = SDL_OpenVideoCapture(instance_id)) == NULL) {
+        return NULL;
+    }
+
+    if (SDL_SetVideoCaptureSpec(device, desired, obtained, allowed_changes) < 0) {
+        SDL_CloseVideoCapture(device);
+        return NULL;
+    }
+    return device;
+#else
+    SDL_Unsupported();
+    return NULL;
+#endif
+}
+
+SDL_VideoCaptureStatus
+SDL_GetVideoCaptureStatus(SDL_VideoCaptureDevice *device)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    if (device == NULL) {
+        return SDL_VIDEO_CAPTURE_INIT;
+    }
+
+    if (device->is_spec_set == SDL_FALSE) {
+        return SDL_VIDEO_CAPTURE_INIT;
+    }
+
+    if (SDL_AtomicGet(&device->shutdown)) {
+        return SDL_VIDEO_CAPTURE_STOPPED;
+    }
+
+    if (SDL_AtomicGet(&device->enabled)) {
+        return SDL_VIDEO_CAPTURE_PLAYING;
+    }
+    return SDL_VIDEO_CAPTURE_INIT;
+#else
+    SDL_Unsupported();
+    return SDL_VIDEO_CAPTURE_FAIL;
+#endif
+}
+
+int
+SDL_VideoCaptureInit(void)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    SDL_zeroa(open_devices);
+
+    SDL_SYS_VideoCaptureInit();
+    return 0;
+#else
+    return 0;
+#endif
+}
+
+void
+SDL_QuitVideoCapture(void)
+{
+#ifdef SDL_VIDEO_CAPTURE
+    int i, n = SDL_arraysize(open_devices);
+    for (i = 0; i < n; i++) {
+        close_device(open_devices[i]);
+    }
+
+    SDL_zeroa(open_devices);
+
+    SDL_SYS_VideoCaptureQuit();
+#endif
+}
+
+#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 */