From patchwork Sun Jun 18 17:45:25 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mark Thompson X-Patchwork-Id: 4021 Delivered-To: ffmpegpatchwork@gmail.com Received: by 10.103.22.4 with SMTP id 4csp582257vsw; Sun, 18 Jun 2017 10:52:21 -0700 (PDT) X-Received: by 10.28.50.194 with SMTP id y185mr2227348wmy.32.1497808341843; Sun, 18 Jun 2017 10:52:21 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1497808341; cv=none; d=google.com; s=arc-20160816; b=jkP3iaU/hdBtaqKM1mARKvtsb7m1rg2NmHpwi7sb+ON4m5mS+E2DJqSW8Xkm0+htY6 C0HFh0Ek8DWxFPJ9Dl55n5l9KUrELDO3vcIi+7j8w6DI4cfl2RJMZFjGExdw6ASWnJb7 6LjyKp1vCn3tp7ql0j/sx+YXRv4mgOSA9IR7wJtCg4nkexadOhzFdcHrbkO2XRGc3Tn5 hU6mrT4csZm5ahibVq27L3mCGRLuXvd6itoNn9DhmMz+6OPTG8sozvoKvJ0YvPync80p 6lhv598l7LVg6iEBnQ5aOGUt3wVgBI7QY5tivZRzwSwH2Mpz79VE6tiVo0xZJb9NHfzw W84A== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:reply-to:list-subscribe :list-help:list-post:list-archive:list-unsubscribe:list-id :precedence:subject:in-reply-to:mime-version:user-agent:date :message-id:from:references:to:dkim-signature:delivered-to :arc-authentication-results; bh=VEVyZCksAbu4q+CH1HqsYgilA6MVw4uPdCkHBK5Ba5U=; b=yJhQfyTBzAh0SKShiw1v6e9wWcg2kELkrvHbVcGHXYeWIMza3S91ork3ffZdqMuOAJ m0X04zupKF46M8h90w2haP0oVk912R+06tLZW144idz9+BwsgpoiBgNMjzyaCD+NvHMx g0AIndUMejUBHR+gn6HjYlXbb8tIQqm48Bag27Z9kAO+SgsaTy8arGqF3qDNWbr61HVS aSPz7epUPSCtCWJFs4jjXyKFPpZpV241fOI+P8Wcva4MFRmdpXWzHl6Tf2KWnVWprqtI rGQTdOoZY2c4481TwRo8ckulbbqLgn03o/wnpslnKx1XdnDnOIBIxLRTPb/AbeuguSIx ENvw== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@jkqxz-net.20150623.gappssmtp.com header.b=2NrOffIb; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id o30si7670315wra.335.2017.06.18.10.52.21; Sun, 18 Jun 2017 10:52:21 -0700 (PDT) Received-SPF: pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) client-ip=79.124.17.100; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@jkqxz-net.20150623.gappssmtp.com header.b=2NrOffIb; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id B383F68A1E3; Sun, 18 Jun 2017 20:52:14 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-wm0-f46.google.com (mail-wm0-f46.google.com [74.125.82.46]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 4B0FE6899C4 for ; Sun, 18 Jun 2017 20:52:08 +0300 (EEST) Received: by mail-wm0-f46.google.com with SMTP id u195so45017809wmd.1 for ; Sun, 18 Jun 2017 10:52:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=jkqxz-net.20150623.gappssmtp.com; s=20150623; h=subject:to:references:from:message-id:date:user-agent:mime-version :in-reply-to:content-transfer-encoding; bh=9ZErtq/Ltb/IJd0KXWeITmiEO2VQYQtfDxXpwDfbRhw=; b=2NrOffIbdwkyCyevVgOv2VIFbh61YXNTzV9o2WKBBndLSPFMBFlVpA0blQHnCx2Y39 tSIpeHtXAJiqbmUH/8Wug+e3tCvAMrp8zj3wDyq2NhYSr2g3oq2DMV737dLP/uSEXGsr JDG9fmKGg46ptqzf1aMUHZHIOJoR6LDPzw5kY9AoZyNoSRnL7DnNQy/T0ZkFxXpA/KF/ MFW/bnXUZjZzU+EiCkgP9cHaOhi5MAPTGCzBC8WsYBZ2XyBOaGYCxqKRq07/b8CmwYv6 4QPgQuYSE2FD+Ol2EhH3WKtUlv6tPK6CxF50HyRoEdNtCIV7XBb0Lzy0gz4NlxxmXIO6 1nDA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding; bh=9ZErtq/Ltb/IJd0KXWeITmiEO2VQYQtfDxXpwDfbRhw=; b=dHBM2AY4QU8TlF5OM/9HsKjlbGemXdkexvaRmHgYqsjLj6B8efFMiwAwhWi7c4xL+R hNUK6M2jAnTqoMFMZFZ9Gh8ynI2yeJUKWt0/M4aRNKAFRceuaduClQKXd/TrirQIIAQY mbuJ9V++yp/AazM4n4dgzeKYshz1/YDOO6bO50FsigzRPc0oEmotmjXrQt7WKx+Xni81 13a0sE4sWN6r9EOyEj/mbwztDHMb3U1eCtpwaeTCXnJk3EU9OXOdQt9YU7R+O+H7GztQ b9QTt3T5ZW43lxDB2sal6Vd5ZCXWcdGxscd9qrDAQFWHXXxoBPyfnW2NynxunrEDzsC9 9QKw== X-Gm-Message-State: AKS2vOxvzkj9NTBSLMfVpJsX01E6yrx6hp0F5UrNrUP5P9wAqObLtSrf yIy0VYB5Wgox8cdKHME= X-Received: by 10.28.150.17 with SMTP id y17mr12804425wmd.51.1497807926291; Sun, 18 Jun 2017 10:45:26 -0700 (PDT) Received: from [192.168.0.8] (cpc91242-cmbg18-2-0-cust650.5-4.cable.virginm.net. [82.8.130.139]) by smtp.gmail.com with ESMTPSA id x71sm16469244wmd.32.2017.06.18.10.45.25 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Sun, 18 Jun 2017 10:45:25 -0700 (PDT) To: FFmpeg development discussions and patches References: <4ccd61f6-860b-d473-5ec6-061525972d7b@jkqxz.net> From: Mark Thompson Message-ID: <1eb3193f-8472-5bd9-481a-d49f172c74d4@jkqxz.net> Date: Sun, 18 Jun 2017 18:45:25 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Thunderbird/45.8.0 MIME-Version: 1.0 In-Reply-To: <4ccd61f6-860b-d473-5ec6-061525972d7b@jkqxz.net> Subject: [FFmpeg-devel] [PATCH 2/2] test only: DRM allocation for Intel, DRM to VAAPI mapping X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" --- libavutil/hwcontext_drm.c | 143 ++++++++++++++++++++++++++++++++++++++++ libavutil/hwcontext_vaapi.c | 155 +++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 297 insertions(+), 1 deletion(-) diff --git a/libavutil/hwcontext_drm.c b/libavutil/hwcontext_drm.c index 0a355568ed..ee1b7c0915 100644 --- a/libavutil/hwcontext_drm.c +++ b/libavutil/hwcontext_drm.c @@ -19,12 +19,15 @@ #include "config.h" #include +#include #include #if HAVE_UNISTD_H # include #endif #include +#include +#include #include #include "hwcontext.h" @@ -70,6 +73,144 @@ static int drm_device_create(AVHWDeviceContext *hwdev, const char *device, return 0; } +static int drm_frames_get_constraints(AVHWDeviceContext *hwdev, + const void *hwconfig, + AVHWFramesConstraints *constraints) +{ + // Hard-coded to NV12 with no size limits. + + constraints->valid_hw_formats = + av_malloc_array(2, sizeof(*constraints->valid_hw_formats)); + if (!constraints->valid_hw_formats) + return AVERROR(ENOMEM); + + constraints->valid_hw_formats[0] = AV_PIX_FMT_DRM_PRIME; + constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE; + + constraints->valid_sw_formats = + av_malloc_array(2, sizeof(*constraints->valid_sw_formats)); + if (!constraints->valid_sw_formats) + return AVERROR(ENOMEM); + + constraints->valid_sw_formats[0] = AV_PIX_FMT_NV12; + constraints->valid_sw_formats[1] = AV_PIX_FMT_NONE; + + return 0; +} + +static void drm_pool_free(void *opaque, uint8_t *data) +{ + AVHWFramesContext *hwfc = opaque; + AVDRMDeviceContext *dev = hwfc->device_ctx->hwctx; + AVDRMFrameDescriptor *desc = (AVDRMFrameDescriptor*)data; + struct drm_mode_destroy_dumb destroy; + uint32_t handle; + int err, i; + + for (i = 0; i < desc->nb_objects; i++) { + err = drmPrimeFDToHandle(dev->fd, desc->objects[0].fd, &handle); + if (err < 0) { + av_log(hwfc, AV_LOG_ERROR, "Failed to retrieve DRM buffer handle " + "from fd %d: %d.\n", desc->objects[0].fd, errno); + continue; + } + + destroy.handle = handle; + ioctl(dev->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy); + } + + av_free(desc); +} + +static AVBufferRef *drm_pool_alloc(void *opaque, int size) +{ + AVHWFramesContext *hwfc = opaque; + AVDRMDeviceContext *dev = hwfc->device_ctx->hwctx; + AVDRMFrameDescriptor *desc; + AVBufferRef *ref; + struct drm_mode_create_dumb create; + int err, fd; + int aligned_height; + + desc = av_mallocz(sizeof(*desc)); + if (!desc) + return NULL; + + // This is to satisfy possible alignment constraints on the offset + // of the second plane (import to VAAPI on Intel requires 16-line + // alignment here). + aligned_height = FFALIGN(hwfc->height, 16); + + create.height = aligned_height * 3 / 2; + create.width = hwfc->width; + create.bpp = 8; + create.flags = 0; + + err = ioctl(dev->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create); + if (err < 0) { + av_log(hwfc, AV_LOG_ERROR, "Failed to create DRM buffer: " + "%d.\n", errno); + return NULL; + } + + err = drmPrimeHandleToFD(dev->fd, create.handle, DRM_RDWR, &fd); + if (err < 0) { + struct drm_mode_destroy_dumb destroy; + + av_log(hwfc, AV_LOG_ERROR, "Failed to map DRM buffer to fd: " + "%d.\n", errno); + + destroy.handle = create.handle; + ioctl(dev->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy); + + return NULL; + } + + desc->nb_objects = 1; + desc->objects[0] = (AVDRMObjectDescriptor) { + .fd = fd, + .size = create.size, + }; + + desc->nb_planes = 2; + desc->planes[0] = (AVDRMPlaneDescriptor) { + .format = DRM_FORMAT_R8, + .object_index = 0, + .plane_index = 0, + .offset = 0, + .pitch = create.pitch, + }; + desc->planes[1] = (AVDRMPlaneDescriptor) { + .format = DRM_FORMAT_RG88, + .object_index = 0, + .plane_index = 0, + .offset = aligned_height * create.pitch, + .pitch = create.pitch, + }; + + ref = av_buffer_create((uint8_t*)desc, sizeof(*desc), + &drm_pool_free, hwfc, 0); + if (!ref) { + drm_pool_free(hwfc, (uint8_t*)desc); + return NULL; + } + + return ref; +} + +static int drm_frames_init(AVHWFramesContext *hwfc) +{ + if (!hwfc->pool) { + hwfc->internal->pool_internal = + av_buffer_pool_init2(sizeof(AVDRMFrameDescriptor), hwfc, + &drm_pool_alloc, NULL); + if (!hwfc->internal->pool_internal) + return AVERROR(ENOMEM); + } + + return 0; +} + static int drm_get_buffer(AVHWFramesContext *hwfc, AVFrame *frame) { frame->buf[0] = av_buffer_pool_get(hwfc->pool); @@ -266,6 +407,8 @@ const HWContextType ff_hwcontext_type_drm = { .device_create = &drm_device_create, + .frames_get_constraints = &drm_frames_get_constraints, + .frames_init = &drm_frames_init, .frames_get_buffer = &drm_get_buffer, .transfer_get_formats = &drm_transfer_get_formats, diff --git a/libavutil/hwcontext_vaapi.c b/libavutil/hwcontext_vaapi.c index 3970726d30..f8ba615995 100644 --- a/libavutil/hwcontext_vaapi.c +++ b/libavutil/hwcontext_vaapi.c @@ -41,6 +41,11 @@ #include "pixdesc.h" #include "pixfmt.h" +#if CONFIG_DRM +#include +# include "hwcontext_drm.h" +#endif + typedef struct VAAPIDevicePriv { #if HAVE_VAAPI_X11 Display *x11_display; @@ -897,6 +902,114 @@ static int vaapi_map_from(AVHWFramesContext *hwfc, AVFrame *dst, return 0; } +#if CONFIG_DRM + +static void vaapi_unmap_from_drm(AVHWFramesContext *dst_fc, + HWMapDescriptor *hwmap) +{ + AVVAAPIDeviceContext *dst_dev = dst_fc->device_ctx->hwctx; + + VASurfaceID surface_id = (VASurfaceID)(uintptr_t)hwmap->priv; + + vaDestroySurfaces(dst_dev->display, &surface_id, 1); +} + +static int vaapi_map_from_drm(AVHWFramesContext *src_fc, AVFrame *dst, + const AVFrame *src, int flags) +{ + AVHWFramesContext *dst_fc = + (AVHWFramesContext*)dst->hw_frames_ctx->data; + AVVAAPIDeviceContext *dst_dev = dst_fc->device_ctx->hwctx; + const AVDRMFrameDescriptor *desc; + VASurfaceID surface_id; + VAStatus vas; + int err, plane; + + unsigned long buffer_handle; + VASurfaceAttribExternalBuffers buffer_desc; + VASurfaceAttrib attrs[2] = { + { + .type = VASurfaceAttribMemoryType, + .flags = VA_SURFACE_ATTRIB_SETTABLE, + .value.type = VAGenericValueTypeInteger, + .value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME, + }, + { + .type = VASurfaceAttribExternalBufferDescriptor, + .flags = VA_SURFACE_ATTRIB_SETTABLE, + .value.type = VAGenericValueTypePointer, + .value.value.p = &buffer_desc, + } + }; + + desc = (AVDRMFrameDescriptor*)src->data[0]; + + if (desc->nb_objects != 1) { + av_log(dst_fc, AV_LOG_ERROR, "VAAPI can only map frames " + "made from single DRM objects.\n"); + return AVERROR(EINVAL); + } + + av_log(dst_fc, AV_LOG_DEBUG, "Map DRM object %d to VAAPI.\n", + desc->objects[0].fd); + + buffer_handle = desc->objects[0].fd; + buffer_desc.pixel_format = VA_FOURCC_NV12; + buffer_desc.width = src_fc->width; + buffer_desc.height = src_fc->height; + buffer_desc.data_size = desc->objects[0].size; + + buffer_desc.num_planes = 2; + for (plane = 0; plane < 2; plane++) { + buffer_desc.pitches[plane] = desc->planes[plane].pitch; + buffer_desc.offsets[plane] = desc->planes[plane].offset; + } + + buffer_desc.buffers = &buffer_handle; + buffer_desc.num_buffers = 1; + buffer_desc.flags = 0; + + vas = vaCreateSurfaces(dst_dev->display, + VA_RT_FORMAT_YUV420, + src->width, src->height, + &surface_id, 1, + attrs, FF_ARRAY_ELEMS(attrs)); + if (vas != VA_STATUS_SUCCESS) { + av_log(dst_fc, AV_LOG_ERROR, "Failed to create surface from DRM " + "object: %d (%s).\n", vas, vaErrorStr(vas)); + return AVERROR(EIO); + } + + err = ff_hwframe_map_create(dst->hw_frames_ctx, dst, src, + &vaapi_unmap_from_drm, + (void*)(uintptr_t)surface_id); + if (err < 0) + return err; + + dst->width = src->width; + dst->height = src->height; + dst->data[3] = (uint8_t*)(uintptr_t)surface_id; + + av_log(dst_fc, AV_LOG_DEBUG, "Mapped DRM object %d to " + "surface %#x.\n", desc->objects[0].fd, surface_id); + + return 0; +} +#endif + +static int vaapi_map_to(AVHWFramesContext *hwfc, AVFrame *dst, + const AVFrame *src, int flags) +{ + switch (src->format) { +#if CONFIG_DRM + case AV_PIX_FMT_DRM_PRIME: + return vaapi_map_from_drm(hwfc, dst, src, flags); +#endif + default: + return AVERROR(ENOSYS); + } +} + static void vaapi_device_free(AVHWDeviceContext *ctx) { AVVAAPIDeviceContext *hwctx = ctx->hwctx; @@ -999,6 +1112,45 @@ static int vaapi_device_create(AVHWDeviceContext *ctx, const char *device, return 0; } +static int vaapi_device_derive(AVHWDeviceContext *ctx, + AVHWDeviceContext *src_ctx, int flags) +{ +#if CONFIG_DRM + if (src_ctx->type == AV_HWDEVICE_TYPE_DRM) { + AVDRMDeviceContext *src_hwctx = src_ctx->hwctx; + AVVAAPIDeviceContext *hwctx = ctx->hwctx; + VADisplay *display; + VAStatus vas; + int major, minor; + + if (src_hwctx->fd < 0) { + av_log(ctx, AV_LOG_ERROR, "DRM instance requires an associated " + "device to derive a VA display from.\n"); + return AVERROR(EINVAL); + } + + display = vaGetDisplayDRM(src_hwctx->fd); + if (!display) { + av_log(ctx, AV_LOG_ERROR, "Failed to open a VA display from " + "DRM device.\n"); + return AVERROR(EIO); + } + + vas = vaInitialize(display, &major, &minor); + if (vas != VA_STATUS_SUCCESS) { + av_log(ctx, AV_LOG_ERROR, "Failed to initialise VAAPI " + "connection: %d (%s).\n", vas, vaErrorStr(vas)); + vaTerminate(display); + return AVERROR(EIO); + } + + hwctx->display = display; + return 0; + } +#endif + return AVERROR(ENOSYS); +} + const HWContextType ff_hwcontext_type_vaapi = { .type = AV_HWDEVICE_TYPE_VAAPI, .name = "VAAPI", @@ -1010,6 +1162,7 @@ const HWContextType ff_hwcontext_type_vaapi = { .frames_priv_size = sizeof(VAAPIFramesContext), .device_create = &vaapi_device_create, + .device_derive = &vaapi_device_derive, .device_init = &vaapi_device_init, .device_uninit = &vaapi_device_uninit, .frames_get_constraints = &vaapi_frames_get_constraints, @@ -1019,7 +1172,7 @@ const HWContextType ff_hwcontext_type_vaapi = { .transfer_get_formats = &vaapi_transfer_get_formats, .transfer_data_to = &vaapi_transfer_data_to, .transfer_data_from = &vaapi_transfer_data_from, - .map_to = NULL, + .map_to = &vaapi_map_to, .map_from = &vaapi_map_from, .pix_fmts = (const enum AVPixelFormat[]) {