/* * KMS/DRM input device * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include <fcntl.h> #include <unistd.h> #include <drm.h> #include <drm_fourcc.h> #include <drm_mode.h> #include <xf86drm.h> #include <xf86drmMode.h> // Required for compatibility when building against libdrm < 2.4.83. #ifndef DRM_FORMAT_MOD_INVALID #define DRM_FORMAT_MOD_INVALID ((1ULL << 56) - 1) #endif #include "libavutil/hwcontext.h" #include "libavutil/hwcontext_drm.h" #include "libavutil/internal.h" #include "libavutil/mathematics.h" #include "libavutil/opt.h" #include "libavutil/pixfmt.h" #include "libavutil/pixdesc.h" #include "libavutil/time.h" #include "libavformat/avformat.h" #include "libavformat/internal.h" typedef struct KMSGrabContext { const AVClass *class; AVBufferRef *device_ref; AVHWDeviceContext *device; AVDRMDeviceContext *hwctx; int fb2_available; AVBufferRef *frames_ref; AVHWFramesContext *frames; uint32_t plane_id; uint32_t drm_format; unsigned int width; unsigned int height; int64_t frame_delay; int64_t frame_last; const char *device_path; enum AVPixelFormat format; int64_t drm_format_modifier; int64_t source_plane; int64_t source_crtc; AVRational framerate; } KMSGrabContext; static void kmsgrab_free_desc(void *opaque, uint8_t *data) { AVDRMFrameDescriptor *desc = (AVDRMFrameDescriptor*)data; int i; for (i = 0; i < desc->nb_objects; i++) close(desc->objects[i].fd); av_free(desc); } static void kmsgrab_free_frame(void *opaque, uint8_t *data) { AVFrame *frame = (AVFrame*)data; av_frame_free(&frame); } static int kmsgrab_get_fb(AVFormatContext *avctx, drmModePlane *plane, AVDRMFrameDescriptor *desc) { KMSGrabContext *ctx = avctx->priv_data; drmModeFB *fb = NULL; int err, fd; fb = drmModeGetFB(ctx->hwctx->fd, plane->fb_id); if (!fb) { err = errno; av_log(avctx, AV_LOG_ERROR, "Failed to get framebuffer " "%"PRIu32": %s.\n", plane->fb_id, strerror(err)); err = AVERROR(err); goto fail; } if (fb->width != ctx->width || fb->height != ctx->height) { av_log(avctx, AV_LOG_ERROR, "Plane %"PRIu32" framebuffer " "dimensions changed: now %"PRIu32"x%"PRIu32".\n", ctx->plane_id, fb->width, fb->height); err = AVERROR(EIO); goto fail; } if (!fb->handle) { av_log(avctx, AV_LOG_ERROR, "No handle set on framebuffer.\n"); err = AVERROR(EIO); goto fail; } err = drmPrimeHandleToFD(ctx->hwctx->fd, fb->handle, O_RDONLY, &fd); if (err < 0) { err = errno; av_log(avctx, AV_LOG_ERROR, "Failed to get PRIME fd from " "framebuffer handle: %s.\n", strerror(err)); err = AVERROR(err); goto fail; } *desc = (AVDRMFrameDescriptor) { .nb_objects = 1, .objects[0] = { .fd = fd, .size = fb->height * fb->pitch, .format_modifier = ctx->drm_format_modifier, }, .nb_layers = 1, .layers[0] = { .format = ctx->drm_format, .nb_planes = 1, .planes[0] = { .object_index = 0, .offset = 0, .pitch = fb->pitch, }, }, }; err = 0; fail: drmModeFreeFB(fb); return err; } #if HAVE_LIBDRM_GETFB2 static int kmsgrab_get_fb2(AVFormatContext *avctx, drmModePlane *plane, AVDRMFrameDescriptor *desc) { KMSGrabContext *ctx = avctx->priv_data; drmModeFB2 *fb; int err, i, nb_objects; uint64_t modifier = ctx->drm_format_modifier; fb = drmModeGetFB2(ctx->hwctx->fd, plane->fb_id); if (!fb) { err = errno; av_log(avctx, AV_LOG_ERROR, "Failed to get framebuffer " "%"PRIu32": %s.\n", plane->fb_id, strerror(err)); return AVERROR(err); } if (fb->pixel_format != ctx->drm_format) { av_log(avctx, AV_LOG_ERROR, "Plane %"PRIu32" framebuffer " "format changed: now %"PRIx32".\n", ctx->plane_id, fb->pixel_format); err = AVERROR(EIO); goto fail; } if (fb->width != ctx->width || fb->height != ctx->height) { av_log(avctx, AV_LOG_ERROR, "Plane %"PRIu32" framebuffer " "dimensions changed: now %"PRIu32"x%"PRIu32".\n", ctx->plane_id, fb->width, fb->height); err = AVERROR(EIO); goto fail; } if (!fb->handles[0]) { av_log(avctx, AV_LOG_ERROR, "No handle set on framebuffer.\n"); err = AVERROR(EIO); goto fail; } if (fb->flags & DRM_MODE_FB_MODIFIERS) modifier = fb->modifier; *desc = (AVDRMFrameDescriptor) { .nb_layers = 1, .layers[0] = { .format = ctx->drm_format, }, }; nb_objects = 0; for (i = 0; i < 4 && fb->handles[i]; i++) { size_t size; int dup = 0, j, obj; size = fb->offsets[i] + fb->height * fb->pitches[i]; for (j = 0; j < i; j++) { if (fb->handles[i] == fb->handles[j]) { dup = 1; break; } } if (dup) { obj = desc->layers[0].planes[j].object_index; if (desc->objects[j].size < size) desc->objects[j].size = size; desc->layers[0].planes[i] = (AVDRMPlaneDescriptor) { .object_index = obj, .offset = fb->offsets[i], .pitch = fb->pitches[i], }; } else { int fd; err = drmPrimeHandleToFD(ctx->hwctx->fd, fb->handles[i], O_RDONLY, &fd); if (err < 0) { err = errno; av_log(avctx, AV_LOG_ERROR, "Failed to get PRIME fd from " "framebuffer handle: %s.\n", strerror(err)); err = AVERROR(err); goto fail; } obj = nb_objects++; desc->objects[obj] = (AVDRMObjectDescriptor) { .fd = fd, .size = size, .format_modifier = modifier, }; desc->layers[0].planes[i] = (AVDRMPlaneDescriptor) { .object_index = obj, .offset = fb->offsets[i], .pitch = fb->pitches[i], }; } } desc->nb_objects = nb_objects; desc->layers[0].nb_planes = i; err = 0; fail: drmModeFreeFB2(fb); return err; } #endif static int kmsgrab_read_packet(AVFormatContext *avctx, AVPacket *pkt) { KMSGrabContext *ctx = avctx->priv_data; drmModePlane *plane = NULL; AVDRMFrameDescriptor *desc = NULL; AVFrame *frame = NULL; int64_t now; int err; now = av_gettime_relative(); if (ctx->frame_last) { int64_t delay; while (1) { delay = ctx->frame_last + ctx->frame_delay - now; if (delay <= 0) break; av_usleep(delay); now = av_gettime_relative(); } } ctx->frame_last = now; now = av_gettime(); plane = drmModeGetPlane(ctx->hwctx->fd, ctx->plane_id); if (!plane) { err = errno; av_log(avctx, AV_LOG_ERROR, "Failed to get plane " "%"PRIu32": %s.\n", ctx->plane_id, strerror(err)); err = AVERROR(err); goto fail; } if (!plane->fb_id) { av_log(avctx, AV_LOG_ERROR, "Plane %"PRIu32" no longer has " "an associated framebuffer.\n", ctx->plane_id); err = AVERROR(EIO); goto fail; } desc = av_mallocz(sizeof(*desc)); if (!desc) { err = AVERROR(ENOMEM); goto fail; } #if HAVE_LIBDRM_GETFB2 if (ctx->fb2_available) err = kmsgrab_get_fb2(avctx, plane, desc); else #endif err = kmsgrab_get_fb(avctx, plane, desc); if (err < 0) goto fail; frame = av_frame_alloc(); if (!frame) { err = AVERROR(ENOMEM); goto fail; } frame->hw_frames_ctx = av_buffer_ref(ctx->frames_ref); if (!frame->hw_frames_ctx) { err = AVERROR(ENOMEM); goto fail; } frame->buf[0] = av_buffer_create((uint8_t*)desc, sizeof(*desc), &kmsgrab_free_desc, avctx, 0); if (!frame->buf[0]) { err = AVERROR(ENOMEM); goto fail; } frame->data[0] = (uint8_t*)desc; frame->format = AV_PIX_FMT_DRM_PRIME; frame->width = ctx->width; frame->height = ctx->height; drmModeFreePlane(plane); plane = NULL; desc = NULL; pkt->buf = av_buffer_create((uint8_t*)frame, sizeof(*frame), &kmsgrab_free_frame, avctx, 0); if (!pkt->buf) { err = AVERROR(ENOMEM); goto fail; } pkt->data = (uint8_t*)frame; pkt->size = sizeof(*frame); pkt->pts = now; pkt->flags |= AV_PKT_FLAG_TRUSTED; return 0; fail: drmModeFreePlane(plane); av_freep(&desc); av_frame_free(&frame); return err; } static const struct { enum AVPixelFormat pixfmt; uint32_t drm_format; } kmsgrab_formats[] = { // Monochrome. #ifdef DRM_FORMAT_R8 { AV_PIX_FMT_GRAY8, DRM_FORMAT_R8 }, #endif #ifdef DRM_FORMAT_R16 { AV_PIX_FMT_GRAY16LE, DRM_FORMAT_R16 }, { AV_PIX_FMT_GRAY16BE, DRM_FORMAT_R16 | DRM_FORMAT_BIG_ENDIAN }, #endif // <8-bit RGB. { AV_PIX_FMT_BGR8, DRM_FORMAT_BGR233 }, { AV_PIX_FMT_RGB555LE, DRM_FORMAT_XRGB1555 }, { AV_PIX_FMT_RGB555BE, DRM_FORMAT_XRGB1555 | DRM_FORMAT_BIG_ENDIAN }, { AV_PIX_FMT_BGR555LE, DRM_FORMAT_XBGR1555 }, { AV_PIX_FMT_BGR555BE, DRM_FORMAT_XBGR1555 | DRM_FORMAT_BIG_ENDIAN }, { AV_PIX_FMT_RGB565LE, DRM_FORMAT_RGB565 }, { AV_PIX_FMT_RGB565BE, DRM_FORMAT_RGB565 | DRM_FORMAT_BIG_ENDIAN }, { AV_PIX_FMT_BGR565LE, DRM_FORMAT_BGR565 }, { AV_PIX_FMT_BGR565BE, DRM_FORMAT_BGR565 | DRM_FORMAT_BIG_ENDIAN }, // 8-bit RGB. { AV_PIX_FMT_RGB24, DRM_FORMAT_RGB888 }, { AV_PIX_FMT_BGR24, DRM_FORMAT_BGR888 }, { AV_PIX_FMT_0RGB, DRM_FORMAT_BGRX8888 }, { AV_PIX_FMT_0BGR, DRM_FORMAT_RGBX8888 }, { AV_PIX_FMT_RGB0, DRM_FORMAT_XBGR8888 }, { AV_PIX_FMT_BGR0, DRM_FORMAT_XRGB8888 }, { AV_PIX_FMT_ARGB, DRM_FORMAT_BGRA8888 }, { AV_PIX_FMT_ABGR, DRM_FORMAT_RGBA8888 }, { AV_PIX_FMT_RGBA, DRM_FORMAT_ABGR8888 }, { AV_PIX_FMT_BGRA, DRM_FORMAT_ARGB8888 }, // 10-bit RGB. { AV_PIX_FMT_X2RGB10LE, DRM_FORMAT_XRGB2101010 }, { AV_PIX_FMT_X2RGB10BE, DRM_FORMAT_XRGB2101010 | DRM_FORMAT_BIG_ENDIAN }, // 8-bit YUV 4:2:0. { AV_PIX_FMT_NV12, DRM_FORMAT_NV12 }, // 8-bit YUV 4:2:2. { AV_PIX_FMT_YUYV422, DRM_FORMAT_YUYV }, { AV_PIX_FMT_YVYU422, DRM_FORMAT_YVYU }, { AV_PIX_FMT_UYVY422, DRM_FORMAT_UYVY }, }; static av_cold int kmsgrab_read_header(AVFormatContext *avctx) { KMSGrabContext *ctx = avctx->priv_data; drmModePlaneRes *plane_res = NULL; drmModePlane *plane = NULL; drmModeFB *fb = NULL; #if HAVE_LIBDRM_GETFB2 drmModeFB2 *fb2 = NULL; #endif AVStream *stream; int err, i; err = av_hwdevice_ctx_create(&ctx->device_ref, AV_HWDEVICE_TYPE_DRM, ctx->device_path, NULL, 0); if (err < 0) { av_log(avctx, AV_LOG_ERROR, "Failed to open DRM device.\n"); return err; } ctx->device = (AVHWDeviceContext*) ctx->device_ref->data; ctx->hwctx = (AVDRMDeviceContext*)ctx->device->hwctx; err = drmSetClientCap(ctx->hwctx->fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1); if (err < 0) { av_log(avctx, AV_LOG_WARNING, "Failed to set universal planes " "capability: primary planes will not be usable.\n"); } if (ctx->source_plane > 0) { plane = drmModeGetPlane(ctx->hwctx->fd, ctx->source_plane); if (!plane) { err = errno; av_log(avctx, AV_LOG_ERROR, "Failed to get plane %"PRId64": " "%s.\n", ctx->source_plane, strerror(err)); err = AVERROR(err); goto fail; } if (plane->fb_id == 0) { av_log(avctx, AV_LOG_ERROR, "Plane %"PRId64" does not have " "an attached framebuffer.\n", ctx->source_plane); err = AVERROR(EINVAL); goto fail; } } else { plane_res = drmModeGetPlaneResources(ctx->hwctx->fd); if (!plane_res) { err = errno; av_log(avctx, AV_LOG_ERROR, "Failed to get plane " "resources: %s.\n", strerror(err)); err = AVERROR(err); goto fail; } for (i = 0; i < plane_res->count_planes; i++) { plane = drmModeGetPlane(ctx->hwctx->fd, plane_res->planes[i]); if (!plane) { err = errno; av_log(avctx, AV_LOG_VERBOSE, "Failed to get " "plane %"PRIu32": %s.\n", plane_res->planes[i], strerror(err)); continue; } av_log(avctx, AV_LOG_DEBUG, "Plane %"PRIu32": " "CRTC %"PRIu32" FB %"PRIu32".\n", plane->plane_id, plane->crtc_id, plane->fb_id); if ((ctx->source_crtc > 0 && plane->crtc_id != ctx->source_crtc) || plane->fb_id == 0) { // Either not connected to the target source CRTC // or not active. drmModeFreePlane(plane); plane = NULL; continue; } break; } if (i == plane_res->count_planes) { if (ctx->source_crtc > 0) { av_log(avctx, AV_LOG_ERROR, "No usable planes found on " "CRTC %"PRId64".\n", ctx->source_crtc); } else { av_log(avctx, AV_LOG_ERROR, "No usable planes found.\n"); } err = AVERROR(EINVAL); goto fail; } av_log(avctx, AV_LOG_INFO, "Using plane %"PRIu32" to " "locate framebuffers.\n", plane->plane_id); } ctx->plane_id = plane->plane_id; #if HAVE_LIBDRM_GETFB2 fb2 = drmModeGetFB2(ctx->hwctx->fd, plane->fb_id); if (!fb2 && errno == ENOSYS) { av_log(avctx, AV_LOG_INFO, "GETFB2 not supported, " "will try to use GETFB instead.\n"); } else if (!fb2) { err = errno; av_log(avctx, AV_LOG_ERROR, "Failed to get " "framebuffer %"PRIu32": %s.\n", plane->fb_id, strerror(err)); err = AVERROR(err); goto fail; } else { av_log(avctx, AV_LOG_INFO, "Template framebuffer is " "%"PRIu32": %"PRIu32"x%"PRIu32" " "format %"PRIx32" modifier %"PRIx64" flags %"PRIx32".\n", fb2->fb_id, fb2->width, fb2->height, fb2->pixel_format, fb2->modifier, fb2->flags); ctx->width = fb2->width; ctx->height = fb2->height; if (!fb2->handles[0]) { av_log(avctx, AV_LOG_ERROR, "No handle set on framebuffer: " "maybe you need some additional capabilities?\n"); err = AVERROR(EINVAL); goto fail; } for (i = 0; i < FF_ARRAY_ELEMS(kmsgrab_formats); i++) { if (kmsgrab_formats[i].drm_format == fb2->pixel_format) { if (ctx->format != AV_PIX_FMT_NONE && ctx->format != kmsgrab_formats[i].pixfmt) { av_log(avctx, AV_LOG_ERROR, "Framebuffer pixel format " "%"PRIx32" does not match expected format.\n", fb2->pixel_format); err = AVERROR(EINVAL); goto fail; } ctx->drm_format = fb2->pixel_format; ctx->format = kmsgrab_formats[i].pixfmt; break; } } if (i == FF_ARRAY_ELEMS(kmsgrab_formats)) { av_log(avctx, AV_LOG_ERROR, "Framebuffer pixel format " "%"PRIx32" is not a known supported format.\n", fb2->pixel_format); err = AVERROR(EINVAL); goto fail; } if (fb2->flags & DRM_MODE_FB_MODIFIERS) { if (ctx->drm_format_modifier != DRM_FORMAT_MOD_INVALID && ctx->drm_format_modifier != fb2->modifier) { av_log(avctx, AV_LOG_ERROR, "Framebuffer format modifier " "%"PRIx64" does not match expected modifier.\n", fb2->modifier); err = AVERROR(EINVAL); goto fail; } else { ctx->drm_format_modifier = fb2->modifier; } } av_log(avctx, AV_LOG_VERBOSE, "Format is %s, from " "DRM format %"PRIx32" modifier %"PRIx64".\n", av_get_pix_fmt_name(ctx->format), ctx->drm_format, ctx->drm_format_modifier); ctx->fb2_available = 1; } #endif if (!ctx->fb2_available) { if (ctx->format == AV_PIX_FMT_NONE) { // Backward compatibility: assume BGR0 if no format supplied. ctx->format = AV_PIX_FMT_BGR0; } for (i = 0; i < FF_ARRAY_ELEMS(kmsgrab_formats); i++) { if (kmsgrab_formats[i].pixfmt == ctx->format) { ctx->drm_format = kmsgrab_formats[i].drm_format; break; } } if (i >= FF_ARRAY_ELEMS(kmsgrab_formats)) { av_log(avctx, AV_LOG_ERROR, "Unsupported format %s.\n", av_get_pix_fmt_name(ctx->format)); return AVERROR(EINVAL); } fb = drmModeGetFB(ctx->hwctx->fd, plane->fb_id); if (!fb) { err = errno; av_log(avctx, AV_LOG_ERROR, "Failed to get " "framebuffer %"PRIu32": %s.\n", plane->fb_id, strerror(err)); err = AVERROR(err); goto fail; } av_log(avctx, AV_LOG_INFO, "Template framebuffer is %"PRIu32": " "%"PRIu32"x%"PRIu32" %"PRIu32"bpp %"PRIu32"b depth.\n", fb->fb_id, fb->width, fb->height, fb->bpp, fb->depth); ctx->width = fb->width; ctx->height = fb->height; if (!fb->handle) { av_log(avctx, AV_LOG_ERROR, "No handle set on framebuffer: " "maybe you need some additional capabilities?\n"); err = AVERROR(EINVAL); goto fail; } } stream = avformat_new_stream(avctx, NULL); if (!stream) { err = AVERROR(ENOMEM); goto fail; } stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO; stream->codecpar->codec_id = AV_CODEC_ID_WRAPPED_AVFRAME; stream->codecpar->width = ctx->width; stream->codecpar->height = ctx->height; stream->codecpar->format = AV_PIX_FMT_DRM_PRIME; avpriv_set_pts_info(stream, 64, 1, 1000000); ctx->frames_ref = av_hwframe_ctx_alloc(ctx->device_ref); if (!ctx->frames_ref) { err = AVERROR(ENOMEM); goto fail; } ctx->frames = (AVHWFramesContext*)ctx->frames_ref->data; ctx->frames->format = AV_PIX_FMT_DRM_PRIME; ctx->frames->sw_format = ctx->format, ctx->frames->width = ctx->width; ctx->frames->height = ctx->height; err = av_hwframe_ctx_init(ctx->frames_ref); if (err < 0) { av_log(avctx, AV_LOG_ERROR, "Failed to initialise " "hardware frames context: %d.\n", err); goto fail; } ctx->frame_delay = av_rescale_q(1, (AVRational) { ctx->framerate.den, ctx->framerate.num }, AV_TIME_BASE_Q); err = 0; fail: drmModeFreePlaneResources(plane_res); drmModeFreePlane(plane); drmModeFreeFB(fb); #if HAVE_LIBDRM_GETFB2 drmModeFreeFB2(fb2); #endif return err; } static av_cold int kmsgrab_read_close(AVFormatContext *avctx) { KMSGrabContext *ctx = avctx->priv_data; av_buffer_unref(&ctx->frames_ref); av_buffer_unref(&ctx->device_ref); return 0; } #define OFFSET(x) offsetof(KMSGrabContext, x) #define FLAGS AV_OPT_FLAG_DECODING_PARAM static const AVOption options[] = { { "device", "DRM device path", OFFSET(device_path), AV_OPT_TYPE_STRING, { .str = "/dev/dri/card0" }, 0, 0, FLAGS }, { "format", "Pixel format for framebuffer", OFFSET(format), AV_OPT_TYPE_PIXEL_FMT, { .i64 = AV_PIX_FMT_NONE }, -1, INT32_MAX, FLAGS }, { "format_modifier", "DRM format modifier for framebuffer", OFFSET(drm_format_modifier), AV_OPT_TYPE_INT64, { .i64 = DRM_FORMAT_MOD_INVALID }, 0, INT64_MAX, FLAGS }, { "crtc_id", "CRTC ID to define capture source", OFFSET(source_crtc), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, UINT32_MAX, FLAGS }, { "plane_id", "Plane ID to define capture source", OFFSET(source_plane), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, UINT32_MAX, FLAGS }, { "framerate", "Framerate to capture at", OFFSET(framerate), AV_OPT_TYPE_RATIONAL, { .dbl = 30.0 }, 0, 1000, FLAGS }, { NULL }, }; static const AVClass kmsgrab_class = { .class_name = "kmsgrab indev", .item_name = av_default_item_name, .option = options, .version = LIBAVUTIL_VERSION_INT, .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT, }; const AVInputFormat ff_kmsgrab_demuxer = { .name = "kmsgrab", .long_name = NULL_IF_CONFIG_SMALL("KMS screen capture"), .priv_data_size = sizeof(KMSGrabContext), .read_header = &kmsgrab_read_header, .read_packet = &kmsgrab_read_packet, .read_close = &kmsgrab_read_close, .flags = AVFMT_NOFILE, .priv_class = &kmsgrab_class, };