git.sesse.net Git - ffmpeg/blob - 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 };