1 /*
2 * KMS/DRM input device
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <fcntl.h>
22 #include <unistd.h>
23
24 #include <drm.h>
25 #include <drm_fourcc.h>
26 #include <drm_mode.h>
27 #include <xf86drm.h>
28 #include <xf86drmMode.h>
29
30 #include "libavutil/hwcontext.h"
31 #include "libavutil/hwcontext_drm.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixfmt.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/time.h"
38
39 #include "libavformat/avformat.h"
40 #include "libavformat/internal.h"
41
42 typedef struct KMSGrabContext {
43 const AVClass *class;
44
45 AVBufferRef *device_ref;
46 AVHWDeviceContext *device;
47 AVDRMDeviceContext *hwctx;
48
49 AVBufferRef *frames_ref;
50 AVHWFramesContext *frames;
51
52 uint32_t plane_id;
53 uint32_t drm_format;
54 unsigned int width;
55 unsigned int height;
56
57 int64_t frame_delay;
58 int64_t frame_last;
59
60 const char *device_path;
61 enum AVPixelFormat format;
62 int64_t drm_format_modifier;
63 int64_t source_plane;
64 int64_t source_crtc;
65 AVRational framerate;
66 } KMSGrabContext;
67
kmsgrab_free_desc(void * opaque,uint8_t * data)68 static void kmsgrab_free_desc(void *opaque, uint8_t *data)
69 {
70 AVDRMFrameDescriptor *desc = (AVDRMFrameDescriptor*)data;
71
72 close(desc->objects[0].fd);
73
74 av_free(desc);
75 }
76
kmsgrab_free_frame(void * opaque,uint8_t * data)77 static void kmsgrab_free_frame(void *opaque, uint8_t *data)
78 {
79 AVFrame *frame = (AVFrame*)data;
80
81 av_frame_free(&frame);
82 }
83
kmsgrab_read_packet(AVFormatContext * avctx,AVPacket * pkt)84 static int kmsgrab_read_packet(AVFormatContext *avctx, AVPacket *pkt)
85 {
86 KMSGrabContext *ctx = avctx->priv_data;
87 drmModePlane *plane;
88 drmModeFB *fb;
89 AVDRMFrameDescriptor *desc;
90 AVFrame *frame;
91 int64_t now;
92 int err, fd;
93
94 now = av_gettime();
95 if (ctx->frame_last) {
96 int64_t delay;
97 while (1) {
98 delay = ctx->frame_last + ctx->frame_delay - now;
99 if (delay <= 0)
100 break;
101 av_usleep(delay);
102 now = av_gettime();
103 }
104 }
105 ctx->frame_last = now;
106
107 plane = drmModeGetPlane(ctx->hwctx->fd, ctx->plane_id);
108 if (!plane) {
109 av_log(avctx, AV_LOG_ERROR, "Failed to get plane "
110 "%"PRIu32".\n", ctx->plane_id);
111 return AVERROR(EIO);
112 }
113 if (!plane->fb_id) {
114 av_log(avctx, AV_LOG_ERROR, "Plane %"PRIu32" no longer has "
115 "an associated framebuffer.\n", ctx->plane_id);
116 return AVERROR(EIO);
117 }
118
119 fb = drmModeGetFB(ctx->hwctx->fd, plane->fb_id);
120 if (!fb) {
121 av_log(avctx, AV_LOG_ERROR, "Failed to get framebuffer "
122 "%"PRIu32".\n", plane->fb_id);
123 return AVERROR(EIO);
124 }
125 if (fb->width != ctx->width || fb->height != ctx->height) {
126 av_log(avctx, AV_LOG_ERROR, "Plane %"PRIu32" framebuffer "
127 "dimensions changed: now %"PRIu32"x%"PRIu32".\n",
128 ctx->plane_id, fb->width, fb->height);
129 return AVERROR(EIO);
130 }
131 if (!fb->handle) {
132 av_log(avctx, AV_LOG_ERROR, "No handle set on framebuffer.\n");
133 return AVERROR(EIO);
134 }
135
136 err = drmPrimeHandleToFD(ctx->hwctx->fd, fb->handle, O_RDONLY, &fd);
137 if (err < 0) {
138 err = errno;
139 av_log(avctx, AV_LOG_ERROR, "Failed to get PRIME fd from "
140 "framebuffer handle: %s.\n", strerror(errno));
141 return AVERROR(err);
142 }
143
144 desc = av_mallocz(sizeof(*desc));
145 if (!desc)
146 return AVERROR(ENOMEM);
147
148 *desc = (AVDRMFrameDescriptor) {
149 .nb_objects = 1,
150 .objects[0] = {
151 .fd = fd,
152 .size = fb->height * fb->pitch,
153 .format_modifier = ctx->drm_format_modifier,
154 },
155 .nb_layers = 1,
156 .layers[0] = {
157 .format = ctx->drm_format,
158 .nb_planes = 1,
159 .planes[0] = {
160 .object_index = 0,
161 .offset = 0,
162 .pitch = fb->pitch,
163 },
164 },
165 };
166
167 frame = av_frame_alloc();
168 if (!frame)
169 return AVERROR(ENOMEM);
170
171 frame->hw_frames_ctx = av_buffer_ref(ctx->frames_ref);
172 if (!frame->hw_frames_ctx)
173 return AVERROR(ENOMEM);
174
175 frame->buf[0] = av_buffer_create((uint8_t*)desc, sizeof(*desc),
176 &kmsgrab_free_desc, avctx, 0);
177 if (!frame->buf[0])
178 return AVERROR(ENOMEM);
179
180 frame->data[0] = (uint8_t*)desc;
181 frame->format = AV_PIX_FMT_DRM_PRIME;
182 frame->width = fb->width;
183 frame->height = fb->height;
184
185 drmModeFreeFB(fb);
186 drmModeFreePlane(plane);
187
188 pkt->buf = av_buffer_create((uint8_t*)frame, sizeof(*frame),
189 &kmsgrab_free_frame, avctx, 0);
190 if (!pkt->buf)
191 return AVERROR(ENOMEM);
192
193 pkt->data = (uint8_t*)frame;
194 pkt->size = sizeof(*frame);
195 pkt->pts = now;
196 pkt->flags |= AV_PKT_FLAG_TRUSTED;
197
198 return 0;
199 }
200
201 static const struct {
202 enum AVPixelFormat pixfmt;
203 uint32_t drm_format;
204 } kmsgrab_formats[] = {
205 #ifdef DRM_FORMAT_R8
206 { AV_PIX_FMT_GRAY8, DRM_FORMAT_R8 },
207 #endif
208 #ifdef DRM_FORMAT_R16
209 { AV_PIX_FMT_GRAY16LE, DRM_FORMAT_R16 },
210 { AV_PIX_FMT_GRAY16BE, DRM_FORMAT_R16 | DRM_FORMAT_BIG_ENDIAN },
211 #endif
212 { AV_PIX_FMT_BGR8, DRM_FORMAT_BGR233 },
213 { AV_PIX_FMT_RGB555LE, DRM_FORMAT_XRGB1555 },
214 { AV_PIX_FMT_RGB555BE, DRM_FORMAT_XRGB1555 | DRM_FORMAT_BIG_ENDIAN },
215 { AV_PIX_FMT_BGR555LE, DRM_FORMAT_XBGR1555 },
216 { AV_PIX_FMT_BGR555BE, DRM_FORMAT_XBGR1555 | DRM_FORMAT_BIG_ENDIAN },
217 { AV_PIX_FMT_RGB565LE, DRM_FORMAT_RGB565 },
218 { AV_PIX_FMT_RGB565BE, DRM_FORMAT_RGB565 | DRM_FORMAT_BIG_ENDIAN },
219 { AV_PIX_FMT_BGR565LE, DRM_FORMAT_BGR565 },
220 { AV_PIX_FMT_BGR565BE, DRM_FORMAT_BGR565 | DRM_FORMAT_BIG_ENDIAN },
221 { AV_PIX_FMT_RGB24, DRM_FORMAT_RGB888 },
222 { AV_PIX_FMT_BGR24, DRM_FORMAT_BGR888 },
223 { AV_PIX_FMT_0RGB, DRM_FORMAT_BGRX8888 },
224 { AV_PIX_FMT_0BGR, DRM_FORMAT_RGBX8888 },
225 { AV_PIX_FMT_RGB0, DRM_FORMAT_XBGR8888 },
226 { AV_PIX_FMT_BGR0, DRM_FORMAT_XRGB8888 },
227 { AV_PIX_FMT_ARGB, DRM_FORMAT_BGRA8888 },
228 { AV_PIX_FMT_ABGR, DRM_FORMAT_RGBA8888 },
229 { AV_PIX_FMT_RGBA, DRM_FORMAT_ABGR8888 },
230 { AV_PIX_FMT_BGRA, DRM_FORMAT_ARGB8888 },
231 { AV_PIX_FMT_YUYV422, DRM_FORMAT_YUYV },
232 { AV_PIX_FMT_YVYU422, DRM_FORMAT_YVYU },
233 { AV_PIX_FMT_UYVY422, DRM_FORMAT_UYVY },
234 };
235
kmsgrab_read_header(AVFormatContext * avctx)236 static av_cold int kmsgrab_read_header(AVFormatContext *avctx)
237 {
238 KMSGrabContext *ctx = avctx->priv_data;
239 drmModePlaneRes *plane_res = NULL;
240 drmModePlane *plane = NULL;
241 drmModeFB *fb = NULL;
242 AVStream *stream;
243 int err, i;
244
245 for (i = 0; i < FF_ARRAY_ELEMS(kmsgrab_formats); i++) {
246 if (kmsgrab_formats[i].pixfmt == ctx->format) {
247 ctx->drm_format = kmsgrab_formats[i].drm_format;
248 break;
249 }
250 }
251 if (i >= FF_ARRAY_ELEMS(kmsgrab_formats)) {
252 av_log(avctx, AV_LOG_ERROR, "Unsupported format %s.\n",
253 av_get_pix_fmt_name(ctx->format));
254 return AVERROR(EINVAL);
255 }
256
257 err = av_hwdevice_ctx_create(&ctx->device_ref, AV_HWDEVICE_TYPE_DRM,
258 ctx->device_path, NULL, 0);
259 if (err < 0) {
260 av_log(avctx, AV_LOG_ERROR, "Failed to open DRM device.\n");
261 return err;
262 }
263 ctx->device = (AVHWDeviceContext*) ctx->device_ref->data;
264 ctx->hwctx = (AVDRMDeviceContext*)ctx->device->hwctx;
265
266 err = drmSetClientCap(ctx->hwctx->fd,
267 DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
268 if (err < 0) {
269 av_log(avctx, AV_LOG_WARNING, "Failed to set universal planes "
270 "capability: primary planes will not be usable.\n");
271 }
272
273 if (ctx->source_plane > 0) {
274 plane = drmModeGetPlane(ctx->hwctx->fd, ctx->source_plane);
275 if (!plane) {
276 err = errno;
277 av_log(avctx, AV_LOG_ERROR, "Failed to get plane %"PRId64": "
278 "%s.\n", ctx->source_plane, strerror(err));
279 err = AVERROR(err);
280 goto fail;
281 }
282
283 if (plane->fb_id == 0) {
284 av_log(avctx, AV_LOG_ERROR, "Plane %"PRId64" does not have "
285 "an attached framebuffer.\n", ctx->source_plane);
286 err = AVERROR(EINVAL);
287 goto fail;
288 }
289 } else {
290 plane_res = drmModeGetPlaneResources(ctx->hwctx->fd);
291 if (!plane_res) {
292 av_log(avctx, AV_LOG_ERROR, "Failed to get plane "
293 "resources: %s.\n", strerror(errno));
294 err = AVERROR(EINVAL);
295 goto fail;
296 }
297
298 for (i = 0; i < plane_res->count_planes; i++) {
299 plane = drmModeGetPlane(ctx->hwctx->fd,
300 plane_res->planes[i]);
301 if (!plane) {
302 err = errno;
303 av_log(avctx, AV_LOG_VERBOSE, "Failed to get "
304 "plane %"PRIu32": %s.\n",
305 plane_res->planes[i], strerror(err));
306 continue;
307 }
308
309 av_log(avctx, AV_LOG_DEBUG, "Plane %"PRIu32": "
310 "CRTC %"PRIu32" FB %"PRIu32".\n",
311 plane->plane_id, plane->crtc_id, plane->fb_id);
312
313 if ((ctx->source_crtc > 0 &&
314 plane->crtc_id != ctx->source_crtc) ||
315 plane->fb_id == 0) {
316 // Either not connected to the target source CRTC
317 // or not active.
318 drmModeFreePlane(plane);
319 plane = NULL;
320 continue;
321 }
322
323 break;
324 }
325
326 if (i == plane_res->count_planes) {
327 if (ctx->source_crtc > 0) {
328 av_log(avctx, AV_LOG_ERROR, "No usable planes found on "
329 "CRTC %"PRId64".\n", ctx->source_crtc);
330 } else {
331 av_log(avctx, AV_LOG_ERROR, "No usable planes found.\n");
332 }
333 err = AVERROR(EINVAL);
334 goto fail;
335 }
336
337 av_log(avctx, AV_LOG_INFO, "Using plane %"PRIu32" to "
338 "locate framebuffers.\n", plane->plane_id);
339 }
340
341 ctx->plane_id = plane->plane_id;
342
343 fb = drmModeGetFB(ctx->hwctx->fd, plane->fb_id);
344 if (!fb) {
345 err = errno;
346 av_log(avctx, AV_LOG_ERROR, "Failed to get "
347 "framebuffer %"PRIu32": %s.\n",
348 plane->fb_id, strerror(err));
349 err = AVERROR(err);
350 goto fail;
351 }
352
353 av_log(avctx, AV_LOG_INFO, "Template framebuffer is %"PRIu32": "
354 "%"PRIu32"x%"PRIu32" %"PRIu32"bpp %"PRIu32"b depth.\n",
355 fb->fb_id, fb->width, fb->height, fb->bpp, fb->depth);
356
357 ctx->width = fb->width;
358 ctx->height = fb->height;
359
360 if (!fb->handle) {
361 av_log(avctx, AV_LOG_ERROR, "No handle set on framebuffer: "
362 "maybe you need some additional capabilities?\n");
363 err = AVERROR(EINVAL);
364 goto fail;
365 }
366
367 stream = avformat_new_stream(avctx, NULL);
368 if (!stream) {
369 err = AVERROR(ENOMEM);
370 goto fail;
371 }
372
373 stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
374 stream->codecpar->codec_id = AV_CODEC_ID_WRAPPED_AVFRAME;
375 stream->codecpar->width = fb->width;
376 stream->codecpar->height = fb->height;
377 stream->codecpar->format = AV_PIX_FMT_DRM_PRIME;
378
379 avpriv_set_pts_info(stream, 64, 1, 1000000);
380
381 ctx->frames_ref = av_hwframe_ctx_alloc(ctx->device_ref);
382 if (!ctx->frames_ref) {
383 err = AVERROR(ENOMEM);
384 goto fail;
385 }
386 ctx->frames = (AVHWFramesContext*)ctx->frames_ref->data;
387
388 ctx->frames->format = AV_PIX_FMT_DRM_PRIME;
389 ctx->frames->sw_format = ctx->format,
390 ctx->frames->width = fb->width;
391 ctx->frames->height = fb->height;
392
393 err = av_hwframe_ctx_init(ctx->frames_ref);
394 if (err < 0) {
395 av_log(avctx, AV_LOG_ERROR, "Failed to initialise "
396 "hardware frames context: %d.\n", err);
397 goto fail;
398 }
399
400 ctx->frame_delay = av_rescale_q(1, (AVRational) { ctx->framerate.den,
401 ctx->framerate.num }, AV_TIME_BASE_Q);
402
403 err = 0;
404 fail:
405 if (plane_res)
406 drmModeFreePlaneResources(plane_res);
407 if (plane)
408 drmModeFreePlane(plane);
409 if (fb)
410 drmModeFreeFB(fb);
411
412 return err;
413 }
414
kmsgrab_read_close(AVFormatContext * avctx)415 static av_cold int kmsgrab_read_close(AVFormatContext *avctx)
416 {
417 KMSGrabContext *ctx = avctx->priv_data;
418
419 av_buffer_unref(&ctx->frames_ref);
420 av_buffer_unref(&ctx->device_ref);
421
422 return 0;
423 }
424
425 #define OFFSET(x) offsetof(KMSGrabContext, x)
426 #define FLAGS AV_OPT_FLAG_DECODING_PARAM
427 static const AVOption options[] = {
428 { "device", "DRM device path",
429 OFFSET(device_path), AV_OPT_TYPE_STRING,
430 { .str = "/dev/dri/card0" }, 0, 0, FLAGS },
431 { "format", "Pixel format for framebuffer",
432 OFFSET(format), AV_OPT_TYPE_PIXEL_FMT,
433 { .i64 = AV_PIX_FMT_BGR0 }, 0, UINT32_MAX, FLAGS },
434 { "format_modifier", "DRM format modifier for framebuffer",
435 OFFSET(drm_format_modifier), AV_OPT_TYPE_INT64,
436 { .i64 = DRM_FORMAT_MOD_NONE }, 0, INT64_MAX, FLAGS },
437 { "crtc_id", "CRTC ID to define capture source",
438 OFFSET(source_crtc), AV_OPT_TYPE_INT64,
439 { .i64 = 0 }, 0, UINT32_MAX, FLAGS },
440 { "plane_id", "Plane ID to define capture source",
441 OFFSET(source_plane), AV_OPT_TYPE_INT64,
442 { .i64 = 0 }, 0, UINT32_MAX, FLAGS },
443 { "framerate", "Framerate to capture at",
444 OFFSET(framerate), AV_OPT_TYPE_RATIONAL,
445 { .dbl = 30.0 }, 0, 1000, FLAGS },
446 { NULL },
447 };
448
449 static const AVClass kmsgrab_class = {
450 .class_name = "kmsgrab indev",
451 .item_name = av_default_item_name,
452 .option = options,
453 .version = LIBAVUTIL_VERSION_INT,
454 .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
455 };
456
457 AVInputFormat ff_kmsgrab_demuxer = {
458 .name = "kmsgrab",
459 .long_name = NULL_IF_CONFIG_SMALL("KMS screen capture"),
460 .priv_data_size = sizeof(KMSGrabContext),
461 .read_header = &kmsgrab_read_header,
462 .read_packet = &kmsgrab_read_packet,
463 .read_close = &kmsgrab_read_close,
464 .flags = AVFMT_NOFILE,
465 .priv_class = &kmsgrab_class,
466 };
467