client: notify dequeueable even if queue is flushed

if queue doesn't have allocated buffers, queue doesn't send dequeueable

Change-Id: Icf1ac45d3b826b49bbe6db9e7bef87e46008c132

diff --git a/src/wayland-tbm-client.c b/src/wayland-tbm-client.c
index b166335..d9f9e71 100644 (file)
--- a/src/wayland-tbm-client.c
+++ b/src/wayland-tbm-client.c
@@ -707,15 +707,12 @@ _wayland_tbm_client_queue_destroy_attach_bufs(struct wayland_tbm_surface_queue *
 }
 
 static void
-_wayland_tbm_client_queue_destroy_unused_attach_bufs(struct wayland_tbm_surface_queue *queue_info, int *need_flush)
+_wayland_tbm_client_queue_destroy_unused_attach_bufs(struct wayland_tbm_surface_queue *queue_info)
 {
        struct wayland_tbm_buffer *buffer, *tmp;
 
-       *need_flush = 0;
-
        wl_list_for_each_safe(buffer, tmp, &queue_info->attach_bufs, link) {
                if (buffer->allocated) {
-                       *need_flush = 1;
                        buffer->expire = 1;
                        continue;
                }
@@ -1040,8 +1037,8 @@ handle_tbm_queue_deactive(void *data,
        tbm_surface_queue_h tbm_queue = NULL;
        tbm_surface_h *surfaces = NULL;
        int flush = 0;
-       int need_flush = 0;
-       int queue_size = 0;
+       int flush_done = 0;
+       int recover_size = 0;
        int count = 0;
        int length = 0;
        int i;
@@ -1069,25 +1066,21 @@ handle_tbm_queue_deactive(void *data,
                        }
 
                        _wayland_tbm_client_queue_get_attach_bufs(queue_info, 1, surfaces, &count);
-                       /* flush the attached surfaces */
-                       _wayland_tbm_client_queue_destroy_unused_attach_bufs(queue_info, &flush);
-
-                       if (queue_info->active_flush_done)
-                               flush = 1;
-                       if (!queue_info->active_flush_invalid)
-                               need_flush = 1;
+                       _wayland_tbm_client_queue_destroy_unused_attach_bufs(queue_info);
                }
        }
 
+       tbm_queue = queue_info->tbm_queue;
+       recover_size = queue_info->queue_size;
+       flush_done = queue_info->active_flush_done;
+       flush = !queue_info->active_flush_invalid;
+
        queue_info->is_active = 0;
        queue_info->active_flush_invalid = 0;
        queue_info->active_flush_done = 0;
        queue_info->active_flush_size = 0;
        queue_info->wait_usable = 0;
 
-       tbm_queue = queue_info->tbm_queue;
-       queue_size = queue_info->queue_size;
-
        pthread_mutex_unlock(&queue_info->lock);
 
        if (surfaces) {
@@ -1097,8 +1090,10 @@ handle_tbm_queue_deactive(void *data,
                free(surfaces);
        }
 
-       if (need_flush)
-               tbm_surface_queue_set_size(tbm_queue, queue_size, flush);
+       if (flush_done) {
+               tbm_surface_queue_set_size(tbm_queue, recover_size, flush);
+               tbm_surface_queue_notify_dequeuable(tbm_queue);
+       }
 }
 
 static void
@@ -1225,7 +1220,6 @@ _handle_tbm_surface_queue_destroy_notify(tbm_surface_queue_h surface_queue,
                }
 
                _wayland_tbm_client_queue_get_attach_bufs(queue_info, 0, surfaces, &count);
-               /* remove the attach_bufs int the queue_info */
                _wayland_tbm_client_queue_destroy_attach_bufs(queue_info);
        }
 
@@ -1279,14 +1273,11 @@ _handle_tbm_surface_queue_reset_notify(tbm_surface_queue_h surface_queue,
 
        WL_TBM_LOG("active_flush invalid queue");
        queue_info->active_flush_invalid = 1;
-       if (queue_size != queue_info->queue_size)
-               recover_size = queue_info->queue_size;
+       recover_size = queue_info->queue_size;
 
        pthread_mutex_unlock(&queue_info->lock);
 
-       if (recover_size)
-               tbm_surface_queue_set_size(surface_queue, recover_size, 0);
-
+       tbm_surface_queue_set_size(surface_queue, recover_size, 0);
        tbm_surface_queue_notify_dequeuable(surface_queue);
 }