HYL_OK3568_LINUX/external/xserver/hw/xfree86/drivers/modesetting/xv.c

/*
 *  Copyright (c) 2019, Fuzhou Rockchip Electronics Co., Ltd
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 */

#ifdef HAVE_DIX_CONFIG_H
#include "dix-config.h"
#endif

#include "driver.h"
#include "dumb_bo.h"
/*
#include "xf86.h"
*/

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <libdrm/drm_fourcc.h>

#include <X11/extensions/Xv.h>
#include "fourcc.h"

#ifndef DRM_FORMAT_NV12_10
#define DRM_FORMAT_NV12_10 fourcc_code('N', 'A', '1', '2')
#endif

#define XVIMAGE_XRGB8888 \
   { \
        DRM_FORMAT_XRGB8888, \
        XvRGB, \
        LSBFirst, \
        {'R','G','B','X', \
          0x00,0x00,0x00,0x10,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71}, \
        32, \
        XvPacked, \
        1, \
        24, 0xff0000, 0x00ff00, 0x0000ff, \
        0, 0, 0, \
        0, 0, 0, \
        0, 0, 0, \
        {'B','G','R', \
          0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, \
        XvTopToBottom \
   }

#define NUM_FORMATS 4

static XF86VideoFormatRec Formats[NUM_FORMATS] = {
    {15, TrueColor}, {16, TrueColor}, {24, TrueColor}, {30, TrueColor}
};

#define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE)

XvAttributeRec ms_exa_xv_attributes[] = {
    {XvSettable | XvGettable, 0, 0xFFFFFFFF, (char *)"XV_DMA_CLIENT_ID"},
    {XvSettable | XvGettable, 0, 0xFFFFFFFF, (char *)"XV_DMA_HOR_STRIDE"},
    {XvSettable | XvGettable, 0, 0xFFFFFFFF, (char *)"XV_DMA_VER_STRIDE"},
    {XvSettable | XvGettable, 0, 0xFFFFFFFF, (char *)"XV_DMA_DRM_FOURCC"},
    {0, 0, 0, NULL}
};
int ms_exa_xv_num_attributes = ARRAY_SIZE(ms_exa_xv_attributes) - 1;

Atom msDmaClient, msDmaHorStride, msDmaVerStride, msDmaDrmFourcc;

XvImageRec ms_exa_xv_images[] = {
    XVIMAGE_NV12,
    XVIMAGE_XRGB8888
};
int ms_exa_xv_num_images = ARRAY_SIZE(ms_exa_xv_images);

#define ALIGN(i,m) (((i) + (m) - 1) & ~((m) - 1))
#define ClipValue(v,min,max) ((v) < (min) ? (min) : (v) > (max) ? (max) : (v))

#define XV_MAX_DMA_FD 3

typedef struct {
    uint32_t dma_client;
    uint32_t dma_hor_stride;
    uint32_t dma_ver_stride;
    uint32_t dma_drm_fourcc;
    int dma_socket_fd;
} ms_exa_port_private;

static void
ms_exa_xv_set_dma_client(ms_exa_port_private *port_priv, uint32_t dma_client)
{
    struct sockaddr_un addr;

    // re-open socket to flush pending messages
    if (port_priv->dma_client)
        close(port_priv->dma_socket_fd);

    port_priv->dma_client = dma_client;

    if (!dma_client)
        goto clear;

    port_priv->dma_socket_fd = socket(PF_UNIX, SOCK_DGRAM | SOCK_NONBLOCK, 0);
    if (port_priv->dma_socket_fd < 0)
        goto clear;

    addr.sun_family = AF_LOCAL;
    snprintf(addr.sun_path, sizeof(addr.sun_path),
             "/tmp/.xv_dma_client.%d", port_priv->dma_client);
    addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';

    unlink(addr.sun_path);
    if (bind(port_priv->dma_socket_fd,
             (struct sockaddr *)&addr, sizeof(addr)) < 0)
        goto clear;

    chmod(addr.sun_path, S_IRUSR | S_IWUSR | S_IROTH | S_IWOTH);

    return;
clear:
    if (port_priv->dma_socket_fd > 0) {
        close(port_priv->dma_socket_fd);
        port_priv->dma_socket_fd = 0;
    }
    port_priv->dma_client = 0;
    port_priv->dma_hor_stride = 0;
    port_priv->dma_ver_stride = 0;
    port_priv->dma_drm_fourcc = 0;
}

static void
ms_exa_xv_stop_video(ScrnInfoPtr pScrn, void *data, Bool cleanup)
{
    ms_exa_port_private *port_priv = data;

    if (!cleanup)
        return;

    ms_exa_xv_set_dma_client(port_priv, 0);
}

static int
ms_exa_xv_set_port_attribute(ScrnInfoPtr pScrn,
                             Atom attribute, INT32 value, void *data)
{
    ms_exa_port_private *port_priv = data;

    if (attribute == msDmaClient)
        ms_exa_xv_set_dma_client(port_priv, ClipValue(value, 0, 0xFFFFFFFF));
    else if (attribute == msDmaHorStride)
        port_priv->dma_hor_stride = ClipValue(value, 0, 0xFFFFFFFF);
    else if (attribute == msDmaVerStride)
        port_priv->dma_ver_stride = ClipValue(value, 0, 0xFFFFFFFF);
    else if (attribute == msDmaDrmFourcc)
        port_priv->dma_drm_fourcc = ClipValue(value, 0, 0xFFFFFFFF);
    else
        return BadMatch;

    return Success;
}

static int
ms_exa_xv_get_port_attribute(ScrnInfoPtr pScrn,
                             Atom attribute, INT32 *value, void *data)
{
    ms_exa_port_private *port_priv = data;

    if (attribute == msDmaClient)
        *value = port_priv->dma_client;
    else if (attribute == msDmaHorStride)
        *value = port_priv->dma_hor_stride;
    else if (attribute == msDmaVerStride)
        *value = port_priv->dma_ver_stride;
    else if (attribute == msDmaDrmFourcc)
        *value = port_priv->dma_drm_fourcc;
    else
        return BadMatch;

    return Success;
}

static void
ms_exa_xv_query_best_size(ScrnInfoPtr pScrn,
                          Bool motion,
                          short vid_w, short vid_h,
                          short drw_w, short drw_h,
                          unsigned int *p_w, unsigned int *p_h, void *data)
{
    *p_w = drw_w;
    *p_h = drw_h;
}

static int
ms_exa_xv_query_image_attributes(ScrnInfoPtr pScrn,
                                 int id,
                                 unsigned short *w, unsigned short *h,
                                 int *pitches, int *offsets)
{
    int size = 0, tmp;

    if (offsets)
        offsets[0] = 0;

    if (id != FOURCC_NV12 && id != DRM_FORMAT_XRGB8888)
        return 0;

    *w = ALIGN(*w, 2);
    *h = ALIGN(*h, 2);
    size = ALIGN(*w, 4);
    if (pitches)
        pitches[0] = size;
    size *= *h;
    if (offsets)
        offsets[1] = size;
    tmp = ALIGN(*w, 4);
    if (id == DRM_FORMAT_XRGB8888)
        tmp *= 4;
    if (pitches)
        pitches[1] = tmp;
    tmp *= (*h >> 1);
    size += tmp;

    return size;
}

static PixmapPtr
ms_exa_xv_create_dma_pixmap(ScrnInfoPtr scrn,
                            ms_exa_port_private *port_priv, int id)
{
    modesettingPtr ms = modesettingPTR(scrn);
    ScreenPtr screen = scrn->pScreen;
    PixmapPtr pixmap = NULL;
    struct dumb_bo *bo = NULL;
    struct iovec iov;
    struct msghdr msg;
    struct cmsghdr *header;
    char buf[CMSG_SPACE (sizeof (int))];
    int dma_fds[XV_MAX_DMA_FD], num_dma_fd = 0;
    int width, height, pitch, bpp, depth;
    uint32_t drm_fourcc;

    if (!port_priv->dma_client || port_priv->dma_socket_fd <= 0)
        return NULL;

    if (!port_priv->dma_hor_stride || !port_priv->dma_ver_stride)
        goto err;

    iov.iov_base = buf;
    iov.iov_len = 1;

    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;
    msg.msg_name = NULL;
    msg.msg_namelen = 0;

    num_dma_fd = 0;
    while (1) {
        msg.msg_control = buf;
        msg.msg_controllen = sizeof(buf);

        if (recvmsg(port_priv->dma_socket_fd, &msg, 0) < 0)
            break;

        /* End with a empty msg */
        header = CMSG_FIRSTHDR(&msg);
        if (!header)
            break;

        for (; header != NULL; header = CMSG_NXTHDR(&msg, header)) {
            if (header->cmsg_level != SOL_SOCKET
                || header->cmsg_type != SCM_RIGHTS
                || header->cmsg_len != CMSG_LEN(sizeof(int)))
                break;

            dma_fds[num_dma_fd++] = *((int *)CMSG_DATA(header));
        }
    }

    /* Only expect 1 buffer */
    if (num_dma_fd != 1)
        goto err;

    width = port_priv->dma_hor_stride;
    height = port_priv->dma_ver_stride;

    drm_fourcc = port_priv->dma_drm_fourcc ? port_priv->dma_drm_fourcc : id;
    if (drm_fourcc == DRM_FORMAT_XRGB8888) {
        pitch = width * 4;
        depth = bpp = 32;
    } else {
        pitch = width * 3 / 2;
        depth = bpp = 12;

        /* HACK: Special depth for NV12_10 and NV16*/
        if (drm_fourcc == DRM_FORMAT_NV12_10) {
            depth = 10;
        } else if (drm_fourcc == DRM_FORMAT_NV16) {
            depth = 16;
        }
    }

    pixmap = drmmode_create_pixmap_header(screen, width, height,
                                          depth, bpp, pitch, NULL);
    if (!pixmap)
        goto err;

    bo = dumb_get_bo_from_fd(ms->drmmode.fd, dma_fds[0],
                             pitch, pitch * height);
    if (!bo)
        goto err_free_pixmap;

    if (!ms_exa_set_pixmap_bo(scrn, pixmap, bo, TRUE))
        goto err_free_bo;

    goto out;

err_free_bo:
    dumb_bo_destroy(ms->drmmode.fd, bo);
err_free_pixmap:
    screen->DestroyPixmap(pixmap);
    pixmap = NULL;
err:
    ErrorF("ms xv failed to import dma pixmap\n");
    ms_exa_xv_set_dma_client(port_priv, 0);
out:
    while (num_dma_fd--)
        close(dma_fds[num_dma_fd]);

    return pixmap;
}

static PixmapPtr
ms_exa_xv_create_pixmap(ScrnInfoPtr scrn, ms_exa_port_private *port_priv,
                        int id,
                        unsigned char *buf,
                        short width,
                        short height)
{
    ScreenPtr screen = scrn->pScreen;
    PixmapPtr pixmap;
    int pitch, bpp;

    if (id == FOURCC_NV12) {
        pitch = ALIGN(width, 4) * 3 / 2;
        bpp = 12;
    } else {
        pitch = ALIGN(width, 4) * 4;
        bpp = 32;
    }

    pixmap = drmmode_create_pixmap_header(screen, width, height,
                                          bpp, bpp, pitch, buf);
    if (!pixmap)
        return NULL;

    pixmap->devKind = pitch;
    pixmap->devPrivate.ptr = buf;

    return pixmap;
}

static int
ms_exa_xv_put_image(ScrnInfoPtr pScrn,
                    short src_x, short src_y,
                    short drw_x, short drw_y,
                    short src_w, short src_h,
                    short drw_w, short drw_h,
                    int id,
                    unsigned char *buf,
                    short width,
                    short height,
                    Bool sync,
                    RegionPtr clipBoxes, void *data, DrawablePtr pDrawable)
{
    ms_exa_port_private *port_priv = data;
    ScreenPtr screen = pScrn->pScreen;
    PixmapPtr src_pixmap, dst_pixmap;
    pixman_f_transform_t transform;
    double sx, sy, tx, ty;
    int ret = Success;

    if (id != FOURCC_NV12 && id != DRM_FORMAT_XRGB8888)
        return BadMatch;

    src_pixmap = ms_exa_xv_create_dma_pixmap(pScrn, port_priv, id);
    if (!src_pixmap) {
        src_pixmap = ms_exa_xv_create_pixmap(pScrn, port_priv, id,
                                             buf, width, height);
        if (!src_pixmap)
            return BadMatch;
    }

    if (pDrawable->type == DRAWABLE_WINDOW)
        dst_pixmap = screen->GetWindowPixmap((WindowPtr) pDrawable);
    else
        dst_pixmap = (PixmapPtr) pDrawable;

    DamageRegionAppend(pDrawable, clipBoxes);

    sx = (double)src_w / drw_w;
    sy = (double)src_h / drw_h;

    tx = drw_x - src_x;
    ty = drw_y - src_y;

#ifdef COMPOSITE
    RegionTranslate(clipBoxes, -dst_pixmap->screen_x, -dst_pixmap->screen_y);
    tx -= dst_pixmap->screen_x;
    ty -= dst_pixmap->screen_y;
#endif

    pixman_f_transform_init_scale(&transform, sx, sy);
    pixman_f_transform_translate(NULL, &transform, tx, ty);

    if (!ms_exa_copy_area(src_pixmap, dst_pixmap, &transform, clipBoxes))
        ret = BadMatch;

    DamageRegionProcessPending(pDrawable);

    screen->DestroyPixmap(src_pixmap);

    return ret;
}

static XF86VideoEncodingRec DummyEncoding[1] = {
    { 0, "XV_IMAGE", 8192, 8192, {1, 1} }
};

XF86VideoAdaptorPtr
ms_exa_xv_init(ScreenPtr screen, int num_texture_ports)
{
    ms_exa_port_private *port_priv;
    XF86VideoAdaptorPtr adapt;
    int i;

    msDmaClient = MAKE_ATOM("XV_DMA_CLIENT_ID");
    msDmaHorStride = MAKE_ATOM("XV_DMA_HOR_STRIDE");
    msDmaVerStride = MAKE_ATOM("XV_DMA_VER_STRIDE");
    msDmaDrmFourcc = MAKE_ATOM("XV_DMA_DRM_FOURCC");

    adapt = calloc(1, sizeof(XF86VideoAdaptorRec) + num_texture_ports *
                   (sizeof(ms_exa_port_private) + sizeof(DevUnion)));
    if (adapt == NULL)
        return NULL;

    adapt->type = XvWindowMask | XvInputMask | XvImageMask;
    adapt->flags = 0;
    adapt->name = "Modesetting Textured Video";
    adapt->nEncodings = 1;
    adapt->pEncodings = DummyEncoding;

    adapt->nFormats = NUM_FORMATS;
    adapt->pFormats = Formats;
    adapt->nPorts = num_texture_ports;
    adapt->pPortPrivates = (DevUnion *) (&adapt[1]);

    adapt->pAttributes = ms_exa_xv_attributes;
    adapt->nAttributes = ms_exa_xv_num_attributes;

    port_priv =
        (ms_exa_port_private *) (&adapt->pPortPrivates[num_texture_ports]);

    adapt->pImages = ms_exa_xv_images;
    adapt->nImages = ms_exa_xv_num_images;

    adapt->PutVideo = NULL;
    adapt->PutStill = NULL;
    adapt->GetVideo = NULL;
    adapt->GetStill = NULL;
    adapt->StopVideo = ms_exa_xv_stop_video;
    adapt->SetPortAttribute = ms_exa_xv_set_port_attribute;
    adapt->GetPortAttribute = ms_exa_xv_get_port_attribute;
    adapt->QueryBestSize = ms_exa_xv_query_best_size;
    adapt->PutImage = ms_exa_xv_put_image;
    adapt->ReputImage = NULL;
    adapt->QueryImageAttributes = ms_exa_xv_query_image_attributes;

    for (i = 0; i < num_texture_ports; i++) {
        ms_exa_port_private *priv = &port_priv[i];

        priv->dma_client = 0;
        priv->dma_socket_fd = 0;
        priv->dma_hor_stride = 0;
        priv->dma_ver_stride = 0;
        priv->dma_drm_fourcc = 0;

        adapt->pPortPrivates[i].ptr = (void *) (priv);
    }
    return adapt;
}