Replace make_streamcompatibility_receiver_validator's transport_file_…

…parser arg with transport_file_validator

Development/nmos-cpp-node/node_implementation.cpp

@@ -190,6 +190,19 @@ namespace impl
     const auto temperature_Celsius = nmos::event_types::measurement(U("temperature"), U("C"));
     const auto temperature_wildcard = nmos::event_types::measurement(U("temperature"), nmos::event_types::wildcard);
     const auto catcall = nmos::event_types::named_enum(nmos::event_types::number, U("caterwaul"));
+
+    const auto validate_sdp_parameters = [](const web::json::value& receiver, const nmos::sdp_parameters& sdp_params)
+    {
+        if (nmos::media_types::video_jxsv == nmos::get_media_type(sdp_params))
+        {
+            nmos::validate_video_jxsv_sdp_parameters(receiver, sdp_params);
+        }
+        else
+        {
+            // validate core media types, i.e., "video/raw", "audio/L", "video/smpte291" and "video/SMPTE2022-6"
+            nmos::validate_sdp_parameters(receiver, sdp_params);
+        }
+    };
 }
 
 // forward declarations for node_implementation_thread
@@ -1146,19 +1159,7 @@ nmos::transport_file_parser make_node_implementation_transport_file_parser()
     // (if this callback is specified, an 'empty' std::function is not allowed)
     return [](const nmos::resource& receiver, const nmos::resource& connection_receiver, const utility::string_t& transport_file_type, const utility::string_t& transport_file_data, slog::base_gate& gate)
     {
-        const auto validate_sdp_parameters = [](const web::json::value& receiver, const nmos::sdp_parameters& sdp_params)
-        {
-            if (nmos::media_types::video_jxsv == nmos::get_media_type(sdp_params))
-            {
-                nmos::validate_video_jxsv_sdp_parameters(receiver, sdp_params);
-            }
-            else
-            {
-                // validate core media types, i.e., "video/raw", "audio/L", "video/smpte291" and "video/SMPTE2022-6"
-                nmos::validate_sdp_parameters(receiver, sdp_params);
-            }
-        };
-        return nmos::details::parse_rtp_transport_file(validate_sdp_parameters, receiver, connection_receiver, transport_file_type, transport_file_data, gate);
+        return nmos::details::parse_rtp_transport_file(impl::validate_sdp_parameters, receiver, connection_receiver, transport_file_type, transport_file_data, gate);
     };
 }
 
@@ -1603,9 +1604,17 @@ nmos::experimental::details::streamcompatibility_sender_validator make_node_impl
     };
 }
 
-nmos::experimental::details::streamcompatibility_receiver_validator make_node_implementation_streamcompatibility_receiver_validator(slog::base_gate& gate)
+nmos::experimental::details::streamcompatibility_receiver_validator make_node_implementation_streamcompatibility_receiver_validator()
 {
-    return nmos::experimental::make_streamcompatibility_receiver_validator(make_node_implementation_transport_file_parser(), gate);
+    // this example uses a custom transport file validator to handle video/jxsv in addition to the core media types
+    const auto transport_file_validator = std::bind(
+        nmos::experimental::details::validate_rtp_transport_file,
+        impl::validate_sdp_parameters,
+        std::placeholders::_1,
+        std::placeholders::_2,
+        std::placeholders::_3
+    );
+    return nmos::experimental::make_streamcompatibility_receiver_validator(transport_file_validator);
 }
 
 namespace impl
@@ -1770,5 +1779,5 @@ nmos::experimental::node_implementation make_node_implementation(nmos::node_mode
         .on_set_effective_edid(set_effective_edid) // may be omitted if not required
         .on_active_constraints_changed(make_node_implementation_streamcompatibility_active_constraints_handler(model, gate))
         .on_validate_sender_resources_against_active_constraints(make_node_implementation_streamcompatibility_sender_validator()) // may be omitted if the default is sufficient
-        .on_validate_receiver_against_transport_file(make_node_implementation_streamcompatibility_receiver_validator(gate));
+        .on_validate_receiver_against_transport_file(make_node_implementation_streamcompatibility_receiver_validator());
 }

Development/nmos/node_server.h

@@ -46,6 +46,7 @@ namespace nmos
             node_implementation()
                 : parse_transport_file(&nmos::parse_rtp_transport_file)
                 , validate_sender_resources(make_streamcompatibility_sender_resources_validator(&nmos::experimental::match_resource_parameters_constraint_set, make_streamcompatibility_sdp_constraint_sets_matcher(&nmos::match_sdp_parameters_constraint_sets)))
+                , validate_receiver(make_streamcompatibility_receiver_validator(&nmos::experimental::validate_rtp_transport_file))
             {}
 
             node_implementation& on_load_server_certificates(nmos::load_server_certificates_handler load_server_certificates) { this->load_server_certificates = std::move(load_server_certificates); return *this; }

Development/nmos/streamcompatibility_behaviour.cpp

@@ -178,7 +178,7 @@ namespace nmos
 
                             if (validate_receiver)
                             {
-                                std::tie(receiver_state, receiver_state_debug) = validate_receiver(transport_file, *receiver, *connection_receiver);
+                                std::tie(receiver_state, receiver_state_debug) = validate_receiver(*receiver, transport_file);
                             }
 
                             if (nmos::fields::state(nmos::fields::status(streamcompatibility_receiver->data)) != receiver_state.name)

Development/nmos/streamcompatibility_validation.cpp

@@ -1,5 +1,6 @@
 #include "nmos/streamcompatibility_validation.h"
 
+#include "nmos/connection_api.h"
 #include "nmos/json_fields.h"
 #include "nmos/model.h"
 #include "nmos/resource.h"
@@ -28,6 +29,26 @@ namespace nmos
 
         }
 
+        void validate_rtp_transport_file(const nmos::resource& receiver, const utility::string_t& transport_file_type, const utility::string_t& transport_file_data)
+        {
+            return details::validate_rtp_transport_file(&validate_sdp_parameters, receiver, transport_file_type, transport_file_data);
+        }
+
+        void details::validate_rtp_transport_file(nmos::details::sdp_parameters_validator validate_sdp_parameters, const nmos::resource& receiver, const utility::string_t& transport_file_type, const utility::string_t& transport_file_data)
+        {
+            if (transport_file_type != nmos::media_types::application_sdp.name)
+            {
+                throw std::runtime_error("unexpected type: " + utility::us2s(transport_file_type));
+            }
+
+            const auto session_description = sdp::parse_session_description(utility::us2s(transport_file_data));
+            auto sdp_transport_params = nmos::parse_session_description(session_description);
+
+            // Validate transport file according to the IS-04 receiver
+
+            validate_sdp_parameters(receiver.data, sdp_transport_params.first);
+        }
+
         // "At any time if State of an active Sender becomes active_constraints_violation, the Sender MUST become inactive.
         // An inactive Sender in this state MUST NOT allow activations.
         // At any time if State of an active Receiver becomes non_compliant_stream, the Receiver SHOULD become inactive.
@@ -122,9 +143,9 @@ namespace nmos
             };
         }
 
-        details::streamcompatibility_receiver_validator make_streamcompatibility_receiver_validator(const nmos::transport_file_parser& parse_and_validate_transport_file, slog::base_gate& gate)
+        details::streamcompatibility_receiver_validator make_streamcompatibility_receiver_validator(const details::transport_file_validator& validate_transport_file)
         {
-            return [parse_and_validate_transport_file, &gate](const web::json::value& transport_file_, const nmos::resource& receiver, const nmos::resource& connection_receiver) -> std::pair<nmos::receiver_state, utility::string_t>
+            return [validate_transport_file](const nmos::resource& receiver, const web::json::value& transport_file_) -> std::pair<nmos::receiver_state, utility::string_t>
             {
                 nmos::receiver_state receiver_state = nmos::receiver_states::unknown;
                 utility::string_t receiver_state_debug;
@@ -138,11 +159,10 @@ namespace nmos
 
                         try
                         {
-                            parse_and_validate_transport_file(receiver, connection_receiver, transport_file.first, transport_file.second, gate);
+                            validate_transport_file(receiver, transport_file.first, transport_file.second);
                         }
                         catch (const std::runtime_error& e)
                         {
-                            slog::log<slog::severities::error>(gate, SLOG_FLF) << "Validation of receiver " << receiver.id << " failed with " << e.what();
                             receiver_state = nmos::receiver_states::non_compliant_stream;
                             receiver_state_debug = utility::conversions::to_string_t(e.what());
                         }

Development/nmos/streamcompatibility_validation.h

@@ -30,13 +30,22 @@ namespace nmos
             // returns Sender's "state" and "debug" values
             typedef std::function<std::pair<nmos::sender_state, utility::string_t>(const nmos::resource& source, const nmos::resource& flow, const nmos::resource& sender, const nmos::resource& connection_sender, const web::json::array& constraint_sets)> streamcompatibility_sender_validator;
             // returns Receiver's "state" and "debug" values
-            typedef std::function<std::pair<nmos::receiver_state, utility::string_t>(const web::json::value& transport_file, const nmos::resource& receiver, const nmos::resource& connection_receiver)> streamcompatibility_receiver_validator;
+            typedef std::function<std::pair<nmos::receiver_state, utility::string_t>(const nmos::resource& receiver, const web::json::value& transport_file)> streamcompatibility_receiver_validator;
+
+            typedef std::function<void(const nmos::resource& receiver, const utility::string_t& transportfile_type, const utility::string_t& transportfile_data)> transport_file_validator;
 
             typedef std::function<bool(const nmos::resource& resource, const web::json::value& constraint_set)> resource_constraints_matcher;
             typedef std::function<bool(const std::pair<utility::string_t, utility::string_t>& transport_file, const web::json::array& constraint_sets)> transport_file_constraint_sets_matcher;
             typedef std::function<bool(const web::json::array& constraint_sets, const sdp_parameters& sdp_params)> sdp_constraint_sets_matcher;
+
+            // Validate the specified transport file for the specified receiver using the specified validator
+            void validate_rtp_transport_file(nmos::details::sdp_parameters_validator validate_sdp_parameters, const nmos::resource& receiver, const utility::string_t& transport_file_type, const utility::string_t& transport_file_data);
         }
 
+        // Validate the specified transport file for the specified receiver using the default validator
+        // (this is the default transport file validator)
+        void validate_rtp_transport_file(const nmos::resource& receiver, const utility::string_t& transport_file_type, const utility::string_t& transport_file_data);
+
         typedef std::map<utility::string_t, std::function<bool(const web::json::value& resource, const web::json::value& con)>> parameter_constraints;
 
         // NMOS Parameter Registers - Capabilities register
@@ -89,7 +98,7 @@ namespace nmos
         nmos::details::connection_resource_patch_validator make_connection_streamcompatibility_validator(nmos::node_model& model);
 
         details::streamcompatibility_sender_validator make_streamcompatibility_sender_resources_validator(const details::resource_constraints_matcher& resource_matcher, const details::transport_file_constraint_sets_matcher& transport_file_matcher);
-        details::streamcompatibility_receiver_validator make_streamcompatibility_receiver_validator(const nmos::transport_file_parser& parse_and_validate_transport_file, slog::base_gate& gate);
+        details::streamcompatibility_receiver_validator make_streamcompatibility_receiver_validator(const details::transport_file_validator& validate_transport_file);
         bool match_resource_parameters_constraint_set(const nmos::resource& resource, const web::json::value& constraint_set);
         details::transport_file_constraint_sets_matcher make_streamcompatibility_sdp_constraint_sets_matcher(const details::sdp_constraint_sets_matcher& match_sdp_parameters_constraint_sets);
     }

Development/nmos/video_jxsv.cpp

@@ -344,24 +344,21 @@ namespace nmos
         return constraint_sets.end() != found;
     }
 
-    namespace experimental
+    bool experimental::match_video_jxsv_resource_parameters_constraint_set(const nmos::resource& resource, const web::json::value& constraint_set)
     {
-        bool match_video_jxsv_resource_parameters_constraint_set(const nmos::resource& resource, const web::json::value& constraint_set)
+        const std::map<nmos::type, nmos::experimental::parameter_constraints> resource_parameter_constraints
         {
-            const std::map<nmos::type, nmos::experimental::parameter_constraints> resource_parameter_constraints
-            {
-                { nmos::types::source,  nmos::experimental::source_parameter_constraints },
-                { nmos::types::flow,    nmos::experimental::video_jxsv_flow_parameter_constraints },
-                { nmos::types::sender,  nmos::experimental::video_jxsv_sender_parameter_constraints }
-            };
+            { nmos::types::source,  nmos::experimental::source_parameter_constraints },
+            { nmos::types::flow,    nmos::experimental::video_jxsv_flow_parameter_constraints },
+            { nmos::types::sender,  nmos::experimental::video_jxsv_sender_parameter_constraints }
+        };
 
-            if (0 == resource_parameter_constraints.count(resource.type))
-            {
-                throw std::logic_error("wrong resource type");
-            }
+        if (0 == resource_parameter_constraints.count(resource.type))
+        {
+            throw std::logic_error("wrong resource type");
+        }
 
-            return nmos::experimental::detail::match_resource_parameters_constraint_set(resource_parameter_constraints.at(resource.type), resource.data, constraint_set);
-        };
+        return nmos::experimental::detail::match_resource_parameters_constraint_set(resource_parameter_constraints.at(resource.type), resource.data, constraint_set);
     }
 
     // See https://specs.amwa.tv/bcp-006-01/branches/v1.0-dev/docs/NMOS_With_JPEG_XS.html#flows