grab.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later AND BSD-3-Clause
 
/*
 * Portions of this file are derived from Raspberry Pi SAND conversion code:
 *
 * Copyright (c) 2018 Raspberry Pi (Trading) Ltd.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of the copyright holder nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * 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 HOLDER 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.
 *
 * Authors: John Cox
 */
 
extern "C" {
#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>
}
 
#include <sys/mman.h>
 
#include <drm_fourcc.h>
 
#include "drmbuffer.h"
#include "grab.h"
#include "logger.h"
#include "videorender.h"
 
/****************************************************************************************
 * Image data conversion helpers
 ***************************************************************************************/
#define OPAQUE      0xff
#define TRANSPARENT 0x00
#define UNMULTIPLY(color, alpha) ((0xff * color) / alpha)
#define BLEND(back, front, alpha) ((front * alpha) + (back * (255 - alpha))) / 255
 
// --- Begin Raspberry Pi BSD-licensed code ---
 
void Sand128ToPlanarY8(uint8_t *dst, const unsigned int dstStride, const uint8_t *src,
                       unsigned int stride1, unsigned int stride2,
                       unsigned int w, unsigned int h)
{
    const unsigned int mask = stride1 - 1;
 
    if (w < stride1) {
        // All in one sand stripe
        const uint8_t *p = src;
        for (unsigned int i = 0; i != h; ++i, dst += dstStride, p += stride1) {
            memcpy(dst, p, w);
        }
    } else {
        const unsigned int sstride = stride1 * stride2;
        const uint8_t *p1 = src;
        const uint8_t *p2 = p1 + sstride;
        const unsigned int w1 = stride1;
        const unsigned int w3 = w & mask;
        const unsigned int w2 = w - (w1 + w3);
 
        for (unsigned int i = 0; i != h; ++i, dst += dstStride, p1 += stride1, p2 += stride1) {
            unsigned int j;
            const uint8_t *p = p2;
            uint8_t *d = dst;
            memcpy(d, p1, w1);
            d += w1;
            for (j = 0; j < w2; j += stride1, d += stride1, p += sstride) {
                memcpy(d, p, stride1);
            }
            memcpy(d, p, w3);
        }
    }
}
 
static void Sand30ToPlanarY16(uint8_t *dst, const unsigned int dstStride,
                              const uint8_t *src,
                              unsigned int stride1, unsigned int stride2,
                              unsigned int w, unsigned int h)
{
    const unsigned int x1 = (w / 3) * 4;
    const unsigned int xrem1 = w - (x1 >> 2) * 3;
    const unsigned int mask = stride1 - 1;
 
    const uint8_t *p0 = src;
    const unsigned int sliceInc = ((stride2 - 1) * stride1) >> 2;
 
    if (x1 == 0)
        return;
 
    for (unsigned int i = 0; i != h; ++i, dst += dstStride, p0 += stride1) {
        unsigned int x = 0;
        const uint32_t *p = (const uint32_t *)p0;
        uint16_t *d = (uint16_t *)dst;
 
        while (x != x1) {
            const uint32_t p3 = *p++;
            *d++ = p3 & 0x3ff;
            *d++ = (p3 >> 10) & 0x3ff;
            *d++ = (p3 >> 20) & 0x3ff;
 
            if (((x += 4) & mask) == 0)
                p += sliceInc;
        }
 
        if (xrem1 != 0) {
            const uint32_t p3 = *p;
 
            *d++ = p3 & 0x3ff;
            if (xrem1 == 2)
                *d++ = (p3 >> 10) & 0x3ff;
        }
    }
}
 
static void Sand30ToPlanarC16(uint8_t *dstU, const unsigned int dstStrideU,
                              uint8_t *dstV, const unsigned int dstStrideV,
                              const uint8_t *src,
                              unsigned int stride1, unsigned int stride2,
                              unsigned int w, unsigned int h)
{
    const unsigned int x1 = (w / 3) * 8;
    const unsigned int xrem1 = w - (x1 >> 3) * 3;
    const unsigned int mask = stride1 - 1;
 
    const uint8_t *p0 = src;
    const unsigned int sliceInc = ((stride2 - 1) * stride1) >> 2;
 
    if (x1 == 0)
        return;
 
    for (unsigned int i = 0; i != h; ++i, dstU += dstStrideU, dstV += dstStrideV, p0 += stride1) {
        unsigned int x = 0;
        const uint32_t *p = (const uint32_t *)p0;
        uint16_t *du = (uint16_t *)dstU;
        uint16_t *dv = (uint16_t *)dstV;
 
        while (x != x1) {
            const uint32_t p3a = *p++;
            const uint32_t p3b = *p++;
 
            *du++ = p3a & 0x3ff;
            *dv++ = (p3a >> 10) & 0x3ff;
            *du++ = (p3a >> 20) & 0x3ff;
            *dv++ = p3b & 0x3ff;
            *du++ = (p3b >> 10) & 0x3ff;
            *dv++ = (p3b >> 20) & 0x3ff;
 
            if (((x += 8) & mask) == 0)
                p += sliceInc;
        }
 
        if (xrem1 != 0) {
            const uint32_t p3a = *p++;
            const uint32_t p3b = *p++;
 
            *du++ = p3a & 0x3ff;
            *dv++ = (p3a >> 10) & 0x3ff;
            if (xrem1 == 2) {
                *du++ = (p3a >> 20) & 0x3ff;
                *dv++ = p3b & 0x3ff;
            }
        }
    }
}
// --- End Raspberry Pi BSD-licensed code ---
 
enum AVPixelFormat DrmFormatToAVFormat(uint32_t pixFmt)
{
    switch (pixFmt) {
        case DRM_FORMAT_NV12:
            return AV_PIX_FMT_NV12;
        case DRM_FORMAT_YUV420:
            return AV_PIX_FMT_YUV420P;
        case DRM_FORMAT_ARGB8888:
            return AV_PIX_FMT_RGBA;
        case DRM_FORMAT_P030:
            return AV_PIX_FMT_YUV420P10;
        default:
            return AV_PIX_FMT_NONE;
    }
 
    return AV_PIX_FMT_NONE;
}
 
static uint8_t *ScaleRgb24(uint8_t *src, int *size, int srcW, int srcH, int dstW, int dstH)
{
    struct SwsContext *swsCtx;
    int dstBufsize = 0;
    int ret;
 
    uint8_t *dstData[4];
    int dstLinesize[4];
    uint8_t *srcData[4] = {src, NULL, NULL, NULL};
    int srcLinesize[4] = {3 * srcW, 0, 0, 0};
 
    swsCtx = sws_getContext(srcW, srcH, AV_PIX_FMT_RGB24,
                            dstW, dstH, AV_PIX_FMT_RGB24,
                            SWS_BILINEAR, NULL, NULL, NULL);
    if (!swsCtx) {
        LOGERROR("%s: Could not create swsCtx", __FUNCTION__);
        return NULL;
    }
 
    if ((ret = av_image_alloc(dstData, dstLinesize, dstW, dstH, AV_PIX_FMT_RGB24, 1)) < 0) {
        LOGERROR("%s: Could not alloc dst image", __FUNCTION__);
        sws_freeContext(swsCtx);
        return NULL;
    }
    dstBufsize = ret;
 
    sws_scale(swsCtx,
              (const uint8_t * const*)srcData, srcLinesize, 0, srcH,
              dstData, dstLinesize);
 
    sws_freeContext(swsCtx);
    *size = dstBufsize;
 
    LOGDEBUG2(L_GRAB, "%s: return scaled image at %p size %d", __FUNCTION__, dstData[0], dstBufsize);
    return dstData[0];
}
 
static void AlphaBlend(uint8_t *result, uint8_t *front, uint8_t *back, const unsigned int width, const unsigned int height)
{
    for (unsigned long index = 0; index < width * height; index++) {
        const uint8_t frontAlpha = front[3];
 
        if (frontAlpha == TRANSPARENT) {
            for (int i = 0; i < 3; i++) {
                result[i] = back[i];
            }
            back += 3;
            front += 4;
            result += 3;
            continue;
        }
 
        if (frontAlpha == OPAQUE) {
            for (int i = 0; i < 3; i++) {
                result[i] = front[i];
            }
            back += 3;
            front += 4;
            result += 3;
            continue;
        }
 
        const uint8_t backR = back[0];
        const uint8_t backG = back[1];
        const uint8_t backB = back[2];
 
        const uint8_t frontR = UNMULTIPLY(front[0], frontAlpha);
        const uint8_t frontG = UNMULTIPLY(front[1], frontAlpha);
        const uint8_t frontB = UNMULTIPLY(front[2], frontAlpha);
 
        const uint8_t R = BLEND(backR, frontR, frontAlpha);
        const uint8_t G = BLEND(backG, frontG, frontAlpha);
        const uint8_t B = BLEND(backB, frontB, frontAlpha);
 
        result[0] = R;
        result[1] = G;
        result[2] = B;
 
        back += 3;
        front += 4;
        result += 3;
    }
}
 
static int BlitVideo(uint8_t *dst, uint8_t *src, int dstW, int dstH, int dstX, int dstY, int srcW, int srcH)
{
    int srcStride = srcW * 3;
    int dstStride = dstW * 3;
 
    if ((dstX + srcW > dstW) || (dstY + srcH > dstH)) {
        LOGDEBUG2(L_GRAB, "%s: wrong dimensions, cropping not supported!", __FUNCTION__);
        return -1;
    }
 
    // blit the (scaled) image into dst
    for (int y = 0; y < srcH; y++) {
        memcpy(&dst[((dstY + y) * dstStride + dstX * 3)], &src[y * srcStride], srcStride);
    }
 
    return 0;
}
 
extern "C" uint8_t * CreateJpeg(uint8_t * image, int *size, int quality,
    int width, int height)
{
    return (uint8_t *) RgbToJpeg((uchar *) image, width, height, *size, quality);
}
 
/*****************************************************************************
 * cGrabBuffer class
 ****************************************************************************/
 
void cGrabBuffer::FreeInput(void)
{
    // early return, because the grab buffer wasn't set
    if (m_outputRect.IsEmpty())
        return;
 
    // free the allocated memory
    for (int plane = 0; plane < m_numPlanes; plane++) {
        if (m_size[plane]) {
            LOGDEBUG2(L_GRAB, "%s: %s: free buf %p (plane %d)", m_identifier, __FUNCTION__, m_pPlane[plane], plane);
            free(m_pPlane[plane]);
        }
    }
 
    // reset member variables
    m_width = 0;
    m_height = 0;
    m_pixFmt = 0;
    m_modifier = 0;
    m_numPlanes = 0;
 
    for (int i = 0; i < 4; i++) {
        m_offset[i] = 0;
        m_pitch[i] = 0;
        m_size[i] = 0;
        m_pPlane[i] = nullptr;
    }
}
 
void cGrabBuffer::Clear(void)
{
    FreeInput(); // input should already be freed and reset after ConvertToRgb
 
    m_outputRect.Set(0, 0, 0, 0);
    m_outputSize = 0;
    m_pOutputData = nullptr; // result needs to be freed by the caller of GetGrabbedData()
}
 
void cGrabBuffer::Set(cDrmBuffer *src)
{
    if (src->GetScreenRect().IsEmpty())
        return;
 
    void *src_buffer = nullptr;
    void *dst_buffer = nullptr;
 
    // planes aren't mmapped, do it (PRIME)
    if (!src->Plane(0)) {
        for (int object = 0; object < src->NumObjects(); object++) {
 
            // memcpy mmapped data
            dst_buffer = malloc(src->Size(object));
            if (!dst_buffer) {
                LOGERROR("%s: %s: cannot allocate destination buffer (%d): %m", m_identifier, __FUNCTION__, errno);
                // @todo handle possible leaks of previous objects
                return;
            }
 
            src_buffer = mmap(NULL, src->Size(object), PROT_READ, MAP_SHARED, src->DmaBufHandle(object), 0);
            if (src_buffer == MAP_FAILED) {
                free(dst_buffer);
                LOGERROR("%s: %s: cannot map buffer size %d prime_fd %d (%d): %m",
                    m_identifier, __FUNCTION__, src->Size(object), src->DmaBufHandle(object), errno);
                // @todo handle possible leaks of previous objects
                return;
            }
 
            memcpy(dst_buffer, src_buffer, src->Size(object));
            munmap(src_buffer, src->Size(object));
 
            for (int plane = 0; plane < src->NumPlanes(); plane++) {
                if (src->ObjectIndex(plane) == object)
                    m_pPlane[plane] = (uint8_t *)dst_buffer;
            }
        }
    } else {
        for (int plane = 0; plane < src->NumPlanes(); plane++) {
            if (!src->Size(plane)) {
                m_pPlane[plane] = m_pPlane[0];
                continue;
            }
 
            dst_buffer = malloc(src->Size(plane));
            if (!dst_buffer) {
                LOGERROR("%s: %s: cannot allocate destination buffer (%d): %m", m_identifier, __FUNCTION__, errno);
                return;
            }
            memcpy(dst_buffer, src->Plane(plane), src->Size(plane));
            m_pPlane[plane] = (uint8_t *)dst_buffer;
        }
    }
 
    m_width = src->Width();
    m_height = src->Height();
    m_pixFmt = src->PixFmt();
    m_modifier = src->Modifier();
    m_numPlanes = src->NumPlanes();
 
    for (int i = 0; i < src->NumPlanes(); i++) {
        m_offset[i] = src->Offset(i);
        m_pitch[i] = src->Pitch(i);
        m_size[i] = src->Size(i);
    }
 
    m_outputRect.Set(src->GetScreenRect().Point(), src->GetScreenRect().Size());
 
    LOGDEBUG2(L_GRAB, "%s: %s: Set input buffer: %dx%d pixFmt %d modifier %d num planes %d with %dx%d at %d|%d",
        m_identifier, __FUNCTION__, m_width, m_height, m_pixFmt, m_modifier, m_numPlanes, m_outputRect.Width(), m_outputRect.Height(), m_outputRect.X(), m_outputRect.Y());
    for (int plane = 0; plane < m_numPlanes; plane++) {
        LOGDEBUG2(L_GRAB, "%s: %s: Copied plane %d address %p pitch %d offset %d size %d",
            m_identifier, __FUNCTION__, plane, m_pPlane[plane], m_pitch[plane], m_offset[plane], m_size[plane]);
    }
}
 
uint8_t *cGrabBuffer::ConvertToRgb(int *size)
{
    uint8_t *srcData[4] = {nullptr};
    uint8_t *dstData[4] = {nullptr};;
    int srcLinesize[4] = {0};
    int dstLinesize[4] = {0};
    int dstW = GetOutputWidth();
    int dstH = GetOutputHeight();
    enum AVPixelFormat dstPixFmt = strcmp(m_identifier, "OSD") == 0 ? AV_PIX_FMT_BGRA : AV_PIX_FMT_RGB24;
 
    int srcW = m_width;
    int srcH = m_height;
 
    enum AVPixelFormat srcPixFmt = DrmFormatToAVFormat(m_pixFmt);
    if (srcPixFmt == AV_PIX_FMT_NONE) {
        LOGERROR("%s: %s: pixel format is not supported!", m_identifier, __FUNCTION__);
        return NULL;
    }
 
    int dstBufsize = 0;
    struct SwsContext *swsCtx;
    int ret;
 
    // planes aren't mmapped, return
    if (!m_pPlane[0]) {
        LOGERROR("%s: %s: prime data is not mapped!", m_identifier, __FUNCTION__);
        return NULL;
    }
 
    // convert yuv to rgb
    swsCtx = sws_getContext(srcW, srcH, srcPixFmt,
                            dstW, dstH, dstPixFmt,
                            SWS_BILINEAR, NULL, NULL, NULL);
    if (!swsCtx) {
        LOGERROR("%s: %s: Could not create swsCtx", m_identifier, __FUNCTION__);
        return NULL;
    }
 
    if ((ret = av_image_alloc(dstData, dstLinesize, dstW, dstH, dstPixFmt, 1)) < 0) {
        LOGERROR("%s: %s: Could not alloc dst image", m_identifier, __FUNCTION__);
        sws_freeContext(swsCtx);
        return NULL;
    }
    dstBufsize = ret;
 
    // De-tile sand format
    uint8_t *tmpData[4] = {0};
    int tmpLinesize[4] = {0};
    int tmpImgSize = 0;
    if (m_modifier == DRM_FORMAT_MOD_BROADCOM_SAND128) {
        if (m_pixFmt == DRM_FORMAT_NV12) {
            int stride1 = 128;
 
            tmpImgSize = av_image_alloc(tmpData, tmpLinesize, srcW, srcH, srcPixFmt, 1);
            if (tmpImgSize < 0) {
                LOGERROR("%s: %s: Could not alloc tmp image", m_identifier, __FUNCTION__);
                sws_freeContext(swsCtx);
                return NULL;
            }
 
            Sand128ToPlanarY8(tmpData[0], tmpLinesize[0],
                              m_pPlane[0] + m_offset[0],
                              stride1, m_pitch[0],
                              srcW, srcH);
            Sand128ToPlanarY8(tmpData[1], tmpLinesize[1],
                              m_pPlane[1] + m_offset[1],
                              stride1, m_pitch[1],
                              srcW, srcH / 2);
 
            srcData[0] = tmpData[0];
            srcData[1] = tmpData[1];
            srcLinesize[0] = tmpLinesize[0];
            srcLinesize[1] = tmpLinesize[1];
        } else if (m_pixFmt == DRM_FORMAT_P030) {
            int stride1 = 128;
 
            tmpImgSize = av_image_alloc(tmpData, tmpLinesize, srcW, srcH, srcPixFmt, 1);
            if (tmpImgSize < 0) {
                LOGERROR("%s: %s: Could not alloc tmp image", m_identifier, __FUNCTION__);
                sws_freeContext(swsCtx);
                return NULL;
            }
 
            Sand30ToPlanarY16(tmpData[0], tmpLinesize[0],
                              m_pPlane[0] + m_offset[0],
                              stride1, m_pitch[0],
                              srcW, srcH);
            Sand30ToPlanarC16(tmpData[1], tmpLinesize[1],
                              tmpData[2], tmpLinesize[2],
                              m_pPlane[1] + m_offset[1],
                              stride1, m_pitch[1],
                              srcW / 2, srcH / 2);
 
            srcData[0] = tmpData[0];
            srcData[1] = tmpData[1];
            srcData[2] = tmpData[2];
            srcLinesize[0] = tmpLinesize[0];
            srcLinesize[1] = tmpLinesize[1];
            srcLinesize[2] = tmpLinesize[2];
        }
    } else {
        // copy src pitches and data
        for (int i = 0; i < m_numPlanes; i++) {
            srcLinesize[i] = m_pitch[i];
            srcData[i] = m_pPlane[i] + m_offset[i];
        }
    }
 
    // scale image
    sws_scale(swsCtx, (const uint8_t * const*)srcData, srcLinesize, 0, srcH, dstData, dstLinesize);
 
    sws_freeContext(swsCtx);
    *size = dstBufsize;
 
    if (tmpImgSize > 0)
        av_freep(&tmpData[0]);
 
    LOGDEBUG2(L_GRAB, "%s: %s: return image at %p size %d", m_identifier, __FUNCTION__, dstData[0], dstBufsize);
 
    return dstData[0];
}
 
 
 
/*****************************************************************************
 * cSoftHdGrab class
 ****************************************************************************/
 
bool cSoftHdGrab::Start(bool jpeg, int quality, int width, int height, int screenWidth, int screenHeight)
{
    m_active = true;
 
    LOGDEBUG2(L_GRAB, "Starting grab for %s image (%dx%d, quality %d)", jpeg ? "jpg" : "pnm", width, height, quality);
 
    // always clear the buffers in case sth. unexpected happend
    m_pRender->ClearGrabBuffers();
 
    m_isJpeg = jpeg;
    m_screenWidth = screenWidth;
    m_screenHeight = screenHeight;
 
    // Set defaults
    m_quality = quality < 0 ? 95 : quality;
    m_grabbedWidth = width   > 0 ? width : screenWidth;
    m_grabbedHeight = height > 0 ? height : screenHeight;
    m_grabbedImage = nullptr;
 
    if (m_pRender->TriggerGrab()) {
        Finish();
        LOGDEBUG2(L_GRAB, "Grabbing %s image (%dx%d, quality %d) failed", jpeg ? "jpg" : "pnm", width, height, quality);
        return false;
    }
 
    return true;
}
 
void cSoftHdGrab::Finish(void)
{
    m_pRender->ClearGrabBuffers();
    m_active = false;
}
 
uint8_t *cSoftHdGrab::GetGrabbedVideoData(int *size, int *width, int *height, int *x, int *y)
{
    cGrabBuffer *grab = m_pRender->GetGrabbedVideoBuffer();
    return GetGrabbedData(size, width, height, x, y, grab);
}
 
uint8_t *cSoftHdGrab::GetGrabbedPipData(int *size, int *width, int *height, int *x, int *y)
{
    cGrabBuffer *grab = m_pRender->GetGrabbedPipBuffer();
    return GetGrabbedData(size, width, height, x, y, grab);
}
 
uint8_t *cSoftHdGrab::GetGrabbedOsdData(int *size, int *width, int *height, int *x, int *y)
{
    cGrabBuffer *grab = m_pRender->GetGrabbedOsdBuffer();
    return GetGrabbedData(size, width, height, x, y, grab);
}
 
 
uint8_t *cSoftHdGrab::GetGrabbedData(int *size, int *width, int *height, int *x, int *y, cGrabBuffer *grab)
{
    int psize = 0;
 
    // early return if no grab buffer is set
    if (!grab->IsSet()) {
        grab->SetOutputData(NULL);
        grab->SetOutputSize(0);
        return nullptr;
    }
 
    // result's width and height are original dimensions how buffer is presented on the screen
    uint8_t *result = grab->ConvertToRgb(&psize);
    grab->FreeInput();
 
    grab->SetOutputData(result);
    grab->SetOutputSize(psize);
 
    if (size)
        *size = grab->GetOutputSize();
    if (width)
        *width = grab->GetOutputWidth();
    if (height)
        *height = grab->GetOutputHeight();
    if (x)
        *x = grab->GetOutputX();
    if (y)
        *y = grab->GetOutputY();
 
    return grab->GetOutputData();
}
 
bool cSoftHdGrab::ProcessGrab(void)
{
    int screenSize = m_screenWidth * m_screenHeight * 3; // we want a RGB24
 
    int videoSize = 0;                  // data size of the grabbed video
    int videoWidth = m_screenWidth;     // width of the grabbed video
    int videoHeight = m_screenHeight;   // height of the grabbed video
    int videoX = 0, videoY = 0;         // x, y of the grabbed video
 
    int pipSize = 0;                    // data size of the grabbed pip video
    int pipWidth = m_screenWidth;       // width of the grabbed pip video
    int pipHeight = m_screenHeight;     // height of the grabbed pip video
    int pipX = 0, pipY = 0;             // x, y of the grabbed pip video
 
    // fetch video data
    // Video comes as RGB, width and height is original screen dimension (video is maybe scaled)
    uint8_t *video = GetGrabbedVideoData(&videoSize, &videoWidth, &videoHeight, &videoX, &videoY);
    if (!video) {
        LOGDEBUG2(L_GRAB, "%s: no video data available, create black screen!", __FUNCTION__);
        video = (uint8_t *)calloc(1, screenSize);
    }
 
    // fetch pip data
    // Pip video comes as RGB, width and height is original screen dimension (video is maybe scaled)
    uint8_t *pip = GetGrabbedPipData(&pipSize, &pipWidth, &pipHeight, &pipX, &pipY);
    if (!pip)
        LOGDEBUG2(L_GRAB, "%s: no pip data available, skip it", __FUNCTION__);
 
    // fetch osd data
    // OSD comes as ARGB, width and height is original screen dimension (osd is always fullscreen)
    uint8_t *osd = GetGrabbedOsdData(NULL, NULL, NULL, NULL, NULL);
    if (!osd)
        LOGDEBUG2(L_GRAB, "%s: no osd data available, skip it", __FUNCTION__);
 
    // blit the video into a full black screen if scaled
    uint8_t *videoResult = video;
 
    bool needsScaling = (videoWidth != m_screenWidth || videoHeight != m_screenHeight || videoX != 0 || videoY != 0);
    if (needsScaling) {
        videoResult = (uint8_t *)calloc(1, screenSize);
        if (BlitVideo(videoResult, video, m_screenWidth, m_screenHeight, videoX, videoY, videoWidth, videoHeight)) {
            free(videoResult);
            free(video);
            Finish();
            LOGDEBUG2(L_GRAB, "grab failed during VIDEO blit");
            return false;
        }
        free(video);
    }
 
    // blit the pip video into the main video if available
    if (pip) {
        if (BlitVideo(videoResult, pip, m_screenWidth, m_screenHeight, pipX, pipY, pipWidth, pipHeight)) {
            free(videoResult);
            free(pip);
            Finish();
            LOGDEBUG2(L_GRAB, "grab failed during PIP blit");
            return false;
        }
        free(pip);
    }
 
    // alphablend fullscreen video/pip with osd if available
    uint8_t *result = videoResult;
    if (osd) {
        result = (uint8_t *)malloc(screenSize);
        AlphaBlend(result, osd, videoResult, m_screenWidth, m_screenHeight);
        free(videoResult);
        free(osd);
    }
 
    // scale result to requested size width + height, if it differs from fullscreen
    uint8_t *scaledResult = result;
    int scaledSize = screenSize;
 
    needsScaling = (m_screenWidth != m_grabbedWidth || m_screenHeight != m_grabbedHeight);
    if (needsScaling) {
        scaledResult = ScaleRgb24(result, &scaledSize, m_screenWidth, m_screenHeight, m_grabbedWidth, m_grabbedHeight);
        free(result);
    }
 
    // make jpeg or pnm
    if (m_isJpeg) {
        m_grabbedImage = CreateJpeg(scaledResult, &m_grabbedSize, m_quality, m_grabbedWidth, m_grabbedHeight);
    } else {  // add header to raw data
        char buf[64];
        int n = snprintf(buf, sizeof(buf), "P6\n%d\n%d\n255\n", m_grabbedWidth, m_grabbedHeight);
        m_grabbedImage = (uint8_t *)malloc(scaledSize + n);
        memcpy(m_grabbedImage, buf, n);
        memcpy(m_grabbedImage + n, scaledResult, scaledSize);
        m_grabbedSize = scaledSize + n;
    }
 
    free(scaledResult);
    LOGDEBUG2(L_GRAB, "Finished %s image (%dx%d, quality %d) at %p (size %d)", m_isJpeg ? "jpg" : "pnm", m_grabbedWidth, m_grabbedHeight, m_isJpeg ? m_quality : 0, m_grabbedImage, m_grabbedSize);
 
    return true;
}