xbmc/utils/DMAHeapBufferObject.cpp

   1 /*
   2  *  Copyright (C) 2005-2020 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "DMAHeapBufferObject.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "utils/BufferObjectFactory.h"
  13 #include "utils/log.h"
  14
  15 #include <array>
  16
  17 #include <drm_fourcc.h>
  18 #include <fcntl.h>
  19 #include <linux/dma-heap.h>
  20 #include <sys/ioctl.h>
  21 #include <sys/mman.h>
  22 #include <unistd.h>
  23
  24 namespace
  25 {
  26
  27 std::array<const char*, 3> DMA_HEAP_PATHS = {
  28     "/dev/dma_heap/reserved",
  29     "/dev/dma_heap/linux,cma",
  30     "/dev/dma_heap/system",
  31 };
  32
  33 static const char* DMA_HEAP_PATH;
  34
  35 } // namespace
  36
  37 std::unique_ptr<CBufferObject> CDMAHeapBufferObject::Create()
  38 {
  39   return std::make_unique<CDMAHeapBufferObject>();
  40 }
  41
  42 void CDMAHeapBufferObject::Register()
  43 {
  44   for (auto path : DMA_HEAP_PATHS)
  45   {
  46     int fd = open(path, O_RDWR);
  47     if (fd < 0)
  48     {
  49       CLog::Log(LOGDEBUG, "CDMAHeapBufferObject::{} unable to open {}: {}", __FUNCTION__, path,
  50                 strerror(errno));
  51       continue;
  52     }
  53
  54     close(fd);
  55     DMA_HEAP_PATH = path;
  56     break;
  57   }
  58
  59   if (!DMA_HEAP_PATH)
  60     return;
  61
  62   CLog::Log(LOGDEBUG, "CDMAHeapBufferObject::{} - using {}", __FUNCTION__, DMA_HEAP_PATH);
  63
  64   CBufferObjectFactory::RegisterBufferObject(CDMAHeapBufferObject::Create);
  65 }
  66
  67 CDMAHeapBufferObject::~CDMAHeapBufferObject()
  68 {
  69   ReleaseMemory();
  70   DestroyBufferObject();
  71
  72   close(m_dmaheapfd);
  73   m_dmaheapfd = -1;
  74 }
  75
  76 bool CDMAHeapBufferObject::CreateBufferObject(uint32_t format, uint32_t width, uint32_t height)
  77 {
  78   if (m_fd >= 0)
  79     return true;
  80
  81   uint32_t bpp{1};
  82
  83   switch (format)
  84   {
  85     case DRM_FORMAT_ARGB8888:
  86       bpp = 4;
  87       break;
  88     case DRM_FORMAT_ARGB1555:
  89     case DRM_FORMAT_RGB565:
  90       bpp = 2;
  91       break;
  92     default:
  93       throw std::runtime_error("CDMAHeapBufferObject: pixel format not implemented");
  94   }
  95
  96   m_stride = width * bpp;
  97
  98   return CreateBufferObject(width * height * bpp);
  99 }
 100
 101 bool CDMAHeapBufferObject::CreateBufferObject(uint64_t size)
 102 {
 103   m_size = size;
 104
 105   if (m_dmaheapfd < 0)
 106   {
 107     m_dmaheapfd = open(DMA_HEAP_PATH, O_RDWR);
 108     if (m_dmaheapfd < 0)
 109     {
 110       CLog::LogF(LOGERROR, "failed to open {}:", DMA_HEAP_PATH, strerror(errno));
 111       return false;
 112     }
 113   }
 114
 115   struct dma_heap_allocation_data allocData{};
 116   allocData.len = m_size;
 117   allocData.fd_flags = (O_CLOEXEC | O_RDWR);
 118   allocData.heap_flags = 0;
 119
 120   int ret = ioctl(m_dmaheapfd, DMA_HEAP_IOCTL_ALLOC, &allocData);
 121   if (ret < 0)
 122   {
 123     CLog::Log(LOGERROR, "CDMAHeapBufferObject::{} - ioctl DMA_HEAP_IOCTL_ALLOC failed, errno={}",
 124               __FUNCTION__, strerror(errno));
 125     return false;
 126   }
 127
 128   m_fd = allocData.fd;
 129   m_size = allocData.len;
 130
 131   if (m_fd < 0 || m_size <= 0)
 132   {
 133     CLog::Log(LOGERROR, "CDMAHeapBufferObject::{} - invalid allocation data: fd={} len={}",
 134               __FUNCTION__, m_fd, m_size);
 135     return false;
 136   }
 137
 138   return true;
 139 }
 140
 141 void CDMAHeapBufferObject::DestroyBufferObject()
 142 {
 143   if (m_fd < 0)
 144     return;
 145
 146   int ret = close(m_fd);
 147   if (ret < 0)
 148     CLog::Log(LOGERROR, "CDMAHeapBufferObject::{} - close failed, errno={}", __FUNCTION__,
 149               strerror(errno));
 150
 151   m_fd = -1;
 152   m_stride = 0;
 153   m_size = 0;
 154 }
 155
 156 uint8_t* CDMAHeapBufferObject::GetMemory()
 157 {
 158   if (m_fd < 0)
 159     return nullptr;
 160
 161   if (m_map)
 162   {
 163     CLog::Log(LOGDEBUG, "CDMAHeapBufferObject::{} - already mapped fd={} map={}", __FUNCTION__,
 164               m_fd, fmt::ptr(m_map));
 165     return m_map;
 166   }
 167
 168   m_map = static_cast<uint8_t*>(mmap(nullptr, m_size, PROT_WRITE, MAP_SHARED, m_fd, 0));
 169   if (m_map == MAP_FAILED)
 170   {
 171     CLog::Log(LOGERROR, "CDMAHeapBufferObject::{} - mmap failed, errno={}", __FUNCTION__,
 172               strerror(errno));
 173     return nullptr;
 174   }
 175
 176   return m_map;
 177 }
 178
 179 void CDMAHeapBufferObject::ReleaseMemory()
 180 {
 181   if (!m_map)
 182     return;
 183
 184   int ret = munmap(m_map, m_size);
 185   if (ret < 0)
 186     CLog::Log(LOGERROR, "CDMAHeapBufferObject::{} - munmap failed, errno={}", __FUNCTION__,
 187               strerror(errno));
 188
 189   m_map = nullptr;
 190 }