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 // Required for compatibility when building against libdrm < 2.4.83.
31 #ifndef DRM_FORMAT_MOD_INVALID
32 #define DRM_FORMAT_MOD_INVALID ((1ULL << 56) - 1)
33 #endif
34
35 #include "libavutil/hwcontext.h"
36 #include "libavutil/hwcontext_drm.h"
37 #include "libavutil/internal.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/pixfmt.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/time.h"
43
44 #include "libavformat/avformat.h"
45 #include "libavformat/internal.h"
46
47 typedef struct KMSGrabContext {
48 const AVClass *class;
49
50 AVBufferRef *device_ref;
51 AVHWDeviceContext *device;
52 AVDRMDeviceContext *hwctx;
53 int fb2_available;
54
55 AVBufferRef *frames_ref;
56 AVHWFramesContext *frames;
57
58 uint32_t plane_id;
59 uint32_t drm_format;
60 unsigned int width;
61 unsigned int height;
62
63 int64_t frame_delay;
64 int64_t frame_last;
65
66 const char *device_path;
67 enum AVPixelFormat format;
68 int64_t drm_format_modifier;
69 int64_t source_plane;
70 int64_t source_crtc;
71 AVRational framerate;
72 } KMSGrabContext;
73
kmsgrab_free_desc(void * opaque,uint8_t * data)74 static void kmsgrab_free_desc(void *opaque, uint8_t *data)
75 {
76 AVDRMFrameDescriptor *desc = (AVDRMFrameDescriptor*)data;
77 int i;
78
79 for (i = 0; i < desc->nb_objects; i++)
80 close(desc->objects[i].fd);
81
82 av_free(desc);
83 }
84
kmsgrab_free_frame(void * opaque,uint8_t * data)85 static void kmsgrab_free_frame(void *opaque, uint8_t *data)
86 {
87 AVFrame *frame = (AVFrame*)data;
88
89 av_frame_free(&frame);
90 }
91
kmsgrab_get_fb(AVFormatContext * avctx,drmModePlane * plane,AVDRMFrameDescriptor * desc)92 static int kmsgrab_get_fb(AVFormatContext *avctx,
93 drmModePlane *plane,
94 AVDRMFrameDescriptor *desc)
95 {
96 KMSGrabContext *ctx = avctx->priv_data;
97 drmModeFB *fb = NULL;
98 int err, fd;
99
100 fb = drmModeGetFB(ctx->hwctx->fd, plane->fb_id);
101 if (!fb) {
102 err = errno;
103 av_log(avctx, AV_LOG_ERROR, "Failed to get framebuffer "
104 "%"PRIu32": %s.\n", plane->fb_id, strerror(err));
105 err = AVERROR(err);
106 goto fail;
107 }
108 if (fb->width != ctx->width || fb->height != ctx->height) {
109 av_log(avctx, AV_LOG_ERROR, "Plane %"PRIu32" framebuffer "
110 "dimensions changed: now %"PRIu32"x%"PRIu32".\n",
111 ctx->plane_id, fb->width, fb->height);
112 err = AVERROR(EIO);
113 goto fail;
114 }
115 if (!fb->handle) {
116 av_log(avctx, AV_LOG_ERROR, "No handle set on framebuffer.\n");
117 err = AVERROR(EIO);
118 goto fail;
119 }
120
121 err = drmPrimeHandleToFD(ctx->hwctx->fd, fb->handle, O_RDONLY, &fd);
122 if (err < 0) {
123 err = errno;
124 av_log(avctx, AV_LOG_ERROR, "Failed to get PRIME fd from "
125 "framebuffer handle: %s.\n", strerror(err));
126 err = AVERROR(err);
127 goto fail;
128 }
129
130 *desc = (AVDRMFrameDescriptor) {
131 .nb_objects = 1,
132 .objects[0] = {
133 .fd = fd,
134 .size = fb->height * fb->pitch,
135 .format_modifier = ctx->drm_format_modifier,
136 },
137 .nb_layers = 1,
138 .layers[0] = {
139 .format = ctx->drm_format,
140 .nb_planes = 1,
141 .planes[0] = {
142 .object_index = 0,
143 .offset = 0,
144 .pitch = fb->pitch,
145 },
146 },
147 };
148
149 err = 0;
150 fail:
151 drmModeFreeFB(fb);
152 return err;
153 }
154
155 #if HAVE_LIBDRM_GETFB2
kmsgrab_get_fb2(AVFormatContext * avctx,drmModePlane * plane,AVDRMFrameDescriptor * desc)156 static int kmsgrab_get_fb2(AVFormatContext *avctx,
157 drmModePlane *plane,
158 AVDRMFrameDescriptor *desc)
159 {
160 KMSGrabContext *ctx = avctx->priv_data;
161 drmModeFB2 *fb;
162 int err, i, nb_objects;
163 uint64_t modifier = ctx->drm_format_modifier;
164
165 fb = drmModeGetFB2(ctx->hwctx->fd, plane->fb_id);
166 if (!fb) {
167 err = errno;
168 av_log(avctx, AV_LOG_ERROR, "Failed to get framebuffer "
169 "%"PRIu32": %s.\n", plane->fb_id, strerror(err));
170 return AVERROR(err);
171 }
172 if (fb->pixel_format != ctx->drm_format) {
173 av_log(avctx, AV_LOG_ERROR, "Plane %"PRIu32" framebuffer "
174 "format changed: now %"PRIx32".\n",
175 ctx->plane_id, fb->pixel_format);
176 err = AVERROR(EIO);
177 goto fail;
178 }
179 if (fb->width != ctx->width || fb->height != ctx->height) {
180 av_log(avctx, AV_LOG_ERROR, "Plane %"PRIu32" framebuffer "
181 "dimensions changed: now %"PRIu32"x%"PRIu32".\n",
182 ctx->plane_id, fb->width, fb->height);
183 err = AVERROR(EIO);
184 goto fail;
185 }
186 if (!fb->handles[0]) {
187 av_log(avctx, AV_LOG_ERROR, "No handle set on framebuffer.\n");
188 err = AVERROR(EIO);
189 goto fail;
190 }
191
192 if (fb->flags & DRM_MODE_FB_MODIFIERS)
193 modifier = fb->modifier;
194
195 *desc = (AVDRMFrameDescriptor) {
196 .nb_layers = 1,
197 .layers[0] = {
198 .format = ctx->drm_format,
199 },
200 };
201
202 nb_objects = 0;
203 for (i = 0; i < 4 && fb->handles[i]; i++) {
204 size_t size;
205 int dup = 0, j, obj;
206
207 size = fb->offsets[i] + fb->height * fb->pitches[i];
208
209 for (j = 0; j < i; j++) {
210 if (fb->handles[i] == fb->handles[j]) {
211 dup = 1;
212 break;
213 }
214 }
215 if (dup) {
216 obj = desc->layers[0].planes[j].object_index;
217
218 if (desc->objects[j].size < size)
219 desc->objects[j].size = size;
220
221 desc->layers[0].planes[i] = (AVDRMPlaneDescriptor) {
222 .object_index = obj,
223 .offset = fb->offsets[i],
224 .pitch = fb->pitches[i],
225 };
226
227 } else {
228 int fd;
229 err = drmPrimeHandleToFD(ctx->hwctx->fd, fb->handles[i],
230 O_RDONLY, &fd);
231 if (err < 0) {
232 err = errno;
233 av_log(avctx, AV_LOG_ERROR, "Failed to get PRIME fd from "
234 "framebuffer handle: %s.\n", strerror(err));
235 err = AVERROR(err);
236 goto fail;
237 }
238
239 obj = nb_objects++;
240 desc->objects[obj] = (AVDRMObjectDescriptor) {
241 .fd = fd,
242 .size = size,
243 .format_modifier = modifier,
244 };
245 desc->layers[0].planes[i] = (AVDRMPlaneDescriptor) {
246 .object_index = obj,
247 .offset = fb->offsets[i],
248 .pitch = fb->pitches[i],
249 };
250 }
251 }
252 desc->nb_objects = nb_objects;
253 desc->layers[0].nb_planes = i;
254
255 err = 0;
256 fail:
257 drmModeFreeFB2(fb);
258 return err;
259 }
260 #endif
261
kmsgrab_read_packet(AVFormatContext * avctx,AVPacket * pkt)262 static int kmsgrab_read_packet(AVFormatContext *avctx, AVPacket *pkt)
263 {
264 KMSGrabContext *ctx = avctx->priv_data;
265 drmModePlane *plane = NULL;
266 AVDRMFrameDescriptor *desc = NULL;
267 AVFrame *frame = NULL;
268 int64_t now;
269 int err;
270
271 now = av_gettime_relative();
272 if (ctx->frame_last) {
273 int64_t delay;
274 while (1) {
275 delay = ctx->frame_last + ctx->frame_delay - now;
276 if (delay <= 0)
277 break;
278 av_usleep(delay);
279 now = av_gettime_relative();
280 }
281 }
282 ctx->frame_last = now;
283 now = av_gettime();
284
285 plane = drmModeGetPlane(ctx->hwctx->fd, ctx->plane_id);
286 if (!plane) {
287 err = errno;
288 av_log(avctx, AV_LOG_ERROR, "Failed to get plane "
289 "%"PRIu32": %s.\n", ctx->plane_id, strerror(err));
290 err = AVERROR(err);
291 goto fail;
292 }
293 if (!plane->fb_id) {
294 av_log(avctx, AV_LOG_ERROR, "Plane %"PRIu32" no longer has "
295 "an associated framebuffer.\n", ctx->plane_id);
296 err = AVERROR(EIO);
297 goto fail;
298 }
299
300 desc = av_mallocz(sizeof(*desc));
301 if (!desc) {
302 err = AVERROR(ENOMEM);
303 goto fail;
304 }
305
306 #if HAVE_LIBDRM_GETFB2
307 if (ctx->fb2_available)
308 err = kmsgrab_get_fb2(avctx, plane, desc);
309 else
310 #endif
311 err = kmsgrab_get_fb(avctx, plane, desc);
312 if (err < 0)
313 goto fail;
314
315 frame = av_frame_alloc();
316 if (!frame) {
317 err = AVERROR(ENOMEM);
318 goto fail;
319 }
320
321 frame->hw_frames_ctx = av_buffer_ref(ctx->frames_ref);
322 if (!frame->hw_frames_ctx) {
323 err = AVERROR(ENOMEM);
324 goto fail;
325 }
326
327 frame->buf[0] = av_buffer_create((uint8_t*)desc, sizeof(*desc),
328 &kmsgrab_free_desc, avctx, 0);
329 if (!frame->buf[0]) {
330 err = AVERROR(ENOMEM);
331 goto fail;
332 }
333
334 frame->data[0] = (uint8_t*)desc;
335 frame->format = AV_PIX_FMT_DRM_PRIME;
336 frame->width = ctx->width;
337 frame->height = ctx->height;
338
339 drmModeFreePlane(plane);
340 plane = NULL;
341 desc = NULL;
342
343 pkt->buf = av_buffer_create((uint8_t*)frame, sizeof(*frame),
344 &kmsgrab_free_frame, avctx, 0);
345 if (!pkt->buf) {
346 err = AVERROR(ENOMEM);
347 goto fail;
348 }
349
350 pkt->data = (uint8_t*)frame;
351 pkt->size = sizeof(*frame);
352 pkt->pts = now;
353 pkt->flags |= AV_PKT_FLAG_TRUSTED;
354
355 return 0;
356
357 fail:
358 drmModeFreePlane(plane);
359 av_freep(&desc);
360 av_frame_free(&frame);
361 return err;
362 }
363
364 static const struct {
365 enum AVPixelFormat pixfmt;
366 uint32_t drm_format;
367 } kmsgrab_formats[] = {
368 // Monochrome.
369 #ifdef DRM_FORMAT_R8
370 { AV_PIX_FMT_GRAY8, DRM_FORMAT_R8 },
371 #endif
372 #ifdef DRM_FORMAT_R16
373 { AV_PIX_FMT_GRAY16LE, DRM_FORMAT_R16 },
374 { AV_PIX_FMT_GRAY16BE, DRM_FORMAT_R16 | DRM_FORMAT_BIG_ENDIAN },
375 #endif
376 // <8-bit RGB.
377 { AV_PIX_FMT_BGR8, DRM_FORMAT_BGR233 },
378 { AV_PIX_FMT_RGB555LE, DRM_FORMAT_XRGB1555 },
379 { AV_PIX_FMT_RGB555BE, DRM_FORMAT_XRGB1555 | DRM_FORMAT_BIG_ENDIAN },
380 { AV_PIX_FMT_BGR555LE, DRM_FORMAT_XBGR1555 },
381 { AV_PIX_FMT_BGR555BE, DRM_FORMAT_XBGR1555 | DRM_FORMAT_BIG_ENDIAN },
382 { AV_PIX_FMT_RGB565LE, DRM_FORMAT_RGB565 },
383 { AV_PIX_FMT_RGB565BE, DRM_FORMAT_RGB565 | DRM_FORMAT_BIG_ENDIAN },
384 { AV_PIX_FMT_BGR565LE, DRM_FORMAT_BGR565 },
385 { AV_PIX_FMT_BGR565BE, DRM_FORMAT_BGR565 | DRM_FORMAT_BIG_ENDIAN },
386 // 8-bit RGB.
387 { AV_PIX_FMT_RGB24, DRM_FORMAT_RGB888 },
388 { AV_PIX_FMT_BGR24, DRM_FORMAT_BGR888 },
389 { AV_PIX_FMT_0RGB, DRM_FORMAT_BGRX8888 },
390 { AV_PIX_FMT_0BGR, DRM_FORMAT_RGBX8888 },
391 { AV_PIX_FMT_RGB0, DRM_FORMAT_XBGR8888 },
392 { AV_PIX_FMT_BGR0, DRM_FORMAT_XRGB8888 },
393 { AV_PIX_FMT_ARGB, DRM_FORMAT_BGRA8888 },
394 { AV_PIX_FMT_ABGR, DRM_FORMAT_RGBA8888 },
395 { AV_PIX_FMT_RGBA, DRM_FORMAT_ABGR8888 },
396 { AV_PIX_FMT_BGRA, DRM_FORMAT_ARGB8888 },
397 // 10-bit RGB.
398 { AV_PIX_FMT_X2RGB10LE, DRM_FORMAT_XRGB2101010 },
399 { AV_PIX_FMT_X2RGB10BE, DRM_FORMAT_XRGB2101010 | DRM_FORMAT_BIG_ENDIAN },
400 // 8-bit YUV 4:2:0.
401 { AV_PIX_FMT_NV12, DRM_FORMAT_NV12 },
402 // 8-bit YUV 4:2:2.
403 { AV_PIX_FMT_YUYV422, DRM_FORMAT_YUYV },
404 { AV_PIX_FMT_YVYU422, DRM_FORMAT_YVYU },
405 { AV_PIX_FMT_UYVY422, DRM_FORMAT_UYVY },
406 };
407
kmsgrab_read_header(AVFormatContext * avctx)408 static av_cold int kmsgrab_read_header(AVFormatContext *avctx)
409 {
410 KMSGrabContext *ctx = avctx->priv_data;
411 drmModePlaneRes *plane_res = NULL;
412 drmModePlane *plane = NULL;
413 drmModeFB *fb = NULL;
414 #if HAVE_LIBDRM_GETFB2
415 drmModeFB2 *fb2 = NULL;
416 #endif
417 AVStream *stream;
418 int err, i;
419
420 err = av_hwdevice_ctx_create(&ctx->device_ref, AV_HWDEVICE_TYPE_DRM,
421 ctx->device_path, NULL, 0);
422 if (err < 0) {
423 av_log(avctx, AV_LOG_ERROR, "Failed to open DRM device.\n");
424 return err;
425 }
426 ctx->device = (AVHWDeviceContext*) ctx->device_ref->data;
427 ctx->hwctx = (AVDRMDeviceContext*)ctx->device->hwctx;
428
429 err = drmSetClientCap(ctx->hwctx->fd,
430 DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
431 if (err < 0) {
432 av_log(avctx, AV_LOG_WARNING, "Failed to set universal planes "
433 "capability: primary planes will not be usable.\n");
434 }
435
436 if (ctx->source_plane > 0) {
437 plane = drmModeGetPlane(ctx->hwctx->fd, ctx->source_plane);
438 if (!plane) {
439 err = errno;
440 av_log(avctx, AV_LOG_ERROR, "Failed to get plane %"PRId64": "
441 "%s.\n", ctx->source_plane, strerror(err));
442 err = AVERROR(err);
443 goto fail;
444 }
445
446 if (plane->fb_id == 0) {
447 av_log(avctx, AV_LOG_ERROR, "Plane %"PRId64" does not have "
448 "an attached framebuffer.\n", ctx->source_plane);
449 err = AVERROR(EINVAL);
450 goto fail;
451 }
452 } else {
453 plane_res = drmModeGetPlaneResources(ctx->hwctx->fd);
454 if (!plane_res) {
455 err = errno;
456 av_log(avctx, AV_LOG_ERROR, "Failed to get plane "
457 "resources: %s.\n", strerror(err));
458 err = AVERROR(err);
459 goto fail;
460 }
461
462 for (i = 0; i < plane_res->count_planes; i++) {
463 plane = drmModeGetPlane(ctx->hwctx->fd,
464 plane_res->planes[i]);
465 if (!plane) {
466 err = errno;
467 av_log(avctx, AV_LOG_VERBOSE, "Failed to get "
468 "plane %"PRIu32": %s.\n",
469 plane_res->planes[i], strerror(err));
470 continue;
471 }
472
473 av_log(avctx, AV_LOG_DEBUG, "Plane %"PRIu32": "
474 "CRTC %"PRIu32" FB %"PRIu32".\n",
475 plane->plane_id, plane->crtc_id, plane->fb_id);
476
477 if ((ctx->source_crtc > 0 &&
478 plane->crtc_id != ctx->source_crtc) ||
479 plane->fb_id == 0) {
480 // Either not connected to the target source CRTC
481 // or not active.
482 drmModeFreePlane(plane);
483 plane = NULL;
484 continue;
485 }
486
487 break;
488 }
489
490 if (i == plane_res->count_planes) {
491 if (ctx->source_crtc > 0) {
492 av_log(avctx, AV_LOG_ERROR, "No usable planes found on "
493 "CRTC %"PRId64".\n", ctx->source_crtc);
494 } else {
495 av_log(avctx, AV_LOG_ERROR, "No usable planes found.\n");
496 }
497 err = AVERROR(EINVAL);
498 goto fail;
499 }
500
501 av_log(avctx, AV_LOG_INFO, "Using plane %"PRIu32" to "
502 "locate framebuffers.\n", plane->plane_id);
503 }
504
505 ctx->plane_id = plane->plane_id;
506
507 #if HAVE_LIBDRM_GETFB2
508 fb2 = drmModeGetFB2(ctx->hwctx->fd, plane->fb_id);
509 if (!fb2 && errno == ENOSYS) {
510 av_log(avctx, AV_LOG_INFO, "GETFB2 not supported, "
511 "will try to use GETFB instead.\n");
512 } else if (!fb2) {
513 err = errno;
514 av_log(avctx, AV_LOG_ERROR, "Failed to get "
515 "framebuffer %"PRIu32": %s.\n",
516 plane->fb_id, strerror(err));
517 err = AVERROR(err);
518 goto fail;
519 } else {
520 av_log(avctx, AV_LOG_INFO, "Template framebuffer is "
521 "%"PRIu32": %"PRIu32"x%"PRIu32" "
522 "format %"PRIx32" modifier %"PRIx64" flags %"PRIx32".\n",
523 fb2->fb_id, fb2->width, fb2->height,
524 fb2->pixel_format, fb2->modifier, fb2->flags);
525
526 ctx->width = fb2->width;
527 ctx->height = fb2->height;
528
529 if (!fb2->handles[0]) {
530 av_log(avctx, AV_LOG_ERROR, "No handle set on framebuffer: "
531 "maybe you need some additional capabilities?\n");
532 err = AVERROR(EINVAL);
533 goto fail;
534 }
535
536 for (i = 0; i < FF_ARRAY_ELEMS(kmsgrab_formats); i++) {
537 if (kmsgrab_formats[i].drm_format == fb2->pixel_format) {
538 if (ctx->format != AV_PIX_FMT_NONE &&
539 ctx->format != kmsgrab_formats[i].pixfmt) {
540 av_log(avctx, AV_LOG_ERROR, "Framebuffer pixel format "
541 "%"PRIx32" does not match expected format.\n",
542 fb2->pixel_format);
543 err = AVERROR(EINVAL);
544 goto fail;
545 }
546 ctx->drm_format = fb2->pixel_format;
547 ctx->format = kmsgrab_formats[i].pixfmt;
548 break;
549 }
550 }
551 if (i == FF_ARRAY_ELEMS(kmsgrab_formats)) {
552 av_log(avctx, AV_LOG_ERROR, "Framebuffer pixel format "
553 "%"PRIx32" is not a known supported format.\n",
554 fb2->pixel_format);
555 err = AVERROR(EINVAL);
556 goto fail;
557 }
558
559 if (fb2->flags & DRM_MODE_FB_MODIFIERS) {
560 if (ctx->drm_format_modifier != DRM_FORMAT_MOD_INVALID &&
561 ctx->drm_format_modifier != fb2->modifier) {
562 av_log(avctx, AV_LOG_ERROR, "Framebuffer format modifier "
563 "%"PRIx64" does not match expected modifier.\n",
564 fb2->modifier);
565 err = AVERROR(EINVAL);
566 goto fail;
567 } else {
568 ctx->drm_format_modifier = fb2->modifier;
569 }
570 }
571 av_log(avctx, AV_LOG_VERBOSE, "Format is %s, from "
572 "DRM format %"PRIx32" modifier %"PRIx64".\n",
573 av_get_pix_fmt_name(ctx->format),
574 ctx->drm_format, ctx->drm_format_modifier);
575
576 ctx->fb2_available = 1;
577 }
578 #endif
579
580 if (!ctx->fb2_available) {
581 if (ctx->format == AV_PIX_FMT_NONE) {
582 // Backward compatibility: assume BGR0 if no format supplied.
583 ctx->format = AV_PIX_FMT_BGR0;
584 }
585 for (i = 0; i < FF_ARRAY_ELEMS(kmsgrab_formats); i++) {
586 if (kmsgrab_formats[i].pixfmt == ctx->format) {
587 ctx->drm_format = kmsgrab_formats[i].drm_format;
588 break;
589 }
590 }
591 if (i >= FF_ARRAY_ELEMS(kmsgrab_formats)) {
592 av_log(avctx, AV_LOG_ERROR, "Unsupported format %s.\n",
593 av_get_pix_fmt_name(ctx->format));
594 return AVERROR(EINVAL);
595 }
596
597 fb = drmModeGetFB(ctx->hwctx->fd, plane->fb_id);
598 if (!fb) {
599 err = errno;
600 av_log(avctx, AV_LOG_ERROR, "Failed to get "
601 "framebuffer %"PRIu32": %s.\n",
602 plane->fb_id, strerror(err));
603 err = AVERROR(err);
604 goto fail;
605 }
606
607 av_log(avctx, AV_LOG_INFO, "Template framebuffer is %"PRIu32": "
608 "%"PRIu32"x%"PRIu32" %"PRIu32"bpp %"PRIu32"b depth.\n",
609 fb->fb_id, fb->width, fb->height, fb->bpp, fb->depth);
610
611 ctx->width = fb->width;
612 ctx->height = fb->height;
613
614 if (!fb->handle) {
615 av_log(avctx, AV_LOG_ERROR, "No handle set on framebuffer: "
616 "maybe you need some additional capabilities?\n");
617 err = AVERROR(EINVAL);
618 goto fail;
619 }
620 }
621
622 stream = avformat_new_stream(avctx, NULL);
623 if (!stream) {
624 err = AVERROR(ENOMEM);
625 goto fail;
626 }
627
628 stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
629 stream->codecpar->codec_id = AV_CODEC_ID_WRAPPED_AVFRAME;
630 stream->codecpar->width = ctx->width;
631 stream->codecpar->height = ctx->height;
632 stream->codecpar->format = AV_PIX_FMT_DRM_PRIME;
633
634 avpriv_set_pts_info(stream, 64, 1, 1000000);
635
636 ctx->frames_ref = av_hwframe_ctx_alloc(ctx->device_ref);
637 if (!ctx->frames_ref) {
638 err = AVERROR(ENOMEM);
639 goto fail;
640 }
641 ctx->frames = (AVHWFramesContext*)ctx->frames_ref->data;
642
643 ctx->frames->format = AV_PIX_FMT_DRM_PRIME;
644 ctx->frames->sw_format = ctx->format,
645 ctx->frames->width = ctx->width;
646 ctx->frames->height = ctx->height;
647
648 err = av_hwframe_ctx_init(ctx->frames_ref);
649 if (err < 0) {
650 av_log(avctx, AV_LOG_ERROR, "Failed to initialise "
651 "hardware frames context: %d.\n", err);
652 goto fail;
653 }
654
655 ctx->frame_delay = av_rescale_q(1, (AVRational) { ctx->framerate.den,
656 ctx->framerate.num }, AV_TIME_BASE_Q);
657
658 err = 0;
659 fail:
660 drmModeFreePlaneResources(plane_res);
661 drmModeFreePlane(plane);
662 drmModeFreeFB(fb);
663 #if HAVE_LIBDRM_GETFB2
664 drmModeFreeFB2(fb2);
665 #endif
666 return err;
667 }
668
kmsgrab_read_close(AVFormatContext * avctx)669 static av_cold int kmsgrab_read_close(AVFormatContext *avctx)
670 {
671 KMSGrabContext *ctx = avctx->priv_data;
672
673 av_buffer_unref(&ctx->frames_ref);
674 av_buffer_unref(&ctx->device_ref);
675
676 return 0;
677 }
678
679 #define OFFSET(x) offsetof(KMSGrabContext, x)
680 #define FLAGS AV_OPT_FLAG_DECODING_PARAM
681 static const AVOption options[] = {
682 { "device", "DRM device path",
683 OFFSET(device_path), AV_OPT_TYPE_STRING,
684 { .str = "/dev/dri/card0" }, 0, 0, FLAGS },
685 { "format", "Pixel format for framebuffer",
686 OFFSET(format), AV_OPT_TYPE_PIXEL_FMT,
687 { .i64 = AV_PIX_FMT_NONE }, -1, INT32_MAX, FLAGS },
688 { "format_modifier", "DRM format modifier for framebuffer",
689 OFFSET(drm_format_modifier), AV_OPT_TYPE_INT64,
690 { .i64 = DRM_FORMAT_MOD_INVALID }, 0, INT64_MAX, FLAGS },
691 { "crtc_id", "CRTC ID to define capture source",
692 OFFSET(source_crtc), AV_OPT_TYPE_INT64,
693 { .i64 = 0 }, 0, UINT32_MAX, FLAGS },
694 { "plane_id", "Plane ID to define capture source",
695 OFFSET(source_plane), AV_OPT_TYPE_INT64,
696 { .i64 = 0 }, 0, UINT32_MAX, FLAGS },
697 { "framerate", "Framerate to capture at",
698 OFFSET(framerate), AV_OPT_TYPE_RATIONAL,
699 { .dbl = 30.0 }, 0, 1000, FLAGS },
700 { NULL },
701 };
702
703 static const AVClass kmsgrab_class = {
704 .class_name = "kmsgrab indev",
705 .item_name = av_default_item_name,
706 .option = options,
707 .version = LIBAVUTIL_VERSION_INT,
708 .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
709 };
710
711 AVInputFormat ff_kmsgrab_demuxer = {
712 .name = "kmsgrab",
713 .long_name = NULL_IF_CONFIG_SMALL("KMS screen capture"),
714 .priv_data_size = sizeof(KMSGrabContext),
715 .read_header = &kmsgrab_read_header,
716 .read_packet = &kmsgrab_read_packet,
717 .read_close = &kmsgrab_read_close,
718 .flags = AVFMT_NOFILE,
719 .priv_class = &kmsgrab_class,
720 };
721