only build jpeg renderer if --ca (no filename) is used

renderers/video_renderer.c

@@ -59,8 +59,6 @@ static int type_265;
 static int type_hls;
 static int type_jpeg;
 
-
-
 typedef enum {
   //GST_PLAY_FLAG_VIDEO         = (1 << 0),
   //GST_PLAY_FLAG_AUDIO         = (1 << 1),
@@ -226,7 +224,7 @@ GstElement *make_video_sink(const char *videosink, const char *videosink_options
 
 void  video_renderer_init(logger_t *render_logger, const char *server_name, videoflip_t videoflip[2], const char *parser,
                           const char *decoder, const char *converter, const char *videosink, const char *videosink_options, 
-                          bool initial_fullscreen, bool video_sync, bool h265_support, guint playbin_version, const char *uri) {
+                          bool initial_fullscreen, bool video_sync, bool h265_support, bool coverart_support, guint playbin_version, const char *uri) {
     GError *error = NULL;
     GstCaps *caps = NULL;
     hls_video = (uri != NULL);
@@ -247,7 +245,6 @@ void  video_renderer_init(logger_t *render_logger, const char *server_name, vide
     type_264 = -1;
     type_265 = -1;
     type_jpeg = -1;
-    
 
     /* this call to g_set_application_name makes server_name appear in the  X11 display window title bar, */
     /* (instead of the program name uxplay taken from (argv[0]). It is only set one time. */
@@ -255,18 +252,22 @@ void  video_renderer_init(logger_t *render_logger, const char *server_name, vide
     const gchar *appname = g_get_application_name();
     if (!appname || strcmp(appname,server_name))  g_set_application_name(server_name);
     appname = NULL;
-
+    n_renderers = 1;
     /* the renderer for hls video will only be built if a HLS uri is provided in 
      * the call to video_renderer_init, in which case the h264/h265 mirror-mode and jpeg
      * audio-mode renderers will not be built.   This is because it appears that we cannot  
      * put playbin into GST_STATE_READY before knowing the uri (?), so cannot use a
      * unified renderer structure with h264, h265, jpeg and hls  */  
     if (hls_video) {
-        n_renderers = 1;
+        type_hls = 0;
-        /* renderer[0]: playbin (hls) */
     } else {
-        n_renderers = h265_support ? 3 : 2;
+        type_264 = 0;
-        /* renderer[0]: jpeg; [1]: h264; [2]: h265 */
+        if (h265_support) {
+            type_265 = n_renderers++;
+        }
+        if (coverart_support) {
+            type_jpeg = n_renderers++;
+        }
     }
     g_assert (n_renderers <= NCODECS);
     for (int i = 0; i < n_renderers; i++) {
@@ -293,7 +294,6 @@ void  video_renderer_init(logger_t *render_logger, const char *server_name, vide
             logger_log(logger, LOGGER_INFO, "Will use GStreamer playbin version %u to play HLS streamed video", playbin_version);	    
             g_assert(renderer_type[i]->pipeline);
             renderer_type[i]->codec = hls;
-            type_hls = i;
             /* if we are not using an autovideosink, build a videosink based on the string "videosink" */
             if (!auto_videosink) { 
                 GstElement *playbin_videosink = make_video_sink(videosink, videosink_options);  
@@ -312,24 +312,17 @@ void  video_renderer_init(logger_t *render_logger, const char *server_name, vide
             g_object_set (G_OBJECT (renderer_type[i]->pipeline), "uri", uri, NULL);
         } else {
             bool jpeg_pipeline = false;
-            switch (i) {
+            if (i == type_264) {
-            case 0:
+                renderer_type[i]->codec = h264;
+                caps = gst_caps_from_string(h264_caps);
+            } else if (i == type_265) {
+                renderer_type[i]->codec = h265;
+                caps = gst_caps_from_string(h265_caps);
+            } else if (i == type_jpeg) {
                 jpeg_pipeline = true;
                 renderer_type[i]->codec = jpeg;
                 caps = gst_caps_from_string(jpeg_caps);
-                type_jpeg = i;
+            } else {
-                break;
-            case 1:
-                renderer_type[i]->codec = h264;
-                caps = gst_caps_from_string(h264_caps);
-                type_264 = i;
-                break;
-            case 2:
-                renderer_type[i]->codec = h265;
-                caps = gst_caps_from_string(h265_caps);
-                type_265 = i;
-                break;
-            default:
                 g_assert(0);
             }
             GString *launch = g_string_new("appsrc name=video_source ! ");
@@ -516,6 +509,9 @@ bool waiting_for_x11_window() {
 
 void video_renderer_display_jpeg(const void *data, int *data_len) {
     GstBuffer *buffer;
+    if (type_jpeg == -1) {
+        return;
+    }
     if (renderer && !strcmp(renderer->codec, jpeg)) {
         buffer = gst_buffer_new_allocate(NULL, *data_len, NULL);
 	g_assert(buffer != NULL);

renderers/video_renderer.h

@@ -49,7 +49,8 @@ typedef struct video_renderer_s video_renderer_t;
 
 void video_renderer_init (logger_t *logger, const char *server_name, videoflip_t videoflip[2], const char *parser,
                           const char *decoder, const char *converter, const char *videosink, const char *videosink_options,
-                          bool initial_fullscreen, bool video_sync, bool h265_support, guint playbin_version,  const char *uri);
+                          bool initial_fullscreen, bool video_sync, bool h265_support, bool coverart_support,
+                          guint playbin_version,  const char *uri);
 void video_renderer_start ();
 void video_renderer_stop ();
 void video_renderer_pause ();

uxplay.cpp

@@ -558,34 +558,43 @@ static guint g_unix_signal_add(gint signum, GSourceFunc handler, gpointer user_d
 }
 #endif
 
+#define MAX_VIDEO_RENDERERS 3
+#define MAX_AUDIO_RENDERERS 2
 static void main_loop()  {
-    guint gst_video_bus_watch_id[3] = { 0 };
+    guint gst_video_bus_watch_id[MAX_VIDEO_RENDERERS] = { 0 };
-    g_assert(n_video_renderers <= 3);
+    guint gst_audio_bus_watch_id[MAX_AUDIO_RENDERERS] = { 0 };
-    guint gst_audio_bus_watch_id[2] = { 0 };
-    g_assert(n_audio_renderers <= 2);
     GMainLoop *loop = g_main_loop_new(NULL,FALSE);
     relaunch_video = false;
     reset_loop = false;
     reset_httpd = false;
     preserve_connections = false;
+    n_video_renderers = 0;
+    n_audio_renderers = 0;
     if (use_video) {
+        n_video_renderers = 1;
         relaunch_video = true;
         if (url.empty()) {
-            /* renderer[0] : jpeg coverart; renderer[1] h264 video; renderer[2] h265 video (optional)  */
+            if (h265_support) {
-            n_video_renderers = h265_support ? 3 : 2;
+                n_video_renderers++;
+            }
+            if (render_coverart) {
+                n_video_renderers++;
+            }
+            /* renderer[0] : h264 video; followed by  h265 video (optional) and jpeg (optional)  */
             gst_x11_window_id = 0;           
         } else {
             /* hls video will be rendered: renderer[0] : hls  */
-	    n_video_renderers = 1;
             url.erase();
             gst_x11_window_id = g_timeout_add(100, (GSourceFunc) x11_window_callback, (gpointer) loop);
         }
+        g_assert(n_video_renderers <= MAX_VIDEO_RENDERERS);
         for (int i = 0; i < n_video_renderers; i++) {
             gst_video_bus_watch_id[i] = (guint) video_renderer_listen((void *)loop, i);
         }
     }
     if (use_audio) {
         n_audio_renderers = 2;
+        g_assert(n_audio_renderers <= MAX_AUDIO_RENDERERS);
         for (int i = 0; i < n_audio_renderers; i++) {
             gst_audio_bus_watch_id[i] = (guint) audio_renderer_listen((void *)loop, i);      
         }
@@ -2727,7 +2736,8 @@ int main (int argc, char *argv[]) {
     if (use_video) {
         video_renderer_init(render_logger, server_name.c_str(), videoflip, video_parser.c_str(),
                             video_decoder.c_str(), video_converter.c_str(), videosink.c_str(),
-                            videosink_options.c_str(), fullscreen, video_sync, h265_support, playbin_version, NULL);
+                            videosink_options.c_str(), fullscreen, video_sync, h265_support,
+                            render_coverart, playbin_version, NULL);
         video_renderer_start();
 #ifdef __OpenBSD__
     } else {
@@ -2811,7 +2821,8 @@ int main (int argc, char *argv[]) {
             const char *uri = (url.empty() ? NULL : url.c_str());
             video_renderer_init(render_logger, server_name.c_str(), videoflip, video_parser.c_str(),
                                 video_decoder.c_str(), video_converter.c_str(), videosink.c_str(),
-                                videosink_options.c_str(), fullscreen, video_sync, h265_support, playbin_version, uri);
+                                videosink_options.c_str(), fullscreen, video_sync, h265_support,
+                                render_coverart, playbin_version, uri);
             video_renderer_start();
         }
         if (reset_httpd) {