avdevice/decklink_dec: Used av_parity instead of duplicated function
[ffmpeg.git] / libavdevice / kmsgrab.c
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
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
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
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
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
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 };
455
456 AVInputFormat ff_kmsgrab_demuxer = {
457     .name           = "kmsgrab",
458     .long_name      = NULL_IF_CONFIG_SMALL("KMS screen capture"),
459     .priv_data_size = sizeof(KMSGrabContext),
460     .read_header    = &kmsgrab_read_header,
461     .read_packet    = &kmsgrab_read_packet,
462     .read_close     = &kmsgrab_read_close,
463     .flags          = AVFMT_NOFILE,
464     .priv_class     = &kmsgrab_class,
465 };