circuitpython/shared-bindings/usb_video/USBFramebuffer.c

// This file is part of the CircuitPython project: https://circuitpython.org
//
// SPDX-FileCopyrightText: Copyright (c) 2024 Jeff Epler for Adafruit Industries
//
// SPDX-License-Identifier: MIT

#include "py/obj.h"
#include "py/objproperty.h"

#include "shared-bindings/usb_video/__init__.h"
#include "shared-bindings/usb_video/USBFramebuffer.h"
#include "shared-module/displayio/__init__.h"
#include "shared-module/framebufferio/FramebufferDisplay.h"
#include "shared-module/framebufferio/__init__.h"
#include "shared-module/usb_video/__init__.h"
#include "shared-module/usb_video/USBFramebuffer.h"
#include "shared-bindings/util.h"

static void check_for_deinit(usb_video_uvcframebuffer_obj_t *self) {
    if (!shared_module_usb_video_uvcframebuffer_get_width(self)) {
        raise_deinited_error();
    }
}

//| class USBFramebuffer:
//|     """Displays to a USB connected computer using the UVC protocol
//|
//|     The data in the framebuffer is in RGB565_SWAPPED format.
//|
//|     This object is most often used with `framebufferio.FramebufferDisplay`. However,
//|     it also supports the ``WritableBuffer`` protocol and can be accessed
//|     as an array of ``H`` (unsigned 16-bit values)."""
//|
//|     def __init__(self) -> None:
//|         """Returns the singleton framebuffer object, if USB video is enabled"""
//|
static mp_obj_t usb_video_uvcframebuffer_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *all_args) {
    static const mp_arg_t allowed_args[] = {};
    mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
    mp_arg_parse_all_kw_array(n_args, n_kw, all_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
    usb_video_uvcframebuffer_obj_t *self = &usb_video_uvcframebuffer_singleton_obj;
    return self;
}

//|     def refresh(self) -> None:
//|         """Transmits the color data in the buffer to the pixels so that
//|         they are shown."""
//|         ...
//|
static mp_obj_t usb_video_uvcframebuffer_refresh(mp_obj_t self_in) {
    usb_video_uvcframebuffer_obj_t *self = (usb_video_uvcframebuffer_obj_t *)self_in;
    check_for_deinit(self);
    shared_module_usb_video_uvcframebuffer_refresh(self);
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_1(usb_video_uvcframebuffer_refresh_obj, usb_video_uvcframebuffer_refresh);

//|     width: int
//|     """The width of the display, in pixels"""
static mp_obj_t usb_video_uvcframebuffer_get_width(mp_obj_t self_in) {
    usb_video_uvcframebuffer_obj_t *self = (usb_video_uvcframebuffer_obj_t *)self_in;
    check_for_deinit(self);
    return MP_OBJ_NEW_SMALL_INT(shared_module_usb_video_uvcframebuffer_get_width(self));
}
MP_DEFINE_CONST_FUN_OBJ_1(usb_video_uvcframebuffer_get_width_obj, usb_video_uvcframebuffer_get_width);
MP_PROPERTY_GETTER(usb_video_uvcframebuffer_width_obj,
    (mp_obj_t)&usb_video_uvcframebuffer_get_width_obj);

//|     height: int
//|     """The height of the display, in pixels"""
//|
//|
static mp_obj_t usb_video_uvcframebuffer_get_height(mp_obj_t self_in) {
    usb_video_uvcframebuffer_obj_t *self = (usb_video_uvcframebuffer_obj_t *)self_in;
    check_for_deinit(self);
    return MP_OBJ_NEW_SMALL_INT(shared_module_usb_video_uvcframebuffer_get_height(self));
}
MP_DEFINE_CONST_FUN_OBJ_1(usb_video_uvcframebuffer_get_height_obj, usb_video_uvcframebuffer_get_height);

MP_PROPERTY_GETTER(usb_video_uvcframebuffer_height_obj,
    (mp_obj_t)&usb_video_uvcframebuffer_get_height_obj);

static const mp_rom_map_elem_t usb_video_uvcframebuffer_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_refresh), MP_ROM_PTR(&usb_video_uvcframebuffer_refresh_obj) },
    { MP_ROM_QSTR(MP_QSTR_width), MP_ROM_PTR(&usb_video_uvcframebuffer_width_obj) },
    { MP_ROM_QSTR(MP_QSTR_height), MP_ROM_PTR(&usb_video_uvcframebuffer_height_obj) },
};
static MP_DEFINE_CONST_DICT(usb_video_uvcframebuffer_locals_dict, usb_video_uvcframebuffer_locals_dict_table);

static void usb_video_uvcframebuffer_get_bufinfo(mp_obj_t self_in, mp_buffer_info_t *bufinfo) {
    shared_module_usb_video_uvcframebuffer_get_bufinfo(self_in, bufinfo);
}

// These version exists so that the prototype matches the protocol,
// avoiding a type cast that can hide errors
static void usb_video_uvcframebuffer_swapbuffers(mp_obj_t self_in, uint8_t *dirty_row_bitmap) {
    (void)dirty_row_bitmap;
    shared_module_usb_video_uvcframebuffer_refresh(self_in);
}

static void usb_video_uvcframebuffer_deinit_proto(mp_obj_t self_in) {
    /* NOTHING */
}

static int usb_video_uvcframebuffer_get_width_proto(mp_obj_t self_in) {
    return shared_module_usb_video_uvcframebuffer_get_width(self_in);
}

static int usb_video_uvcframebuffer_get_height_proto(mp_obj_t self_in) {
    return shared_module_usb_video_uvcframebuffer_get_height(self_in);
}

static int usb_video_uvcframebuffer_get_native_frames_per_second_proto(mp_obj_t self_in) {
    return 10;
}

static bool usb_video_uvcframebuffer_get_reverse_pixels_in_word_proto(mp_obj_t self_in) {
    return true;
}


static const framebuffer_p_t usb_video_uvcframebuffer_proto = {
    MP_PROTO_IMPLEMENT(MP_QSTR_protocol_framebuffer)
    .get_bufinfo = usb_video_uvcframebuffer_get_bufinfo,
    .get_width = usb_video_uvcframebuffer_get_width_proto,
    .get_height = usb_video_uvcframebuffer_get_height_proto,
    .get_native_frames_per_second = usb_video_uvcframebuffer_get_native_frames_per_second_proto,
    .swapbuffers = usb_video_uvcframebuffer_swapbuffers,
    .deinit = usb_video_uvcframebuffer_deinit_proto,
    .get_reverse_pixels_in_word = usb_video_uvcframebuffer_get_reverse_pixels_in_word_proto,
};

static mp_int_t usb_video_uvcframebuffer_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
    shared_module_usb_video_uvcframebuffer_get_bufinfo(self_in, bufinfo);
    bufinfo->typecode = 'H';
    return 0;
}

MP_DEFINE_CONST_OBJ_TYPE(
    usb_video_USBFramebuffer_type,
    MP_QSTR_USBFramebuffer,
    MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS,
    locals_dict, &usb_video_uvcframebuffer_locals_dict,
    make_new, usb_video_uvcframebuffer_make_new,
    buffer, usb_video_uvcframebuffer_get_buffer,
    protocol, &usb_video_uvcframebuffer_proto
    );