hwcontext_vaapi: Fix DRM format mapping
[ffmpeg.git] / libavutil / hwcontext_drm.c
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18
19 #include <fcntl.h>
20 #include <sys/mman.h>
21 #include <unistd.h>
22
23 #include <drm.h>
24 #include <xf86drm.h>
25
26 #include "avassert.h"
27 #include "hwcontext.h"
28 #include "hwcontext_drm.h"
29 #include "hwcontext_internal.h"
30 #include "imgutils.h"
31
32
33 static void drm_device_free(AVHWDeviceContext *hwdev)
34 {
35     AVDRMDeviceContext *hwctx = hwdev->hwctx;
36
37     close(hwctx->fd);
38 }
39
40 static int drm_device_create(AVHWDeviceContext *hwdev, const char *device,
41                              AVDictionary *opts, int flags)
42 {
43     AVDRMDeviceContext *hwctx = hwdev->hwctx;
44     drmVersionPtr version;
45
46     hwctx->fd = open(device, O_RDWR);
47     if (hwctx->fd < 0)
48         return AVERROR(errno);
49
50     version = drmGetVersion(hwctx->fd);
51     if (!version) {
52         av_log(hwdev, AV_LOG_ERROR, "Failed to get version information "
53                "from %s: probably not a DRM device?\n", device);
54         close(hwctx->fd);
55         return AVERROR(EINVAL);
56     }
57
58     av_log(hwdev, AV_LOG_VERBOSE, "Opened DRM device %s: driver %s "
59            "version %d.%d.%d.\n", device, version->name,
60            version->version_major, version->version_minor,
61            version->version_patchlevel);
62
63     drmFreeVersion(version);
64
65     hwdev->free = &drm_device_free;
66
67     return 0;
68 }
69
70 static int drm_get_buffer(AVHWFramesContext *hwfc, AVFrame *frame)
71 {
72     frame->buf[0] = av_buffer_pool_get(hwfc->pool);
73     if (!frame->buf[0])
74         return AVERROR(ENOMEM);
75
76     frame->data[0] = (uint8_t*)frame->buf[0]->data;
77
78     frame->format = AV_PIX_FMT_DRM_PRIME;
79     frame->width  = hwfc->width;
80     frame->height = hwfc->height;
81
82     return 0;
83 }
84
85 typedef struct DRMMapping {
86     // Address and length of each mmap()ed region.
87     int nb_regions;
88     void *address[AV_DRM_MAX_PLANES];
89     size_t length[AV_DRM_MAX_PLANES];
90 } DRMMapping;
91
92 static void drm_unmap_frame(AVHWFramesContext *hwfc,
93                             HWMapDescriptor *hwmap)
94 {
95     DRMMapping *map = hwmap->priv;
96     int i;
97
98     for (i = 0; i < map->nb_regions; i++)
99         munmap(map->address[i], map->length[i]);
100
101     av_free(map);
102 }
103
104 static int drm_map_frame(AVHWFramesContext *hwfc,
105                          AVFrame *dst, const AVFrame *src, int flags)
106 {
107     const AVDRMFrameDescriptor *desc = (AVDRMFrameDescriptor*)src->data[0];
108     DRMMapping *map;
109     int err, i, p, plane;
110     int mmap_prot;
111     void *addr;
112
113     map = av_mallocz(sizeof(*map));
114     if (!map)
115         return AVERROR(ENOMEM);
116
117     mmap_prot = 0;
118     if (flags & AV_HWFRAME_MAP_READ)
119         mmap_prot |= PROT_READ;
120     if (flags & AV_HWFRAME_MAP_WRITE)
121         mmap_prot |= PROT_WRITE;
122
123     av_assert0(desc->nb_objects <= AV_DRM_MAX_PLANES);
124     for (i = 0; i < desc->nb_objects; i++) {
125         addr = mmap(NULL, desc->objects[i].size, mmap_prot, MAP_SHARED,
126                     desc->objects[i].fd, 0);
127         if (addr == MAP_FAILED) {
128             err = AVERROR(errno);
129             av_log(hwfc, AV_LOG_ERROR, "Failed to map DRM object %d to "
130                    "memory: %d.\n", desc->objects[i].fd, errno);
131             goto fail;
132         }
133
134         map->address[i] = addr;
135         map->length[i]  = desc->objects[i].size;
136     }
137     map->nb_regions = i;
138
139     plane = 0;
140     for (i = 0; i < desc->nb_layers; i++) {
141         const AVDRMLayerDescriptor *layer = &desc->layers[i];
142         for (p = 0; p < layer->nb_planes; p++) {
143             dst->data[plane] =
144                 (uint8_t*)map->address[layer->planes[p].object_index] +
145                                        layer->planes[p].offset;
146             dst->linesize[plane] =     layer->planes[p].pitch;
147             ++plane;
148         }
149     }
150     av_assert0(plane <= AV_DRM_MAX_PLANES);
151
152     dst->width  = src->width;
153     dst->height = src->height;
154
155     err = ff_hwframe_map_create(src->hw_frames_ctx, dst, src,
156                                 &drm_unmap_frame, map);
157     if (err < 0)
158         goto fail;
159
160     return 0;
161
162 fail:
163     for (i = 0; i < desc->nb_objects; i++) {
164         if (map->address[i])
165             munmap(map->address[i], map->length[i]);
166     }
167     av_free(map);
168     return err;
169 }
170
171 static int drm_transfer_get_formats(AVHWFramesContext *ctx,
172                                     enum AVHWFrameTransferDirection dir,
173                                     enum AVPixelFormat **formats)
174 {
175     enum AVPixelFormat *pix_fmts;
176
177     pix_fmts = av_malloc_array(2, sizeof(*pix_fmts));
178     if (!pix_fmts)
179         return AVERROR(ENOMEM);
180
181     pix_fmts[0] = ctx->sw_format;
182     pix_fmts[1] = AV_PIX_FMT_NONE;
183
184     *formats = pix_fmts;
185     return 0;
186 }
187
188 static int drm_transfer_data_from(AVHWFramesContext *hwfc,
189                                   AVFrame *dst, const AVFrame *src)
190 {
191     AVFrame *map;
192     int err;
193
194     if (dst->width > hwfc->width || dst->height > hwfc->height)
195         return AVERROR(EINVAL);
196
197     map = av_frame_alloc();
198     if (!map)
199         return AVERROR(ENOMEM);
200     map->format = dst->format;
201
202     err = drm_map_frame(hwfc, map, src, AV_HWFRAME_MAP_READ);
203     if (err)
204         goto fail;
205
206     map->width  = dst->width;
207     map->height = dst->height;
208
209     err = av_frame_copy(dst, map);
210     if (err)
211         goto fail;
212
213     err = 0;
214 fail:
215     av_frame_free(&map);
216     return err;
217 }
218
219 static int drm_transfer_data_to(AVHWFramesContext *hwfc,
220                                 AVFrame *dst, const AVFrame *src)
221 {
222     AVFrame *map;
223     int err;
224
225     if (src->width > hwfc->width || src->height > hwfc->height)
226         return AVERROR(EINVAL);
227
228     map = av_frame_alloc();
229     if (!map)
230         return AVERROR(ENOMEM);
231     map->format = src->format;
232
233     err = drm_map_frame(hwfc, map, dst, AV_HWFRAME_MAP_WRITE |
234                                         AV_HWFRAME_MAP_OVERWRITE);
235     if (err)
236         goto fail;
237
238     map->width  = src->width;
239     map->height = src->height;
240
241     err = av_frame_copy(map, src);
242     if (err)
243         goto fail;
244
245     err = 0;
246 fail:
247     av_frame_free(&map);
248     return err;
249 }
250
251 static int drm_map_from(AVHWFramesContext *hwfc, AVFrame *dst,
252                         const AVFrame *src, int flags)
253 {
254     int err;
255
256     if (hwfc->sw_format != dst->format)
257         return AVERROR(ENOSYS);
258
259     err = drm_map_frame(hwfc, dst, src, flags);
260     if (err)
261         return err;
262
263     err = av_frame_copy_props(dst, src);
264     if (err)
265         return err;
266
267     return 0;
268 }
269
270 const HWContextType ff_hwcontext_type_drm = {
271     .type                   = AV_HWDEVICE_TYPE_DRM,
272     .name                   = "DRM",
273
274     .device_hwctx_size      = sizeof(AVDRMDeviceContext),
275
276     .device_create          = &drm_device_create,
277
278     .frames_get_buffer      = &drm_get_buffer,
279
280     .transfer_get_formats   = &drm_transfer_get_formats,
281     .transfer_data_to       = &drm_transfer_data_to,
282     .transfer_data_from     = &drm_transfer_data_from,
283     .map_from               = &drm_map_from,
284
285     .pix_fmts = (const enum AVPixelFormat[]) {
286         AV_PIX_FMT_DRM_PRIME,
287         AV_PIX_FMT_NONE
288     },
289 };