vdisp/gl: some refactoring

- mv message and curson handling to sep function
- restruct lock-guarded block
- do not make context current every time (it is already done once in
display_gl_run())
- replace own CHECK_RC with CHK_PTHR

Author: MartinPulec

src/video_display/gl.c

@@ -98,15 +98,6 @@
 #define SYSTEM_VSYNC 0xFE
 #define SINGLE_BUF 0xFF // use single buffering instead of double
 
-#define CHECK_RC(cmd)                                                          \
-        do {                                                                   \
-                int rc = cmd;                                                  \
-                if (rc != 0) {                                                 \
-                        MSG(ERROR, "%s:%d: " #cmd ": %s\n", __func__,          \
-                            __LINE__, ug_strerror(rc));                        \
-                }                                                              \
-        } while (0)
-
 static const char * deinterlace_fp = STRINGIFY(
 \043version 110\n
 uniform sampler2D image;
@@ -1365,11 +1356,8 @@ draw_pause()
         gl_check_error_nonfatal();
 }
 
-static void gl_process_frames(struct state_gl *s)
-{
-        struct video_frame *frame;
-
-        struct message *msg;
+static void gl_process_msg_cursor(struct state_gl *s) {
+        struct message *msg = nullptr;
         while ((msg = check_message(&s->mod))) {
                 struct msg_universal *msg_univ = (void *) msg;
                 log_msg(LOG_LEVEL_VERBOSE, MOD_NAME "Received message: %s\n", msg_univ->text);
@@ -1403,35 +1391,42 @@ static void gl_process_frames(struct state_gl *s)
                         }
                 }
         }
+}
 
+static void
+gl_process_frames(struct state_gl *s)
+{
+        gl_process_msg_cursor(s);
+
+        struct video_frame *frame = nullptr;
+
+        CHK_PTHR(pthread_mutex_lock(&s->lock));
         {
-                CHECK_RC(pthread_mutex_lock(&s->lock));
                 time_ns_t timeout_ns =
                     MIN(2.0 / s->current_display_desc.fps, 0.1) * NS_IN_SEC;
                 while (simple_linked_list_size(s->frame_queue) == 0) {
                         int rc = ug_pthread_cond_timedwait(&s->new_frame_ready_cv,
                                                         &s->lock, &timeout_ns);
                         if (rc != 0) {
-                                CHECK_RC(pthread_mutex_unlock(&s->lock));
-                                return;
+                                goto unlock;
                         }
                 }
                 frame = (struct video_frame *) simple_linked_list_pop(s->frame_queue);
-                CHECK_RC(pthread_mutex_unlock(&s->lock));
-                CHECK_RC(pthread_cond_signal(&s->frame_consumed_cv));
+        }
+unlock:
+        CHK_PTHR(pthread_mutex_unlock(&s->lock));
 
-                if (!frame) {
-                        return;
-                }
+        CHK_PTHR(pthread_cond_signal(&s->frame_consumed_cv));
 
-                glfwMakeContextCurrent(s->window);
+        if (!frame) {
+                return;
         }
 
         if (!video_desc_eq(video_desc_from_frame(frame), s->current_display_desc)) {
                 gl_reconfigure_screen(s, video_desc_from_frame(frame));
         }
 
-        CHECK_RC(pthread_mutex_lock(&s->lock));
+        CHK_PTHR(pthread_mutex_lock(&s->lock));
         if (s->current_frame) {
                 if (s->paused) {
                         SWAP_PTR(frame, s->current_frame);
@@ -1441,7 +1436,7 @@ static void gl_process_frames(struct state_gl *s)
                                           s->current_frame);
         }
         s->current_frame = frame;
-        CHECK_RC(pthread_mutex_unlock(&s->lock));
+        CHK_PTHR(pthread_mutex_unlock(&s->lock));
 
         glBindTexture(GL_TEXTURE_2D, s->texture_display);
 
@@ -1635,10 +1630,10 @@ display_gl_print_depth(GLFWmonitor *monitor)
 
 static void display_gl_render_last(GLFWwindow *win) {
         struct state_gl *s = glfwGetWindowUserPointer(win);
-        CHECK_RC(pthread_mutex_lock(&s->lock));
+        CHK_PTHR(pthread_mutex_lock(&s->lock));
         struct video_frame *f = s->current_frame;
         s->current_frame = nullptr;
-        CHECK_RC(pthread_mutex_unlock(&s->lock));
+        CHK_PTHR(pthread_mutex_unlock(&s->lock));
         if (!f) {
                 return;
         }
@@ -2346,9 +2341,9 @@ static void display_gl_done(void *state)
         simple_linked_list_destroy(s->frame_queue);
         simple_linked_list_destroy(s->free_frame_queue);
 
-        CHECK_RC(pthread_cond_destroy(&s->new_frame_ready_cv));
-        CHECK_RC(pthread_cond_destroy(&s->frame_consumed_cv));
-        CHECK_RC(pthread_mutex_destroy(&s->lock));
+        CHK_PTHR(pthread_cond_destroy(&s->new_frame_ready_cv));
+        CHK_PTHR(pthread_cond_destroy(&s->frame_consumed_cv));
+        CHK_PTHR(pthread_mutex_destroy(&s->lock));
 
         free(s);
 }
@@ -2358,7 +2353,7 @@ static struct video_frame * display_gl_getf(void *state)
         struct state_gl *s = (struct state_gl *) state;
         assert(s->magic == MAGIC_GL);
 
-        CHECK_RC(pthread_mutex_lock(&s->lock));
+        CHK_PTHR(pthread_mutex_lock(&s->lock));
         while (simple_linked_list_size(s->free_frame_queue) > 0) {
                 struct video_frame *buffer =
                     simple_linked_list_pop(s->free_frame_queue);
@@ -2368,7 +2363,7 @@ static struct video_frame * display_gl_getf(void *state)
                 }
                 vf_free(buffer);
         }
-        CHECK_RC(pthread_mutex_unlock(&s->lock));
+        CHK_PTHR(pthread_mutex_unlock(&s->lock));
 
         struct video_frame *buffer = vf_alloc_desc_data(s->current_desc);
         vf_clear(buffer);
@@ -2383,24 +2378,24 @@ static bool display_gl_putf(void *state, struct video_frame *frame, long long ti
 
         if(!frame) {
                 glfwSetWindowShouldClose(s->window, GLFW_TRUE);
-                CHECK_RC(pthread_mutex_lock(&s->lock));
+                CHK_PTHR(pthread_mutex_lock(&s->lock));
                 simple_linked_list_append(s->frame_queue, frame);
-                CHECK_RC(pthread_mutex_unlock(&s->lock));
-                CHECK_RC(pthread_cond_signal(&s->new_frame_ready_cv));
+                CHK_PTHR(pthread_mutex_unlock(&s->lock));
+                CHK_PTHR(pthread_cond_signal(&s->new_frame_ready_cv));
                 return true;
         }
 
-        CHECK_RC(pthread_mutex_lock(&s->lock));
+        CHK_PTHR(pthread_mutex_lock(&s->lock));
         switch (timeout_ns) {
                 case PUTF_DISCARD:
                         vf_recycle(frame);
                         simple_linked_list_append(s->free_frame_queue, frame);
-                        CHECK_RC(pthread_mutex_unlock(&s->lock));
+                        CHK_PTHR(pthread_mutex_unlock(&s->lock));
                         return 0;
                 case PUTF_BLOCKING:
                         while (simple_linked_list_size(s->frame_queue) >=
                                MAX_BUFFER_SIZE) {
-                                CHECK_RC(pthread_cond_wait(
+                                CHK_PTHR(pthread_cond_wait(
                                     &s->frame_consumed_cv, &s->lock));
                         }
                         break;
@@ -2422,13 +2417,13 @@ static bool display_gl_putf(void *state, struct video_frame *frame, long long ti
                 MSG(VERBOSE, "1 frame(s) dropped!\n");
                 vf_recycle(frame);
                 simple_linked_list_append(s->free_frame_queue, frame);
-                CHECK_RC(pthread_mutex_unlock(&s->lock));
+                CHK_PTHR(pthread_mutex_unlock(&s->lock));
                 return false;
         }
         simple_linked_list_append(s->frame_queue, frame);
 
-        CHECK_RC(pthread_mutex_unlock(&s->lock));
-        CHECK_RC(pthread_cond_signal(&s->new_frame_ready_cv));
+        CHK_PTHR(pthread_mutex_unlock(&s->lock));
+        CHK_PTHR(pthread_cond_signal(&s->new_frame_ready_cv));
 
         return !s->paused;
 }