xref: /aosp_15_r20/external/virglrenderer/src/virgl_video.c (revision bbecb9d118dfdb95f99bd754f8fa9be01f189df3)

/**************************************************************************
 *
 * Copyright (C) 2022 Kylin Software Co., Ltd.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 **************************************************************************/

/**
 * @file
 * Implementation of general video codec interface.
 *
 * This implementation is currently based on VA-API, and other interfaces,
 * such as VDPAU and proprietary interfaces, can also be considered in the
 * future.
 *
 * Two objects are implemented here:
 * virgl_video_buffer:
 *   Buffer for storing raw YUV formatted data. Currently, it is a wrapper
 *   for VASurface.
 * virgl_video_codec:
 *   Represents a video encoder or decoder. It's a wrapper of VAContext and
 *   mainly provides the following methods:
 *   - virgl_video_begin_frame()
 *     It calls vaBeginPicture() to prepare for encoding and decoding. For
 *     encoding, it also needs to upload the raw picture data from the guest
 *     side into the local VASurface.
 *   - virgl_video_decode_bitstream()
 *     It constructs the decoding-related VABuffers according to the picture
 *     description information, and then calls vaRenderPicture() for decoding.
 *   - virgl_video_encode_bitstream()
 *     It constructs the encoding-related VABuffers according to the picture
 *     description information, and then calls vaRenderPicture() for encoding.
 *   - virgl_video_end_frame()
 *     It calls vaEndPicture() to end encoding and decoding. After decoding,
 *     it transmits the raw picture data from VASurface to the guest side,
 *     and after encoding, it transmits the result and the coded data in
 *     VACodedBuffer to the guest side.
 *
 * @author Feng Jiang <[email protected]>
 */


#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <epoxy/gl.h>
#include <epoxy/egl.h>
#include <va/va.h>
#include <va/va_drm.h>
#include <va/va_drmcommon.h>
#include <drm_fourcc.h>

#include "pipe/p_video_state.h"
#include "util/u_memory.h"
#include "virgl_hw.h"
#include "virgl_video_hw.h"
#include "virgl_util.h"
#include "virgl_video.h"

/*
 * The max size of codec buffer is approximately:
 *   num_of_macroblocks * max_size_of_per_macroblock + size_of_some_headers
 * Now, we only support YUV420 formats, this means that we have a limit of
 * 3200 bits(400 Bytes) per macroblock. To simplify the calculation, we
 * directly use 512 instead of 400.
 */
#define CODED_BUF_DEFAULT_SIZE(width, height) \
    ((width) * (height) / (16 * 16) * 512)

struct virgl_video_buffer {
    enum pipe_format format;
    uint32_t width;
    uint32_t height;
    bool interlanced;
    VASurfaceID va_sfc;
    struct virgl_video_dma_buf *dmabuf;
    void *opaque;                               /* User opaque data */
};


struct virgl_video_codec {
   enum pipe_video_profile profile;
   uint32_t level;
   enum pipe_video_entrypoint entrypoint;
   enum pipe_video_chroma_format chroma_format;
   uint32_t width;
   uint32_t height;
   uint32_t max_references;
   VAContextID va_ctx;
   VAConfigID  va_cfg;
   struct virgl_video_buffer *buffer;
   struct virgl_video_buffer *ref_pic_list[32]; /* Enc: reference pictures */
   VABufferID  va_coded_buf;                    /* Enc: VACodedBuffer */
   void *opaque;                                /* User opaque data */
};


static VADisplay va_dpy;

static struct virgl_video_callbacks *callbacks = NULL;

static enum pipe_video_profile pipe_profile_from_va(VAProfile profile)
{
   switch (profile) {
   case VAProfileMPEG2Simple:
      return PIPE_VIDEO_PROFILE_MPEG2_SIMPLE;
   case VAProfileMPEG2Main:
      return PIPE_VIDEO_PROFILE_MPEG2_MAIN;
   case VAProfileMPEG4Simple:
      return PIPE_VIDEO_PROFILE_MPEG4_SIMPLE;
   case VAProfileMPEG4AdvancedSimple:
      return PIPE_VIDEO_PROFILE_MPEG4_ADVANCED_SIMPLE;
   case VAProfileVC1Simple:
      return PIPE_VIDEO_PROFILE_VC1_SIMPLE;
   case VAProfileVC1Main:
      return PIPE_VIDEO_PROFILE_VC1_MAIN;
   case VAProfileVC1Advanced:
      return PIPE_VIDEO_PROFILE_VC1_ADVANCED;
   case VAProfileH264ConstrainedBaseline:
      return PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE;
   case VAProfileH264Main:
      return PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN;
   case VAProfileH264High:
      return PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
   case VAProfileHEVCMain:
      return PIPE_VIDEO_PROFILE_HEVC_MAIN;
   case VAProfileHEVCMain10:
      return PIPE_VIDEO_PROFILE_HEVC_MAIN_10;
   case VAProfileJPEGBaseline:
      return PIPE_VIDEO_PROFILE_JPEG_BASELINE;
   case VAProfileVP9Profile0:
      return PIPE_VIDEO_PROFILE_VP9_PROFILE0;
   case VAProfileVP9Profile2:
      return PIPE_VIDEO_PROFILE_VP9_PROFILE2;
   case VAProfileAV1Profile0:
      return PIPE_VIDEO_PROFILE_AV1_MAIN;
   case VAProfileNone:
       return PIPE_VIDEO_PROFILE_UNKNOWN;
   default:
      return PIPE_VIDEO_PROFILE_UNKNOWN;
   }
}

/* NOTE: mesa va frontend only supports VLD and EncSlice */
static enum pipe_video_entrypoint pipe_entrypoint_from_va(
        VAEntrypoint entrypoint)
{
    switch (entrypoint) {
    case VAEntrypointVLD:
        return PIPE_VIDEO_ENTRYPOINT_BITSTREAM;
    case VAEntrypointIDCT:
        return PIPE_VIDEO_ENTRYPOINT_IDCT;
    case VAEntrypointMoComp:
        return PIPE_VIDEO_ENTRYPOINT_MC;
    case VAEntrypointEncSlice: /* fall through */
    case VAEntrypointEncSliceLP:
        return PIPE_VIDEO_ENTRYPOINT_ENCODE;
    default:
        return PIPE_VIDEO_ENTRYPOINT_UNKNOWN;
    }
}

static enum pipe_format pipe_format_from_va_fourcc(unsigned format)
{
   switch(format) {
   case VA_FOURCC('N','V','1','2'):
      return PIPE_FORMAT_NV12;
/* TODO: These are already defined in mesa, but not yet in virglrenderer
   case VA_FOURCC('P','0','1','0'):
      return PIPE_FORMAT_P010;
   case VA_FOURCC('P','0','1','6'):
      return PIPE_FORMAT_P016;
*/
   case VA_FOURCC('I','4','2','0'):
      return PIPE_FORMAT_IYUV;
   case VA_FOURCC('Y','V','1','2'):
      return PIPE_FORMAT_YV12;
   case VA_FOURCC('Y','U','Y','V'):
   case VA_FOURCC('Y','U','Y','2'):
      return PIPE_FORMAT_YUYV;
   case VA_FOURCC('U','Y','V','Y'):
      return PIPE_FORMAT_UYVY;
   case VA_FOURCC('B','G','R','A'):
      return PIPE_FORMAT_B8G8R8A8_UNORM;
   case VA_FOURCC('R','G','B','A'):
      return PIPE_FORMAT_R8G8B8A8_UNORM;
   case VA_FOURCC('B','G','R','X'):
      return PIPE_FORMAT_B8G8R8X8_UNORM;
   case VA_FOURCC('R','G','B','X'):
      return PIPE_FORMAT_R8G8B8X8_UNORM;
   default:
      return PIPE_FORMAT_NONE;
   }
}


static VAProfile va_profile_from_pipe(enum pipe_video_profile profile)
{
   switch (profile) {
   case PIPE_VIDEO_PROFILE_MPEG2_SIMPLE:
      return VAProfileMPEG2Simple;
   case PIPE_VIDEO_PROFILE_MPEG2_MAIN:
      return VAProfileMPEG2Main;
   case PIPE_VIDEO_PROFILE_MPEG4_SIMPLE:
      return VAProfileMPEG4Simple;
   case PIPE_VIDEO_PROFILE_MPEG4_ADVANCED_SIMPLE:
      return VAProfileMPEG4AdvancedSimple;
   case PIPE_VIDEO_PROFILE_VC1_SIMPLE:
      return VAProfileVC1Simple;
   case PIPE_VIDEO_PROFILE_VC1_MAIN:
      return VAProfileVC1Main;
   case PIPE_VIDEO_PROFILE_VC1_ADVANCED:
      return VAProfileVC1Advanced;
   case PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE:
      return VAProfileH264ConstrainedBaseline;
   case PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN:
      return VAProfileH264Main;
   case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH:
      return VAProfileH264High;
   case PIPE_VIDEO_PROFILE_HEVC_MAIN:
      return VAProfileHEVCMain;
   case PIPE_VIDEO_PROFILE_HEVC_MAIN_10:
      return VAProfileHEVCMain10;
   case PIPE_VIDEO_PROFILE_JPEG_BASELINE:
      return VAProfileJPEGBaseline;
   case PIPE_VIDEO_PROFILE_VP9_PROFILE0:
      return VAProfileVP9Profile0;
   case PIPE_VIDEO_PROFILE_VP9_PROFILE2:
      return VAProfileVP9Profile2;
   case PIPE_VIDEO_PROFILE_AV1_MAIN:
      return VAProfileAV1Profile0;
   case PIPE_VIDEO_PROFILE_MPEG4_AVC_EXTENDED:
   case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH10:
   case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH422:
   case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH444:
   case PIPE_VIDEO_PROFILE_MPEG4_AVC_CONSTRAINED_BASELINE:
   case PIPE_VIDEO_PROFILE_HEVC_MAIN_12:
   case PIPE_VIDEO_PROFILE_HEVC_MAIN_STILL:
   case PIPE_VIDEO_PROFILE_HEVC_MAIN_444:
   case PIPE_VIDEO_PROFILE_UNKNOWN:
      return VAProfileNone;
   default:
      return -1;
   }
}

/*
 * There is no invalid entrypoint defined in libva,
 * so add this definition to make the code clear
 */
#define VAEntrypointNone 0
static int va_entrypoint_from_pipe(enum pipe_video_entrypoint entrypoint)
{
    switch (entrypoint) {
    case PIPE_VIDEO_ENTRYPOINT_BITSTREAM:
        return VAEntrypointVLD;
    case PIPE_VIDEO_ENTRYPOINT_IDCT:
        return VAEntrypointIDCT;
    case PIPE_VIDEO_ENTRYPOINT_MC:
        return VAEntrypointMoComp;
    case PIPE_VIDEO_ENTRYPOINT_ENCODE:
        return VAEntrypointEncSlice;
    default:
        return VAEntrypointNone;
    }
}

static uint32_t va_format_from_pipe_chroma(
        enum pipe_video_chroma_format chroma_format)
{
    switch (chroma_format) {
    case PIPE_VIDEO_CHROMA_FORMAT_400:
        return VA_RT_FORMAT_YUV400;
    case PIPE_VIDEO_CHROMA_FORMAT_420:
        return VA_RT_FORMAT_YUV420;
    case PIPE_VIDEO_CHROMA_FORMAT_422:
        return VA_RT_FORMAT_YUV422;
    case PIPE_VIDEO_CHROMA_FORMAT_444:
        return VA_RT_FORMAT_YUV444;
    case PIPE_VIDEO_CHROMA_FORMAT_NONE:
    default:
        return 0;
    }
}

static uint32_t drm_format_from_va_fourcc(uint32_t va_fourcc)
{
    switch (va_fourcc) {
    case VA_FOURCC_NV12:
        return DRM_FORMAT_NV12;
    case VA_FOURCC_NV21:
        return DRM_FORMAT_NV21;
    default:
        return DRM_FORMAT_INVALID;
    }
}

static void fill_video_dma_buf(struct virgl_video_dma_buf *dmabuf,
                               const VADRMPRIMESurfaceDescriptor *desc)
{
    unsigned i, j, obj_idx;
    struct virgl_video_dma_buf_plane *plane;

/*
    virgl_log("surface: fourcc=0x%08x, size=%ux%u, num_objects=%u,
              num_layers=%u\n", desc->fourcc, desc->width, desc->height,
              desc->num_objects, desc->num_layers);

    for (i = 0; i < desc->num_objects; i++)
        virgl_log("  objects[%u]: fd=%d, size=%u, modifier=0x%lx\n",
                  i, desc->objects[i].fd, desc->objects[i].size,
                  desc->objects[i].drm_format_modifier);

    for (i = 0; i < desc->num_layers; i++)
        virgl_log("  layers[%u] : format=0x%08x, num_planes=%u, "
                  "obj=%u,%u,%u,%u, offset=%u,%u,%u,%u, pitch=%u,%u,%u,%u\n",
                  i, desc->layers[i].drm_format, desc->layers[i].num_planes,
                  desc->layers[i].object_index[0],
                  desc->layers[i].object_index[1],
                  desc->layers[i].object_index[2],
                  desc->layers[i].object_index[3],
                  desc->layers[i].offset[0],
                  desc->layers[i].offset[1],
                  desc->layers[i].offset[2],
                  desc->layers[i].offset[3],
                  desc->layers[i].pitch[0],
                  desc->layers[i].pitch[1],
                  desc->layers[i].pitch[2],
                  desc->layers[i].pitch[3]);
*/

    dmabuf->drm_format = drm_format_from_va_fourcc(desc->fourcc);
    dmabuf->width = desc->width;
    dmabuf->height = desc->height;

    for (i = 0, dmabuf->num_planes = 0; i < desc->num_layers; i++) {
        for (j = 0; j < desc->layers[i].num_planes &&
                    dmabuf->num_planes < ARRAY_SIZE(dmabuf->planes); j++) {

            obj_idx = desc->layers[i].object_index[j];
            plane = &dmabuf->planes[dmabuf->num_planes++];
            plane->drm_format = desc->layers[i].drm_format;
            plane->offset     = desc->layers[i].offset[j];
            plane->pitch      = desc->layers[i].pitch[j];
            plane->fd         = desc->objects[obj_idx].fd;
            plane->size       = desc->objects[obj_idx].size;
            plane->modifier   = desc->objects[obj_idx].drm_format_modifier;
        }
    }
}

static struct virgl_video_dma_buf *export_video_dma_buf(
                                        struct virgl_video_buffer *buffer,
                                        unsigned flags)
{
    struct virgl_video_dma_buf *dmabuf;
    uint32_t exp_flags;
    VAStatus va_stat;
    VADRMPRIMESurfaceDescriptor desc;

    exp_flags = VA_EXPORT_SURFACE_SEPARATE_LAYERS;

    if (flags & VIRGL_VIDEO_DMABUF_READ_ONLY)
        exp_flags |= VA_EXPORT_SURFACE_READ_ONLY;

    if (flags & VIRGL_VIDEO_DMABUF_WRITE_ONLY)
        exp_flags |= VA_EXPORT_SURFACE_WRITE_ONLY;

    dmabuf = calloc(1, sizeof(*dmabuf));
    if (!dmabuf)
        return NULL;

    va_stat = vaExportSurfaceHandle(va_dpy, buffer->va_sfc,
                    VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2, exp_flags, &desc);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("export surface failed, err = 0x%X\n", va_stat);
        goto free_dmabuf;
    }

    fill_video_dma_buf(dmabuf, &desc);
    dmabuf->flags = flags;
    dmabuf->buf   = buffer;

    return dmabuf;

free_dmabuf:
    free(dmabuf);
    return NULL;
}

static void destroy_video_dma_buf(struct virgl_video_dma_buf *dmabuf)
{
    unsigned i;

    if (dmabuf) {
        for (i = 0; i < dmabuf->num_planes; i++)
            close(dmabuf->planes[i].fd);

        free(dmabuf);
    }
}

static void encode_upload_picture(struct virgl_video_codec *codec,
                                  struct virgl_video_buffer *buffer)
{
    VAStatus va_stat;

    if (!callbacks || !callbacks->encode_upload_picture)
        return;

    va_stat = vaSyncSurface(va_dpy, buffer->va_sfc);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("sync surface failed, err = 0x%x\n", va_stat);
        return;
    }

    if (!buffer->dmabuf)
        buffer->dmabuf = export_video_dma_buf(buffer, VIRGL_VIDEO_DMABUF_WRITE_ONLY);

    if (buffer->dmabuf)
        callbacks->encode_upload_picture(codec, buffer->dmabuf);
}

static void encode_completed(struct virgl_video_codec *codec,
                             struct virgl_video_buffer *buffer)
{
    VAStatus va_stat;
    VACodedBufferSegment *buf, *buf_list;
    void **coded_bufs = NULL;
    unsigned *coded_sizes = NULL;
    unsigned i, num_coded_bufs = 0;

    if (!callbacks || !callbacks->encode_completed)
        return;

    va_stat = vaMapBuffer(va_dpy, codec->va_coded_buf, (void **)(&buf_list));
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("map coded buffer failed, err = 0x%x\n", va_stat);
        return;
    }

    for (buf = buf_list; buf; buf = (VACodedBufferSegment *)buf->next)
        num_coded_bufs++;

    coded_bufs = calloc(num_coded_bufs, sizeof(void *));
    coded_sizes = calloc(num_coded_bufs, sizeof(unsigned));
    if (!coded_bufs || !coded_sizes) {
        virgl_log("alloc memory failed, num_coded_bufs %u\n", num_coded_bufs);
        goto fail_unmap_buffer;
    }

    for (buf = buf_list, i = 0; buf; buf = (VACodedBufferSegment *)buf->next) {
        coded_bufs[i]  = buf->buf;
        coded_sizes[i++] = buf->size;
    }

    callbacks->encode_completed(codec, buffer->dmabuf, NULL, num_coded_bufs,
                                (const void * const*)coded_bufs, coded_sizes);

fail_unmap_buffer:
    vaUnmapBuffer(va_dpy, codec->va_coded_buf);
    free(coded_bufs);
    free(coded_sizes);
}

static void decode_completed(struct virgl_video_codec *codec,
                             struct virgl_video_buffer *buffer)
{
    if (!callbacks || !callbacks->decode_completed)
        return;

    if (!buffer->dmabuf)
        buffer->dmabuf = export_video_dma_buf(buffer, VIRGL_VIDEO_DMABUF_READ_ONLY);

    if (buffer->dmabuf)
        callbacks->decode_completed(codec, buffer->dmabuf);
}

static VASurfaceID get_enc_ref_pic(struct virgl_video_codec *codec,
                                   uint32_t frame_num)
{
    uint32_t idx;
    struct virgl_video_create_buffer_args args;

    if (frame_num == VA_INVALID_ID)
        return VA_INVALID_ID;

    idx = frame_num % ARRAY_SIZE(codec->ref_pic_list);

    if (!codec->ref_pic_list[idx]) {
        args.format = PIPE_FORMAT_NV21;
        args.width = codec->width;
        args.height = codec->height;
        args.interlaced = 0;
        args.opaque = NULL;
        codec->ref_pic_list[idx] = virgl_video_create_buffer(&args);
        if (!codec->ref_pic_list[idx]) {
            virgl_log("create ref pic for frame_num %u failed\n", frame_num);
            return VA_INVALID_ID;
        }
    }

    return codec->ref_pic_list[idx]->va_sfc;
}

int virgl_video_init(int drm_fd,
                     struct virgl_video_callbacks *cbs, unsigned int flags)
{
    VAStatus va_stat;
    int major_ver, minor_ver;
    const char *driver;

    (void)flags;

    if (drm_fd < 0) {
        virgl_log("invalid drm fd: %d\n", drm_fd);
        return -1;
    }

    va_dpy = vaGetDisplayDRM(drm_fd);
    if (!va_dpy) {
        virgl_log("get va display failed\n");
        return -1;
    }

    va_stat = vaInitialize(va_dpy, &major_ver, &minor_ver);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("init va library failed\n");
        virgl_video_destroy();
        return -1;
    }

    virgl_log("VA-API version: %d.%d\n", major_ver, minor_ver);

    driver = vaQueryVendorString(va_dpy);
    virgl_log("Driver version: %s\n", driver ? driver : "<unknown>");

    if (!driver || !strstr(driver, "Mesa Gallium")) {
        virgl_log("only supports mesa va drivers now\n");
        virgl_video_destroy();
        return -1;
    }

    callbacks = cbs;

    return 0;
}

void virgl_video_destroy(void)
{
    if (va_dpy) {
        vaTerminate(va_dpy);
        va_dpy = NULL;
    }

    callbacks = NULL;
}

static int fill_vcaps_entry(VAProfile profile, VAEntrypoint entrypoint,
                            struct virgl_video_caps *vcaps)
{
    VAConfigID cfg;
    VASurfaceAttrib *attrs;
    unsigned i, num_attrs;

    /* FIXME: default values */
    vcaps->profile = pipe_profile_from_va(profile);
    vcaps->entrypoint = pipe_entrypoint_from_va(entrypoint);
    vcaps->max_level = 0;
    vcaps->stacked_frames = 0;
    vcaps->max_width = 0;
    vcaps->max_height = 0;
    vcaps->prefered_format = PIPE_FORMAT_NONE;
    vcaps->max_macroblocks = 1;
    vcaps->npot_texture = 1;
    vcaps->supports_progressive = 1;
    vcaps->supports_interlaced = 0;
    vcaps->prefers_interlaced = 0;
    vcaps->max_temporal_layers = 0;

    vaCreateConfig(va_dpy, profile, entrypoint, NULL, 0, &cfg);

    vaQuerySurfaceAttributes(va_dpy, cfg, NULL, &num_attrs);
    attrs = calloc(num_attrs, sizeof(VASurfaceAttrib));
    if (!attrs)
        return -1;

    vaQuerySurfaceAttributes(va_dpy, cfg, attrs, &num_attrs);
    for (i = 0; i < num_attrs; i++) {
        switch (attrs[i].type) {
        case VASurfaceAttribMaxHeight:
            vcaps->max_height = attrs[i].value.value.i;
            break;
        case VASurfaceAttribMaxWidth:
            vcaps->max_width = attrs[i].value.value.i;
            break;
        case VASurfaceAttribPixelFormat:
            if (PIPE_FORMAT_NONE == vcaps->prefered_format)
                vcaps->prefered_format = \
                    pipe_format_from_va_fourcc(attrs[i].value.value.i);
            break;
        default:
            break;
        }
    }

    free(attrs);

    vaDestroyConfig(va_dpy, cfg);

    return 0;
}

int virgl_video_fill_caps(union virgl_caps *caps)
{
    int i, j;
    int num_profiles, num_entrypoints;
    VAProfile *profiles = NULL;
    VAEntrypoint *entrypoints = NULL;

    if (!va_dpy || !caps)
        return -1;

    num_entrypoints = vaMaxNumEntrypoints(va_dpy);
    entrypoints = calloc(num_entrypoints, sizeof(VAEntrypoint));
    if (!entrypoints)
        return -1;

    num_profiles = vaMaxNumProfiles(va_dpy);
    profiles = calloc(num_profiles, sizeof(VAProfile));
    if (!profiles) {
        free(entrypoints);
        return -1;
    }

    vaQueryConfigProfiles(va_dpy, profiles, &num_profiles);
    for (i = 0, caps->v2.num_video_caps = 0; i < num_profiles; i++) {
        /* only support H.264 and H.265 now */
        if (profiles[i] != VAProfileH264Main &&
            profiles[i] != VAProfileH264High &&
            profiles[i] != VAProfileH264ConstrainedBaseline &&
            profiles[i] != VAProfileHEVCMain)
            continue;

        vaQueryConfigEntrypoints(va_dpy, profiles[i],
                                 entrypoints, &num_entrypoints);
        for (j = 0; j < num_entrypoints &&
             caps->v2.num_video_caps < ARRAY_SIZE(caps->v2.video_caps); j++) {
            /* support encoding and decoding */
            if (VAEntrypointVLD != entrypoints[j] &&
                VAEntrypointEncSlice != entrypoints[j])
                continue;

            fill_vcaps_entry(profiles[i], entrypoints[j],
                    &caps->v2.video_caps[caps->v2.num_video_caps++]);
        }
    }

    free(profiles);
    free(entrypoints);

    return 0;
}

struct virgl_video_codec *virgl_video_create_codec(
        const struct virgl_video_create_codec_args *args)
{
    VAStatus va_stat;
    VAConfigID cfg;
    VAContextID ctx;
    VAConfigAttrib attr;
    VAProfile profile;
    VAEntrypoint entrypoint;
    uint32_t format;
    struct virgl_video_codec *codec;

    if (!va_dpy || !args)
        return NULL;

    profile = va_profile_from_pipe(args->profile);
    entrypoint = va_entrypoint_from_pipe(args->entrypoint);
    format = va_format_from_pipe_chroma(args->chroma_format);
    if (VAProfileNone == profile || VAEntrypointNone == entrypoint)
        return NULL;

    codec = (struct virgl_video_codec *)calloc(1, sizeof(*codec));
    if (!codec)
        return NULL;

    attr.type = VAConfigAttribRTFormat;
    vaGetConfigAttributes(va_dpy, profile, entrypoint, &attr, 1);
    if (!(attr.value & format)) {
        virgl_log("format 0x%x not supported, supported formats: 0x%x\n",
                  format, attr.value);
        goto err;
    }

    va_stat = vaCreateConfig(va_dpy, profile, entrypoint, &attr, 1, &cfg);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("create config failed, err = 0x%x\n", va_stat);
        goto err;
    }
    codec->va_cfg = cfg;

    va_stat = vaCreateContext(va_dpy, cfg, args->width, args->height,
                                VA_PROGRESSIVE, NULL, 0, &ctx);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("create context failed, err = 0x%x\n", va_stat);
        goto err;
    }
    codec->va_ctx = ctx;

    codec->profile = args->profile;
    codec->level = args->level;
    codec->entrypoint = args->entrypoint;
    codec->chroma_format = args->chroma_format;
    codec->width = args->width;
    codec->height = args->height;
    codec->max_references = args->max_references;
    codec->opaque = args->opaque;

    if (entrypoint == VAEntrypointEncSlice) {
        vaCreateBuffer(va_dpy, codec->va_ctx, VAEncCodedBufferType,
                       CODED_BUF_DEFAULT_SIZE(codec->width, codec->height),
                       1, NULL, &codec->va_coded_buf);
    }

    return codec;

err:
    virgl_video_destroy_codec(codec);

    return NULL;
}

void virgl_video_destroy_codec(struct virgl_video_codec *codec)
{
    unsigned i;

    if (!va_dpy || !codec)
        return;

    if (codec->va_ctx)
        vaDestroyContext(va_dpy, codec->va_ctx);

    if (codec->va_cfg)
        vaDestroyConfig(va_dpy, codec->va_cfg);

    if (codec->va_coded_buf)
        vaDestroyBuffer(va_dpy, codec->va_coded_buf);

    for (i = 0; i < ARRAY_SIZE(codec->ref_pic_list); i++) {
        if (codec->ref_pic_list[i])
            free(codec->ref_pic_list[i]);
    }

    free(codec);
}

struct virgl_video_buffer *virgl_video_create_buffer(
        const struct virgl_video_create_buffer_args *args)
{
    VAStatus va_stat;
    VASurfaceID sfc;
    uint32_t format;
    struct virgl_video_buffer *buffer;

    if (!va_dpy || !args)
        return NULL;

    /*
     * FIXME: always use YUV420 now,
     * may be use va_format_from_pipe(args->format)
     */
    format = VA_RT_FORMAT_YUV420;
    if (!format) {
        virgl_log("pipe format %d not supported\n", args->format);
        return NULL;
    }

    buffer = (struct virgl_video_buffer *)calloc(1, sizeof(*buffer));
    if (!buffer)
        return NULL;

    va_stat = vaCreateSurfaces(va_dpy, format,
                               args->width, args->height, &sfc, 1, NULL, 0);
    if (VA_STATUS_SUCCESS != va_stat) {
        free(buffer);
        return NULL;
    }

    buffer->va_sfc = sfc;
    buffer->format = args->format;
    buffer->width  = args->width;
    buffer->height = args->height;
    buffer->opaque = args->opaque;

    return buffer;
}

void virgl_video_destroy_buffer(struct virgl_video_buffer *buffer)
{
    if (!va_dpy || !buffer)
        return;

    if (buffer->dmabuf)
        destroy_video_dma_buf(buffer->dmabuf);

    if (buffer->va_sfc)
        vaDestroySurfaces(va_dpy, &buffer->va_sfc, 1);

    free(buffer);
}

void *virgl_video_codec_opaque_data(struct virgl_video_codec *codec)
{
    return codec ? codec->opaque : NULL;
}

enum pipe_video_profile virgl_video_codec_profile(
        const struct virgl_video_codec *codec)
{
    return codec ? codec->profile : PIPE_VIDEO_PROFILE_UNKNOWN;
}

uint32_t virgl_video_buffer_id(const struct virgl_video_buffer *buffer)
{
    return (uint32_t)(buffer ? buffer->va_sfc : VA_INVALID_SURFACE);
}

void *virgl_video_buffer_opaque_data(struct virgl_video_buffer *buffer)
{
    return buffer ? buffer->opaque : NULL;
}

int virgl_video_begin_frame(struct virgl_video_codec *codec,
                            struct virgl_video_buffer *target)
{
    VAStatus va_stat;

    if (!va_dpy || !codec || !target)
        return -1;

    if (codec->entrypoint == PIPE_VIDEO_ENTRYPOINT_ENCODE)
        encode_upload_picture(codec, target);

    codec->buffer = target;
    va_stat = vaBeginPicture(va_dpy, codec->va_ctx, target->va_sfc);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("begin picture failed, err = 0x%x\n", va_stat);
        return -1;
    }

    return 0;
}


#define ITEM_SET(dest, src, member) \
        (dest)->member = (src)->member

#define ITEM_CPY(dest, src, member) \
        memcpy(&(dest)->member, &(src)->member, sizeof((dest)->member))


static void h264_init_picture(VAPictureH264 *pic)
{
    pic->picture_id           = VA_INVALID_SURFACE;
    pic->frame_idx            = 0;
    pic->flags                = VA_PICTURE_H264_INVALID;
    pic->TopFieldOrderCnt     = 0;
    pic->BottomFieldOrderCnt  = 0;
}

/*
 * Refer to vlVaHandlePictureParameterBufferH264() in mesa,
 * and comment out some unused parameters.
 */
static void h264_fill_picture_param(struct virgl_video_codec *codec,
                            struct virgl_video_buffer *target,
                            const struct virgl_h264_picture_desc *desc,
                            VAPictureParameterBufferH264 *vapp)
{
    unsigned i;
    VAPictureH264 *pic;

    (void)codec;

    /* CurrPic */
    pic = &vapp->CurrPic;
    pic->picture_id = target->va_sfc;
    pic->frame_idx  = desc->frame_num;
    pic->flags = desc->is_reference ? VA_PICTURE_H264_SHORT_TERM_REFERENCE : 0;
    if (desc->field_pic_flag)
        pic->flags |= (desc->bottom_field_flag ? VA_PICTURE_H264_BOTTOM_FIELD
                                               : VA_PICTURE_H264_TOP_FIELD);
    pic->TopFieldOrderCnt = desc->field_order_cnt[0];
    pic->BottomFieldOrderCnt = desc->field_order_cnt[1];


    /* ReferenceFrames */
    for (i = 0; i < ARRAY_SIZE(vapp->ReferenceFrames); i++)
        h264_init_picture(&vapp->ReferenceFrames[i]);

    for (i = 0; i < desc->num_ref_frames; i++) {
        pic = &vapp->ReferenceFrames[i];

        pic->picture_id = desc->buffer_id[i];
        pic->frame_idx  = desc->frame_num_list[i];
        pic->flags = (desc->is_long_term[i]
                      ? VA_PICTURE_H264_LONG_TERM_REFERENCE
                      : VA_PICTURE_H264_SHORT_TERM_REFERENCE);
        if (desc->top_is_reference[i] && desc->bottom_is_reference[i]) {
            // Full frame. This block intentionally left blank. No flags set.
        } else {
            if (desc->top_is_reference[i])
                pic->flags |= VA_PICTURE_H264_TOP_FIELD;
            else
                pic->flags |= VA_PICTURE_H264_BOTTOM_FIELD;
        }
        pic->TopFieldOrderCnt = desc->field_order_cnt_list[i][0];
        pic->BottomFieldOrderCnt = desc->field_order_cnt_list[i][1];
    }

    //vapp->picture_width_in_mbs_minus1  = (codec->width - 1) / 16;
    //vapp->picture_height_in_mbs_minus1 = (codec->height - 1) / 16;
    ITEM_SET(vapp, &desc->pps.sps, bit_depth_luma_minus8);
    ITEM_SET(vapp, &desc->pps.sps, bit_depth_chroma_minus8);
    ITEM_SET(vapp, desc, num_ref_frames);

    ITEM_SET(&vapp->seq_fields.bits, &desc->pps.sps, chroma_format_idc);
    //vapp->seq_fields.bits.residual_colour_transform_flag       = 0;
    //vapp->seq_fields.bits.gaps_in_frame_num_value_allowed_flag = 0;
    ITEM_SET(&vapp->seq_fields.bits, &desc->pps.sps, frame_mbs_only_flag);
    ITEM_SET(&vapp->seq_fields.bits,
             &desc->pps.sps, mb_adaptive_frame_field_flag);
    ITEM_SET(&vapp->seq_fields.bits, &desc->pps.sps, direct_8x8_inference_flag);
    ITEM_SET(&vapp->seq_fields.bits, &desc->pps.sps, MinLumaBiPredSize8x8);
    ITEM_SET(&vapp->seq_fields.bits, &desc->pps.sps, log2_max_frame_num_minus4);
    ITEM_SET(&vapp->seq_fields.bits, &desc->pps.sps, pic_order_cnt_type);
    ITEM_SET(&vapp->seq_fields.bits,
             &desc->pps.sps, log2_max_pic_order_cnt_lsb_minus4);
    ITEM_SET(&vapp->seq_fields.bits,
             &desc->pps.sps, delta_pic_order_always_zero_flag);

    //ITEM_SET(vapp, &desc->pps, num_slice_groups_minus1);
    //ITEM_SET(vapp, &desc->pps, slice_group_map_type);
    //ITEM_SET(vapp, &desc->pps, slice_group_change_rate_minus1);
    ITEM_SET(vapp, &desc->pps, pic_init_qp_minus26);
    ITEM_SET(vapp, &desc->pps, pic_init_qs_minus26);
    ITEM_SET(vapp, &desc->pps, chroma_qp_index_offset);
    ITEM_SET(vapp, &desc->pps, second_chroma_qp_index_offset);

    ITEM_SET(&vapp->pic_fields.bits, &desc->pps, entropy_coding_mode_flag);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps, weighted_pred_flag);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps, weighted_bipred_idc);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps, transform_8x8_mode_flag);
    ITEM_SET(&vapp->pic_fields.bits, desc,       field_pic_flag);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps, constrained_intra_pred_flag);
    vapp->pic_fields.bits.pic_order_present_flag =
             desc->pps.bottom_field_pic_order_in_frame_present_flag;
    ITEM_SET(&vapp->pic_fields.bits,
             &desc->pps, deblocking_filter_control_present_flag);
    ITEM_SET(&vapp->pic_fields.bits,
             &desc->pps, redundant_pic_cnt_present_flag);
    vapp->pic_fields.bits.reference_pic_flag = desc->is_reference;

    ITEM_SET(vapp, desc, frame_num);
}


 /* Refer to vlVaHandleIQMatrixBufferH264() in mesa */
static void h264_fill_iq_matrix(const struct virgl_h264_picture_desc *desc,
                                VAIQMatrixBufferH264 *vaiqm)
{
    ITEM_CPY(vaiqm, &desc->pps, ScalingList4x4);
    ITEM_CPY(vaiqm, &desc->pps, ScalingList8x8);
}

/*
 * Refer to vlVaHandleSliceParameterBufferH264() in mesa,
 * and comment out some unused parameters.
 */
static void h264_fill_slice_param(const struct virgl_h264_picture_desc *desc,
                                  VASliceParameterBufferH264 *vasp)
{
    //vasp->slice_data_size;
    //vasp->slice_data_offset;
    //vasp->slice_data_flag;
    //vasp->slice_data_bit_offset;
    //vasp->first_mb_in_slice;
    //vasp->slice_type;
    //vasp->direct_spatial_mv_pred_flag;
    ITEM_SET(vasp, desc, num_ref_idx_l0_active_minus1);
    ITEM_SET(vasp, desc, num_ref_idx_l1_active_minus1);
    //vasp->cabac_init_idc;
    //vasp->slice_qp_delta;
    //vasp->disable_deblocking_filter_idc;
    //vasp->slice_alpha_c0_offset_div2;
    //vasp->slice_beta_offset_div2;
    //vasp->RefPicList0[32];
    //vasp->RefPicList1[32];

    /* see pred_weight_table */
    //vasp->luma_log2_weight_denom;
    //vasp->chroma_log2_weight_denom;
    //vasp->luma_weight_l0_flag;
    //vasp->luma_weight_l0[32];
    //vasp->luma_offset_l0[32];
    //vasp->chroma_weight_l0_flag;
    //vasp->chroma_weight_l0[32][2];
    //vasp->chroma_offset_l0[32][2];
    //vasp->luma_weight_l1_flag;
    //vasp->luma_weight_l1[32];
    //vasp->luma_offset_l1[32];
    //vasp->chroma_weight_l1_flag;
    //vasp->chroma_weight_l1[32][2];
    //vasp->chroma_offset_l1[32][2];
}

/*
 * Refer to vlVaHandleVAEncPictureParameterBufferTypeH264() in mesa,
 * and comment out some unused parameters.
 */
static void h264_fill_enc_picture_param(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h264_enc_picture_desc *desc,
                            VAEncPictureParameterBufferH264 *param)
{
    unsigned i;

    (void)codec;
    (void)source;

    /* CurrPic */
    param->CurrPic.picture_id = get_enc_ref_pic(codec, desc->frame_num);
    //CurrPic.frame_idx;
    //CurrPic.flags;
    param->CurrPic.TopFieldOrderCnt = desc->pic_order_cnt;
    //CurrPic.BottomFieldOrderCnt;

    /* ReferenceFrames */
    for (i = 0; i < ARRAY_SIZE(param->ReferenceFrames); i++)
        h264_init_picture(&param->ReferenceFrames[i]);

    /* coded_buf */
    param->coded_buf = codec->va_coded_buf;

    //pic_parameter_set_id;
    //seq_parameter_set_id;
    //last_picture;
    //frame_num
    param->pic_init_qp = desc->quant_i_frames;
    param->num_ref_idx_l0_active_minus1 = desc->num_ref_idx_l0_active_minus1;
    param->num_ref_idx_l1_active_minus1 = desc->num_ref_idx_l1_active_minus1;
    //chroma_qp_index_offset;
    //second_chroma_qp_index_offset;

    /* pic_fields */
    param->pic_fields.bits.idr_pic_flag =
                      (desc->picture_type == PIPE_H2645_ENC_PICTURE_TYPE_IDR);
    param->pic_fields.bits.reference_pic_flag = !desc->not_referenced;
    param->pic_fields.bits.entropy_coding_mode_flag = desc->pic_ctrl.enc_cabac_enable;
    //pic_fields.bits.weighted_pred_flag
    //pic_fields.bits.weighted_bipred_idc
    //pic_fields.bits.constrained_intra_pred_flag
    //pic_fields.bits.transform_8x8_mode_flag
    //pic_fields.bits.deblocking_filter_control_present_flag
    //pic_fields.bits.redundant_pic_cnt_present_flag
    //pic_fields.bits.pic_order_present_flag
    //pic_fields.bits.pic_scaling_matrix_present_flag

}

/*
 * Refer to vlVaHandleVAEncSliceParameterBufferTypeH264() in mesa,
 * and comment out some unused parameters.
 */
static void h264_fill_enc_slice_param(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h264_enc_picture_desc *desc,
                            VAEncSliceParameterBufferH264 *param)
{
    unsigned i;
    const struct virgl_h264_slice_descriptor *sd;

    (void)codec;
    (void)source;

    /* Get the lastest slice descriptor */
    if (desc->num_slice_descriptors &&
        desc->num_slice_descriptors <= ARRAY_SIZE(desc->slices_descriptors)) {
        sd = &desc->slices_descriptors[desc->num_slice_descriptors - 1];
        param->macroblock_address = sd->macroblock_address;
        param->num_macroblocks    = sd->num_macroblocks;
        //macroblock_info;
    }

    switch (desc->picture_type) {
    case PIPE_H2645_ENC_PICTURE_TYPE_P:
        param->slice_type = 0;
        break;
    case PIPE_H2645_ENC_PICTURE_TYPE_B:
        param->slice_type = 1;
        break;
    case PIPE_H2645_ENC_PICTURE_TYPE_I:
    case PIPE_H2645_ENC_PICTURE_TYPE_IDR: /* fall through */
        param->slice_type = 2;
        break;
    case PIPE_H2645_ENC_PICTURE_TYPE_SKIP:
    default:
        break;
    }

    //pic_parameter_set_id;
    //idr_pic_id;
    //pic_order_cnt_lsb;
    //delta_pic_order_cnt_bottom;
    //delta_pic_order_cnt[2];
    //direct_spatial_mv_pred_flag;

    /*
     * Sine num_ref_idx_l0_active_minus1 and num_ref_idx_l1_active_minus1
     * have been passed by VAEncPictureParameterBufferH264,
     * num_ref_idx_active_override_flag is always set to 0.
     */
    param->num_ref_idx_active_override_flag = 0;
    //num_ref_idx_l0_active_minus1
    //num_ref_idx_l1_active_minus1

    /* Reference List */
    for (i = 0; i < 32; i++) {
        h264_init_picture(&param->RefPicList0[i]);
        h264_init_picture(&param->RefPicList1[i]);

        param->RefPicList0[i].picture_id =
                    get_enc_ref_pic(codec, desc->ref_idx_l0_list[i]);
        param->RefPicList1[i].picture_id =
                    get_enc_ref_pic(codec, desc->ref_idx_l1_list[i]);

        if (param->RefPicList0[i].picture_id != VA_INVALID_ID)
            param->RefPicList0[i].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;

        if (param->RefPicList1[i].picture_id != VA_INVALID_ID)
            param->RefPicList1[i].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
    }

    //luma_log2_weight_denom;
    //chroma_log2_weight_denom;
    //luma_weight_l0_flag;
    //luma_weight_l0[32];
    //luma_offset_l0[32];
    //chroma_weight_l0_flag;
    //chroma_weight_l0[32][2];
    //chroma_offset_l0[32][2];
    //luma_weight_l1_flag;
    //luma_weight_l1[32];
    //luma_offset_l1[32];
    //chroma_weight_l1_flag;
    //chroma_weight_l1[32][2];
    //chroma_offset_l1[32][2];
    param->cabac_init_idc = desc->pic_ctrl.enc_cabac_init_idc;
    //slice_qp_delta;
    //disable_deblocking_filter_idc;
    //slice_alpha_c0_offset_div2;
    //slice_beta_offset_div2;

}

/*
 * Refer to vlVaHandleVAEncSequenceParameterBufferTypeH264() in mesa,
 * and comment out some unused parameters.
 */
static void h264_fill_enc_seq_param(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h264_enc_picture_desc *desc,
                            VAEncSequenceParameterBufferH264 *param)
{
    (void)codec;
    (void)source;

    //seq_parameter_set_id;
    param->level_idc = codec->level;
    //intra_period;
    param->intra_idr_period = desc->intra_idr_period;
    //ip_period;
    //bits_per_second;
    param->max_num_ref_frames = codec->max_references;
    //picture_width_in_mbs;
    //picture_height_in_mbs;

    /* seq_fields.bits */
    //seq_fields.bits.chroma_format_idc
    //seq_fields.bits.frame_mbs_only_flag
    //seq_fields.bits.mb_adaptive_frame_field_flag
    //seq_fields.bits.seq_scaling_matrix_present_flag
    //seq_fields.bits.direct_8x8_inference_flag
    //seq_fields.bits.log2_max_frame_num_minus4
    ITEM_SET(&param->seq_fields.bits, &desc->seq, pic_order_cnt_type);
    //seq_fields.bit.log2_max_pic_order_cnt_lsb_minus4
    //seq_fields.bit.delta_pic_order_always_zero_flag

    //bit_depth_luma_minus8;
    //bit_depth_chroma_minus8;

    //num_ref_frames_in_pic_order_cnt_cycle;
    //offset_for_non_ref_pic;
    //offset_for_top_to_bottom_field;
    //offset_for_ref_frame[256];
    if (desc->seq.enc_frame_cropping_flag) {
        param->frame_cropping_flag      = desc->seq.enc_frame_cropping_flag;
        param->frame_crop_left_offset   = desc->seq.enc_frame_crop_left_offset;
        param->frame_crop_right_offset  = desc->seq.enc_frame_crop_right_offset;
        param->frame_crop_top_offset    = desc->seq.enc_frame_crop_top_offset;
        param->frame_crop_bottom_offset = desc->seq.enc_frame_crop_bottom_offset;
    }

    ITEM_SET(param, &desc->seq, vui_parameters_present_flag);

    // vui_fields.bits
    if (desc->seq.vui_parameters_present_flag) {
        ITEM_SET(&param->vui_fields.bits, &desc->seq.vui_flags,
                 aspect_ratio_info_present_flag);
        ITEM_SET(&param->vui_fields.bits, &desc->seq.vui_flags,
                 timing_info_present_flag);
    }
    //vui_fields.bits.bitstream_restriction_flag
    //vui_fields.bits.log2_max_mv_length_horizontal
    //vui_fields.bits.log2_max_mv_length_vertical
    //vui_fields.bits.fixed_frame_rate_flag
    //vui_fields.bits.low_delay_hrd_flag
    //vui_fields.bits.motion_vectors_over_pic_boundaries_flag

    if (desc->seq.vui_parameters_present_flag) {
        ITEM_SET(param, &desc->seq, aspect_ratio_idc);
        ITEM_SET(param, &desc->seq, sar_width);
        ITEM_SET(param, &desc->seq, sar_height);
    }
    ITEM_SET(param, &desc->seq, num_units_in_tick);
    ITEM_SET(param, &desc->seq, time_scale);
}

/*
 * Refer to vlVaHandleVAEncMiscParameterTypeRateControlH264() in mesa,
 * and comment out some unused parameters.
 */
static void h264_fill_enc_misc_param_rate_ctrl(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h264_enc_picture_desc *desc,
                            VAEncMiscParameterRateControl *param)
{
    unsigned temporal_id = 0; /* always 0 now */
    const struct virgl_h264_enc_rate_control *rc = &desc->rate_ctrl[temporal_id];

    (void)codec;
    (void)source;

    param->bits_per_second = rc->peak_bitrate;
    if (desc->rate_ctrl[0].rate_ctrl_method !=
        PIPE_H2645_ENC_RATE_CONTROL_METHOD_CONSTANT) {
        param->target_percentage = rc->target_bitrate *
                                   param->bits_per_second / 100.0;
    }
    //window_size;
    //initial_qp;
    param->min_qp = rc->min_qp;
    //basic_unit_size;

    /* rc_flags */
    //rc_flags.bits.reset
    param->rc_flags.bits.disable_frame_skip = !rc->skip_frame_enable;
    param->rc_flags.bits.disable_bit_stuffing = !rc->fill_data_enable;
    //rc_flags.bits.mb_rate_control
    param->rc_flags.bits.temporal_id = temporal_id;
    //rc_flags.bits.cfs_I_frames
    //rc_flags.bits.enable_parallel_brc
    //rc_flags.bits.enable_dynamic_scaling
    //rc_flags.bits.frame_tolerance_mode

    //ICQ_quality_factor;
    param->max_qp = rc->max_qp;
    //quality_factor;
    //target_frame_size;
}

/*
 * Refer to vlVaHandleVAEncMiscParameterTypeFrameRateH264() in mesa,
 * and comment out some unused parameters.
 */
static void h264_fill_enc_misc_param_frame_rate(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h264_enc_picture_desc *desc,
                            VAEncMiscParameterFrameRate *param)
{
    unsigned temporal_id = 0; /* always 0 now */
    const struct virgl_h264_enc_rate_control *rc = &desc->rate_ctrl[temporal_id];

    (void)codec;
    (void)source;

    param->framerate = rc->frame_rate_num | (rc->frame_rate_den << 16);
    param->framerate_flags.bits.temporal_id = temporal_id;
}

static int h264_decode_bitstream(struct virgl_video_codec *codec,
                                 struct virgl_video_buffer *target,
                                 const struct virgl_h264_picture_desc *desc,
                                 unsigned num_buffers,
                                 const void * const *buffers,
                                 const unsigned *sizes)
{
    unsigned i;
    int err = 0;
    VAStatus va_stat;
    VABufferID *slice_data_buf, pic_param_buf, iq_matrix_buf, slice_param_buf;
    VAPictureParameterBufferH264 pic_param;
    VAIQMatrixBufferH264 iq_matrix;
    VASliceParameterBufferH264 slice_param;

    slice_data_buf = calloc(num_buffers, sizeof(VABufferID));
    if (!slice_data_buf) {
        virgl_log("alloc slice data buffer id failed\n");
        return -1;
    }

    h264_fill_picture_param(codec, target, desc, &pic_param);
    vaCreateBuffer(va_dpy, codec->va_ctx, VAPictureParameterBufferType,
                   sizeof(pic_param), 1, &pic_param, &pic_param_buf);

    h264_fill_iq_matrix(desc, &iq_matrix);
    vaCreateBuffer(va_dpy, codec->va_ctx, VAIQMatrixBufferType,
                   sizeof(iq_matrix), 1, &iq_matrix, &iq_matrix_buf);

    h264_fill_slice_param(desc, &slice_param);
    vaCreateBuffer(va_dpy, codec->va_ctx, VASliceParameterBufferType,
                   sizeof(slice_param), 1, &slice_param, &slice_param_buf);

    for (i = 0; i < num_buffers; i++) {
        vaCreateBuffer(va_dpy, codec->va_ctx, VASliceDataBufferType,
                      sizes[i], 1, (void *)(buffers[i]), &slice_data_buf[i]);
    }

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &pic_param_buf, 1);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render picture param failed, err = 0x%x\n", va_stat);
        err = -1;
        goto err;
    }

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &iq_matrix_buf, 1);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render iq matrix failed, err = 0x%x\n", va_stat);
        err = -1;
        goto err;
    }

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &slice_param_buf, 1);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render slice param failed, err = 0x%x\n", va_stat);
        err = -1;
        goto err;
    }

    for (i = 0; i < num_buffers; i++) {
        va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &slice_data_buf[i], 1);

        if (VA_STATUS_SUCCESS != va_stat) {
            virgl_log("render slice data failed, err = 0x%x\n", va_stat);
            err = -1;
        }
    }

err:
    vaDestroyBuffer(va_dpy, pic_param_buf);
    vaDestroyBuffer(va_dpy, iq_matrix_buf);
    vaDestroyBuffer(va_dpy, slice_param_buf);
    for (i = 0; i < num_buffers; i++)
        vaDestroyBuffer(va_dpy, slice_data_buf[i]);
    free(slice_data_buf);

    return err;
}

static int h264_encode_render_sequence(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h264_enc_picture_desc *desc)
{
    int err = 0;
    VAStatus va_stat;
    VAEncSequenceParameterBufferH264 seq_param;
    VAEncMiscParameterBuffer *misc_param;
    VABufferID seq_param_buf, rc_param_buf, fr_param_buf;

    memset(&seq_param, 0, sizeof(seq_param));
    h264_fill_enc_seq_param(codec, source, desc, &seq_param);
    vaCreateBuffer(va_dpy, codec->va_ctx, VAEncSequenceParameterBufferType,
                   sizeof(seq_param), 1, &seq_param, &seq_param_buf);

    vaCreateBuffer(va_dpy, codec->va_ctx, VAEncMiscParameterBufferType,
                   sizeof(VAEncMiscParameterBuffer) +
                   sizeof(VAEncMiscParameterRateControl), 1, NULL, &rc_param_buf);
    vaMapBuffer(va_dpy, rc_param_buf, (void **)&misc_param);
    misc_param->type = VAEncMiscParameterTypeRateControl;
    h264_fill_enc_misc_param_rate_ctrl(codec, source, desc,
                    (VAEncMiscParameterRateControl *)misc_param->data);
    vaUnmapBuffer(va_dpy, rc_param_buf);

    vaCreateBuffer(va_dpy, codec->va_ctx, VAEncMiscParameterBufferType,
                   sizeof(VAEncMiscParameterBuffer) +
                   sizeof(VAEncMiscParameterFrameRate), 1, NULL, &fr_param_buf);
    vaMapBuffer(va_dpy, fr_param_buf, (void **)&misc_param);
    misc_param->type = VAEncMiscParameterTypeFrameRate;
    h264_fill_enc_misc_param_frame_rate(codec, source, desc,
                    (VAEncMiscParameterFrameRate *)misc_param->data);
    vaUnmapBuffer(va_dpy, fr_param_buf);

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &seq_param_buf, 1);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render h264 sequence param failed, err = 0x%x\n", va_stat);
        err = -1;
        goto error;
    }

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &rc_param_buf, 1);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render h264 rate control param failed, err = 0x%x\n", va_stat);
        err = -1;
        goto error;
    }

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &fr_param_buf, 1);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render h264 frame rate param failed, err = 0x%x\n", va_stat);
        err = -1;
        goto error;
    }

error:
    vaDestroyBuffer(va_dpy, seq_param_buf);
    vaDestroyBuffer(va_dpy, rc_param_buf);
    vaDestroyBuffer(va_dpy, fr_param_buf);

    return err;
}

static int h264_encode_render_picture(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h264_enc_picture_desc *desc)
{
    VAStatus va_stat;
    VABufferID pic_param_buf;
    VAEncPictureParameterBufferH264 pic_param;

    memset(&pic_param, 0, sizeof(pic_param));
    h264_fill_enc_picture_param(codec, source, desc, &pic_param);
    vaCreateBuffer(va_dpy, codec->va_ctx, VAEncPictureParameterBufferType,
                   sizeof(pic_param), 1, &pic_param, &pic_param_buf);

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &pic_param_buf, 1);
    vaDestroyBuffer(va_dpy, pic_param_buf);

    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render h264 picture param failed, err = 0x%x\n", va_stat);
        return -1;
    }

    return 0;
}

static int h264_encode_render_slice(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h264_enc_picture_desc *desc)
{
    VAStatus va_stat;
    VABufferID slice_param_buf;
    VAEncSliceParameterBufferH264 slice_param;

    memset(&slice_param, 0, sizeof(slice_param));
    h264_fill_enc_slice_param(codec, source, desc, &slice_param);
    vaCreateBuffer(va_dpy, codec->va_ctx, VAEncSliceParameterBufferType,
                   sizeof(slice_param), 1, &slice_param, &slice_param_buf);

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &slice_param_buf, 1);
    vaDestroyBuffer(va_dpy, slice_param_buf);

    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render h264 slice param failed, err = 0x%x\n", va_stat);
        return -1;
    }

    return 0;
}

static int h264_encode_bitstream(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h264_enc_picture_desc *desc)
{
    if (desc->picture_type == PIPE_H2645_ENC_PICTURE_TYPE_IDR) {
        h264_encode_render_sequence(codec, source, desc);
    }

    h264_encode_render_picture(codec, source, desc);
    h264_encode_render_slice(codec, source, desc);

    return 0;
}

static void h265_init_picture(VAPictureHEVC *pic)
{
    pic->picture_id     = VA_INVALID_SURFACE;
    pic->pic_order_cnt  = 0;
    pic->flags          = VA_PICTURE_HEVC_INVALID;
}

/*
 * Refer to vlVaHandlePictureParameterBufferHEVC() in mesa,
 * and comment out some unused parameters.
 */
static void h265_fill_picture_param(struct virgl_video_codec *codec,
                            struct virgl_video_buffer *target,
                            const struct virgl_h265_picture_desc *desc,
                            VAPictureParameterBufferHEVC *vapp)
{
    unsigned i;

    (void)codec;
    (void)target;

    //vapp->CurrPic.picture_id
    vapp->CurrPic.pic_order_cnt = desc->CurrPicOrderCntVal;
    //vapp->CurrPic.flags

    for (i = 0; i < 15; i++) {
        vapp->ReferenceFrames[i].pic_order_cnt = desc->PicOrderCntVal[i];
        vapp->ReferenceFrames[i].picture_id = desc->ref[i];
        vapp->ReferenceFrames[i].flags = VA_INVALID_SURFACE == desc->ref[i]
                                       ? VA_PICTURE_HEVC_INVALID : 0;
    }
    for (i = 0; i < desc->NumPocStCurrBefore; i++)
        vapp->ReferenceFrames[desc->RefPicSetStCurrBefore[i]].flags |= \
                VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE;
    for (i = 0; i < desc->NumPocStCurrAfter; i++)
        vapp->ReferenceFrames[desc->RefPicSetStCurrAfter[i]].flags |= \
                VA_PICTURE_HEVC_RPS_ST_CURR_AFTER;
    for (i = 0; i < desc->NumPocLtCurr; i++)
        vapp->ReferenceFrames[desc->RefPicSetLtCurr[i]].flags |= \
                VA_PICTURE_HEVC_RPS_LT_CURR;

    ITEM_SET(vapp, &desc->pps.sps, pic_width_in_luma_samples);
    ITEM_SET(vapp, &desc->pps.sps, pic_height_in_luma_samples);

    ITEM_SET(&vapp->pic_fields.bits, &desc->pps.sps, chroma_format_idc);
    ITEM_SET(&vapp->pic_fields.bits,
             &desc->pps.sps, separate_colour_plane_flag);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps.sps, pcm_enabled_flag);
    ITEM_SET(&vapp->pic_fields.bits,
             &desc->pps.sps, scaling_list_enabled_flag);
    ITEM_SET(&vapp->pic_fields.bits,
             &desc->pps, transform_skip_enabled_flag);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps.sps, amp_enabled_flag);
    ITEM_SET(&vapp->pic_fields.bits,
             &desc->pps.sps, strong_intra_smoothing_enabled_flag);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps, sign_data_hiding_enabled_flag);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps, constrained_intra_pred_flag);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps, cu_qp_delta_enabled_flag);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps, weighted_pred_flag);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps, weighted_bipred_flag);
    ITEM_SET(&vapp->pic_fields.bits,
             &desc->pps, transquant_bypass_enabled_flag);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps, tiles_enabled_flag);
    ITEM_SET(&vapp->pic_fields.bits,
             &desc->pps, entropy_coding_sync_enabled_flag);
    ITEM_SET(&vapp->pic_fields.bits, &desc->pps,
             pps_loop_filter_across_slices_enabled_flag);
    if (desc->pps.tiles_enabled_flag)
        ITEM_SET(&vapp->pic_fields.bits,
                 &desc->pps, loop_filter_across_tiles_enabled_flag);
    if (desc->pps.sps.pcm_enabled_flag)
        ITEM_SET(&vapp->pic_fields.bits,
                 &desc->pps.sps, pcm_loop_filter_disabled_flag);
    //ITEM_SET(vapp->pic_fields.bits, desc->pps.sps, NoPicReorderingFlag);
    //ITEM_SET(vapp->pic_fields.bits, desc->pps.sps, NoBiPredFlag);

    ITEM_SET(vapp, &desc->pps.sps, sps_max_dec_pic_buffering_minus1);
    ITEM_SET(vapp, &desc->pps.sps, bit_depth_luma_minus8);
    ITEM_SET(vapp, &desc->pps.sps, bit_depth_chroma_minus8);
    if (desc->pps.sps.pcm_enabled_flag) {
        ITEM_SET(vapp, &desc->pps.sps, pcm_sample_bit_depth_luma_minus1);
        ITEM_SET(vapp, &desc->pps.sps, pcm_sample_bit_depth_chroma_minus1);
    }
    ITEM_SET(vapp, &desc->pps.sps, log2_min_luma_coding_block_size_minus3);
    ITEM_SET(vapp, &desc->pps.sps, log2_diff_max_min_luma_coding_block_size);
    ITEM_SET(vapp, &desc->pps.sps, log2_min_transform_block_size_minus2);
    ITEM_SET(vapp, &desc->pps.sps, log2_diff_max_min_transform_block_size);
    if (desc->pps.sps.pcm_enabled_flag) {
        ITEM_SET(vapp, &desc->pps.sps,
                 log2_min_pcm_luma_coding_block_size_minus3);
        ITEM_SET(vapp, &desc->pps.sps,
                 log2_diff_max_min_pcm_luma_coding_block_size);
    }
    ITEM_SET(vapp, &desc->pps.sps, max_transform_hierarchy_depth_intra);
    ITEM_SET(vapp, &desc->pps.sps, max_transform_hierarchy_depth_inter);
    ITEM_SET(vapp, &desc->pps, init_qp_minus26);
    ITEM_SET(vapp, &desc->pps, diff_cu_qp_delta_depth);
    ITEM_SET(vapp, &desc->pps, pps_cb_qp_offset);
    ITEM_SET(vapp, &desc->pps, pps_cr_qp_offset);
    ITEM_SET(vapp, &desc->pps, log2_parallel_merge_level_minus2);
    if (desc->pps.tiles_enabled_flag) {
        ITEM_SET(vapp, &desc->pps, num_tile_columns_minus1);
        ITEM_SET(vapp, &desc->pps, num_tile_rows_minus1);
        ITEM_CPY(vapp, &desc->pps, column_width_minus1);
        ITEM_CPY(vapp, &desc->pps, row_height_minus1);
    }

    ITEM_SET(&vapp->slice_parsing_fields.bits,
             &desc->pps, lists_modification_present_flag);
    ITEM_SET(&vapp->slice_parsing_fields.bits,
             &desc->pps.sps, long_term_ref_pics_present_flag);
    ITEM_SET(&vapp->slice_parsing_fields.bits,
             &desc->pps.sps, sps_temporal_mvp_enabled_flag);
    ITEM_SET(&vapp->slice_parsing_fields.bits,
             &desc->pps, cabac_init_present_flag);
    ITEM_SET(&vapp->slice_parsing_fields.bits,
             &desc->pps, output_flag_present_flag);
    ITEM_SET(&vapp->slice_parsing_fields.bits,
             &desc->pps, dependent_slice_segments_enabled_flag);
    ITEM_SET(&vapp->slice_parsing_fields.bits,
             &desc->pps, pps_slice_chroma_qp_offsets_present_flag);
    ITEM_SET(&vapp->slice_parsing_fields.bits,
             &desc->pps.sps, sample_adaptive_offset_enabled_flag);
    ITEM_SET(&vapp->slice_parsing_fields.bits,
             &desc->pps, deblocking_filter_override_enabled_flag);
    vapp->slice_parsing_fields.bits.pps_disable_deblocking_filter_flag = \
             desc->pps.pps_deblocking_filter_disabled_flag;
    ITEM_SET(&vapp->slice_parsing_fields.bits,
             &desc->pps, slice_segment_header_extension_present_flag);
    vapp->slice_parsing_fields.bits.RapPicFlag = desc->RAPPicFlag;
    vapp->slice_parsing_fields.bits.IdrPicFlag = desc->IDRPicFlag;
    //vapp->slice_parsing_fields.bits.IntraPicFlag

    ITEM_SET(vapp, &desc->pps.sps, log2_max_pic_order_cnt_lsb_minus4);
    ITEM_SET(vapp, &desc->pps.sps, num_short_term_ref_pic_sets);
    vapp->num_long_term_ref_pic_sps = desc->pps.sps.num_long_term_ref_pics_sps;
    ITEM_SET(vapp, &desc->pps, num_ref_idx_l0_default_active_minus1);
    ITEM_SET(vapp, &desc->pps, num_ref_idx_l1_default_active_minus1);
    ITEM_SET(vapp, &desc->pps, pps_beta_offset_div2);
    ITEM_SET(vapp, &desc->pps, pps_tc_offset_div2);
    ITEM_SET(vapp, &desc->pps, num_extra_slice_header_bits);

    ITEM_SET(vapp, &desc->pps, st_rps_bits);
}

/*
 * Refer to vlVaHandleSliceParameterBufferHEVC() in mesa,
 * and comment out some unused parameters.
 */
static void h265_fill_slice_param(const struct virgl_h265_picture_desc *desc,
                                  VASliceParameterBufferHEVC *vapp)
{
    unsigned i, j;

    //slice_data_size;
    //slice_data_offset;
    //slice_data_flag;
    //slice_data_byte_offset;
    //slice_segment_address;
    for (i = 0; i < 2; i++) {
        for (j = 0; j < 15; j++)
            vapp->RefPicList[i][j] = desc->RefPicList[i][j];
    }
    //LongSliceFlags;
    //collocated_ref_idx;
    //num_ref_idx_l0_active_minus1;
    //num_ref_idx_l1_active_minus1;
    //slice_qp_delta;
    //slice_cb_qp_offset;
    //slice_cr_qp_offset;
    //slice_beta_offset_div2;
    //slice_tc_offset_div2;
    //luma_log2_weight_denom;
    //delta_chroma_log2_weight_denom;
    //delta_luma_weight_l0[15];
    //luma_offset_l0[15];
    //delta_chroma_weight_l0[15][2];
    //ChromaOffsetL0[15][2];
    //delta_luma_weight_l1[15];
    //luma_offset_l1[15];
    //delta_chroma_weight_l1[15][2];
    //ChromaOffsetL1[15][2];
    //five_minus_max_num_merge_cand;
    //num_entry_point_offsets;
    //entry_offset_to_subset_array;
    //slice_data_num_emu_prevn_bytes;
    //va_reserved[VA_PADDING_LOW - 2];
}

/*
 * Refer to vlVaHandleVAEncSequenceParameterBufferTypeHEVC() in mesa,
 * and comment out some unused parameters.
 */
static void h265_fill_enc_seq_param(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h265_enc_picture_desc *desc,
                            VAEncSequenceParameterBufferHEVC *param)
{
    (void)codec;
    (void)source;

    ITEM_SET(param, &desc->seq, general_profile_idc);
    ITEM_SET(param, &desc->seq, general_level_idc);
    ITEM_SET(param, &desc->seq, general_tier_flag);
    ITEM_SET(param, &desc->seq, intra_period);
    //intra_idr_period
    ITEM_SET(param, &desc->seq, ip_period);
    //bits_per_second
    ITEM_SET(param, &desc->seq, pic_width_in_luma_samples);
    ITEM_SET(param, &desc->seq, pic_height_in_luma_samples);

    /* seq_fields.bits */
    ITEM_SET(&param->seq_fields.bits, &desc->seq, chroma_format_idc);
    //seq_fields.bits.separate_colour_plane_flag
    ITEM_SET(&param->seq_fields.bits, &desc->seq, bit_depth_luma_minus8);
    ITEM_SET(&param->seq_fields.bits, &desc->seq, bit_depth_chroma_minus8);
    //seq_fields.bits.scaling_list_enabled_flag
    ITEM_SET(&param->seq_fields.bits, &desc->seq, strong_intra_smoothing_enabled_flag);
    ITEM_SET(&param->seq_fields.bits, &desc->seq, amp_enabled_flag);
    ITEM_SET(&param->seq_fields.bits, &desc->seq, sample_adaptive_offset_enabled_flag);
    ITEM_SET(&param->seq_fields.bits, &desc->seq, pcm_enabled_flag);
    //seq_fields.bits.pcm_loop_filter_disabled_flag
    ITEM_SET(&param->seq_fields.bits, &desc->seq, sps_temporal_mvp_enabled_flag);
    //seq_fields.bits.low_delay_seq
    //seq_fields.bits.hierachical_flag
    //seq_fields.bits.reserved_bits

    ITEM_SET(param, &desc->seq, log2_min_luma_coding_block_size_minus3);
    ITEM_SET(param, &desc->seq, log2_diff_max_min_luma_coding_block_size);
    ITEM_SET(param, &desc->seq, log2_min_transform_block_size_minus2);
    ITEM_SET(param, &desc->seq, log2_diff_max_min_transform_block_size);
    ITEM_SET(param, &desc->seq, max_transform_hierarchy_depth_inter);
    ITEM_SET(param, &desc->seq, max_transform_hierarchy_depth_intra);
    //pcm_sample_bit_depth_luma_minus1
    //pcm_sample_bit_depth_chroma_minus1
    //log2_min_pcm_luma_coding_block_size_minus3
    //log2_max_pcm_luma_coding_block_size_minus3
    ITEM_SET(param, &desc->seq, vui_parameters_present_flag);

    /* vui_fields.bits */
    if (desc->seq.vui_parameters_present_flag) {
        ITEM_SET(&param->vui_fields.bits, &desc->seq.vui_flags,
                 aspect_ratio_info_present_flag);
    }
    //vui_fields.bits.neutral_chroma_indication_flag
    //vui_fields.bits.field_seq_flag
    if (desc->seq.vui_parameters_present_flag) {
        param->vui_fields.bits.vui_timing_info_present_flag =
            desc->seq.vui_flags.timing_info_present_flag;
    }
    //vui_fields.bits.bitstream_restriction_flag
    //vui_fields.bits.tiles_fixed_structure_flag
    //vui_fields.bits.motion_vectors_over_pic_boundaries_flag
    //vui_fields.bits.restricted_ref_pic_lists_flag
    //vui_fields.bits.log2_max_mv_length_horizontal
    //vui_fields.bits.log2_max_mv_length_vertical

    if (desc->seq.vui_parameters_present_flag) {
        ITEM_SET(param, &desc->seq, aspect_ratio_idc);
        ITEM_SET(param, &desc->seq, sar_width);
        ITEM_SET(param, &desc->seq, sar_height);
    }
    param->vui_num_units_in_tick = desc->seq.num_units_in_tick;
    param->vui_time_scale = desc->seq.time_scale;
    //min_spatial_segmentation_idc
    //max_bytes_per_pic_denom
    //max_bits_per_min_cu_denom

    //scc_fields.bits.palette_mode_enabled_flag
}

/*
 * Refer to vlVaHandleVAEncPictureParameterBufferTypeHEVC() in mesa,
 * and comment out some unused parameters.
 */
static void h265_fill_enc_picture_param(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h265_enc_picture_desc *desc,
                            VAEncPictureParameterBufferHEVC *param)
{
    unsigned i;

    (void)source;

    param->decoded_curr_pic.picture_id = get_enc_ref_pic(codec, desc->frame_num);
    param->decoded_curr_pic.pic_order_cnt = desc->pic_order_cnt;

    for (i = 0; i < 15; i++) {
        h265_init_picture(&param->reference_frames[i]);
    }

    param->coded_buf = codec->va_coded_buf;
    //collocated_ref_pic_index
    //last_picture
    param->pic_init_qp = desc->rc.quant_i_frames;
    //diff_cu_qp_delta_depth
    //pps_cb_qp_offset
    //pps_cr_qp_offset
    //num_tile_columns_minus1
    //num_tile_rows_minus1
    //column_width_minus1[19]
    //row_height_minus1[21]
    ITEM_SET(param, &desc->pic, log2_parallel_merge_level_minus2);
    //ctu_max_bitsize_allowed
    param->num_ref_idx_l0_default_active_minus1 = desc->num_ref_idx_l0_active_minus1;
    param->num_ref_idx_l1_default_active_minus1 = desc->num_ref_idx_l1_active_minus1;
    //slice_pic_parameter_set_id
    ITEM_SET(param, &desc->pic, nal_unit_type);

    param->pic_fields.bits.idr_pic_flag =
        (desc->picture_type == PIPE_H2645_ENC_PICTURE_TYPE_IDR);
    switch (desc->picture_type) {
    case PIPE_H2645_ENC_PICTURE_TYPE_IDR: /* fallthrough */
    case PIPE_H2645_ENC_PICTURE_TYPE_I:
        param->pic_fields.bits.coding_type = 1;
        break;
    case PIPE_H2645_ENC_PICTURE_TYPE_P:
        param->pic_fields.bits.coding_type = 2;
        break;
    case PIPE_H2645_ENC_PICTURE_TYPE_B:
        param->pic_fields.bits.coding_type = 3;
        break;
    default:
        break;
    }

    param->pic_fields.bits.reference_pic_flag = !desc->not_referenced;
    //pic_fields.bits.dependent_slice_segments_enabled_flag
    //pic_fields.bits.sign_data_hiding_enabled_flag
    ITEM_SET(&param->pic_fields.bits, &desc->pic, constrained_intra_pred_flag);
    ITEM_SET(&param->pic_fields.bits, &desc->pic, transform_skip_enabled_flag);
    //pic_fields.bits.cu_qp_delta_enabled_flag
    //pic_fields.bits.weighted_pred_flag
    //pic_fields.bits.weighted_bipred_flag
    //pic_fields.bits.transquant_bypass_enabled_flag
    //pic_fields.bits.tiles_enabled_flag
    //pic_fields.bits.entropy_coding_sync_enabled_flag
    //pic_fields.bits.loop_filter_across_tiles_enabled_flag
    ITEM_SET(&param->pic_fields.bits, &desc->pic,
             pps_loop_filter_across_slices_enabled_flag);
    //pic_fields.bits.scaling_list_data_present_flag
    //pic_fields.bits.screen_content_flag
    //pic_fields.bits.enable_gpu_weighted_prediction
    //pic_fields.bits.no_output_of_prior_pics_flag

    //hierarchical_level_plus1
    //scc_fields.bits.pps_curr_pic_ref_enabled_flag
}

/*
 * Refer to vlVaHandleVAEncSliceParameterBufferTypeHEVC() in mesa,
 * and comment out some unused parameters.
 */
static void h265_fill_enc_slice_param(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h265_enc_picture_desc *desc,
                            VAEncSliceParameterBufferHEVC *param)
{
    unsigned i;
    const struct virgl_h265_slice_descriptor *sd;

    (void)source;

    /* Get the lastest slice descriptor */
    if (desc->num_slice_descriptors &&
        desc->num_slice_descriptors <= ARRAY_SIZE(desc->slices_descriptors)) {
        sd = &desc->slices_descriptors[desc->num_slice_descriptors - 1];
        ITEM_SET(param, sd, slice_segment_address);
        ITEM_SET(param, sd, num_ctu_in_slice);
    }

    switch (desc->picture_type) {
    case PIPE_H2645_ENC_PICTURE_TYPE_P:
        param->slice_type = 0;
        break;
    case PIPE_H2645_ENC_PICTURE_TYPE_B:
        param->slice_type = 1;
        break;
    case PIPE_H2645_ENC_PICTURE_TYPE_I:
    case PIPE_H2645_ENC_PICTURE_TYPE_IDR: /* fall through */
        param->slice_type = 2;
        break;
    case PIPE_H2645_ENC_PICTURE_TYPE_SKIP:
    default:
        break;
    }

    //slice_pic_parameter_set_id

    //num_ref_idx_l0_active_minus1
    //num_ref_idx_l1_active_minus1

    for (i = 0; i < 15; i++) {
        h265_init_picture(&param->ref_pic_list0[i]);
        h265_init_picture(&param->ref_pic_list1[i]);

        param->ref_pic_list0[i].picture_id =
                    get_enc_ref_pic(codec, desc->ref_idx_l0_list[i]);
        param->ref_pic_list1[i].picture_id =
                    get_enc_ref_pic(codec, desc->ref_idx_l1_list[i]);

        if (param->ref_pic_list0[i].picture_id != VA_INVALID_ID)
            param->ref_pic_list0[i].flags = VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE;

        if (param->ref_pic_list1[i].picture_id != VA_INVALID_ID)
            param->ref_pic_list1[i].flags = VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE;
    }

    //luma_log2_weight_denom
    //delta_chroma_log2_weight_denom
    //delta_luma_weight_l0[15]
    //luma_offset_l0[15]
    //delta_chroma_weight_l0[15][2]
    //chroma_offset_l0[15][2]
    //delta_luma_weight_l1[15]
    //luma_offset_l1[15]
    //delta_chroma_weight_l1[15][2]
    //chroma_offset_l1[15][2]
    ITEM_SET(param, &desc->slice, max_num_merge_cand);
    //slice_qp_delta
    ITEM_SET(param, &desc->slice, slice_cb_qp_offset);
    ITEM_SET(param, &desc->slice, slice_cr_qp_offset);
    ITEM_SET(param, &desc->slice, slice_beta_offset_div2);
    ITEM_SET(param, &desc->slice, slice_tc_offset_div2);

    //slice_fields.bits.last_slice_of_pic_flag
    //slice_fields.bits.dependent_slice_segment_flag
    //slice_fields.bits.colour_plane_id
    //slice_fields.bits.slice_temporal_mvp_enabled_flag
    //slice_fields.bits.slice_sao_luma_flag
    //slice_fields.bits.slice_sao_chroma_flag
    /*
     * Sine num_ref_idx_l0_active_minus1 and num_ref_idx_l1_active_minus1
     * have been passed by VAEncPictureParameterBufferHEVC,
     * num_ref_idx_active_override_flag is always set to 0.
     */
    param->slice_fields.bits.num_ref_idx_active_override_flag = 0;
    //slice_fields.bits.mvd_l1_zero_flag
    ITEM_SET(&param->slice_fields.bits, &desc->slice, cabac_init_flag);
    ITEM_SET(&param->slice_fields.bits, &desc->slice,
             slice_deblocking_filter_disabled_flag);
    ITEM_SET(&param->slice_fields.bits,
             &desc->slice, slice_loop_filter_across_slices_enabled_flag);
    //slice_fields.bits.collocated_from_l0_flag

    //pred_weight_table_bit_offset
    //pred_weight_table_bit_length;
}

/*
 * Refer to vlVaHandleVAEncMiscParameterTypeRateControlHEVC() in mesa,
 * and comment out some unused parameters.
 */
static void h265_fill_enc_misc_param_rate_ctrl(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h265_enc_picture_desc *desc,
                            VAEncMiscParameterRateControl *param)
{
    (void)codec;
    (void)source;

    param->bits_per_second = desc->rc.peak_bitrate;
    if (desc->rc.rate_ctrl_method !=
        PIPE_H2645_ENC_RATE_CONTROL_METHOD_CONSTANT) {
        param->target_percentage = desc->rc.target_bitrate *
                                   param->bits_per_second / 100.0;
    }
    //window_size;
    //initial_qp;
    param->min_qp = desc->rc.min_qp;
    //basic_unit_size;

    /* rc_flags */
    //rc_flags.bits.reset
    param->rc_flags.bits.disable_frame_skip = !desc->rc.skip_frame_enable;
    param->rc_flags.bits.disable_bit_stuffing = !desc->rc.fill_data_enable;
    //rc_flags.bits.mb_rate_control
    //rc_flags.bits.temporal_id
    //rc_flags.bits.cfs_I_frames
    //rc_flags.bits.enable_parallel_brc
    //rc_flags.bits.enable_dynamic_scaling
    //rc_flags.bits.frame_tolerance_mode

    //ICQ_quality_factor;
    param->max_qp = desc->rc.max_qp;
    //quality_factor;
    //target_frame_size;
}

/*
 * Refer to vlVaHandleVAEncMiscParameterTypeFrameRateHEVC() in mesa,
 * and comment out some unused parameters.
 */
static void h265_fill_enc_misc_param_frame_rate(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h265_enc_picture_desc *desc,
                            VAEncMiscParameterFrameRate *param)
{
    (void)codec;
    (void)source;

    param->framerate = desc->rc.frame_rate_num | (desc->rc.frame_rate_den << 16);
    //framerate_flags
}

static int h265_decode_bitstream(struct virgl_video_codec *codec,
                                 struct virgl_video_buffer *target,
                                 const struct virgl_h265_picture_desc *desc,
                                 unsigned num_buffers,
                                 const void * const *buffers,
                                 const unsigned *sizes)
{
    unsigned i;
    int err = 0;
    VAStatus va_stat;
    VABufferID *slice_data_buf, pic_param_buf, slice_param_buf;
    VAPictureParameterBufferHEVC pic_param = {0};
    VASliceParameterBufferHEVC slice_param = {0};

    slice_data_buf = calloc(num_buffers, sizeof(VABufferID));
    if (!slice_data_buf) {
        virgl_log("alloc slice data buffer id failed\n");
        return -1;
    }

    h265_fill_picture_param(codec, target, desc, &pic_param);
    vaCreateBuffer(va_dpy, codec->va_ctx, VAPictureParameterBufferType,
                   sizeof(pic_param), 1, &pic_param, &pic_param_buf);

    h265_fill_slice_param(desc, &slice_param);
    vaCreateBuffer(va_dpy, codec->va_ctx, VASliceParameterBufferType,
                   sizeof(slice_param), 1, &slice_param, &slice_param_buf);

    for (i = 0; i < num_buffers; i++) {
        vaCreateBuffer(va_dpy, codec->va_ctx, VASliceDataBufferType,
                      sizes[i], 1, (void *)(buffers[i]), &slice_data_buf[i]);
    }

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &pic_param_buf, 1);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render picture param failed, err = 0x%x\n", va_stat);
        err = -1;
        goto err;
    }

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &slice_param_buf, 1);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render slice param failed, err = 0x%x\n", va_stat);
        err = -1;
        goto err;
    }

    for (i = 0; i < num_buffers; i++) {
        va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &slice_data_buf[i], 1);

        if (VA_STATUS_SUCCESS != va_stat) {
            virgl_log("render slice data failed, err = 0x%x\n", va_stat);
            err = -1;
        }
    }

err:
    vaDestroyBuffer(va_dpy, pic_param_buf);
    vaDestroyBuffer(va_dpy, slice_param_buf);
    for (i = 0; i < num_buffers; i++)
        vaDestroyBuffer(va_dpy, slice_data_buf[i]);
    free(slice_data_buf);

    return err;
}

static int h265_encode_render_sequence(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h265_enc_picture_desc *desc)
{
    int err = 0;
    VAStatus va_stat;
    VAEncSequenceParameterBufferHEVC seq_param;
    VAEncMiscParameterBuffer *misc_param;
    VABufferID seq_param_buf, rc_param_buf, fr_param_buf;

    memset(&seq_param, 0, sizeof(seq_param));
    h265_fill_enc_seq_param(codec, source, desc, &seq_param);
    vaCreateBuffer(va_dpy, codec->va_ctx, VAEncSequenceParameterBufferType,
                   sizeof(seq_param), 1, &seq_param, &seq_param_buf);

    vaCreateBuffer(va_dpy, codec->va_ctx, VAEncMiscParameterBufferType,
                   sizeof(VAEncMiscParameterBuffer) +
                   sizeof(VAEncMiscParameterRateControl), 1, NULL, &rc_param_buf);
    vaMapBuffer(va_dpy, rc_param_buf, (void **)&misc_param);
    misc_param->type = VAEncMiscParameterTypeRateControl;
    h265_fill_enc_misc_param_rate_ctrl(codec, source, desc,
                    (VAEncMiscParameterRateControl *)misc_param->data);
    vaUnmapBuffer(va_dpy, rc_param_buf);

    vaCreateBuffer(va_dpy, codec->va_ctx, VAEncMiscParameterBufferType,
                   sizeof(VAEncMiscParameterBuffer) +
                   sizeof(VAEncMiscParameterFrameRate), 1, NULL, &fr_param_buf);
    vaMapBuffer(va_dpy, fr_param_buf, (void **)&misc_param);
    misc_param->type = VAEncMiscParameterTypeFrameRate;
    h265_fill_enc_misc_param_frame_rate(codec, source, desc,
                    (VAEncMiscParameterFrameRate *)misc_param->data);
    vaUnmapBuffer(va_dpy, fr_param_buf);

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &seq_param_buf, 1);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render h265 sequence param failed, err = 0x%x\n", va_stat);
        err = -1;
        goto error;
    }

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &rc_param_buf, 1);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render h265 rate control param failed, err = 0x%x\n", va_stat);
        err = -1;
        goto error;
    }

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &fr_param_buf, 1);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render h265 frame rate param failed, err = 0x%x\n", va_stat);
        err = -1;
        goto error;
    }

error:
    vaDestroyBuffer(va_dpy, seq_param_buf);
    vaDestroyBuffer(va_dpy, rc_param_buf);
    vaDestroyBuffer(va_dpy, fr_param_buf);

    return err;
}

static int h265_encode_render_picture(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h265_enc_picture_desc *desc)
{
    VAStatus va_stat;
    VABufferID pic_param_buf;
    VAEncPictureParameterBufferHEVC pic_param;

    memset(&pic_param, 0, sizeof(pic_param));
    h265_fill_enc_picture_param(codec, source, desc, &pic_param);
    vaCreateBuffer(va_dpy, codec->va_ctx, VAEncPictureParameterBufferType,
                   sizeof(pic_param), 1, &pic_param, &pic_param_buf);

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &pic_param_buf, 1);
    vaDestroyBuffer(va_dpy, pic_param_buf);

    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render h265 picture param failed, err = 0x%x\n", va_stat);
        return -1;
    }

    return 0;
}

static int h265_encode_render_slice(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h265_enc_picture_desc *desc)
{
    VAStatus va_stat;
    VABufferID slice_param_buf;
    VAEncSliceParameterBufferHEVC slice_param;

    memset(&slice_param, 0, sizeof(slice_param));
    h265_fill_enc_slice_param(codec, source, desc, &slice_param);
    vaCreateBuffer(va_dpy, codec->va_ctx, VAEncSliceParameterBufferType,
                   sizeof(slice_param), 1, &slice_param, &slice_param_buf);

    va_stat = vaRenderPicture(va_dpy, codec->va_ctx, &slice_param_buf, 1);
    vaDestroyBuffer(va_dpy, slice_param_buf);

    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("render h265 slice param failed, err = 0x%x\n", va_stat);
        return -1;
    }

    return 0;
}

static int h265_encode_bitstream(
                            struct virgl_video_codec *codec,
                            struct virgl_video_buffer *source,
                            const struct virgl_h265_enc_picture_desc *desc)
{
    if (desc->picture_type == PIPE_H2645_ENC_PICTURE_TYPE_IDR) {
        h265_encode_render_sequence(codec, source, desc);
    }

    h265_encode_render_picture(codec, source, desc);
    h265_encode_render_slice(codec, source, desc);

    return 0;
}

int virgl_video_decode_bitstream(struct virgl_video_codec *codec,
                                 struct virgl_video_buffer *target,
                                 const union virgl_picture_desc *desc,
                                 unsigned num_buffers,
                                 const void * const *buffers,
                                 const unsigned *sizes)
{

    if (!va_dpy || !codec || !target || !desc
        || !num_buffers || !buffers || !sizes)
        return -1;

    if (desc->base.profile != codec->profile) {
        virgl_log("profiles not matched, picture: %d, codec: %d\n",
                desc->base.profile, codec->profile);
        return -1;
    }

    switch (codec->profile) {
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_CONSTRAINED_BASELINE:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_EXTENDED:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH10:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH422:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH444:
        return h264_decode_bitstream(codec, target, &desc->h264,
                                     num_buffers, buffers, sizes);
    case PIPE_VIDEO_PROFILE_HEVC_MAIN:
    case PIPE_VIDEO_PROFILE_HEVC_MAIN_10:
    case PIPE_VIDEO_PROFILE_HEVC_MAIN_STILL:
    case PIPE_VIDEO_PROFILE_HEVC_MAIN_12:
    case PIPE_VIDEO_PROFILE_HEVC_MAIN_444:
        return h265_decode_bitstream(codec, target, &desc->h265,
                                     num_buffers, buffers, sizes);
    default:
        break;
    }

    return -1;
}

int virgl_video_encode_bitstream(struct virgl_video_codec *codec,
                                 struct virgl_video_buffer *source,
                                 const union virgl_picture_desc *desc)
{
    if (!va_dpy || !codec || !source || !desc)
        return -1;

    if (desc->base.profile != codec->profile) {
        virgl_log("profiles not matched, picture: %d, codec: %d\n",
                desc->base.profile, codec->profile);
        return -1;
    }

    switch (codec->profile) {
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_CONSTRAINED_BASELINE:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_EXTENDED:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH10:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH422:
    case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH444:
        return h264_encode_bitstream(codec, source, &desc->h264_enc);
    case PIPE_VIDEO_PROFILE_HEVC_MAIN:
    case PIPE_VIDEO_PROFILE_HEVC_MAIN_10:
    case PIPE_VIDEO_PROFILE_HEVC_MAIN_STILL:
    case PIPE_VIDEO_PROFILE_HEVC_MAIN_12:
    case PIPE_VIDEO_PROFILE_HEVC_MAIN_444:
        return h265_encode_bitstream(codec, source, &desc->h265_enc);
    default:
        break;
    }

    return -1;
}

int virgl_video_end_frame(struct virgl_video_codec *codec,
                          struct virgl_video_buffer *target)
{
    VAStatus va_stat;

    if (!va_dpy || !codec || !target)
        return -1;

    va_stat = vaEndPicture(va_dpy, codec->va_ctx);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("end picture failed, err = 0x%x\n", va_stat);
        return -1;
    }

    va_stat = vaSyncSurface(va_dpy, target->va_sfc);
    if (VA_STATUS_SUCCESS != va_stat) {
        virgl_log("sync surface failed, err = 0x%x\n", va_stat);
        return -1;
    }

    if (codec->entrypoint != PIPE_VIDEO_ENTRYPOINT_ENCODE) {
        decode_completed(codec, target);
    } else {
        encode_completed(codec, target);
    }

    return 0;
}