/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Copyright (C) 2019, Google Inc. * * format_convert.cpp - qcam - Convert buffer to RGB */ #include #include #include #include "format_converter.h" #define RGBSHIFT 8 #ifndef MAX #define MAX(a,b) ((a)>(b)?(a):(b)) #endif #ifndef MIN #define MIN(a,b) ((a)<(b)?(a):(b)) #endif #ifndef CLAMP #define CLAMP(a,low,high) MAX((low),MIN((high),(a))) #endif #ifndef CLIP #define CLIP(x) CLAMP(x,0,255) #endif int FormatConverter::configure(unsigned int format, unsigned int width, unsigned int height) { switch (format) { case V4L2_PIX_FMT_NV12: formatFamily_ = NV; horzSubSample_ = 2; vertSubSample_ = 2; nvSwap_ = false; break; case V4L2_PIX_FMT_NV21: formatFamily_ = NV; horzSubSample_ = 2; vertSubSample_ = 2; nvSwap_ = true; break; case V4L2_PIX_FMT_NV16: formatFamily_ = NV; horzSubSample_ = 2; vertSubSample_ = 1; nvSwap_ = false; break; case V4L2_PIX_FMT_NV61: formatFamily_ = NV; horzSubSample_ = 2; vertSubSample_ = 1; nvSwap_ = true; break; case V4L2_PIX_FMT_NV24: formatFamily_ = NV; horzSubSample_ = 1; vertSubSample_ = 1; nvSwap_ = false; break; case V4L2_PIX_FMT_NV42: formatFamily_ = NV; horzSubSample_ = 1; vertSubSample_ = 1; nvSwap_ = true; break; case V4L2_PIX_FMT_BGR24: formatFamily_ = RGB; r_pos_ = 2; g_pos_ = 1; b_pos_ = 0; bpp_ = 3; break; case V4L2_PIX_FMT_RGB24: formatFamily_ = RGB; r_pos_ = 0; g_pos_ = 1; b_pos_ = 2; bpp_ = 3; break; case V4L2_PIX_FMT_ARGB32: formatFamily_ = RGB; r_pos_ = 1; g_pos_ = 2; b_pos_ = 3; bpp_ = 4; break; case V4L2_PIX_FMT_VYUY: formatFamily_ = YUV; y_pos_ = 1; cb_pos_ = 2; break; case V4L2_PIX_FMT_YVYU: formatFamily_ = YUV; y_pos_ = 0; cb_pos_ = 3; break; case V4L2_PIX_FMT_UYVY: formatFamily_ = YUV; y_pos_ = 1; cb_pos_ = 0; break; case V4L2_PIX_FMT_YUYV: formatFamily_ = YUV; y_pos_ = 0; cb_pos_ = 1; break; case V4L2_PIX_FMT_MJPEG: formatFamily_ = MJPEG; break; default: return -EINVAL; }; format_ = format; width_ = width; height_ = height; return 0; } void FormatConverter::convert(const unsigned char *src, size_t size, QImage *dst) { switch (formatFamily_) { case MJPEG: dst->loadFromData(src, size, "JPEG"); break; case YUV: convertYUV(src, dst->bits()); break; case RGB: convertRGB(src, dst->bits()); break; case NV: convertNV(src, dst->bits()); break; }; } static void yuv_to_rgb(int y, int u, int v, int *r, int *g, int *b) { int c = y - 16; int d = u - 128; int e = v - 128; *r = CLIP(( 298 * c + 409 * e + 128) >> RGBSHIFT); *g = CLIP(( 298 * c - 100 * d - 208 * e + 128) >> RGBSHIFT); *b = CLIP(( 298 * c + 516 * d + 128) >> RGBSHIFT); } void FormatConverter::convertNV(const unsigned char *src, unsigned char *dst) { unsigned int c_stride = width_ * (2 / horzSubSample_); unsigned int c_inc = horzSubSample_ == 1 ? 2 : 0; unsigned int cb_pos = nvSwap_ ? 1 : 0; unsigned int cr_pos = nvSwap_ ? 0 : 1; const unsigned char *src_c = src + width_ * height_; int r, g, b; for (unsigned int y = 0; y < height_; y++) { const unsigned char *src_y = src + y * width_; const unsigned char *src_cb = src_c + (y / vertSubSample_) * c_stride + cb_pos; const unsigned char *src_cr = src_c + (y / vertSubSample_) * c_stride + cr_pos; for (unsigned int x = 0; x < width_; x += 2) { yuv_to_rgb(*src_y, *src_cb, *src_cr, &r, &g, &b); dst[0] = b; dst[1] = g; dst[2] = r; dst[3] = 0xff; src_y++; src_cb += c_inc; src_cr += c_inc; dst += 4; yuv_to_rgb(*src_y, *src_cb, *src_cr, &r, &g, &b); dst[0] = b; dst[1] = g; dst[2] = r; dst[3] = 0xff; src_y++; src_cb += 2; src_cr += 2; dst += 4; } } } void FormatConverter::convertRGB(const unsigned char *src, unsigned char *dst) { unsigned int x, y; int r, g, b; for (y = 0; y < height_; y++) { for (x = 0; x < width_; x++) { r = src[bpp_ * x + r_pos_]; g = src[bpp_ * x + g_pos_]; b = src[bpp_ * x + b_pos_]; dst[4 * x + 0] = b; dst[4 * x + 1] = g; dst[4 * x + 2] = r; dst[4 * x + 3] = 0xff; } src += width_ * bpp_; dst += width_ * 4; } } void FormatConverter::convertYUV(const unsigned char *src, unsigned char *dst) { unsigned int src_x, src_y, dst_x, dst_y; unsigned int src_stride; unsigned int dst_stride; unsigned int cr_pos; int r, g, b, y, cr, cb; cr_pos = (cb_pos_ + 2) % 4; src_stride = width_ * 2; dst_stride = width_ * 4; for (src_y = 0, dst_y = 0; dst_y < height_; src_y++, dst_y++) { for (src_x = 0, dst_x = 0; dst_x < width_; ) { cb = src[src_y * src_stride + src_x * 4 + cb_pos_]; cr = src[src_y * src_stride + src_x * 4 + cr_pos]; y = src[src_y * src_stride + src_x * 4 + y_pos_]; yuv_to_rgb(y, cb, cr, &r, &g, &b); dst[dst_y * dst_stride + 4 * dst_x + 0] = b; dst[dst_y * dst_stride + 4 * dst_x + 1] = g; dst[dst_y * dst_stride + 4 * dst_x + 2] = r; dst[dst_y * dst_stride + 4 * dst_x + 3] = 0xff; dst_x++; y = src[src_y * src_stride + src_x * 4 + y_pos_ + 2]; yuv_to_rgb(y, cb, cr, &r, &g, &b); dst[dst_y * dst_stride + 4 * dst_x + 0] = b; dst[dst_y * dst_stride + 4 * dst_x + 1] = g; dst[dst_y * dst_stride + 4 * dst_x + 2] = r; dst[dst_y * dst_stride + 4 * dst_x + 3] = 0xff; dst_x++; src_x++; } } } n66' href='#n66'>66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184

# SPDX-License-Identifier: GPL-2.0-or-later
# Copyright (C) 2022, Tomi Valkeinen <tomi.valkeinen@ideasonboard.com>

import pykms
import selectors
import sys


class KMSRenderer:
    def __init__(self, state):
        self.state = state

        self.cm = state.cm
        self.contexts = state.contexts
        self.running = False

        card = pykms.Card()

        res = pykms.ResourceManager(card)
        conn = res.reserve_connector()
        crtc = res.reserve_crtc(conn)
        mode = conn.get_default_mode()
        modeb = mode.to_blob(card)

        req = pykms.AtomicReq(card)
        req.add_connector(conn, crtc)
        req.add_crtc(crtc, modeb)
        r = req.commit_sync(allow_modeset=True)
        assert(r == 0)

        self.card = card
        self.resman = res
        self.crtc = crtc
        self.mode = mode

        self.bufqueue = []
        self.current = None
        self.next = None
        self.cam_2_drm = {}

    # KMS

    def close(self):
        req = pykms.AtomicReq(self.card)
        for s in self.streams:
            req.add_plane(s['plane'], None, None, dst=(0, 0, 0, 0))
        req.commit()

    def add_plane(self, req, stream, fb):
        s = next(s for s in self.streams if s['stream'] == stream)
        idx = s['idx']
        plane = s['plane']

        if idx % 2 == 0:
            x = 0
        else:
            x = self.mode.hdisplay - fb.width

        if idx // 2 == 0:
            y = 0
        else:
            y = self.mode.vdisplay - fb.height

        req.add_plane(plane, fb, self.crtc, dst=(x, y, fb.width, fb.height))

    def apply_request(self, drmreq):

        buffers = drmreq['camreq'].buffers

        req = pykms.AtomicReq(self.card)

        for stream, fb in buffers.items():
            drmfb = self.cam_2_drm.get(fb, None)
            self.add_plane(req, stream, drmfb)

        req.commit()

    def handle_page_flip(self, frame, time):
        old = self.current
        self.current = self.next

        if len(self.bufqueue) > 0:
            self.next = self.bufqueue.pop(0)
        else:
            self.next = None

        if self.next:
            drmreq = self.next

            self.apply_request(drmreq)

        if old:
            req = old['camreq']
            ctx = old['camctx']
            self.state.request_processed(ctx, req)

    def queue(self, drmreq):
        if not self.next:
            self.next = drmreq
            self.apply_request(drmreq)
        else:
            self.bufqueue.append(drmreq)

    # libcamera

    def setup(self):
        self.streams = []

        idx = 0
        for ctx in self.contexts:
            for stream in ctx.streams:

                cfg = stream.configuration
                fmt = cfg.pixel_format