Cppcheck report - GATE C/C++ Framework: gate/io/videosources_screen.c

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, Stefan Meislinger <sm@opengate.at>                 |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/
#include "gate/io/videosources.h"
#include "gate/platforms.h"
#include "gate/results.h"

#if defined(GATE_SYS_WIN)
#	if defined(GATE_SYS_WINSTORE) || defined(GATE_SYS_WIN16)
#		define GATE_IO_VIDEO_NO_IMPL
#	else
#		define GATE_IO_VIDEO_WINAPI
#		define GATE_IO_VIDEO_SCREEN_INTERFACE
#	endif
#elif defined(GATE_SYS_ANDROID)
#	define GATE_IO_VIDEO_ANDROID
#elif defined(GATE_SYS_LINUX)
#	define GATE_IO_VIDEO_X11
#	define GATE_IO_VIDEO_SCREEN_INTERFACE
#else
#	define GATE_IO_VIDEO_NO_IMPL
#endif



#if defined(GATE_IO_VIDEO_SCREEN_INTERFACE)

static char const* screenctrl_get_interface_name(void* thisptr);
static void screenctrl_release(void* thisptr);
static int screenctrl_retain(void* thisptr);

static char const* screenctrl_get_id(void* thisptr);
static char const* screenctrl_get_name(void* thisptr);
static gate_intptr_t screenctrl_get_handle(void* thisptr);
static gate_size_t screenctrl_get_supported_formats(void* thisptr, gate_video_format_t* format_buffer, gate_size_t format_buffer_count);

static gate_result_t screenctrl_open(void* thisptr, gate_video_format_t const* format);
static gate_result_t screenctrl_close(void* thisptr);

static gate_result_t screenctrl_read(void* thisptr, gate_video_frame_t* frame);

static gate_result_t screenctrl_get_cursor_pos(void* thisptr, gate_int32_t* ptr_x, gate_int32_t* ptr_y);
static gate_result_t screenctrl_move_cursor(void* thisptr, gate_int32_t x, gate_int32_t y);
static gate_result_t screenctrl_change_cursor_button_state(void* thisptr, gate_int32_t x, gate_int32_t y, gate_enumint_t button_id, gate_enumint_t button_state);
static gate_result_t screenctrl_change_key_state(void* thisptr, gate_input_keycode_t key_code, gate_enumint_t key_state);

static GATE_INTERFACE_VTBL(gate_video_screencontrol) const* init_video_screencontrol_vtbl()
{
    static GATE_INTERFACE_VTBL(gate_video_screencontrol) global_vtbl;
    if (global_vtbl.get_interface_name == NULL)
    {
        GATE_INTERFACE_VTBL(gate_video_screencontrol) const local_vtbl =
        {
            &screenctrl_get_interface_name,
            &screenctrl_release,
            &screenctrl_retain,

            &screenctrl_read,

            &screenctrl_get_id,
            &screenctrl_get_name,
            &screenctrl_get_handle,
            &screenctrl_get_supported_formats,

            &screenctrl_open,
            &screenctrl_close,

            &screenctrl_get_cursor_pos,
            &screenctrl_move_cursor,
            &screenctrl_change_cursor_button_state,
            &screenctrl_change_key_state
        };
        global_vtbl = local_vtbl;
    }

    return &global_vtbl;
}

#endif


#if defined(GATE_IO_VIDEO_WINAPI)

#include "gate/debugging.h"
#include "gate/graphics/platform/win32_gdi.h"

#if !defined(GATE_SYS_WINCE)
#define	GATE_USE_NT_DESKTOP_API 1
#endif

typedef struct win32screen_class
{
    GATE_INTERFACE_VTBL(gate_video_screencontrol) const* vtbl;

    gate_atomic_int_t ref_counter;

    unsigned x;
    unsigned y;
    unsigned width;
    unsigned height;
    unsigned bits_per_pixel;
    unsigned line_len;

    void* hdesk;
    TCHAR		deskname[128];
    gate_size_t	deskname_length;

    HDC			hscreen;
    HDC			hdc;
    HGDIOBJ		hbmp_backup;
    HBITMAP		hbmp;
    void* bitmap_bits;
    gate_size_t	bitmap_bits_length;

} win32screen_t;

typedef struct
{
    BITMAPINFO info;
    RGBQUAD	colors[256];
}  BITMAPINFO_PAL;

static unsigned init_bmp_pal(RGBQUAD* pal)
{
    gate_color_rgb_t gate_pal[256];
    unsigned pal_len = (unsigned)gate_color_palette_rgb8_create(gate_pal);
    unsigned ndx = 0;
    for (; ndx != pal_len; ++ndx)
    {
        pal[ndx].rgbRed = gate_pal[ndx].r;
        pal[ndx].rgbGreen = gate_pal[ndx].g;
        pal[ndx].rgbBlue = gate_pal[ndx].b;
        pal[ndx].rgbReserved = 0;
    }
    return pal_len;
}

static gate_bool_t win32_open_screen(win32screen_t* self)
{
    gate_win32_userapi_t* const user32 = gate_win32_userapi();
    gate_result_t succeeded = false;
    HDC screen = NULL;
    HDC mem = NULL;
    HBITMAP bmp = NULL;
    void* bits = NULL;
    BITMAPINFO_PAL bmpinfo_pal;
    BITMAPINFOHEADER* hdr = &bmpinfo_pal.info.bmiHeader;
    RGBQUAD* ptr_rgb;

    do
    {
        if (!user32) break;

        screen = user32->UserGetDC(NULL);
        if (!screen) break;

        mem = gdi.GdiCreateCompatibleDC(screen);
        if (!mem) break;

        gate_mem_clear(&bmpinfo_pal, sizeof(bmpinfo_pal));
        hdr->biSize = sizeof(BITMAPINFOHEADER);
        hdr->biWidth = (LONG)self->width;
        hdr->biHeight = (LONG)self->height;
        hdr->biPlanes = 1;
        hdr->biBitCount = self->bits_per_pixel;
        hdr->biCompression = BI_RGB;
        hdr->biSizeImage = 0;
        hdr->biXPelsPerMeter = 0;
        hdr->biYPelsPerMeter = 0;
        hdr->biClrImportant = 0;
        hdr->biClrUsed = 0;

        if (self->bits_per_pixel == 1)
        {
            hdr->biClrUsed = 2;
            ptr_rgb = &bmpinfo_pal.info.bmiColors[0];
            ptr_rgb->rgbBlue = ptr_rgb->rgbGreen = ptr_rgb->rgbRed = ptr_rgb->rgbReserved = 0;
            ptr_rgb = &bmpinfo_pal.info.bmiColors[1];
            ptr_rgb->rgbBlue = ptr_rgb->rgbGreen = ptr_rgb->rgbRed = 255;
            ptr_rgb->rgbReserved = 0;
        }
        else if (self->bits_per_pixel == 8)
        {
            hdr->biClrUsed = init_bmp_pal(&bmpinfo_pal.info.bmiColors[0]);
        }
        bmp = gdi.GdiCreateDIBSection(screen, &bmpinfo_pal.info, DIB_RGB_COLORS, &bits, NULL, 0);
        if (NULL == bmp) break;

        /* success-case: */
        self->hscreen = screen;
        self->hbmp_backup = gdi.GdiSelectObject(mem, (HGDIOBJ)bmp);
        self->hdc = mem;
        self->hbmp = bmp;
        self->bitmap_bits = bits;
        succeeded = true;
    } while (0);

    if (!succeeded)
    {
        if (mem) gdi.GdiDeleteDC(mem);
        if (screen) user32->UserReleaseDC(NULL, screen);
    }
    return succeeded;
}

static void win32_close_screen(win32screen_t* self)
{
    if (self->hdc)
    {
        gdi.GdiSelectObject(self->hdc, self->hbmp_backup);
        gdi.GdiDeleteObject((HGDIOBJ)self->hbmp);
        gdi.GdiDeleteDC(self->hdc);
        gdi.GdiDeleteDC(self->hscreen);
        self->hbmp_backup = NULL;
        self->hbmp = NULL;
        self->hdc = NULL;
    }

    if (self->hscreen)
    {
        self->hscreen = NULL;
    }
}

#if defined(GATE_USE_NT_DESKTOP_API)

static gate_size_t win32_get_desktop_name(void* hdesk, TCHAR* desktop_name_buffer, gate_size_t desktop_name_buffer_capacity)
{
    gate_win32_userapi_t* const user32 = gate_win32_userapi();
    DWORD bytes_needed;

    if (!user32 || !user32->UserGetUserObjectInformation ||
        !user32->UserGetUserObjectInformation(hdesk, UOI_NAME, desktop_name_buffer, (DWORD)desktop_name_buffer_capacity * sizeof(TCHAR), &bytes_needed))
    {
        /* api not available, or failed */
        return 0;
    }
    return bytes_needed / sizeof(TCHAR);
}

static gate_bool_t win32_open_input_desktop(void** ptr_hdesk, TCHAR* ptr_deskname, gate_size_t* ptr_deskname_length)
{
    gate_win32_userapi_t* const user32 = gate_win32_userapi();
    void* hdesk;

    if (!user32 || !user32->UserOpenInputDesktop)
    {
        return false;
    }

    hdesk = user32->UserOpenInputDesktop(0, FALSE, GENERIC_ALL);
    if (hdesk == NULL)
    {
        return false;
    }
    *ptr_deskname_length = win32_get_desktop_name(hdesk, ptr_deskname, *ptr_deskname_length);
    *ptr_hdesk = hdesk;
    return true;
}

static void win32_close_desktop(void** hdesk)
{
    if (*hdesk)
    {
        gate_win32_userapi_t* const user32 = gate_win32_userapi();
        user32->UserCloseDesktop((HDESK)*hdesk);
        *hdesk = NULL;
    }
}

static gate_bool_t win32_are_desktops_equal(void* desk1, TCHAR const* desk1name, gate_size_t desk1name_len, void* desk2, TCHAR const* desk2name, gate_size_t desk2name_len)
{
    if (desk1 == desk2)
    {
        return true;
    }
    if (desk1name_len != desk2name_len)
    {
        return false;
    }
    else
    {
        return 0 == gate_win32_winstr_comp_range(desk1name, desk2name, desk1name_len);
    }
}

static gate_bool_t win32_change_thread_desktop(void* target_desktop)
{
    gate_win32_userapi_t* const user32 = gate_win32_userapi();
    if (!user32 || !user32->UserSetThreadDesktop
        || !user32->UserSetThreadDesktop((HDESK)target_desktop))
    {
        GATE_DEBUG_TRACE("SetThreadDesktop() failed");
        return false;
    }
    return true;
}

static gate_bool_t screenctrl_update_desktop(win32screen_t* self)
{
    void* input_hdesk = NULL;
    TCHAR input_deskname[128];
    gate_size_t input_deskname_len = sizeof(input_deskname) / sizeof(input_deskname[0]);
    gate_bool_t result = win32_open_input_desktop(&input_hdesk, input_deskname, &input_deskname_len);
    if (!result)
    {
        GATE_DEBUG_TRACE("Failed to open input desktop");
        return false;
    }
    result = win32_are_desktops_equal(self->hdesk, self->deskname, self->deskname_length, input_hdesk, input_deskname, input_deskname_len);
    if (result)
    {
        /* desktops are equal, no change required */
        win32_close_desktop(&input_hdesk);
        return true;
    }
    /* switch to new desktop */
    result = win32_change_thread_desktop(input_hdesk);
    if (!result)
    {
        GATE_DEBUG_TRACE("Failed to switch thread-desktop");
        win32_close_desktop(&input_hdesk);
        return false;
    }
    /* close old desktop handle and screen objects */
    win32_close_screen(self);
    win32_close_desktop(&self->hdesk);
    /* install new desktop handle */
    self->hdesk = input_hdesk;
    gate_mem_copy(&self->deskname[0], input_deskname, input_deskname_len * sizeof(TCHAR));
    self->deskname_length = input_deskname_len;
    self->deskname[self->deskname_length] = 0;
    return true;
}

#endif /* GATE_USE_NT_DESKTOP_API */


static gate_bool_t screenctrl_is_screen_opened(win32screen_t* self)
{
    return (self->hscreen != NULL) && (self->hdc != NULL) && (self->hbmp != NULL);
}


static void screenctrl_destroy(win32screen_t* self)
{
    win32_close_screen(self);
#if defined(GATE_USE_NT_DESKTOP_API)
    win32_close_desktop(&self->hdesk);
#endif
}

static char const* screenctrl_get_interface_name(void* thisptr)
{
    return GATE_INTERFACE_NAME_VIDEO_SOURCE_SCREENCONTROL;
}

static void screenctrl_release(void* thisptr)
{
    win32screen_t* const self = (win32screen_t*)thisptr;
    if (gate_atomic_int_dec(&self->ref_counter) == 0)
    {
        screenctrl_destroy(self);
    }
}
static int screenctrl_retain(void* thisptr)
{
    win32screen_t* const self = (win32screen_t*)thisptr;
    return gate_atomic_int_inc(&self->ref_counter);
}

static char const* screenctrl_get_id(void* thisptr)
{
    return "screen";
}
static char const* screenctrl_get_name(void* thisptr)
{
    return "screen";
}
static gate_intptr_t screenctrl_get_handle(void* thisptr)
{
    win32screen_t* const self = (win32screen_t*)thisptr;
    return (gate_intptr_t)self->hscreen;
}

#ifndef SM_CXVIRTUALSCREEN
#define SM_CXVIRTUALSCREEN      78
#endif

#ifndef SM_CYVIRTUALSCREEN
#define SM_CYVIRTUALSCREEN      79
#endif

static gate_size_t screenctrl_get_supported_formats(void* thisptr, gate_video_format_t* format_buffer, gate_size_t format_buffer_count)
{
    gate_win32_userapi_t* const user32 = gate_win32_userapi();
    win32screen_t* const self = (win32screen_t*)thisptr;<--- Variable 'self' is assigned a value that is never used.
    int sx, sy;

    if ((format_buffer_count == 0) || (format_buffer == NULL))
    {
        return 0;
    }

    sx = user32->UserGetSystemMetrics(SM_CXVIRTUALSCREEN);
    sy = user32->UserGetSystemMetrics(SM_CYVIRTUALSCREEN);
    if (sx == 0) sx = user32->UserGetSystemMetrics(SM_CXSCREEN);
    if (sy == 0) sy = user32->UserGetSystemMetrics(SM_CYSCREEN);

    format_buffer->encoding_id = 0;
    format_buffer->compression = 0;
    format_buffer->frames_per_second = 5.0f;
    format_buffer->width = sx;
    format_buffer->height = sy;
    format_buffer->bits_per_pixel = 24;

    return 1;
}

static gate_bool_t screenctrl_is_opened(win32screen_t* self)
{
    if ((self->width == 0) || (self->height == 0) || (self->bits_per_pixel == 0))
    {
        return false;
    }
    return true;
}

static gate_result_t screenctrl_open(void* thisptr, gate_video_format_t const* format)
{
    win32screen_t* const self = (win32screen_t*)thisptr;

    if (screenctrl_is_opened(self))
    {
        return GATE_RESULT_INVALIDSTATE;
    }

    if ((NULL == format) || (format->width == 0) || (format->height == 0))
    {
        return GATE_RESULT_INVALIDARG;
    }

    switch (format->bits_per_pixel)
    {
    case 1:
    case 8:
    case 16:
    case 24:
        self->bits_per_pixel = format->bits_per_pixel;
        break;
    default:
        self->bits_per_pixel = 24;
        break;
    }

    self->x = 0;
    self->y = 0;
    self->width = format->width;
    self->height = format->height;
    self->line_len = ((self->bits_per_pixel * self->width) / 8 + 3) & 0xfffffffc;

#if defined(GATE_USE_NT_DESKTOP_API)
    screenctrl_update_desktop(self);
#endif

    return GATE_RESULT_OK;
}

static gate_result_t screenctrl_close(void* thisptr)
{
    win32screen_t* const self = (win32screen_t*)thisptr;

    win32_close_screen(self);
#if defined(GATE_USE_NT_DESKTOP_API)
    win32_close_desktop(&self->hdesk);
#endif

    self->width = 0;
    self->height = 0;
    self->bits_per_pixel;
    self->bitmap_bits = NULL;
    self->bitmap_bits_length = 0;

    return GATE_RESULT_OK;
}

static gate_result_t screenctrl_read(void* thisptr, gate_video_frame_t* frame)
{
    win32screen_t* const self = (win32screen_t*)thisptr;
    gate_bool_t update_succeeded;
    gate_rasterimage_t raster = GATE_INIT_EMPTY;
    unsigned y, x;
    unsigned char const* ptr_src;
    unsigned char* ptr_dst;

    if ((self->width == 0) || (self->height == 0))
    {
        return GATE_RESULT_INVALIDSTATE;
    }

#if defined(GATE_USE_NT_DESKTOP_API)
    update_succeeded = screenctrl_update_desktop(self);
    if (!update_succeeded)
    {
        GATE_DEBUG_TRACE("Failed to update desktop object");
    }
#endif

    if (!screenctrl_is_screen_opened(self))
    {
        if (!win32_open_screen(self))
        {
            GATE_DEBUG_TRACE("Failed to open screen");
            return GATE_RESULT_FAILED;
        }
    }

    update_succeeded = gdi.GdiBitBlt(self->hdc, 0, 0, self->width, self->height, self->hscreen, self->x, self->y, SRCCOPY);
    if (!update_succeeded)
    {
        GATE_DEBUG_TRACE("Failed to copy screen into memory buffer");
        return GATE_RESULT_FAILED;
    }

    switch (self->bits_per_pixel)
    {
    case 1:
    {
        if (NULL == gate_rasterimage_create(&raster, GATE_IMAGE_PIXELFORMAT_PAL8, self->width, self->height, NULL))
        {
            return GATE_RESULT_OUTOFMEMORY;
        }
        for (y = 0; y != self->height; ++y)
        {
            ptr_src = (unsigned char const*)self->bitmap_bits + (self->height - 1 - y) * self->line_len;
            ptr_dst = (unsigned char*)gate_rasterimage_get_line_ptr(&raster, y);
            for (x = 0; x != self->width; ++x)
            {
                gate_uint8_t b = ptr_src[x / 8];
                gate_uint8_t bit = x % 8;
                *ptr_dst = ((b & (1 << (7 - bit))) == 0) ? 0 : 15;
                ++ptr_dst;
            }
        }
        break;
    }
    case 8:
    {
        if (NULL == gate_rasterimage_create(&raster, GATE_IMAGE_PIXELFORMAT_PAL8, self->width, self->height, NULL))
        {
            return GATE_RESULT_OUTOFMEMORY;
        }
        for (y = 0; y != self->height; ++y)
        {
            ptr_src = (unsigned char const*)self->bitmap_bits + (self->height - 1 - y) * self->line_len;
            ptr_dst = (unsigned char*)gate_rasterimage_get_line_ptr(&raster, y);
            gate_mem_copy(ptr_dst, ptr_src, self->width);
        }
        break;
    }
    case 15:
    case 16:
    {
        if (NULL == gate_rasterimage_create(&raster, GATE_IMAGE_PIXELFORMAT_RGB555, self->width, self->height, NULL))
        {
            return GATE_RESULT_OUTOFMEMORY;
        }
        for (y = 0; y != self->height; ++y)
        {
            ptr_src = (unsigned char const*)self->bitmap_bits + (self->height - 1 - y) * self->line_len;
            ptr_dst = (unsigned char*)gate_rasterimage_get_line_ptr(&raster, y);
            for (x = 0; x != self->width; ++x)
            {
                gate_uint8_t const b = (ptr_src[0] & 0x1f) << 3;
                gate_uint8_t const g = ((ptr_src[0] >> 5) | ((ptr_src[1] & 0x03) << 3)) << 3;
                gate_uint8_t const r = (ptr_src[1] & 0x7c) << 1;

                unsigned const num = ((unsigned)(r >> 3)) << 10
                    | ((unsigned)(g >> 3)) << 5
                    | ((unsigned)(b >> 3));
                ptr_dst[0] = (gate_uint8_t)(num & 0xff);
                ptr_dst[1] = (gate_uint8_t)(num >> 8);

                ptr_src += 2;
                ptr_dst += 2;
            }
        }
        break;
    }
    case 24:
    {
        if (NULL == gate_rasterimage_create(&raster, GATE_IMAGE_PIXELFORMAT_RGB24, self->width, self->height, NULL))
        {
            return GATE_RESULT_OUTOFMEMORY;
        }
        for (y = 0; y != self->height; ++y)
        {
            ptr_src = (unsigned char const*)self->bitmap_bits + (self->height - 1 - y) * self->line_len;
            ptr_dst = (unsigned char*)gate_rasterimage_get_line_ptr(&raster, y);
            for (x = 0; x != self->width; ++x)
            {
                /* BGR to RGB */
                ptr_dst[0] = ptr_src[2];
                ptr_dst[1] = ptr_src[1];
                ptr_dst[2] = ptr_src[0];
                ptr_src += 3;
                ptr_dst += 3;
            }
        }
        break;
    }
    default:
    {
        return GATE_RESULT_NOTSUPPORTED;
    }
    }

    frame->format.encoding_id = 0;
    frame->format.compression = 0;
    frame->format.frames_per_second = 5.0f;
    frame->format.width = self->width;
    frame->format.height = self->height;
    frame->format.bits_per_pixel = self->bits_per_pixel;

    frame->record_time = 0;
    gate_mem_copy(&frame->image, &raster, sizeof(raster));
    return GATE_RESULT_OK;
}

static gate_result_t win32_send_input(INPUT* inp)
{
    gate_win32_userapi_t* const user32 = gate_win32_userapi();
    UINT result;

    if (!user32)
    {
        return GATE_RESULT_NOTAVAILABLE;
    }

    if (user32->UserSendInput)
    {
        result = user32->UserSendInput(1, inp, sizeof(INPUT));
        if (result != 1)
        {
            return GATE_RESULT_FAILED;
        }
        return GATE_RESULT_OK;
    }

    /* win95 NT 3.1 do not support SendInput: */
    if ((inp->type == INPUT_MOUSE) && (user32->UserMouse_event))
    {
        user32->UserMouse_event(inp->mi.dwFlags, inp->mi.dx, inp->mi.dy, inp->mi.mouseData, inp->mi.dwExtraInfo);
        return GATE_RESULT_OK;
    }

    if ((inp->type == INPUT_KEYBOARD) && (user32->UserKeybd_event))
    {
        user32->UserKeybd_event((BYTE)inp->ki.wVk, (BYTE)inp->ki.wScan, inp->ki.dwFlags, inp->ki.dwExtraInfo);
        return GATE_RESULT_OK;
    }

    return GATE_RESULT_NOTSUPPORTED;
}

#ifndef MOUSEEVENTF_VIRTUALDESK
#define MOUSEEVENTF_VIRTUALDESK	0x4000
#endif

static void win32_prepare_mouse_input(INPUT* inp, gate_int32_t x, gate_int32_t y)
{
    gate_win32_userapi_t* const user32 = gate_win32_userapi();

    int screen_width;
    int screen_height;

    if (user32)
    {
        screen_width = user32->UserGetSystemMetrics(SM_CXVIRTUALSCREEN);
        screen_height = user32->UserGetSystemMetrics(SM_CYVIRTUALSCREEN);
        if (screen_width == 0) screen_width = user32->UserGetSystemMetrics(SM_CXSCREEN);
        if (screen_height == 0) screen_height = user32->UserGetSystemMetrics(SM_CYSCREEN);
        inp->mi.dwExtraInfo = user32->UserGetMessageExtraInfo();
    }
    else
    {
        screen_width = 640;
        screen_height = 480;
        inp->mi.dwExtraInfo = 0;
    }

    inp->type = INPUT_MOUSE;
    inp->mi.dx = (screen_width > 0) ? (x * 65536 / screen_width) : 0;
    inp->mi.dy = (screen_height > 0) ? (y * 65536 / screen_height) : 0;
    inp->mi.mouseData = 0;
    inp->mi.dwFlags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE | MOUSEEVENTF_VIRTUALDESK;
    inp->mi.time = 0;
}

static gate_result_t screenctrl_get_cursor_pos(void* thisptr, gate_int32_t* ptr_x, gate_int32_t* ptr_y)
{
    gate_win32_userapi_t* const user32 = gate_win32_userapi();
    POINT pnt;
    if (!user32)
    {
        return GATE_RESULT_FAILED;
    }
    if (!user32->UserGetCursorPos(&pnt))
    {
        return GATE_RESULT_FAILED;
    }
    if (ptr_x) *ptr_x = pnt.x;
    if (ptr_y) *ptr_y = pnt.y;
    return GATE_RESULT_OK;
}
static gate_result_t screenctrl_move_cursor(void* thisptr, gate_int32_t x, gate_int32_t y)
{
    INPUT inp;
    win32_prepare_mouse_input(&inp, x, y);
    return win32_send_input(&inp);
}
static gate_result_t screenctrl_change_cursor_button_state(void* thisptr, gate_int32_t x, gate_int32_t y, gate_enumint_t button_id, gate_enumint_t button_state)
{
    INPUT inp;
    win32_prepare_mouse_input(&inp, x, y);
    if (GATE_FLAG_ENABLED(button_state, GATE_VIDEO_SCREENCONTROL_STATE_DOWN))
    {
        /* mouse down */
        if (button_id == GATE_VIDEO_SCREENCONTROL_BUTTON_LEFT)	inp.mi.dwFlags |= MOUSEEVENTF_LEFTDOWN;
        if (button_id == GATE_VIDEO_SCREENCONTROL_BUTTON_MIDDLE)	inp.mi.dwFlags |= MOUSEEVENTF_MIDDLEDOWN;
        if (button_id == GATE_VIDEO_SCREENCONTROL_BUTTON_RIGHT)	inp.mi.dwFlags |= MOUSEEVENTF_RIGHTDOWN;
    }
    else if (GATE_FLAG_ENABLED(button_state, GATE_VIDEO_SCREENCONTROL_STATE_UP))
    {
        /* mouse up */
        if (button_id == GATE_VIDEO_SCREENCONTROL_BUTTON_LEFT)	inp.mi.dwFlags |= MOUSEEVENTF_LEFTUP;
        if (button_id == GATE_VIDEO_SCREENCONTROL_BUTTON_MIDDLE)	inp.mi.dwFlags |= MOUSEEVENTF_MIDDLEUP;
        if (button_id == GATE_VIDEO_SCREENCONTROL_BUTTON_RIGHT)	inp.mi.dwFlags |= MOUSEEVENTF_RIGHTUP;
    }
    return win32_send_input(&inp);
}

static gate_input_keystates_t extract_state_keys_from_key_state_flags(gate_enumint_t key_state)
{
    gate_input_keystates_t value = 0;
    if (GATE_FLAG_ENABLED(key_state, GATE_VIDEO_SCREENCONTROL_STATE_CTRL)) value |= GATE_KBD_KEYSTATE_CTRL;
    if (GATE_FLAG_ENABLED(key_state, GATE_VIDEO_SCREENCONTROL_STATE_MENU)) value |= GATE_KBD_KEYSTATE_MENU;
    if (GATE_FLAG_ENABLED(key_state, GATE_VIDEO_SCREENCONTROL_STATE_SHIFT)) value |= GATE_KBD_KEYSTATE_SHIFT;
    return value;
}

static void win32_prepare_key_input(INPUT* inp, gate_input_keycode_t keycode, gate_input_keystates_t keystates, gate_bool_t down)
{
    gate_win32_userapi_t* const user32 = gate_win32_userapi();
    gate_input_nativekeycode_t vk = 0;

    if (user32 && user32->UserGetMessageExtraInfo)
    {
        inp->ki.dwExtraInfo = user32->UserGetMessageExtraInfo();
    }
    else
    {
        inp->ki.dwExtraInfo = 0;
    }

    inp->type = INPUT_KEYBOARD;
    gate_keyboard_build_native_key(keycode, keystates, &vk);
    inp->ki.wVk = (WORD)vk;
    inp->ki.wScan = 0;
    inp->ki.dwFlags = down ? 0 : KEYEVENTF_KEYUP;
    inp->ki.time = 0;
}

static gate_result_t screenctrl_change_key_state(void* thisptr, gate_input_keycode_t key_code, gate_enumint_t key_state)
{
    INPUT inp;
    gate_input_keystates_t state_keys = extract_state_keys_from_key_state_flags(key_state);
    win32_prepare_key_input(&inp, key_code, state_keys, GATE_FLAG_ENABLED(key_state, GATE_VIDEO_SCREENCONTROL_STATE_DOWN));
    return win32_send_input(&inp);
}


gate_result_t gate_video_screencontrol_create(gate_video_screencontrol_t** ptr_source)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    win32screen_t* impl = NULL;

    do
    {
        ret = gate_win32_gdi_init();
        GATE_BREAK_IF_FAILED(ret);

        impl = (win32screen_t*)gate_mem_alloc(sizeof(win32screen_t));
        if (impl == NULL)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        gate_mem_clear(impl, sizeof(win32screen_t));
        impl->vtbl = init_video_screencontrol_vtbl();
        gate_atomic_int_init(&impl->ref_counter, 1);

        if (ptr_source)
        {
            *ptr_source = (gate_video_screencontrol_t*)impl;
            impl = NULL;
        }
        ret = GATE_RESULT_OK;
    } while (0);

    if (impl != NULL)
    {
        screenctrl_release(impl);
    }

    return ret;
}


#endif


#if defined(GATE_IO_VIDEO_X11)

#include "gate/platform/posix/xlib.h"
#include "gate/debugging.h"

typedef struct x11screen_class
{
    GATE_INTERFACE_VTBL(gate_video_screencontrol) const* vtbl;

    gate_atomic_int_t ref_counter;
    Display* x11_display;
    Window x11_root;
    gate_video_format_t format;
    GC x11_gc;
    int x11_screen;
    Colormap x11_colmap;
} x11screen_t;


static gate_result_t x11screen_init(x11screen_t* self)
{
    gate_result_t result;

    do
    {
        result = gate_xlib_load_functions();
        GATE_BREAK_IF_FAILED(result);

        self->x11_display = xlib.XOpenDisplay(NULL);
        if (self->x11_display == NULL)
        {
            self->x11_display = xlib.XOpenDisplay(":0");
        }
        if (self->x11_display == NULL)
        {
            GATE_DEBUG_TRACE("Failed to open X11 display");
            result = GATE_RESULT_FAILED;
            break;
        }
        self->x11_root = xlib.XDefaultRootWindow(self->x11_display);

    } while (0);

    return result;
}

static void x11screen_destroy(x11screen_t* self)
{

    if (self->x11_display)
    {
        xlib.XCloseDisplay(self->x11_display);
        self->x11_display = NULL;
    }
}


static char const* screenctrl_get_interface_name(void* thisptr)
{
    return GATE_INTERFACE_NAME_VIDEO_SOURCE_SCREENCONTROL;
}


static void screenctrl_release(void* thisptr)
{
    x11screen_t* const self = (x11screen_t*)thisptr;
    if (gate_atomic_int_dec(&self->ref_counter) == 0)
    {
        x11screen_destroy(self);
        gate_mem_dealloc(self);
    }
}
static int screenctrl_retain(void* thisptr)
{
    x11screen_t* const self = (x11screen_t*)thisptr;
    return gate_atomic_int_inc(&self->ref_counter);
}
static char const* screenctrl_get_id(void* thisptr)
{
    return "screen";
}
static char const* screenctrl_get_name(void* thisptr)
{
    return "screen";
}
static gate_intptr_t screenctrl_get_handle(void* thisptr)
{
    x11screen_t* const self = (x11screen_t*)thisptr;
    return (gate_intptr_t)self->x11_display;
}
static gate_size_t screenctrl_get_supported_formats(void* thisptr, gate_video_format_t* format_buffer, gate_size_t format_buffer_count)
{
    x11screen_t* const self = (x11screen_t*)thisptr;
    XWindowAttributes attrs = GATE_INIT_EMPTY;

    if ((format_buffer == NULL) || (format_buffer_count < 1))
    {
        GATE_DEBUG_TRACE("Not enough space in output buffer");
        return 0;
    }

    /* get screen dimensions */
    xlib.XGetWindowAttributes(self->x11_display, self->x11_root, &attrs);

    format_buffer->encoding_id = 0;
    format_buffer->compression = 0;
    format_buffer->frames_per_second = 5;
    format_buffer->width = (gate_uint32_t)attrs.width;
    format_buffer->height = (gate_uint32_t)attrs.height;
    format_buffer->bits_per_pixel = 32;

    return 1;	/* one entry was used */
}

static gate_result_t screenctrl_open(void* thisptr, gate_video_format_t const* format)
{
    x11screen_t* const self = (x11screen_t*)thisptr;

    if (self->x11_gc != NULL)
    {
        GATE_DEBUG_TRACE("Error: X11 GC is already initialized");
        return GATE_RESULT_INVALIDSTATE;
    }

    gate_mem_copy(&self->format, format, sizeof(gate_video_format_t));

    self->x11_gc = xlib.XCreateGC(self->x11_display, self->x11_root, 0, NULL);
    if (!self->x11_gc)
    {
        GATE_DEBUG_TRACE("Error: Failed to create GC on current display");
        return GATE_RESULT_FAILED;
    }
    self->x11_screen = xlib.XDefaultScreen(self->x11_display);
    self->x11_colmap = xlib.XDefaultColormap(self->x11_display, self->x11_screen);
    return GATE_RESULT_OK;
}
static gate_result_t screenctrl_close(void* thisptr)
{
    x11screen_t* const self = (x11screen_t*)thisptr;

    if (!self->x11_gc)
    {
        xlib.XFreeGC(self->x11_display, self->x11_gc);
        self->x11_gc = NULL;
        self->x11_screen = 0;
        self->x11_colmap = 0;
    }
    return GATE_RESULT_OK;
}

static gate_result_t ximage32_to_raster(XImage* ptr_ximage, gate_rasterimage_t* ptr_raster)
{
    unsigned char const* ptr_src_pixel = (unsigned char const*)ptr_ximage->data;
    gate_color_rgb_t* ptr_dst_pixel;
<--- The scope of the variable 'ptr_dst_pixel' can be reduced. [+]
The scope of the variable 'ptr_dst_pixel' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    unsigned int y, x;

    if (NULL == gate_rasterimage_create(ptr_raster, GATE_IMAGE_PIXELFORMAT_RGB24,
        (unsigned)ptr_ximage->width, (unsigned)ptr_ximage->height, NULL))
    {
        return GATE_RESULT_OUTOFMEMORY;
    }

    for (y = 0; y != ptr_raster->height; ++y)
    {
        ptr_dst_pixel = (gate_color_rgb_t*)gate_rasterimage_get_line_ptr(ptr_raster, y);
        for (x = 0; x != ptr_raster->width; ++x)
        {
            ptr_dst_pixel->b = *(ptr_src_pixel++);
            ptr_dst_pixel->g = *(ptr_src_pixel++);
            ptr_dst_pixel->r = *(ptr_src_pixel++);
            ++ptr_src_pixel;	/* skip A value */
            ++ptr_dst_pixel;
        }
    }
    return GATE_RESULT_OK;
}

static gate_result_t ximage16_to_raster(XImage* ptr_ximage, gate_rasterimage_t* ptr_raster)
{
    unsigned char const* ptr_src_pixel = (unsigned char const*)ptr_ximage->data;
    gate_color_rgb_t* ptr_dst_pixel;
<--- The scope of the variable 'ptr_dst_pixel' can be reduced. [+]
The scope of the variable 'ptr_dst_pixel' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    unsigned int y, x;

    if (NULL == gate_rasterimage_create(ptr_raster, GATE_IMAGE_PIXELFORMAT_RGB24,
        (unsigned)ptr_ximage->width, (unsigned)ptr_ximage->height, NULL))
    {
        return GATE_RESULT_OUTOFMEMORY;
    }

    for (y = 0; y != ptr_raster->height; ++y)
    {
        ptr_dst_pixel = (gate_color_rgb_t*)gate_rasterimage_get_line_ptr(ptr_raster, y);
        for (x = 0; x != ptr_raster->width; ++x)
        {
            const gate_uint16_t col = (gate_uint16_t)(ptr_src_pixel[0]) | (((gate_uint16_t)ptr_src_pixel[1]) << 8);
            ptr_dst_pixel->b = (gate_uint8_t)((col & 0x001F) << 3);
            ptr_dst_pixel->g = (gate_uint8_t)((col & 0x07e0) >> 3);
            ptr_dst_pixel->r = (gate_uint8_t)((col & 0xF800) >> 8);
            ptr_src_pixel += 2;
            ++ptr_dst_pixel;
        }
    }
    return GATE_RESULT_OK;
}

static gate_result_t ximage_to_raster(Display* display, Colormap colmap, XImage* ptr_ximage, gate_rasterimage_t* ptr_raster)
{
    gate_color_rgb_t* ptr_dst_pixel;
<--- The scope of the variable 'ptr_dst_pixel' can be reduced. [+]
The scope of the variable 'ptr_dst_pixel' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    unsigned int y, x;
    XColor xcol;

    if (NULL == gate_rasterimage_create(ptr_raster, GATE_IMAGE_PIXELFORMAT_RGB24,
        (unsigned)ptr_ximage->width, (unsigned)ptr_ximage->height, NULL))
    {
        return GATE_RESULT_OUTOFMEMORY;
    }

    for (y = 0; y != ptr_raster->height; ++y)
    {
        ptr_dst_pixel = (gate_color_rgb_t*)gate_rasterimage_get_line_ptr(ptr_raster, y);
        for (x = 0; x != ptr_raster->width; ++x)
        {
            xcol.pixel = xlib.XGetPixel(ptr_ximage, (int)x, (int)y);
            xlib.XQueryColor(display, colmap, &xcol);

            ptr_dst_pixel->r = (gate_uint8_t)(xcol.red >> 8);
            ptr_dst_pixel->g = (gate_uint8_t)(xcol.green >> 8);
            ptr_dst_pixel->b = (gate_uint8_t)(xcol.blue >> 8);
            ++ptr_dst_pixel;
        }
    }
    return GATE_RESULT_OK;
}

static gate_result_t screenctrl_read(void* thisptr, gate_video_frame_t* frame)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    x11screen_t* const self = (x11screen_t*)thisptr;
    XImage* ptr_ximage = NULL;
    gate_rasterimage_t raster = GATE_INIT_EMPTY;

    do
    {
        ptr_ximage = xlib.XGetImage(self->x11_display, self->x11_root,
            0, 0, self->format.width, self->format.height, AllPlanes, ZPixmap);
        if (ptr_ximage == NULL)
        {
            ret = GATE_RESULT_FAILED;
            break;
        }

        if ((ptr_ximage->bits_per_pixel == 32) && (ptr_ximage->depth == 24))
        {
            ret = ximage32_to_raster(ptr_ximage, &raster);
        }
        else if ((ptr_ximage->bits_per_pixel == 16) && (ptr_ximage->depth == 16))
        {
            ret = ximage16_to_raster(ptr_ximage, &raster);
        }
        else
        {
            ret = ximage_to_raster(self->x11_display, self->x11_colmap, ptr_ximage, &raster);
        }

        GATE_BREAK_IF_FAILED(ret);

        frame->format.bits_per_pixel = raster.bits_per_pixel;
        frame->format.compression = 0;
        frame->format.encoding_id = 0;
        frame->format.frames_per_second = self->format.frames_per_second;
        frame->format.width = raster.width;
        frame->format.height = raster.height;
        gate_rasterimage_duplicate(&frame->image, &raster);
        frame->record_time = 0;

        ret = GATE_RESULT_OK;
    } while (0);

    gate_rasterimage_release(&raster);

    if (ptr_ximage != NULL)
    {
        xlib.XDestroyImage(ptr_ximage);
    }

    return ret;
}

static gate_result_t screenctrl_get_cursor_pos(void* thisptr, gate_int32_t* ptr_x, gate_int32_t* ptr_y)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    x11screen_t* const self = (x11screen_t*)thisptr;
    Window win, subwin;
    int gx, gy, wx, wy;
    unsigned int state;

    if (xlib.XQueryPointer(self->x11_display, self->x11_root, &win, &subwin, &gx, &gy, &wx, &wy, &state))
    {
        if (ptr_x) *ptr_x = gx;
        if (ptr_y) *ptr_y = gy;
        return GATE_RESULT_OK;
    }
    return GATE_RESULT_FAILED;
}

static gate_result_t screenctrl_move_cursor(void* thisptr, gate_int32_t x, gate_int32_t y)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    x11screen_t* const self = (x11screen_t*)thisptr;
    xlib.XWarpPointer(self->x11_display, None, self->x11_root, 0, 0, 0, 0, (int)x, (int)y);
    return GATE_RESULT_OK;
}

static gate_result_t screenctrl_change_cursor_button_state(void* thisptr, gate_int32_t x, gate_int32_t y, gate_enumint_t button_id, gate_enumint_t button_state)
{
    /* http://www.linuxquestions.org/questions/programming-9/simulating-a-mouse-click-594576/ */

    gate_result_t ret = GATE_RESULT_FAILED;
    x11screen_t* const self = (x11screen_t*)thisptr;
    XEvent xevt = GATE_INIT_EMPTY;
    XButtonEvent* evt = &xevt.xbutton;

    xlib.XWarpPointer(self->x11_display, None, self->x11_root, 0, 0, 0, 0, (int)x, (int)y);

    /* find inner sub-window */
    evt->type = (button_state == GATE_VIDEO_SCREENCONTROL_STATE_DOWN) ? ButtonPress : ButtonRelease;
    evt->display = self->x11_display;
    evt->same_screen = True;
    evt->time = CurrentTime;

    evt->subwindow = self->x11_root;
    do
    {
        evt->window = evt->subwindow;
        xlib.XQueryPointer(self->x11_display, evt->window, &evt->root, &evt->subwindow, &evt->x_root, &evt->y_root, &evt->x, &evt->y, &evt->state);
    } while (evt->subwindow != 0);



    evt->state = 0;
    if (button_id == GATE_VIDEO_SCREENCONTROL_BUTTON_LEFT)
    {
        evt->button = Button1;
        evt->state |= Button1Mask;
    }
    else if (button_id == GATE_VIDEO_SCREENCONTROL_BUTTON_MIDDLE)
    {
        evt->button = Button2;
        evt->state |= Button2Mask;
    }
    else if (button_id == GATE_VIDEO_SCREENCONTROL_BUTTON_RIGHT)
    {
        evt->button = Button3;
        evt->state |= Button3Mask;
    }

    xlib.XSendEvent(self->x11_display, PointerWindow, True, 0xfff, &xevt);
    xlib.XFlush(self->x11_display);

    return GATE_RESULT_OK;
}

static gate_result_t screenctrl_change_key_state(void* thisptr, gate_input_keycode_t key_code, gate_enumint_t key_state)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    x11screen_t* const self = (x11screen_t*)thisptr;
    XKeyEvent evt;
    int focus_state;
    Window focus_win = self->x11_root;
    KeySym x11_key_sym = key_code;
    gate_bool_t key_down = GATE_FLAG_ENABLED(key_state, GATE_VIDEO_SCREENCONTROL_STATE_DOWN);
    unsigned int x11_state = 0;

    if (key_down && GATE_FLAG_ENABLED(key_state, GATE_VIDEO_SCREENCONTROL_STATE_CTRL))
    {
        x11_state |= ControlMask;
    }
    if (key_down && GATE_FLAG_ENABLED(key_state, GATE_VIDEO_SCREENCONTROL_STATE_MENU))
    {
        x11_state |= Mod1Mask;
    }
    if (key_down && GATE_FLAG_ENABLED(key_state, GATE_VIDEO_SCREENCONTROL_STATE_SHIFT))
    {
        x11_state |= ShiftMask;
    }

    xlib.XGetInputFocus(self->x11_display, &focus_win, &focus_state);

    evt.display = self->x11_display;
    evt.window = focus_win;
    evt.root = self->x11_root;
    evt.subwindow = None;
    evt.time = CurrentTime;
    evt.x = 1;
    evt.y = 1;
    evt.x_root = 1;
    evt.y_root = 1;
    evt.same_screen = True;
    evt.send_event = True;
    evt.keycode = xlib.XKeysymToKeycode(self->x11_display, x11_key_sym);
    evt.state = x11_state;
    evt.type = key_down ? KeyPress : KeyRelease;
    xlib.XSendEvent(evt.display, evt.window, True, KeyPressMask, (XEvent*)&evt);

    return GATE_RESULT_OK;
}



gate_result_t gate_video_screencontrol_create(gate_video_screencontrol_t** ptr_source)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    x11screen_t* impl = NULL;

    do
    {
        impl = (x11screen_t*)gate_mem_alloc(sizeof(x11screen_t));
        if (impl == NULL)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        gate_mem_clear(impl, sizeof(x11screen_t));
        impl->vtbl = init_video_screencontrol_vtbl();
        gate_atomic_int_init(&impl->ref_counter, 1);

        ret = x11screen_init(impl);
        GATE_BREAK_IF_FAILED(ret);

        if (ptr_source)
        {
            *ptr_source = (gate_video_screencontrol_t*)impl;
            impl = NULL;
        }
        ret = GATE_RESULT_OK;
    } while (0);

    if (impl != NULL)
    {
        screenctrl_release(impl);
    }

    return ret;
}

#endif

#if defined(GATE_IO_VIDEO_ANDROID)

gate_result_t gate_video_screencontrol_create(gate_video_screencontrol_t** ptr_source)
{
    GATE_UNUSED_ARG(ptr_source);
    /* TODO */
    return GATE_RESULT_NOTSUPPORTED;
}

#endif


#if defined(GATE_IO_VIDEO_NO_IMPL)

gate_result_t gate_video_screencontrol_create(gate_video_screencontrol_t** ptr_source)
{
    GATE_UNUSED_ARG(ptr_source);
    return GATE_RESULT_NOTSUPPORTED;
}

#endif