static struct wl_buffer *
create_buffer() {
struct wl_shm_pool *pool;
int stride = WIDTH * 4; // 4 bytes per pixel
int size = stride * HEIGHT;
int fd;
struct wl_buffer *buff;
fd = os_create_anonymous_file(size);
if (fd < 0) {
fprintf(stderr, "creating a buffer file for %d B failed: %m\n",
size);
exit(1);
}
shm_data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (shm_data == MAP_FAILED) {
fprintf(stderr, "mmap failed: %m\n");
close(fd);
exit(1);
}
pool = wl_shm_create_pool(shm, fd, size);
buff = wl_shm_pool_create_buffer(pool, 0,
WIDTH, HEIGHT,
stride,
WL_SHM_FORMAT_XRGB8888);
//wl_buffer_add_listener(buffer, &buffer_listener, buffer);
wl_shm_pool_destroy(pool);
return buff;
}
struct wl_buffer *
gst_wl_shm_memory_construct_wl_buffer (GstMemory * mem, GstWlDisplay * display,
const GstVideoInfo * info)
{
GstWlShmMemory *shm_mem = (GstWlShmMemory *) mem;
gint width, height, stride;
gsize size;
enum wl_shm_format format;
struct wl_shm_pool *wl_pool;
struct wl_buffer *wbuffer;
width = GST_VIDEO_INFO_WIDTH (info);
height = GST_VIDEO_INFO_HEIGHT (info);
stride = GST_VIDEO_INFO_PLANE_STRIDE (info, 0);
size = GST_VIDEO_INFO_SIZE (info);
format = gst_video_format_to_wl_shm_format (GST_VIDEO_INFO_FORMAT (info));
g_return_val_if_fail (gst_is_wl_shm_memory (mem), NULL);
g_return_val_if_fail (size <= mem->size, NULL);
g_return_val_if_fail (shm_mem->fd != -1, NULL);
GST_DEBUG_OBJECT (mem->allocator, "Creating wl_buffer of size %"
G_GSSIZE_FORMAT " (%d x %d, stride %d), format %s", size, width, height,
stride, gst_wl_shm_format_to_string (format));
wl_pool = wl_shm_create_pool (display->shm, shm_mem->fd, mem->size);
wbuffer = wl_shm_pool_create_buffer (wl_pool, 0, width, height, stride,
format);
close (shm_mem->fd);
shm_mem->fd = -1;
wl_shm_pool_destroy (wl_pool);
return wbuffer;
}
void noia_controller_create_shm_buffer(NoiaScreenshooter* shooter,
NoiaCtlOutput* ctl_output)
{
unsigned stride = 4 * ctl_output->w;
unsigned size = stride * ctl_output->h;
char name[32];
snprintf(name, sizeof(name), "shm-output-%d", ctl_output->id);
int fd = noia_environment_open_file(name, size, RUNTIME_PATH);
if (fd < 0) {
printf("Creating a buffer file for %u bytes failed! (%m)\n", size);
return;
}
ctl_output->data =
(uint8_t*) mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (ctl_output->data == MAP_FAILED) {
printf("Creating shared memory map failed! (%m)\n");
close(fd);
return;
}
struct wl_shm_pool* pool = wl_shm_create_pool(shooter->shm, fd, size);
ctl_output->buffer =
wl_shm_pool_create_buffer(pool, 0, ctl_output->w, ctl_output->h,
stride, WL_SHM_FORMAT_XRGB8888);
wl_shm_pool_destroy(pool);
close(fd);
}
static void
create_shm_buffer(struct touch *touch)
{
struct wl_shm_pool *pool;
int fd, size, stride;
stride = touch->width * 4;
size = stride * touch->height;
fd = os_create_anonymous_file(size);
if (fd < 0) {
fprintf(stderr, "creating a buffer file for %d B failed: %m\n",
size);
exit(1);
}
touch->data =
mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (touch->data == MAP_FAILED) {
fprintf(stderr, "mmap failed: %m\n");
close(fd);
exit(1);
}
pool = wl_shm_create_pool(touch->shm, fd, size);
touch->buffer =
wl_shm_pool_create_buffer(pool, 0,
touch->width, touch->height, stride,
WL_SHM_FORMAT_ARGB8888);
wl_shm_pool_destroy(pool);
close(fd);
}
static void
_destroy_buffer (BufferData *buffer)
{
if (!buffer)
return;
buffer->disposed = TRUE;
/* If the buffer is acquired by the compositor, don't free it
* yet, but wait until it's been released.
*/
if (!buffer->released)
return;
if (buffer->surface)
cairo_surface_destroy (buffer->surface);
if (buffer->wl_buffer)
wl_buffer_destroy (buffer->wl_buffer);
if (buffer->wl_pool)
wl_shm_pool_destroy (buffer->wl_pool);
if (buffer->data && buffer->data_len)
munmap (buffer->data, buffer->data_len);
g_free (buffer);
}
static struct wl_buffer *
create_bad_shm_buffer(struct client *client, int width, int height)
{
struct wl_shm *shm = client->wl_shm;
int stride = width * 4;
int size = stride * height;
struct wl_shm_pool *pool;
struct wl_buffer *buffer;
int fd;
fd = os_create_anonymous_file(size);
assert(fd >= 0);
pool = wl_shm_create_pool(shm, fd, size);
buffer = wl_shm_pool_create_buffer(pool, 0, width, height, stride,
WL_SHM_FORMAT_ARGB8888);
wl_shm_pool_destroy(pool);
/* Truncate the file to a small size, so that the compositor
* will access it out-of-bounds, and hit SIGBUS.
*/
assert(ftruncate(fd, 12) == 0);
close(fd);
return buffer;
}
struct wl_buffer *
create_shm_buffer(struct client *client, int width, int height, void **pixels)
{
struct wl_shm *shm = client->wl_shm;
int stride = width * 4;
int size = stride * height;
struct wl_shm_pool *pool;
struct wl_buffer *buffer;
int fd;
void *data;
fd = os_create_anonymous_file(size);
assert(fd >= 0);
data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (data == MAP_FAILED) {
close(fd);
assert(data != MAP_FAILED);
}
pool = wl_shm_create_pool(shm, fd, size);
buffer = wl_shm_pool_create_buffer(pool, 0, width, height, stride,
WL_SHM_FORMAT_ARGB8888);
wl_shm_pool_destroy(pool);
close(fd);
if (pixels)
*pixels = data;
return buffer;
}
static void
shm_pool_destroy (struct shm_pool *pool)
{
munmap (pool->data, pool->size);
wl_shm_pool_destroy (pool->pool);
free (pool);
}
static void wl_callback_done(void* data, struct wl_callback* callback, uint32_t time)
{
wlfWindow* window = data;
wlfBuffer* buffer;
struct wl_shm_pool* shm_pool;
void* shm_data;
void* free_data;
int fd;
int fdt;
if (!window->buffers[0].busy)
buffer = &window->buffers[0];
else if (!window->buffers[1].busy)
buffer = &window->buffers[1];
else
return;
if (!buffer->buffer) {
fd = shm_open("/wlfreerdp_shm", O_CREAT | O_RDWR, 0666);
fdt = ftruncate(fd, window->width * window->height * 4);
if (fdt != 0)
{
WLog_ERR(TAG, "window_redraw: could not allocate memory");
close(fd);
return;
}
shm_data = mmap(NULL, window->width * window->height * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (shm_data == MAP_FAILED)
{
WLog_ERR(TAG, "window_redraw: failed to memory map buffer");
close(fd);
return;
}
shm_pool = wl_shm_create_pool(window->display->shm, fd, window->width * window->height * 4);
buffer->buffer = wl_shm_pool_create_buffer(shm_pool, 0, window->width, window->height, window->width* 4, WL_SHM_FORMAT_XRGB8888);
wl_buffer_add_listener(buffer->buffer, &wl_buffer_listener, buffer);
wl_shm_pool_destroy(shm_pool);
shm_unlink("/wlfreerdp_shm");
close(fd);
free_data = buffer->shm_data;
buffer->shm_data = shm_data;
munmap(free_data, window->width * window->height * 4);
}
/* this is the real surface data */
memcpy(buffer->shm_data, (void*) window->data, window->width * window->height * 4);
wl_surface_attach(window->surface, buffer->buffer, 0, 0);
wl_surface_damage(window->surface, 0, 0, window->width, window->height);
if (callback) wl_callback_destroy(callback);
window->callback = wl_surface_frame(window->surface);
wl_callback_add_listener(window->callback, &wl_callback_listener, window);
wl_surface_commit(window->surface);
buffer->busy = TRUE;
}
int UwacWindowShmAllocBuffers(UwacWindow* w, int nbuffers, int allocSize, uint32_t width,
uint32_t height, enum wl_shm_format format)
{
int ret = UWAC_SUCCESS;
UwacBuffer* newBuffers;
int i, fd;
void* data;
struct wl_shm_pool* pool;
newBuffers = realloc(w->buffers, (w->nbuffers + nbuffers) * sizeof(UwacBuffer));
if (!newBuffers)
return UWAC_ERROR_NOMEMORY;
w->buffers = newBuffers;
memset(w->buffers + w->nbuffers, 0, sizeof(UwacBuffer) * nbuffers);
fd = uwac_create_anonymous_file(allocSize * nbuffers);
if (fd < 0)
{
return UWAC_ERROR_INTERNAL;
}
data = mmap(NULL, allocSize * nbuffers, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (data == MAP_FAILED)
{
ret = UWAC_ERROR_NOMEMORY;
goto error_mmap;
}
pool = wl_shm_create_pool(w->display->shm, fd, allocSize * nbuffers);
if (!pool)
{
ret = UWAC_ERROR_NOMEMORY;
goto error_mmap;
}
for (i = 0; i < nbuffers; i++)
{
UwacBuffer* buffer = &w->buffers[w->nbuffers + i];
#ifdef HAVE_PIXMAN_REGION
pixman_region32_init(&buffer->damage);
#else
region16_init(&buffer->damage);
#endif
buffer->data = data + (allocSize * i);
buffer->wayland_buffer = wl_shm_pool_create_buffer(pool, allocSize * i, width, height, w->stride,
format);
wl_buffer_add_listener(buffer->wayland_buffer, &buffer_listener, buffer);
}
wl_shm_pool_destroy(pool);
w->nbuffers += nbuffers;
error_mmap:
close(fd);
return ret;
}
void hello_free_memory_pool(struct wl_shm_pool *pool)
{
struct pool_data *data;
data = wl_shm_pool_get_user_data(pool);
wl_shm_pool_destroy(pool);
munmap(data->memory, data->capacity*sizeof(pixel));
free(data);
}
static void Prepare(vout_display_t *vd, picture_t *pic, subpicture_t *subpic,
vlc_tick_t date)
{
VLC_UNUSED(date);
vout_display_sys_t *sys = vd->sys;
struct wl_display *display = sys->embed->display.wl;
struct wl_surface *surface = sys->embed->handle.wl;
struct picture_buffer_t *picbuf = pic->p_sys;
if (picbuf->fd == -1)
return;
struct buffer_data *d = malloc(sizeof (*d));
if (unlikely(d == NULL))
return;
d->picture = pic;
d->counter = &sys->active_buffers;
off_t offset = picbuf->offset;
const size_t stride = pic->p->i_pitch;
const size_t size = pic->p->i_lines * stride;
struct wl_shm_pool *pool;
struct wl_buffer *buf;
pool = wl_shm_create_pool(sys->shm, picbuf->fd, offset + size);
if (pool == NULL)
{
free(d);
return;
}
if (sys->viewport == NULL) /* Poor man's crop */
offset += 4 * vd->fmt.i_x_offset
+ pic->p->i_pitch * vd->fmt.i_y_offset;
buf = wl_shm_pool_create_buffer(pool, offset, vd->fmt.i_visible_width,
vd->fmt.i_visible_height, stride,
WL_SHM_FORMAT_XRGB8888);
wl_shm_pool_destroy(pool);
if (buf == NULL)
{
free(d);
return;
}
picture_Hold(pic);
wl_buffer_add_listener(buf, &buffer_cbs, d);
wl_surface_attach(surface, buf, 0, 0);
wl_surface_damage(surface, 0, 0, sys->display_width, sys->display_height);
wl_display_flush(display);
sys->active_buffers++;
(void) subpic;
}
static block_t *Shoot(demux_t *demux)
{
demux_sys_t *sys = demux->p_sys;
int fd = vlc_memfd();
if (fd == -1)
{
msg_Err(demux, "buffer creation error: %s", vlc_strerror_c(errno));
return NULL;
}
/* NOTE: one extra line for overflow if screen-left > 0 */
uint32_t pitch = 4u * sys->width;
size_t size = (pitch * (sys->height + 1) + sys->pagemask) & ~sys->pagemask;
block_t *block = NULL;
if (ftruncate(fd, size) < 0)
{
msg_Err(demux, "buffer allocation error: %s", vlc_strerror_c(errno));
goto out;
}
struct wl_shm_pool *pool = wl_shm_create_pool(sys->shm, fd, size);
if (pool == NULL)
goto out;
struct wl_buffer *buffer;
buffer = wl_shm_pool_create_buffer(pool, 0, sys->width, sys->height,
pitch, WL_SHM_FORMAT_XRGB8888);
wl_shm_pool_destroy(pool);
if (buffer == NULL)
goto out;
sys->done = false;
screenshooter_shoot(sys->screenshooter, sys->output, buffer);
while (!sys->done)
wl_display_roundtrip(sys->display);
wl_buffer_destroy(buffer);
block = block_File(fd, true);
if (block != NULL)
{
size_t skip = (sys->y * sys->width + sys->x) * 4;
block->p_buffer += skip;
block->i_buffer -= skip;
}
out:
vlc_close(fd);
return block;
}
void shm_buffer_destroy(shm_buffer_t *buffer)
{
if (!buffer)
return;
wl_buffer_destroy(buffer->buffer);
wl_shm_pool_destroy(buffer->shm_pool);
munmap(buffer->data, buffer->pool_size);
close(buffer->fd);
free(buffer);
}
static void
draw_initial_frame(struct wayland_output *output)
{
struct wayland_compositor *c =
(struct wayland_compositor *) output->base.compositor;
struct wl_shm *shm = c->parent.shm;
struct wl_surface *surface = output->parent.surface;
struct wl_shm_pool *pool;
struct wl_buffer *buffer;
int width, height, stride;
int size;
int fd;
void *data;
width = output->mode.width + c->border.left + c->border.right;
height = output->mode.height + c->border.top + c->border.bottom;
stride = width * 4;
size = height * stride;
fd = os_create_anonymous_file(size);
if (fd < 0) {
perror("os_create_anonymous_file");
return;
}
data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (data == MAP_FAILED) {
perror("mmap");
close(fd);
return;
}
pool = wl_shm_create_pool(shm, fd, size);
buffer = wl_shm_pool_create_buffer(pool, 0,
width, height,
stride,
WL_SHM_FORMAT_ARGB8888);
wl_buffer_add_listener(buffer, &buffer_listener, buffer);
wl_shm_pool_destroy(pool);
close(fd);
memset(data, 0, size);
wl_surface_attach(surface, buffer, 0, 0);
/* We only need to damage some part, as its only transparant
* pixels anyway. */
wl_surface_damage(surface, 0, 0, 1, 1);
}
uint8_t fini_wayland_buffer(struct wayland *wayland)
{
uint8_t exit_code = 0;
wl_buffer_destroy(wayland->back_buffer);
wl_buffer_destroy(wayland->front_buffer);
wl_shm_pool_destroy(wayland->shm_pool);
if (munmap(wayland->data, wayland->capacity) < 0) {
exit_code |= EXIT_CODE_OS_ERROR_BIT;
}
if (close(wayland->fd) < 0) {
exit_code |= EXIT_CODE_OS_ERROR_BIT;
}
return exit_code;
}
/*****************************************************************************
* local functions
****************************************************************************/
static void createShmBuffer()
{
struct wl_shm_pool *pool;
char filename[] = "/tmp/wayland-shm-XXXXXX";
int fd = -1;
int size = 0;
fd = mkstemp(filename);
if (fd < 0){
fprintf(stderr, "open %s failed: %m\n", filename);
return;
}
size = g_wlContextStruct.ctx_bmp->stride * g_wlContextStruct.ctx_bmp->height;
if (ftruncate(fd, size) < 0){
fprintf(stderr, "ftruncate failed: %m\n");
close(fd);
return;
}
g_wlContextStruct.data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (MAP_FAILED == g_wlContextStruct.data)
{
fprintf(stderr, "mmap failed: %m\n");
close(fd);
return;
}
pool = wl_shm_create_pool(g_wlContextStruct.wlShm, fd, size);
g_wlContextStruct.wlBuffer = wl_shm_pool_create_buffer(pool, 0, g_wlContextStruct.ctx_bmp->width,
g_wlContextStruct.ctx_bmp->height,
g_wlContextStruct.ctx_bmp->stride,
WL_SHM_FORMAT_XRGB8888);
if (NULL == g_wlContextStruct.wlBuffer)
{
fprintf(stderr, "wl_shm_create_buffer failed: %m\n");
close(fd);
return;
}
wl_surface_attach(g_wlContextStruct.wlSurface, g_wlContextStruct.wlBuffer, 0, 0);
wl_shm_pool_destroy(pool);
close(fd);
return;
}
wl_buffer* createShmBuffer(wl_shm* shm, uint32_t width, uint32_t height) {
int32_t stride = width * 4;
int32_t size = stride * height;
int fd = createAnonymousFile(size);
mData = reinterpret_cast<uint8_t*>(
mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
if (mData == MAP_FAILED) {
close(fd);
throw WLException("Cannot create shm buffer");
}
wl_shm_pool* pool = wl_shm_create_pool(shm, fd, size);
wl_buffer* buff =
wl_shm_pool_create_buffer(pool, 0, width, height, stride, WL_SHM_FORMAT_XRGB8888);
wl_shm_pool_destroy(pool);
close(fd);
return buff;
}
static struct wl_buffer *
create_shm_buffer(struct display *display,
int width, int height, uint32_t format, void **data_out)
{
char filename[] = "/tmp/wayland-shm-XXXXXX";
struct wl_shm_pool *pool;
struct wl_buffer *buffer;
int fd, size, stride;
void *data;
fd = mkstemp(filename);
if (fd < 0) {
fprintf(stderr, "open %s failed: %m\n", filename);
return NULL;
}
stride = width * 4;
size = stride * height;
if (ftruncate(fd, size) < 0) {
fprintf(stderr, "ftruncate failed: %m\n");
close(fd);
return NULL;
}
data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
unlink(filename);
if (data == MAP_FAILED) {
fprintf(stderr, "mmap failed: %m\n");
close(fd);
return NULL;
}
pool = wl_shm_create_pool(display->shm, fd, size);
buffer = wl_shm_pool_create_buffer(pool, 0,
width, height, stride, format);
wl_shm_pool_destroy(pool);
close(fd);
*data_out = data;
return buffer;
}
static void
_evas_swapper_shm_pool_free(Wl_Swapper *ws)
{
LOGFN(__FILE__, __LINE__, __FUNCTION__);
/* check for valid swapper */
if (!ws) return;
/* check for valid pool */
if (!ws->pool) return;
/* unmap any existing data */
if (ws->data) munmap(ws->data, ws->pool_size);
/* destroy the shm pool */
wl_shm_pool_destroy(ws->pool);
ws->pool_size = 0;
ws->used_size = 0;
}
struct wl_buffer *
gst_wl_shm_memory_construct_wl_buffer (GstMemory * mem, GstWlDisplay * display,
const GstVideoInfo * info)
{
gint width, height, stride;
gsize offset, size, memsize, maxsize;
enum wl_shm_format format;
struct wl_shm_pool *wl_pool;
struct wl_buffer *wbuffer;
if (!gst_wl_shm_validate_video_info (info)) {
GST_DEBUG_OBJECT (display, "Unsupported strides and offsets.");
return NULL;
}
width = GST_VIDEO_INFO_WIDTH (info);
height = GST_VIDEO_INFO_HEIGHT (info);
stride = GST_VIDEO_INFO_PLANE_STRIDE (info, 0);
size = GST_VIDEO_INFO_SIZE (info);
format = gst_video_format_to_wl_shm_format (GST_VIDEO_INFO_FORMAT (info));
memsize = gst_memory_get_sizes (mem, &offset, &maxsize);
offset += GST_VIDEO_INFO_PLANE_OFFSET (info, 0);
g_return_val_if_fail (gst_is_fd_memory (mem), NULL);
g_return_val_if_fail (size <= memsize, NULL);
g_return_val_if_fail (gst_wl_display_check_format_for_shm (display,
GST_VIDEO_INFO_FORMAT (info)), NULL);
GST_DEBUG_OBJECT (display, "Creating wl_buffer from SHM of size %"
G_GSSIZE_FORMAT " (%d x %d, stride %d), format %s", size, width, height,
stride, gst_wl_shm_format_to_string (format));
wl_pool = wl_shm_create_pool (display->shm, gst_fd_memory_get_fd (mem),
memsize);
wbuffer = wl_shm_pool_create_buffer (wl_pool, offset, width, height, stride,
format);
wl_shm_pool_destroy (wl_pool);
return wbuffer;
}
static void
gst_wayland_buffer_destroy (GstWaylandSink * sink, GstWlBuffer * buffer)
{
if (buffer->wlsink) {
buffer->wlsink = NULL;
gst_object_unref (sink);
}
if (buffer->wbuffer) {
wl_buffer_destroy (buffer->wbuffer);
buffer->wbuffer = NULL;
}
if (buffer->pool) {
wl_shm_pool_destroy (buffer->pool);
buffer->pool = NULL;
}
GST_MINI_OBJECT_CLASS (gst_wlbuffer_parent_class)->finalize (GST_MINI_OBJECT
(buffer));
}
static gboolean
gst_wayland_buffer_pool_stop (GstBufferPool * pool)
{
GstWaylandBufferPool *self = GST_WAYLAND_BUFFER_POOL (pool);
GST_DEBUG_OBJECT (self, "Stopping wayland buffer pool");
munmap (self->data, self->size);
wl_shm_pool_destroy (self->wl_pool);
self->wl_pool = NULL;
self->size = 0;
self->used = 0;
/* all buffers are about to be destroyed;
* we should no longer do anything with them */
g_mutex_lock (&self->buffers_map_mutex);
g_hash_table_remove_all (self->buffers_map);
g_mutex_unlock (&self->buffers_map_mutex);
return GST_BUFFER_POOL_CLASS (parent_class)->stop (pool);
}
xdl_int XdevLWindowWayland::createBuffer() {
// Couldn't create anonymous file.
m_fd = createAnonymousFile(getWidth() * getHeight() * 4);
if(-1 == m_fd) {
XDEVL_MODULE_ERROR("mmap failed\n");
return ERR_ERROR;
}
// Couldn't map memory.
m_shm_data = (xdl_uint8*)mmap(NULL, getWidth() * getHeight() * 4, PROT_READ | PROT_WRITE, MAP_SHARED, m_fd, 0);
if(m_shm_data == MAP_FAILED) {
XDEVL_MODULE_ERROR("mmap failed\n");
close(m_fd);
return ERR_ERROR;
}
m_pool = wl_shm_create_pool(m_sharedMemory, m_fd, getWidth() * getHeight() * 4);
m_buffer = wl_shm_pool_create_buffer(m_pool, 0, getWidth(), getHeight(), getWidth() * 4, WL_SHM_FORMAT_XRGB8888);
wl_shm_pool_destroy(m_pool);
return ERR_OK;
}
static int
create_shm_buffer(struct display *display, struct buffer *buffer,
int width, int height, uint32_t format)
{
struct wl_shm_pool *pool;
int fd, size, pitch;
void *data;
pitch = width * 4;
size = pitch * height;
fd = os_create_anonymous_file(size);
if (fd < 0) {
fprintf(stderr, "creating a buffer file for %d B failed: %m\n",
size);
return -1;
}
data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (data == MAP_FAILED) {
fprintf(stderr, "mmap failed: %m\n");
close(fd);
return -1;
}
pool = wl_shm_create_pool(display->shm, fd, size);
buffer->buffer = wl_shm_pool_create_buffer(pool, 0,
width, height,
pitch, format);
wl_buffer_add_listener(buffer->buffer, &buffer_listener, buffer);
wl_shm_pool_destroy(pool);
close(fd);
buffer->shm_data = data;
return 0;
}
static struct wl_buffer *
create_shm_buffer(struct display *display,
int width, int height, uint32_t format, void **data_out)
{
struct wl_shm_pool *pool;
struct wl_buffer *buffer;
int fd, size, stride;
void *data;
stride = width * 4;
size = stride * height;
fd = os_create_anonymous_file(size);
if (fd < 0) {
fprintf(stderr, "creating a buffer file for %d B failed: %m\n",
size);
return NULL;
}
data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (data == MAP_FAILED) {
fprintf(stderr, "mmap failed: %m\n");
close(fd);
return NULL;
}
pool = wl_shm_create_pool(display->shm, fd, size);
buffer = wl_shm_pool_create_buffer(pool, 0,
width, height, stride, format);
wl_shm_pool_destroy(pool);
close(fd);
*data_out = data;
return buffer;
}
uint8_t init_wayland_buffer(struct wayland *wayland)
{
wayland->fd = syscall(SYS_memfd_create, "nes-emulator",
MFD_CLOEXEC | MFD_ALLOW_SEALING);
if (wayland->fd < 0) {
return EXIT_CODE_OS_ERROR_BIT;
}
int32_t stride = wayland->width * sizeof(uint32_t);
int32_t single_capacity = stride * wayland->height;
wayland->capacity = single_capacity * 2;
if (ftruncate(wayland->fd, wayland->capacity) < 0) {
uint8_t exit_code = EXIT_CODE_OS_ERROR_BIT;
if (close(wayland->fd) < 0) {
exit_code |= EXIT_CODE_OS_ERROR_BIT;
}
return exit_code;
}
wayland->data = mmap(NULL, wayland->capacity, PROT_WRITE | PROT_READ,
MAP_SHARED, wayland->fd, 0);
if (wayland->data == MAP_FAILED) {
uint8_t exit_code = EXIT_CODE_OS_ERROR_BIT;
if (close(wayland->fd) < 0) {
exit_code |= EXIT_CODE_OS_ERROR_BIT;
}
return exit_code;
}
wayland->front_data = wayland->data;
wayland->back_data = wayland->data + (wayland->width * wayland->height);
wayland->shm_pool = wl_shm_create_pool(wayland->shm,
wayland->fd, wayland->capacity);
if (wayland->shm_pool == NULL) {
uint8_t exit_code = EXIT_CODE_WAYLAND_BIT;
if (munmap(wayland->data, wayland->capacity) < 0) {
exit_code |= EXIT_CODE_OS_ERROR_BIT;
}
if (close(wayland->fd) < 0) {
exit_code |= EXIT_CODE_OS_ERROR_BIT;
}
return exit_code;
}
wayland->front_buffer = wl_shm_pool_create_buffer(
wayland->shm_pool, 0, wayland->width, wayland->height,
stride, WL_SHM_FORMAT_ARGB8888);
if (wayland->front_buffer == NULL) {
uint8_t exit_code = EXIT_CODE_WAYLAND_BIT;
wl_shm_pool_destroy(wayland->shm_pool);
if (munmap(wayland->data, wayland->capacity) < 0) {
exit_code |= EXIT_CODE_OS_ERROR_BIT;
}
if (close(wayland->fd) < 0) {
exit_code |= EXIT_CODE_OS_ERROR_BIT;
}
return exit_code;
}
wayland->back_buffer = wl_shm_pool_create_buffer(
wayland->shm_pool, single_capacity,
wayland->width, wayland->height,
stride, WL_SHM_FORMAT_ARGB8888);
if (wayland->back_buffer == NULL) {
uint8_t exit_code = EXIT_CODE_WAYLAND_BIT;
wl_buffer_destroy(wayland->front_buffer);
wl_shm_pool_destroy(wayland->shm_pool);
if (munmap(wayland->data, wayland->capacity) < 0) {
exit_code |= EXIT_CODE_OS_ERROR_BIT;
}
if (close(wayland->fd) < 0) {
exit_code |= EXIT_CODE_OS_ERROR_BIT;
}
return exit_code;
}
return 0;
}
static gboolean
_eventd_nd_wl_create_buffer(EventdNdSurface *self)
{
struct wl_shm_pool *pool;
struct wl_buffer *buffer;
gint fd;
gpointer data;
gint width, height, stride;
gsize size;
width = self->width * self->context->scale;
height = self->height * self->context->scale;
stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
size = stride * height;
gchar *filename;
filename = g_build_filename(g_get_user_runtime_dir(), PACKAGE_NAME G_DIR_SEPARATOR_S "wayland-surface", NULL);
fd = g_open(filename, O_CREAT | O_RDWR | O_CLOEXEC, 0);
g_unlink(filename);
g_free(filename);
if ( fd < 0 )
{
g_warning("creating a buffer file for %zu B failed: %s\n", size, g_strerror(errno));
return FALSE;
}
if ( ftruncate(fd, size) < 0 )
{
close(fd);
return FALSE;
}
data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if ( data == MAP_FAILED )
{
g_warning("mmap failed: %s\n", g_strerror(errno));
close(fd);
return FALSE;
}
cairo_surface_t *cairo_surface;
cairo_surface = cairo_image_surface_create_for_data(data, CAIRO_FORMAT_ARGB32, width, height, 4 * width);
cairo_surface_set_device_scale(cairo_surface, self->context->scale, self->context->scale);
self->context->nd->notification_draw(self->notification, cairo_surface, TRUE);
cairo_surface_destroy(cairo_surface);
munmap(data, size);
pool = wl_shm_create_pool(self->context->shm, fd, size);
buffer = wl_shm_pool_create_buffer(pool, 0, width, height, stride, WL_SHM_FORMAT_ARGB8888);
wl_shm_pool_destroy(pool);
close(fd);
if ( self->buffer != NULL )
_eventd_nd_wl_buffer_release(self->buffer, self->buffer->buffer);
self->buffer = g_new0(EventdNdWlBuffer, 1);
self->buffer->buffer = buffer;
self->buffer->data = data;
self->buffer->size = size;
wl_buffer_add_listener(buffer, &_eventd_nd_wl_buffer_listener, self->buffer);
wl_surface_damage(self->surface, 0, 0, self->width, self->height);
wl_surface_attach(self->surface, self->buffer->buffer, 0, 0);
if ( wl_surface_get_version(self->surface) >= WL_SURFACE_SET_BUFFER_SCALE_SINCE_VERSION )
wl_surface_set_buffer_scale(self->surface, self->context->scale);
wl_surface_commit(self->surface);
return TRUE;
}
ShmBuffer::~ShmBuffer()
{
munmap(image.bits(), image.byteCount());
wl_buffer_destroy(handle);
wl_shm_pool_destroy(shm_pool);
}
QWaylandShmBuffer::~QWaylandShmBuffer(void)
{
delete mMarginsImage;
munmap((void *) mImage.constBits(), mImage.byteCount());
wl_buffer_destroy(mBuffer);
wl_shm_pool_destroy(mShmPool);
}
