/************************************************************************** * * 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 */ #include #include #include #include #include #include #include #include #include #include #include #include #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 : ""); 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(¶m->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(¶m->RefPicList0[i]); h264_init_picture(¶m->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(¶m->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(¶m->vui_fields.bits, &desc->seq.vui_flags, aspect_ratio_info_present_flag); ITEM_SET(¶m->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(¶m->seq_fields.bits, &desc->seq, chroma_format_idc); //seq_fields.bits.separate_colour_plane_flag ITEM_SET(¶m->seq_fields.bits, &desc->seq, bit_depth_luma_minus8); ITEM_SET(¶m->seq_fields.bits, &desc->seq, bit_depth_chroma_minus8); //seq_fields.bits.scaling_list_enabled_flag ITEM_SET(¶m->seq_fields.bits, &desc->seq, strong_intra_smoothing_enabled_flag); ITEM_SET(¶m->seq_fields.bits, &desc->seq, amp_enabled_flag); ITEM_SET(¶m->seq_fields.bits, &desc->seq, sample_adaptive_offset_enabled_flag); ITEM_SET(¶m->seq_fields.bits, &desc->seq, pcm_enabled_flag); //seq_fields.bits.pcm_loop_filter_disabled_flag ITEM_SET(¶m->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(¶m->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(¶m->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(¶m->pic_fields.bits, &desc->pic, constrained_intra_pred_flag); ITEM_SET(¶m->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(¶m->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(¶m->ref_pic_list0[i]); h265_init_picture(¶m->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(¶m->slice_fields.bits, &desc->slice, cabac_init_flag); ITEM_SET(¶m->slice_fields.bits, &desc->slice, slice_deblocking_filter_disabled_flag); ITEM_SET(¶m->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; }