main: vrxtx opt setting simplified

handle the proto-specific tweaks in the vrxtx module itself (iHDTV,
RTSP, SDP)

iHDTV, while not supposed to work, anyways, had the display device
set always since some time, which would disallow running as a sender
(because from the display pointer it assumed that it is the receiver).

Author: MartinPulec

src/main.cpp

@@ -1476,34 +1476,14 @@ int main(int argc, char *argv[])
 #endif /* USE_RT */
 
         try {
-                // iHDTV
-                opt.video.capture_device = (opt.video.rxtx_mode & MODE_SENDER) != 0U ? uv.capture_device : nullptr;
-                // was but overriden later to uv.display_device unconditionaly:
-                // param.display_device = (opt.video_rxtx_mode & MODE_RECEIVER) != 0U ? uv.display_device : nullptr;
-
-                //RTP
-                opt.video.start_time = start_time;
-
-                // UltraGrid RTP
-                opt.video.display_device = uv.display_device;
-
-                if (strcmp(opt.video_protocol, "rtsp") == 0) {
-                        rtsp_types_t avType = rtsp_type_none;
-                        if ((strcmp("none", opt.audio.send_cfg) != 0)) {
-                                avType = (rtsp_types_t) (avType | rtsp_type_audio); // AStream
-                        }
-                        if (strcmp("none", vidcap_params_get_driver(
-                                               opt.vidcap_params_head)) != 0) {
-                                avType = (rtsp_types_t) (avType | rtsp_type_video); // VStream
-                        }
-                        if (avType == rtsp_type_none) {
-                                printf("[RTSP SERVER CHECK] no stream type... check capture devices input...\n");
-                        }
-
-                        opt.video.av_type = avType;
-                }
-
-                sdp_set_properties(opt.video.receiver, opt.video.rxtx_mode & MODE_SENDER && strcasecmp(opt.video_protocol, "sdp") == 0, opt.audio.send_port != 0 && strcasecmp(opt.audio.proto, "sdp") == 0);
+                opt.video.capture_device = uv.capture_device; // iHDTV
+                opt.video.start_time = start_time; // RTP protocols
+                opt.video.display_device = uv.display_device; // UltraGrid RTP, iHDTV
+                // RTSP + SDP
+                opt.video.send_audio = strcmp("none", opt.audio.send_cfg) != 0;
+                opt.video.send_video =
+                    strcmp("none", vidcap_params_get_driver(
+                                       opt.vidcap_params_head)) != 0;
 
                 uv.state_video_rxtx = video_rxtx::create(opt.video_protocol, &opt.video, &opt.common);
                 if (!uv.state_video_rxtx) {

src/video_rxtx.hpp

@@ -60,7 +60,7 @@ struct video_frame;
 
 struct vrxtx_params {
         const char     *compression; ///< nullptr selects proto dfl
-        enum rxtx_mode  rxtx_mode;
+        enum rxtx_mode  rxtx_mode;      ///< sender, receiver or both
         struct display *display_device; ///< only iHDTV, UG RTP
         struct vidcap  *capture_device; ///< iHDTV only
         const char     *receiver;
@@ -71,7 +71,8 @@ struct vrxtx_params {
         enum video_mode decoder_mode;
         const char     *protocol_opts;
         long long       start_time;
-        long            av_type;      ///< RTSP only
+        bool            send_audio;   ///< RTSP+SDP
+        bool            send_video;   ///< RTSP+SDP
         struct module  *sender_mod;   ///< set by video_rxtx::create
         struct module  *receiver_mod; ///< set by video_rxtx::create
 };
@@ -90,7 +91,8 @@ struct vrxtx_params {
                 .decoder_mode   = VIDEO_NORMAL, \
                 .protocol_opts  = "", \
                 .start_time     = 0, \
-                .av_type        = 0, \
+                .send_audio     = false, \
+                .send_video     = false, \
                 .sender_mod     = nullptr, \
                 .receiver_mod   = nullptr, \
         }

src/video_rxtx/h264_rtp.cpp

@@ -75,7 +75,16 @@ h264_rtp_video_rxtx::h264_rtp_video_rxtx(const struct vrxtx_params *params,
 {
         rtsp_params.rtsp_port = (unsigned) rtsp_port;
         rtsp_params.parent = common->parent;
-        rtsp_params.avType = (rtsp_types_t) params->av_type;
+
+        auto avType = (rtsp_types_t) (params->send_audio ? rtsp_type_audio : 0);
+        avType = (rtsp_types_t) (avType |
+                                 (params->send_video ? rtsp_type_video : 0));
+        if (avType == rtsp_type_none) {
+                printf("[RTSP SERVER CHECK] no stream type... check capture devices input...\n");
+                throw 1;
+        }
+        rtsp_params.avType = avType;;
+
         rtsp_params.rtp_port_video = params->rx_port;  //server rtp port
 }
 

src/video_rxtx/h264_sdp.cpp

@@ -79,6 +79,9 @@ h264_sdp_video_rxtx::h264_sdp_video_rxtx(const struct vrxtx_params *params,
         LOG(LOG_LEVEL_WARNING) << "Warning: SDP support is experimental only. Things may be broken - feel free to report them but the support may be limited.\n";
         m_saved_addr = m_requested_receiver;
         m_saved_tx_port = params->tx_port;
+
+        sdp_set_properties(params->receiver, params->send_video, params->send_audio);
+
         if (int ret = sdp_set_options(opts)) {
                 throw ret == 1 ? 0 : 1;
         }

src/video_rxtx/ihdtv.cpp

@@ -51,6 +51,7 @@
  *
  */
 
+#include <cassert>          // for assert
 #include <cstdio>           // for NULL, printf
 #include <memory>           // for shared_ptr
 #include <string>           // for basic_string, string
@@ -151,14 +152,15 @@ ihdtv_video_rxtx::ihdtv_video_rxtx(const struct vrxtx_params *params,
         printf("Initializing ihdtv protocol\n");
 
         // we cannot act as both together, because parameter parsing would have to be revamped
-        if (params->capture_device && params->display_device) {
+        if ((params->rxtx_mode == (MODE_SENDER | MODE_RECEIVER))) {
                throw string 
                         ("Error: cannot act as both sender and receiver together in ihdtv mode");
         }
 
-        m_display_device = static_cast<struct display *>(params->display_device);
+        m_display_device = params->display_device;
 
-        if (m_display_device) {
+        if ((params->rxtx_mode & MODE_RECEIVER) != 0U) {
+                assert(params->display_device != nullptr);
                 if (ihdtv_init_rx_session
                                 (&m_rx_connection, (argc == 0) ? NULL : argv[0],
                                  (argc ==
@@ -168,7 +170,8 @@ ihdtv_video_rxtx::ihdtv_video_rxtx(const struct vrxtx_params *params,
                 }
         }
 
-        if (params->capture_device != nullptr) {
+        if ((params->rxtx_mode & MODE_SENDER) != 0U) {
+                assert(params->capture_device != nullptr);
                 if (argc == 0) {
                         throw string("Error: specify the destination address");
                 }