// Copyright 2019 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
|
// Use of this source code is governed by a BSD-style license that can be
|
// found in the LICENSE file.
|
|
#include "buffer.h"
|
|
#include <assert.h>
|
#include <fcntl.h>
|
#include <string.h>
|
#include <sys/ioctl.h>
|
#include <sys/mman.h>
|
#include <unistd.h>
|
|
#include "key_string.h"
|
#include "utils.h"
|
|
namespace easymedia
|
{
|
|
MediaBuffer::MemType StringToMemType(const char* s)
|
{
|
if (s) {
|
#ifdef LIBION
|
if (!strcmp(s, KEY_MEM_ION) || !strcmp(s, KEY_MEM_HARDWARE)) {
|
return MediaBuffer::MemType::MEM_HARD_WARE;
|
}
|
#endif
|
#ifdef LIBDRM
|
if (!strcmp(s, KEY_MEM_DRM) || !strcmp(s, KEY_MEM_HARDWARE)) {
|
return MediaBuffer::MemType::MEM_HARD_WARE;
|
}
|
#endif
|
LOG("warning: %s is not supported or not integrated, fallback to common\n", s);
|
}
|
return MediaBuffer::MemType::MEM_COMMON;
|
}
|
|
static int free_common_memory(void* buffer)
|
{
|
if (buffer) {
|
free(buffer);
|
}
|
|
return 0;
|
}
|
|
static MediaBuffer alloc_common_memory(size_t size)
|
{
|
void* buffer = malloc(size);
|
if (!buffer) {
|
return MediaBuffer();
|
}
|
return MediaBuffer(buffer, size, -1, buffer, free_common_memory);
|
}
|
|
static MediaGroupBuffer* alloc_common_memory_group(size_t size)
|
{
|
void* buffer = malloc(size);
|
if (!buffer) {
|
return nullptr;
|
}
|
MediaGroupBuffer* mgb = new MediaGroupBuffer(buffer, size, -1, buffer, free_common_memory);
|
|
return mgb;
|
}
|
|
#ifdef LIBION
|
#include <ion/ion.h>
|
class IonBuffer
|
{
|
public:
|
IonBuffer(int param_client, ion_user_handle_t param_handle, int param_fd, void* param_map_ptr, size_t param_len)
|
: client(param_client), handle(param_handle), fd(param_fd), map_ptr(param_map_ptr), len(param_len)
|
{
|
}
|
~IonBuffer();
|
|
private:
|
int client;
|
ion_user_handle_t handle;
|
int fd;
|
void* map_ptr;
|
size_t len;
|
};
|
|
IonBuffer::~IonBuffer()
|
{
|
if (map_ptr) {
|
munmap(map_ptr, len);
|
}
|
if (fd >= 0) {
|
close(fd);
|
}
|
if (client < 0) {
|
return;
|
}
|
if (handle) {
|
int ret = ion_free(client, handle);
|
if (ret) {
|
LOG("ion_free() failed <handle: %d>: %m!\n", handle);
|
}
|
}
|
ion_close(client);
|
}
|
|
static int free_ion_memory(void* buffer)
|
{
|
assert(buffer);
|
IonBuffer* ion_buffer = static_cast<IonBuffer*>(buffer);
|
delete ion_buffer;
|
return 0;
|
}
|
|
static MediaBuffer alloc_ion_memory(size_t size)
|
{
|
ion_user_handle_t handle;
|
int ret;
|
int fd;
|
void* ptr;
|
IonBuffer* buffer;
|
int client = ion_open();
|
if (client < 0) {
|
LOG("ion_open() failed: %m\n");
|
goto err;
|
}
|
ret = ion_alloc(client, size, 0, ION_HEAP_TYPE_DMA_MASK, 0, &handle);
|
if (ret) {
|
LOG("ion_alloc() failed: %m\n");
|
ion_close(client);
|
goto err;
|
}
|
ret = ion_share(client, handle, &fd);
|
if (ret < 0) {
|
LOG("ion_share() failed: %m\n");
|
ion_free(client, handle);
|
ion_close(client);
|
goto err;
|
}
|
ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_LOCKED, fd, 0);
|
if (!ptr) {
|
LOG("ion mmap() failed: %m\n");
|
ion_free(client, handle);
|
ion_close(client);
|
close(fd);
|
goto err;
|
}
|
buffer = new IonBuffer(client, handle, fd, ptr, size);
|
if (!buffer) {
|
ion_free(client, handle);
|
ion_close(client);
|
close(fd);
|
munmap(ptr, size);
|
goto err;
|
}
|
|
return MediaBuffer(ptr, size, fd, buffer, free_ion_memory);
|
err:
|
return MediaBuffer();
|
}
|
#endif
|
|
#ifdef LIBDRM
|
|
#include <drm_fourcc.h>
|
#include <xf86drm.h>
|
/**
|
* Copy from libdrm_macros.h while is not exposed by libdrm,
|
* be replaced by #include "libdrm_macros.h" someday.
|
*/
|
/**
|
* Static (compile-time) assertion.
|
* Basically, use COND to dimension an array. If COND is false/zero the
|
* array size will be -1 and we'll get a compilation error.
|
*/
|
#define STATIC_ASSERT(COND) \
|
do { \
|
(void)sizeof(char[1 - 2 * !(COND)]); \
|
} while (0)
|
|
#if defined(ANDROID) && !defined(__LP64__)
|
#include <errno.h> /* for EINVAL */
|
|
extern void* __mmap2(void*, size_t, int, int, int, size_t);
|
|
static inline void* drm_mmap(void* addr, size_t length, int prot, int flags, int fd, loff_t offset)
|
{
|
/* offset must be aligned to 4096 (not necessarily the page size) */
|
if (offset & 4095) {
|
errno = EINVAL;
|
return MAP_FAILED;
|
}
|
|
return __mmap2(addr, length, prot, flags, fd, (size_t)(offset >> 12));
|
}
|
|
#define drm_munmap(addr, length) munmap(addr, length)
|
|
#else
|
|
/* assume large file support exists */
|
#define drm_mmap(addr, length, prot, flags, fd, offset) mmap(addr, length, prot, flags, fd, offset)
|
|
static inline int drm_munmap(void* addr, size_t length)
|
{
|
/* Copied from configure code generated by AC_SYS_LARGEFILE */
|
#define LARGE_OFF_T ((((off_t)1 << 31) << 31) - 1 + (((off_t)1 << 31) << 31))
|
STATIC_ASSERT(LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1);
|
#undef LARGE_OFF_T
|
|
return munmap(addr, length);
|
}
|
#endif
|
|
// default
|
static int card_index = 0;
|
static int drm_device_open(const char* device = nullptr)
|
{
|
drmVersionPtr version;
|
char drm_dev[] = "/dev/dri/card0000";
|
uint64_t has_dumb;
|
|
if (!device) {
|
snprintf(drm_dev, sizeof(drm_dev), DRM_DEV_NAME, DRM_DIR_NAME, card_index);
|
device = drm_dev;
|
}
|
int fd = open(device, O_RDWR);
|
if (fd < 0) {
|
return fd;
|
}
|
version = drmGetVersion(fd);
|
if (!version) {
|
LOG("Failed to get version information "
|
"from %s: probably not a DRM device?\n",
|
device);
|
close(fd);
|
return -1;
|
}
|
LOG("Opened DRM device %s: driver %s "
|
"version %d.%d.%d.\n",
|
device, version->name, version->version_major, version->version_minor, version->version_patchlevel);
|
drmFreeVersion(version);
|
if (drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &has_dumb) < 0 || !has_dumb) {
|
LOG("drm device '%s' "
|
"does not support dumb buffers\n",
|
device);
|
close(fd);
|
return -1;
|
}
|
return fd;
|
}
|
|
class DrmDevice
|
{
|
public:
|
DrmDevice()
|
{
|
fd = drm_device_open();
|
}
|
~DrmDevice()
|
{
|
if (fd >= 0) {
|
close(fd);
|
}
|
}
|
bool Valid()
|
{
|
return fd >= 0;
|
}
|
|
const static std::shared_ptr<DrmDevice>& GetInstance()
|
{
|
const static std::shared_ptr<DrmDevice> mDrmDevice = std::make_shared<DrmDevice>();
|
|
return mDrmDevice;
|
}
|
|
int fd;
|
};
|
|
class DrmBuffer
|
{
|
public:
|
DrmBuffer(std::shared_ptr<DrmDevice> dev, size_t s, __u32 flags = 0)
|
: device(dev), handle(0), len(UPALIGNTO(s, PAGE_SIZE)), fd(-1), map_ptr(nullptr)
|
{
|
struct drm_mode_create_dumb dmcb;
|
memset(&dmcb, 0, sizeof(struct drm_mode_create_dumb));
|
dmcb.bpp = 8;
|
dmcb.width = len;
|
dmcb.height = 1;
|
dmcb.flags = flags;
|
int ret = drmIoctl(dev->fd, DRM_IOCTL_MODE_CREATE_DUMB, &dmcb);
|
if (ret < 0) {
|
LOG("Failed to create dumb<w,h,bpp: %d,%d,%d>: %m\n", dmcb.width, dmcb.height, dmcb.bpp);
|
return;
|
}
|
assert(dmcb.handle > 0);
|
assert(dmcb.size >= dmcb.width * dmcb.height * dmcb.bpp / 8);
|
handle = dmcb.handle;
|
len = dmcb.size;
|
ret = drmPrimeHandleToFD(dev->fd, dmcb.handle, DRM_CLOEXEC, &fd);
|
if (ret) {
|
LOG("Failed to convert drm handle to fd: %m\n");
|
return;
|
}
|
assert(fd >= 0);
|
}
|
~DrmBuffer()
|
{
|
if (map_ptr) {
|
drm_munmap(map_ptr, len);
|
}
|
int ret;
|
if (handle > 0) {
|
struct drm_mode_destroy_dumb data = {
|
.handle = handle,
|
};
|
ret = drmIoctl(device->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &data);
|
if (ret) {
|
LOG("Failed to free drm handle <%d>: %m\n", handle);
|
}
|
}
|
if (fd >= 0) {
|
ret = close(fd);
|
if (ret) {
|
LOG("Failed to close drm buffer fd <%d>: %m\n", fd);
|
}
|
}
|
}
|
bool MapToVirtual()
|
{
|
struct drm_mode_map_dumb dmmd;
|
memset(&dmmd, 0, sizeof(dmmd));
|
dmmd.handle = handle;
|
int ret = drmIoctl(device->fd, DRM_IOCTL_MODE_MAP_DUMB, &dmmd);
|
if (ret) {
|
LOG("Failed to map dumb: %m\n");
|
return false;
|
}
|
// default read and write
|
void* ptr = drm_mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, device->fd, dmmd.offset);
|
if (ptr == MAP_FAILED) {
|
LOG("Failed to drm_mmap: %m\n");
|
return false;
|
}
|
assert(ptr);
|
map_ptr = ptr;
|
return true;
|
}
|
bool Valid()
|
{
|
return fd >= 0;
|
}
|
|
std::shared_ptr<DrmDevice> device;
|
__u32 handle;
|
size_t len;
|
int fd;
|
void* map_ptr;
|
};
|
|
static int free_drm_memory(void* buffer)
|
{
|
assert(buffer);
|
delete static_cast<DrmBuffer*>(buffer);
|
return 0;
|
}
|
|
/* memory type definitions. */
|
enum drm_rockchip_gem_mem_type
|
{
|
/* Physically Continuous memory. */
|
ROCKCHIP_BO_CONTIG = 1 << 0,
|
/* cachable mapping. */
|
ROCKCHIP_BO_CACHABLE = 1 << 1,
|
/* write-combine mapping. */
|
ROCKCHIP_BO_WC = 1 << 2,
|
ROCKCHIP_BO_SECURE = 1 << 3,
|
ROCKCHIP_BO_MASK = ROCKCHIP_BO_CONTIG | ROCKCHIP_BO_CACHABLE | ROCKCHIP_BO_WC
|
};
|
|
static MediaBuffer alloc_drm_memory(size_t size, bool map = true)
|
{
|
const static std::shared_ptr<DrmDevice>& drm_dev = DrmDevice::GetInstance();
|
DrmBuffer* db = nullptr;
|
do {
|
if (!drm_dev || !drm_dev->Valid()) {
|
break;
|
}
|
db = new DrmBuffer(drm_dev, size, ROCKCHIP_BO_CACHABLE);
|
if (!db || !db->Valid()) {
|
break;
|
}
|
if (map && !db->MapToVirtual()) {
|
break;
|
}
|
return MediaBuffer(db->map_ptr, db->len, db->fd, db, free_drm_memory);
|
} while (false);
|
if (db) {
|
delete db;
|
}
|
return MediaBuffer();
|
}
|
|
static MediaGroupBuffer* alloc_drm_memory_group(size_t size, bool map = true)
|
{
|
const static std::shared_ptr<DrmDevice>& drm_dev = DrmDevice::GetInstance();
|
DrmBuffer* db = nullptr;
|
|
do {
|
if (!drm_dev || !drm_dev->Valid()) {
|
break;
|
}
|
db = new DrmBuffer(drm_dev, size, ROCKCHIP_BO_CACHABLE);
|
if (!db || !db->Valid()) {
|
break;
|
}
|
if (map && !db->MapToVirtual()) {
|
break;
|
}
|
MediaGroupBuffer* mgb = nullptr;
|
mgb = new MediaGroupBuffer(db->map_ptr, db->len, db->fd, db, free_drm_memory);
|
return mgb;
|
} while (false);
|
if (db) {
|
delete db;
|
}
|
|
return nullptr;
|
}
|
|
#endif
|
|
std::shared_ptr<MediaBuffer> MediaBuffer::Alloc(size_t size, MemType type)
|
{
|
MediaBuffer&& mb = Alloc2(size, type);
|
if (mb.GetSize() == 0) {
|
return nullptr;
|
}
|
return std::make_shared<MediaBuffer>(mb);
|
}
|
|
MediaBuffer MediaBuffer::Alloc2(size_t size, MemType type)
|
{
|
switch (type) {
|
case MemType::MEM_COMMON:
|
return alloc_common_memory(size);
|
#ifdef LIBION
|
case MemType::MEM_HARD_WARE:
|
return alloc_ion_memory(size);
|
#endif
|
#ifdef LIBDRM
|
case MemType::MEM_HARD_WARE:
|
return alloc_drm_memory(size);
|
#endif
|
default:
|
LOG("unknown memtype\n");
|
return MediaBuffer();
|
}
|
}
|
|
std::shared_ptr<MediaBuffer> MediaBuffer::Clone(MediaBuffer& src, MemType dst_type)
|
{
|
size_t size = src.GetValidSize();
|
if (!size) {
|
return nullptr;
|
}
|
auto new_buffer = Alloc(size, dst_type);
|
if (!new_buffer) {
|
LOG_NO_MEMORY();
|
return nullptr;
|
}
|
if (src.IsHwBuffer() && new_buffer->IsHwBuffer()) {
|
LOG_TODO(); // TODO: fd -> fd by RGA
|
}
|
memcpy(new_buffer->GetPtr(), src.GetPtr(), size);
|
new_buffer->SetValidSize(size);
|
new_buffer->CopyAttribute(src);
|
return new_buffer;
|
}
|
|
void MediaBuffer::CopyAttribute(MediaBuffer& src_attr)
|
{
|
type = src_attr.GetType();
|
user_flag = src_attr.GetUserFlag();
|
ustimestamp = src_attr.GetUSTimeStamp();
|
eof = src_attr.IsEOF();
|
}
|
|
struct dma_buf_sync {
|
uint64_t flags;
|
};
|
|
#define DMA_BUF_SYNC_READ (1 << 0)
|
#define DMA_BUF_SYNC_WRITE (2 << 0)
|
#define DMA_BUF_SYNC_RW (DMA_BUF_SYNC_READ | DMA_BUF_SYNC_WRITE)
|
#define DMA_BUF_SYNC_START (0 << 2)
|
#define DMA_BUF_SYNC_END (1 << 2)
|
#define DMA_BUF_SYNC_VALID_FLAGS_MASK (DMA_BUF_SYNC_RW | DMA_BUF_SYNC_END)
|
#define DMA_BUF_BASE 'b'
|
#define DMA_BUF_IOCTL_SYNC _IOW(DMA_BUF_BASE, 0, struct dma_buf_sync)
|
|
void MediaBuffer::BeginCPUAccess(bool readonly)
|
{
|
struct dma_buf_sync sync = {0};
|
|
if (fd < 0) {
|
return;
|
}
|
|
if (readonly) {
|
sync.flags = DMA_BUF_SYNC_READ | DMA_BUF_SYNC_START;
|
} else {
|
sync.flags = DMA_BUF_SYNC_RW | DMA_BUF_SYNC_START;
|
}
|
|
int ret = ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync);
|
if (ret < 0) {
|
LOG("%s: %s\n", __func__, strerror(errno));
|
}
|
}
|
|
void MediaBuffer::EndCPUAccess(bool readonly)
|
{
|
struct dma_buf_sync sync = {0};
|
|
if (fd < 0) {
|
return;
|
}
|
|
if (readonly) {
|
sync.flags = DMA_BUF_SYNC_READ | DMA_BUF_SYNC_END;
|
} else {
|
sync.flags = DMA_BUF_SYNC_RW | DMA_BUF_SYNC_END;
|
}
|
|
int ret = ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync);
|
if (ret < 0) {
|
LOG("%s: %s\n", __func__, strerror(errno));
|
}
|
}
|
|
MediaGroupBuffer* MediaGroupBuffer::Alloc(size_t size, MediaBuffer::MemType type)
|
{
|
switch (type) {
|
case MediaBuffer::MemType::MEM_COMMON:
|
return alloc_common_memory_group(size);
|
#ifdef LIBDRM
|
case MediaBuffer::MemType::MEM_HARD_WARE:
|
return alloc_drm_memory_group(size);
|
#endif
|
default:
|
LOG("unknown memtype\n");
|
return nullptr;
|
}
|
}
|
|
BufferPool::BufferPool(int cnt, int size, MediaBuffer::MemType type)
|
{
|
bool sucess = true;
|
|
if (cnt <= 0) {
|
LOG("ERROR: BufferPool: cnt:%d is invalid!\n", cnt);
|
return;
|
}
|
|
for (int i = 0; i < cnt; i++) {
|
auto mgb = MediaGroupBuffer::Alloc(size, type);
|
if (!mgb) {
|
sucess = false;
|
break;
|
}
|
mgb->SetBufferPool(this);
|
LOGD("Create: pool:%p, mgb:%p, ptr:%p, fd:%d, size:%zu\n", this, mgb, mgb->GetPtr(), mgb->GetFD(),
|
mgb->GetSize());
|
ready_buffers.push_back(mgb);
|
}
|
|
if (!sucess) {
|
while (ready_buffers.size() > 0) {
|
ready_buffers.pop_front();
|
}
|
LOG("ERROR: BufferPool: Create buffer pool failed! Please check space is "
|
"enough!\n");
|
return;
|
}
|
buf_cnt = cnt;
|
buf_size = size;
|
LOGD("BufferPool: Create buffer pool:%p, size:%d, cnt:%d\n", this, size, cnt);
|
}
|
|
BufferPool::~BufferPool()
|
{
|
int cnt = 0;
|
int wait_times = 30;
|
|
while (busy_buffers.size() > 0) {
|
if (wait_times-- <= 0) {
|
LOG("ERROR: BufferPool: waiting bufferpool free for 900ms, TimeOut!\n");
|
break;
|
}
|
easymedia::usleep(30000); // wait 30ms
|
}
|
|
MediaGroupBuffer* mgb = NULL;
|
while (ready_buffers.size() > 0) {
|
mgb = ready_buffers.front();
|
ready_buffers.pop_front();
|
LOGD("BufferPool: #%02d Destroy buffer pool(ready):[%p,%p]\n", cnt, this, mgb);
|
delete mgb;
|
cnt++;
|
}
|
|
while (busy_buffers.size() > 0) {
|
mgb = busy_buffers.front();
|
busy_buffers.pop_front();
|
LOG("WARN: BufferPool: #%02d Destroy buffer pool(busy):[%p,%p]\n", cnt, this, mgb);
|
delete mgb;
|
cnt++;
|
}
|
}
|
|
static int __groupe_buffer_free(void* data)
|
{
|
assert(data);
|
if (data == NULL) {
|
LOG("ERROR: BufferPool: free ptr is null!\n");
|
return 0;
|
}
|
MediaGroupBuffer* mgb = (MediaGroupBuffer*)data;
|
if (mgb->pool == NULL) {
|
LOG("ERROR: BufferPool: free pool ptr is null!\n");
|
return 0;
|
}
|
|
BufferPool* bp = (BufferPool*)mgb->pool;
|
|
return bp->PutBuffer(mgb);
|
}
|
|
std::shared_ptr<MediaBuffer> BufferPool::GetBuffer(bool block)
|
{
|
AutoLockMutex _alm(mtx);
|
|
while (1) {
|
if (!ready_buffers.size()) {
|
if (block) {
|
mtx.wait();
|
} else {
|
return nullptr;
|
}
|
}
|
// mtx.notify wake up all mtx.wait.
|
if (ready_buffers.size() > 0) {
|
break;
|
}
|
}
|
|
auto mgb = ready_buffers.front();
|
ready_buffers.pop_front();
|
busy_buffers.push_back(mgb);
|
|
auto&& mb =
|
std::make_shared<MediaBuffer>(mgb->GetPtr(), mgb->GetSize(), mgb->GetFD(), mgb, __groupe_buffer_free);
|
return mb;
|
}
|
|
int BufferPool::PutBuffer(MediaGroupBuffer* mgb)
|
{
|
std::list<MediaGroupBuffer*>::iterator it;
|
bool sucess = false;
|
AutoLockMutex _alm(mtx);
|
|
for (it = busy_buffers.begin(); it != busy_buffers.end();) {
|
if (*it == mgb) {
|
sucess = true;
|
it = busy_buffers.erase(it);
|
ready_buffers.push_back(mgb);
|
mtx.notify();
|
break;
|
}
|
it++;
|
}
|
|
if (!sucess) {
|
LOG("ERROR: BufferPool: Unknow media group buffer:%p\n", mgb);
|
}
|
|
return sucess ? 0 : -1;
|
}
|
|
void BufferPool::DumpInfo()
|
{
|
int id = 0;
|
LOG("##BufferPool DumpInfo:%p\n", this);
|
LOG("\tcnt:%d\n", buf_cnt);
|
LOG("\tsize:%zu\n", buf_size);
|
LOG("\tready buffers(%d):\n", ready_buffers.size());
|
for (auto dev : ready_buffers)
|
LOG("\t #%02d Pool:%p, mgb:%p, ptr:%p\n", id++, dev->pool, dev, dev->GetPtr());
|
LOG("\tbusy buffers(%d):\n", busy_buffers.size());
|
id = 0;
|
for (auto dev : busy_buffers)
|
LOG("\t #%02d Pool:%p, mgb:%p, ptr:%p\n", id++, dev->pool, dev, dev->GetPtr());
|
}
|
|
} // namespace easymedia
|
