buffer: use tdm_private_layer_buffer structure for layer buffers

Change-Id: I45b5e8842328da77e9fd78bce811d018f3229431

diff --git a/src/tdm.c b/src/tdm.c
index 041d4c2..924c54c 100644 (file)
--- a/src/tdm.c
+++ b/src/tdm.c
@@ -1168,8 +1168,10 @@ tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_s
                                char str[TDM_PATH_LEN];
                                if (l->usable || l->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)
                                        continue;
+                               if (!l->showing_buffer)
+                                       continue;
                                snprintf(str, TDM_PATH_LEN, "layer_%d_%d", o->index, l->index);
-                               tdm_helper_dump_buffer_str(l->showing_buffer, path, str);
+                               tdm_helper_dump_buffer_str(l->showing_buffer->buffer, path, str);
                        }
                }
 

diff --git a/src/tdm_display.c b/src/tdm_display.c
index e468b0d..bae364e 100644 (file)
--- a/src/tdm_display.c
+++ b/src/tdm_display.c
@@ -105,6 +105,8 @@
 static void _tdm_layer_committed(tdm_private_layer *private_layer);
 static void _tdm_layer_cb_wait_vblank(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
                                                                          unsigned int tv_sec, unsigned int tv_usec, void *user_data);
+static void _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data);
+static void _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data);
 
 EXTERN tdm_error
 tdm_display_get_capabilities(tdm_display *dpy,
@@ -1758,6 +1760,7 @@ EXTERN tdm_error
 tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 {
        tdm_func_layer *func_layer;
+       tdm_private_layer_buffer *layer_buffer;
 
        LAYER_FUNC_ENTRY();
 
@@ -1787,6 +1790,13 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
                return TDM_ERROR_NOT_IMPLEMENTED;
        }
 
+       layer_buffer = calloc(1, sizeof * layer_buffer);
+       if (!layer_buffer) {
+               _pthread_mutex_unlock(&private_display->lock);
+               TDM_ERR("alloc failed");
+               return TDM_ERROR_OUT_OF_MEMORY;
+       }
+
        ret = func_layer->layer_set_buffer(private_layer->layer_backend, buffer);
        TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
@@ -1800,15 +1810,18 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
                 */
                if (private_layer->waiting_buffer) {
                        _pthread_mutex_unlock(&private_display->lock);
-                       tdm_buffer_unref_backend(private_layer->waiting_buffer);
+                       tdm_buffer_unref_backend(private_layer->waiting_buffer->buffer);
                        _pthread_mutex_lock(&private_display->lock);
+                       free(private_layer->waiting_buffer);
                }
 
-               private_layer->waiting_buffer = tdm_buffer_ref_backend(buffer);
+               private_layer->waiting_buffer = layer_buffer;
+               private_layer->waiting_buffer->buffer = tdm_buffer_ref_backend(buffer);
                if (tdm_debug_module & TDM_DEBUG_BUFFER)
                        TDM_INFO("layer(%p) waiting_buffer(%p)",
-                                        private_layer, private_layer->waiting_buffer);
-       }
+                                        private_layer, private_layer->waiting_buffer->buffer);
+       } else
+               free(layer_buffer);
 
        _pthread_mutex_unlock(&private_display->lock);
 
@@ -1826,10 +1839,21 @@ tdm_layer_unset_buffer(tdm_layer *layer)
 
        func_layer = &private_display->func_layer;
 
+       if (private_layer->buffer_queue) {
+               if (private_layer->waiting_buffer)
+                       tbm_surface_queue_release(private_layer->buffer_queue, private_layer->waiting_buffer->buffer);
+               if (private_layer->showing_buffer)
+                       tbm_surface_queue_release(private_layer->buffer_queue, private_layer->showing_buffer->buffer);
+               tbm_surface_queue_remove_acquirable_cb(private_layer->buffer_queue, _tbm_layer_queue_acquirable_cb, layer);
+               tbm_surface_queue_remove_destroy_cb(private_layer->buffer_queue, _tbm_layer_queue_destroy_cb, layer);
+               private_layer->buffer_queue = NULL;
+       }
+
        if (private_layer->waiting_buffer) {
                _pthread_mutex_unlock(&private_display->lock);
-               tdm_buffer_unref_backend(private_layer->waiting_buffer);
+               tdm_buffer_unref_backend(private_layer->waiting_buffer->buffer);
                _pthread_mutex_lock(&private_display->lock);
+               free(private_layer->waiting_buffer);
                private_layer->waiting_buffer = NULL;
 
                if (tdm_debug_module & TDM_DEBUG_BUFFER)
@@ -1839,8 +1863,9 @@ tdm_layer_unset_buffer(tdm_layer *layer)
 
        if (private_layer->showing_buffer) {
                _pthread_mutex_unlock(&private_display->lock);
-               tdm_buffer_unref_backend(private_layer->showing_buffer);
+               tdm_buffer_unref_backend(private_layer->showing_buffer->buffer);
                _pthread_mutex_lock(&private_display->lock);
+               free(private_layer->showing_buffer);
                private_layer->showing_buffer = NULL;
 
                if (tdm_debug_module & TDM_DEBUG_BUFFER)
@@ -1907,13 +1932,13 @@ _tdm_layer_committed(tdm_private_layer *private_layer)
 
        if (private_layer->showing_buffer) {
                _pthread_mutex_unlock(&private_display->lock);
-               tdm_buffer_unref_backend(private_layer->showing_buffer);
+               tdm_buffer_unref_backend(private_layer->showing_buffer->buffer);
                _pthread_mutex_lock(&private_display->lock);
 
                if (private_layer->buffer_queue) {
                        _pthread_mutex_unlock(&private_display->lock);
                        tbm_surface_queue_release(private_layer->buffer_queue,
-                                                                         private_layer->showing_buffer);
+                                                                         private_layer->showing_buffer->buffer);
                        _pthread_mutex_lock(&private_display->lock);
                }
        }
@@ -1924,7 +1949,7 @@ _tdm_layer_committed(tdm_private_layer *private_layer)
        if (tdm_debug_module & TDM_DEBUG_BUFFER)
                TDM_INFO("layer(%p) waiting_buffer(%p) showing_buffer(%p)",
                                 private_layer, private_layer->waiting_buffer,
-                                private_layer->showing_buffer);
+                                (private_layer->showing_buffer) ? private_layer->showing_buffer->buffer : NULL);
 }
 
 static void
@@ -2236,7 +2261,7 @@ tdm_layer_get_displaying_buffer(tdm_layer *layer, tdm_error *error)
                *error = TDM_ERROR_NONE;
 
        if (private_layer->showing_buffer) {
-               buffer = private_layer->showing_buffer;
+               buffer = private_layer->showing_buffer->buffer;
        } else {
                if (error)
                        *error = TDM_ERROR_OPERATION_FAILED;
@@ -2256,6 +2281,7 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
        tdm_layer *layer = data;
        tdm_func_layer *func_layer;
        tbm_surface_h surface = NULL;
+       tdm_private_layer_buffer *layer_buffer;
        LAYER_FUNC_ENTRY_VOID_RETURN();
 
        _pthread_mutex_lock(&private_display->lock);
@@ -2266,11 +2292,19 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
                return;
        }
 
+       layer_buffer = calloc(1, sizeof * layer_buffer);
+       if (!layer_buffer) {
+               _pthread_mutex_unlock(&private_display->lock);
+               TDM_ERR("alloc failed");
+               return;
+       }
+
        if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &surface) ||
                surface == NULL) {
                TDM_ERR("layer(%p) tbm_surface_queue_acquire() failed surface:%p",
                                private_layer, surface);
                _pthread_mutex_unlock(&private_display->lock);
+               free(layer_buffer);
                return;
        }
 
@@ -2279,19 +2313,21 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
 
        if (ret == TDM_ERROR_NONE) {
                if (private_layer->waiting_buffer) {
-                       TDM_DBG("layer(%p) drop waiting_buffer(%p)", private_layer, private_layer->waiting_buffer);
+                       TDM_DBG("layer(%p) drop waiting_buffer(%p)", private_layer, private_layer->waiting_buffer->buffer);
                        _pthread_mutex_unlock(&private_display->lock);
-                       tdm_buffer_unref_backend(private_layer->waiting_buffer);
+                       tdm_buffer_unref_backend(private_layer->waiting_buffer->buffer);
                        tbm_surface_queue_release(private_layer->buffer_queue,
-                                                                         private_layer->waiting_buffer);
+                                                                         private_layer->waiting_buffer->buffer);
                        _pthread_mutex_lock(&private_display->lock);
+                       free(private_layer->waiting_buffer);
                }
 
-               private_layer->waiting_buffer = tdm_buffer_ref_backend(surface);
+               private_layer->waiting_buffer = layer_buffer;
+               private_layer->waiting_buffer->buffer = tdm_buffer_ref_backend(surface);
 
                if (tdm_debug_module & TDM_DEBUG_BUFFER)
                        TDM_INFO("layer(%p) waiting_buffer(%p)",
-                                        private_layer, private_layer->waiting_buffer);
+                                        private_layer, private_layer->waiting_buffer->buffer);
 
                if (private_display->commit_type == TDM_COMMIT_TYPE_OUTPUT) {
                        ret = _tdm_output_commit(private_layer->private_output, 0, NULL, NULL);
@@ -2304,7 +2340,8 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
                } else {
                        TDM_NEVER_GET_HERE();
                }
-       }
+       } else
+               free(layer_buffer);
 
        _pthread_mutex_unlock(&private_display->lock);
 }
@@ -2321,10 +2358,12 @@ _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data)
 
        if (private_layer->waiting_buffer) {
                _pthread_mutex_unlock(&private_display->lock);
-               tdm_buffer_unref_backend(private_layer->waiting_buffer);
+               tdm_buffer_unref_backend(private_layer->waiting_buffer->buffer);
                tbm_surface_queue_release(private_layer->buffer_queue,
-                                                                 private_layer->waiting_buffer);
+                                                                 private_layer->waiting_buffer->buffer);
                _pthread_mutex_lock(&private_display->lock);
+               free(private_layer->waiting_buffer);
+               private_layer->waiting_buffer = NULL;
        }
 
        private_layer->buffer_queue = NULL;
@@ -2362,9 +2401,10 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
 
        if (private_layer->waiting_buffer) {
                _pthread_mutex_unlock(&private_display->lock);
-               tdm_buffer_unref_backend(private_layer->waiting_buffer);
+               tdm_buffer_unref_backend(private_layer->waiting_buffer->buffer);
                tbm_surface_queue_release(private_layer->buffer_queue,
-                                                                 private_layer->waiting_buffer);
+                                                                 private_layer->waiting_buffer->buffer);
+               free(private_layer->waiting_buffer);
                private_layer->waiting_buffer = NULL;
                _pthread_mutex_lock(&private_display->lock);
 
@@ -2388,58 +2428,7 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
 EXTERN tdm_error
 tdm_layer_unset_buffer_queue(tdm_layer *layer)
 {
-       tdm_func_layer *func_layer;
-       LAYER_FUNC_ENTRY();
-
-       _pthread_mutex_lock(&private_display->lock);
-
-       func_layer = &private_display->func_layer;
-
-       if (private_layer->waiting_buffer) {
-               _pthread_mutex_unlock(&private_display->lock);
-               tdm_buffer_unref_backend(private_layer->waiting_buffer);
-               tbm_surface_queue_release(private_layer->buffer_queue,
-                                                                 private_layer->waiting_buffer);
-               private_layer->waiting_buffer = NULL;
-               _pthread_mutex_lock(&private_display->lock);
-
-               if (tdm_debug_module & TDM_DEBUG_BUFFER)
-                       TDM_INFO("layer(%p) waiting_buffer(%p)",
-                                        private_layer, private_layer->waiting_buffer);
-       }
-
-       if (private_layer->showing_buffer) {
-               _pthread_mutex_unlock(&private_display->lock);
-               tdm_buffer_unref_backend(private_layer->showing_buffer);
-               tbm_surface_queue_release(private_layer->buffer_queue,
-                                                                 private_layer->showing_buffer);
-               _pthread_mutex_lock(&private_display->lock);
-               private_layer->showing_buffer = NULL;
-
-               if (tdm_debug_module & TDM_DEBUG_BUFFER)
-                       TDM_INFO("layer(%p) showing_buffer(%p)",
-                                        private_layer, private_layer->showing_buffer);
-       }
-
-       tbm_surface_queue_remove_acquirable_cb(private_layer->buffer_queue, _tbm_layer_queue_acquirable_cb, layer);
-       tbm_surface_queue_remove_destroy_cb(private_layer->buffer_queue, _tbm_layer_queue_destroy_cb, layer);
-       private_layer->buffer_queue = NULL;
-       private_layer->usable = 1;
-
-       if (private_layer->usable)
-               TDM_INFO("layer(%p) now usable", private_layer);
-
-       if (!func_layer->layer_unset_buffer) {
-               _pthread_mutex_unlock(&private_display->lock);
-               TDM_ERR("not implemented!!");
-               return TDM_ERROR_NOT_IMPLEMENTED;
-       }
-
-       ret = func_layer->layer_unset_buffer(private_layer->layer_backend);
-
-       _pthread_mutex_unlock(&private_display->lock);
-
-       return ret;
+       return tdm_layer_unset_buffer(layer);
 }
 
 EXTERN tdm_error

diff --git a/src/tdm_helper.c b/src/tdm_helper.c
index 06ecba4..4873d12 100644 (file)
--- a/src/tdm_helper.c
+++ b/src/tdm_helper.c
@@ -838,14 +838,17 @@ tdm_helper_get_display_information(tdm_display *dpy, char *reply, int *len)
                                ret = func_layer->layer_get_info(private_layer->layer_backend, &info);
                                TDM_DBG_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, unlock);
 
-                               format = tbm_surface_get_format(private_layer->showing_buffer);
-                               tbm_surface_get_info(private_layer->showing_buffer, &buf_info);
+                               if (!private_layer->showing_buffer)
+                                       continue;
+
+                               format = tbm_surface_get_format(private_layer->showing_buffer->buffer);
+                               tbm_surface_get_info(private_layer->showing_buffer->buffer, &buf_info);
 
                                if (IS_RGB(format))
                                        size.h = buf_info.planes[0].stride >> 2;
                                else
                                        size.h = buf_info.planes[0].stride;
-                               size.v = tbm_surface_get_height(private_layer->showing_buffer);
+                               size.v = tbm_surface_get_height(private_layer->showing_buffer->buffer);
 
                                if (info.src_config.format)
                                        format = (info.src_config.format) ? : format;
@@ -854,7 +857,7 @@ tdm_helper_get_display_information(tdm_display *dpy, char *reply, int *len)
                                                         private_layer->index,
                                                         private_output->index,
                                                         private_layer->caps.zpos,
-                                                        private_layer->showing_buffer, FOURCC_STR(format), size.h, size.v,
+                                                        private_layer->showing_buffer->buffer, FOURCC_STR(format), size.h, size.v,
                                                         info.src_config.pos.w, info.src_config.pos.h, info.src_config.pos.x, info.src_config.pos.y,
                                                         info.dst_pos.w, info.dst_pos.h, info.dst_pos.x, info.dst_pos.y,
                                                         tdm_transform_str(info.transform));

diff --git a/src/tdm_private.h b/src/tdm_private.h
index c7a08d8..5631377 100644 (file)
--- a/src/tdm_private.h
+++ b/src/tdm_private.h
@@ -130,6 +130,7 @@ typedef struct _tdm_private_vblank_handler tdm_private_vblank_handler;
 typedef struct _tdm_private_output_commit_handler tdm_private_output_commit_handler;
 typedef struct _tdm_private_layer_commit_handler tdm_private_layer_commit_handler;
 typedef struct _tdm_private_change_handler tdm_private_change_handler;
+typedef struct _tdm_private_layer_buffer tdm_private_layer_buffer;
 
 struct _tdm_private_display {
        pthread_mutex_t lock;
@@ -229,9 +230,9 @@ struct _tdm_private_layer {
        tdm_caps_layer caps;
        tdm_layer *layer_backend;
 
-       tbm_surface_h pending_buffer;
-       tbm_surface_h waiting_buffer;
-       tbm_surface_h showing_buffer;
+       tdm_private_layer_buffer *pending_buffer;
+       tdm_private_layer_buffer *waiting_buffer;
+       tdm_private_layer_buffer *showing_buffer;
        tbm_surface_queue_h buffer_queue;
 
        struct list_head capture_list;
@@ -358,6 +359,11 @@ struct _tdm_private_change_handler {
        pid_t owner_tid;
 };
 
+struct _tdm_private_layer_buffer {
+       tbm_surface_h buffer;
+       struct list_head link;
+};
+
 typedef struct _tdm_buffer_info {
        tbm_surface_h buffer;