static struct drm_fb *drm_fb_get_from_bo(struct gbm_bo *bo)
{
int ret;
unsigned width, height, stride, handle;
struct drm_fb *fb = (struct drm_fb*)gbm_bo_get_user_data(bo);
if (fb)
return fb;
fb = (struct drm_fb*)calloc(1, sizeof(*fb));
fb->bo = bo;
width = gbm_bo_get_width(bo);
height = gbm_bo_get_height(bo);
stride = gbm_bo_get_stride(bo);
handle = gbm_bo_get_handle(bo).u32;
RARCH_LOG("[KMS]: New FB: %ux%u (stride: %u).\n",
width, height, stride);
ret = drmModeAddFB(g_drm_fd, width, height, 24, 32,
stride, handle, &fb->fb_id);
if (ret < 0)
goto error;
gbm_bo_set_user_data(bo, fb, drm_fb_destroy_callback);
return fb;
error:
RARCH_ERR("[KMS]: Failed to create FB: %s\n", strerror(errno));
free(fb);
return NULL;
}
static void
swap(struct gbm_winsys *winsys)
{
struct gbm_dev *dev = winsys->dev;
struct gbm_context *context = winsys->context;
struct gbm_bo *bo;
uint32_t handle, stride;
uint32_t width, height;
uint32_t fb_id;
eglSwapBuffers(context->edpy, context->egl_surface);
bo = gbm_surface_lock_front_buffer(context->gbm_surface);
width = gbm_bo_get_width(bo);
height = gbm_bo_get_height(bo);
stride = gbm_bo_get_stride(bo);
handle = gbm_bo_get_handle(bo).u32;
if (drmModeAddFB(dev->fd,
width, height,
24, /* depth */
32, /* bpp */
stride,
handle,
&fb_id)) {
fprintf(stderr,
"Failed to create new back buffer handle: %m\n");
} else {
if (dev->saved_crtc == NULL &&
set_initial_crtc(dev, fb_id))
return;
if (drmModePageFlip(dev->fd,
dev->crtc,
fb_id,
DRM_MODE_PAGE_FLIP_EVENT,
dev)) {
fprintf(stderr, "Failed to page flip: %m\n");
return;
}
dev->pending_swap = 1;
wait_swap(dev);
free_current_bo(context);
context->current_bo = bo;
context->current_fb_id = fb_id;
}
}
static PixmapPtr
xwl_glamor_create_pixmap_for_bo(ScreenPtr screen, struct gbm_bo *bo, int depth)
{
PixmapPtr pixmap;
struct xwl_pixmap *xwl_pixmap;
struct xwl_screen *xwl_screen = xwl_screen_get(screen);
xwl_pixmap = malloc(sizeof *xwl_pixmap);
if (xwl_pixmap == NULL)
return NULL;
pixmap = glamor_create_pixmap(screen,
gbm_bo_get_width(bo),
gbm_bo_get_height(bo),
depth,
GLAMOR_CREATE_PIXMAP_NO_TEXTURE);
if (pixmap == NULL) {
free(xwl_pixmap);
return NULL;
}
if (lastGLContext != xwl_screen->glamor_ctx) {
lastGLContext = xwl_screen->glamor_ctx;
xwl_glamor_egl_make_current(xwl_screen->glamor_ctx);
}
xwl_pixmap->bo = bo;
xwl_pixmap->buffer = NULL;
xwl_pixmap->image = eglCreateImageKHR(xwl_screen->egl_display,
xwl_screen->egl_context,
EGL_NATIVE_PIXMAP_KHR,
xwl_pixmap->bo, NULL);
glGenTextures(1, &xwl_pixmap->texture);
glBindTexture(GL_TEXTURE_2D, xwl_pixmap->texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, xwl_pixmap->image);
glBindTexture(GL_TEXTURE_2D, 0);
xwl_pixmap_set_private(pixmap, xwl_pixmap);
glamor_set_pixmap_texture(pixmap, xwl_pixmap->texture);
glamor_set_pixmap_type(pixmap, GLAMOR_TEXTURE_DRM);
return pixmap;
}
drm_fb * CDRMUtils::DrmFbGetFromBo(struct gbm_bo *bo)
{
{
struct drm_fb *fb = static_cast<drm_fb *>(gbm_bo_get_user_data(bo));
if(fb)
{
return fb;
}
}
struct drm_fb *fb = new drm_fb;
fb->bo = bo;
uint32_t width,
height,
handles[4] = {0},
strides[4] = {0},
offsets[4] = {0};
width = gbm_bo_get_width(bo);
height = gbm_bo_get_height(bo);
handles[0] = gbm_bo_get_handle(bo).u32;
strides[0] = gbm_bo_get_stride(bo);
memset(offsets, 0, 16);
auto ret = drmModeAddFB2(m_fd,
width,
height,
m_primary_plane->format,
handles,
strides,
offsets,
&fb->fb_id,
0);
if(ret)
{
delete (fb);
CLog::Log(LOGDEBUG, "CDRMUtils::%s - failed to add framebuffer", __FUNCTION__);
return nullptr;
}
gbm_bo_set_user_data(bo, fb, DrmFbDestroyCallback);
return fb;
}
void mgm::RealKMSOutput::set_cursor(gbm_bo* buffer)
{
if (current_crtc)
{
if (auto result = drmModeSetCursor(
drm_fd,
current_crtc->crtc_id,
gbm_bo_get_handle(buffer).u32,
gbm_bo_get_width(buffer),
gbm_bo_get_height(buffer)))
{
fatal_error("drmModeSetCursor failed (returned %d)", result);
}
has_cursor_ = true;
}
}
void QKmsScreen::performPageFlip()
{
if (!m_next_bo)
return;
uint32_t width = gbm_bo_get_width(m_next_bo);
uint32_t height = gbm_bo_get_height(m_next_bo);
uint32_t stride = gbm_bo_get_stride(m_next_bo);
uint32_t handle = gbm_bo_get_handle(m_next_bo).u32;
uint32_t fb_id;
int ret = drmModeAddFB(m_device->fd(), width, height, 24, 32,
stride, handle, &fb_id);
if (ret) {
qFatal("kms: Failed to create fb: fd %d, w %d, h %d, stride %d, handle %d, ret %d",
m_device->fd(), width, height, stride, handle, ret);
}
if (!m_modeSet) {
//Set the Mode of the screen.
int ret = drmModeSetCrtc(m_device->fd(), m_crtcId, fb_id,
0, 0, &m_connectorId, 1, &m_mode);
if (ret)
qFatal("failed to set mode");
m_modeSet = true;
// Initialize cursor
static int hideCursor = qgetenv("QT_QPA_KMS_HIDECURSOR").toInt();
if (!hideCursor) {
QCursor cursor(Qt::ArrowCursor);
m_cursor->changeCursor(&cursor, 0);
}
}
int pageFlipStatus = drmModePageFlip(m_device->fd(), m_crtcId,
fb_id,
DRM_MODE_PAGE_FLIP_EVENT, this);
if (pageFlipStatus)
{
qWarning("Pageflip status: %d", pageFlipStatus);
gbm_surface_release_buffer(m_gbmSurface, m_next_bo);
m_next_bo = 0;
}
}
static void update_framebuffer_from_bo(
const struct MPGLContext *ctx, struct gbm_bo *bo)
{
struct priv *p = ctx->priv;
p->fb.bo = bo;
p->fb.fd = p->kms->fd;
p->fb.width = gbm_bo_get_width(bo);
p->fb.height = gbm_bo_get_height(bo);
int stride = gbm_bo_get_stride(bo);
int handle = gbm_bo_get_handle(bo).u32;
int ret = drmModeAddFB(p->kms->fd, p->fb.width, p->fb.height,
24, 32, stride, handle, &p->fb.id);
if (ret) {
MP_ERR(ctx->vo, "Failed to create framebuffer: %s\n", mp_strerror(errno));
}
gbm_bo_set_user_data(bo, &p->fb, framebuffer_destroy_callback);
}
uint32_t
update_buffer_nativesurface(struct ivi_share_nativesurface *p_nativesurface)
{
if (NULL == p_nativesurface || NULL == p_nativesurface->surface) {
return IVI_SHAREBUFFER_NOT_AVAILABLE;
}
struct drm_backend *backend =
(struct drm_backend*)p_nativesurface->surface->compositor->backend;
if (NULL == backend) {
return IVI_SHAREBUFFER_NOT_AVAILABLE;
}
struct weston_buffer *buffer = p_nativesurface->surface->buffer_ref.buffer;
if (!buffer) {
return IVI_SHAREBUFFER_NOT_AVAILABLE;
}
struct gbm_bo *bo = gbm_bo_import(backend->gbm, GBM_BO_IMPORT_WL_BUFFER,
buffer->legacy_buffer, GBM_BO_USE_SCANOUT);
if (!bo) {
weston_log("failed to import gbm_bo\n");
return IVI_SHAREBUFFER_INVALID;
}
struct drm_gem_flink flink = {0};
flink.handle = gbm_bo_get_handle(bo).u32;
if (drmIoctl(gbm_device_get_fd(backend->gbm), DRM_IOCTL_GEM_FLINK, &flink) != 0) {
weston_log("gem_flink: returned non-zero failed\n");
gbm_bo_destroy(bo);
return IVI_SHAREBUFFER_INVALID;
}
uint32_t name = flink.name;
uint32_t width = gbm_bo_get_width(bo);
uint32_t height = gbm_bo_get_height(bo);
uint32_t stride = gbm_bo_get_stride(bo);
uint32_t format = IVI_SHARE_SURFACE_FORMAT_ARGB8888;
uint32_t ret = IVI_SHAREBUFFER_STABLE;
if (name != p_nativesurface->name) {
ret |= IVI_SHAREBUFFER_DAMAGE;
}
if (width != p_nativesurface->width) {
ret |= IVI_SHAREBUFFER_CONFIGURE;
}
if (height != p_nativesurface->height) {
ret |= IVI_SHAREBUFFER_CONFIGURE;
}
if (stride != p_nativesurface->stride) {
ret |= IVI_SHAREBUFFER_CONFIGURE;
}
p_nativesurface->name = name;
p_nativesurface->width = width;
p_nativesurface->height = height;
p_nativesurface->stride = stride;
p_nativesurface->format = format;
gbm_bo_destroy(bo);
return ret;
}
