rename map param to decoders, drop dot prefix, deal with humble brokenness

Author: berndpfrommer

CMakeLists.txt

@@ -37,6 +37,9 @@ find_package(sensor_msgs REQUIRED)
 find_package(std_msgs REQUIRED)
 
 
+if(${image_transport_VERSION} VERSION_GREATER_EQUAL "6.0.0")
+  add_definitions(-DIMAGE_TRANSPORT_RESOLVES_BASE_TOPIC)
+endif()
 if(${image_transport_VERSION} VERSION_GREATER_EQUAL "6.3.0")
   add_definitions(-DIMAGE_TRANSPORT_USE_QOS)
 endif()

README.md

@@ -75,7 +75,7 @@ Here is a list of the available encoding parameters:
 - ``encoder``: the libav (ffmpeg) encoder being used. The default is ``libx264``, which is on-CPU unaccelerated encoding.
   Depending on your hardware, your encoding options may include the hardware accelerated ``h264_nvenc`` or ``h264_vaapi``.
   You can list all available encoders with ``ffmpeg --codecs``. In the h264 row, look for ``(encoders)``.
-- ``av_options``: default is empty (""). Comma-separeted list of valid
+- ``encoder_av_options``: default is empty (""). Comma-separeted list of valid
    libav options in the form of (key:value),  e.g.:``'preset:ll,profile:main,crf:0'``.
    See the ffmpeg documentation for [more](https://trac.ffmpeg.org/wiki/Encode/H.264).
 - ``gop_size``: The number of frames between keyframes. Default: 10.
@@ -87,34 +87,39 @@ Here is a list of the available encoding parameters:
 - ``qmax``: Max quantization rate. Defaults to 10.
   See [ffmpeg documentation](https://www.ffmpeg.org/ffmpeg-codecs.html).
   The larger this number, the worse the image looks, and the more efficient the encoding.
-- ``measure_performance``: For performance debugging (developers only). Defaults to false.
-- ``performance_interval``: How many frames to wait between logging performance data. Ignore.
+- ``encoder_measure_performance``: For performance debugging (developers only). Defaults to false.
 
 The parameters are under the ``ffmpeg`` variable block. If you launch
 your publisher node (camera driver), you can give it a parameter list on the way like so:
 ```
-        parameters=[{'.image_raw.ffmpeg.encoder': 'hevc_nvenc',
-                     '.image_raw.ffmpeg.av_options': 'preset:ll,profile:main,crf:0'}]
+        parameters=[{'image_raw.ffmpeg.encoder': 'hevc_nvenc',
+                     'image_raw.ffmpeg.encoder_av_options': 'preset:ll,profile:main,crf:0'}]
 ```
 See the example launch file for a V4L USB camera (``usb_camera.launch.py``).
 If the above parameter settings don't work, use the ``ros2 param dump <your_node_name>``
 command to find out what the proper parameter path is.
 
 ### Subscriber (viewer)
 
-The subscriber has only one parameter (``map.<some_encoding>``), which is the map between a codec and a comma-separated list of libav decoders that can be used for decoding.
-If you don't set the map parameter, the Subscriber plugin will try to decode with a default set of libav decoders that support the appropriate codec.
-The map is exposed as the ROS``ffmpeg.map`` parameter, which is prefixed by the image base name, e.g. ``camera.image_raw``.
-The easiest way to find the exact naming of the parameter is to run the node and to use ``ros2 param list`` to find the ``ffmpeg.map`` parameter.
+- ``decoder_av_options`` comma-separated list of libav options to pass
+   to the decoder, like ``foo:bar,foobar:baz``. Default: empty string.
+- ``decoder_measure_performance`` enables performance
+   measurements. Default: false.
+- ``decoders.<codec>.<av_source_pixel_format>.<cv_bridge_target_format>.<original_ros_encoding>`` specifies the decoders to use for a given FFMPEGPacket encoding.
+  If no decoders are specified for the full encoding, a less specific parameter will be tested, i.e. ``decoders.<codec>.<av_source_pixel_format>.<cv_bridge_target_format>``, then ``decoders.<codec>.<av_source_pixel_format>``, and finally ``decoders.<codec>``.
+  If all parameters are found to be empty, the Subscriber plugin will try to decode with a default set of libav decoders that support the appropriate codec.
+
+All parameters are prefixed again by the image topic and the transport, just like for the publisher node.
+The easiest way to find the exact naming of the parameter is to run the node and to use ``ros2 param list`` to find the ``ffmpeg.decoders`` parameter.
 Please also refer to the republisher launch script example.
 
 Typically ROS2 parameters are passed to a node by *initializing* the parameters before launching the node, and the node then reads the parameter when it *declares* the parameter.
 Unfortunately, this route is not available for the popular ``rqt`` based suite of image viewing tools such as ``rqt_image_view``, since ``rqt`` does not read command line arguments and therefore no parameters can be initialized. The only workaround there is to:
 1) start e.g. ``rqt_image_view``
-2) select the ffmpeg image transport in the drop down box. This will *declare* the ``map`` parameter so you can set it in the next step.
+2) select the ffmpeg image transport in the drop down box. This will *declare* the ``decoders`` parameter so you can set it in the next step.
 3) find the node name with ``ros2 node list`` and set the parameter using something like
-``ros2 param set <name_of_your_viewer_node> camera.image_raw.ffmpeg.map.hevc hevc_cuvid``. This assumes your viewer node is subscribing to the topic ``/camera/image_raw/ffmpeg``.
-4) again using the drop down box, switch to another image transport and back to ffmpeg. This will cause the ffmpeg transport plugin to apply the updated ``map`` parameter.
+``ros2 param set <name_of_your_viewer_node> camera.image_raw.ffmpeg.decoders.hevc hevc_cuvid``. This assumes your viewer node is subscribing to the topic ``/camera/image_raw/ffmpeg``.
+4) again using the drop down box, switch to another image transport and back to ffmpeg. This will cause the ffmpeg transport plugin to apply the updated ``decoders`` parameter.
 
 ### Republishing
 
@@ -127,19 +132,19 @@ For example to first try to decode incoming ``hevc`` packets with the ``hevc_cuv
 
 - ROS 2 Humble:
   ```
-  ros2 run image_transport republish ffmpeg in/ffmpeg:=image_raw/ffmpeg raw out:=image_raw/uncompressed --ros-args -p "ffmpeg_image_transport.map.hevc:=hevc_cuvid,hevc"
+  ros2 run image_transport republish ffmpeg in/ffmpeg:=image_raw/ffmpeg raw out:=image_raw/uncompressed --ros-args -p "ffmpeg_image_transport.decoders.hevc:=hevc_cuvid,hevc"
   ```
 - ROS 2 Jazzy:
   ```
-  ros2 run image_transport republish --ros-args -p in_transport:=ffmpeg -p out_transport:=raw --remap in/ffmpeg:=image_raw/ffmpeg --remap out:=image_raw/uncompressed -p "ffmpeg_image_transport.map.hevc:=hevc_cuvid,hevc"
+  ros2 run image_transport republish --ros-args -p in_transport:=ffmpeg -p out_transport:=raw --remap in/ffmpeg:=image_raw/ffmpeg --remap out:=image_raw/uncompressed -p "ffmpeg_image_transport.decoders.hevc:=hevc_cuvid,hevc"
   ```
 
 Note: The commands below use the Humble syntax and need to be changed as shown here for Jazzy.
 
 Republishing is generally not necessary so long as publisher and subscriber both properly use
 an image transport.
 Some nodes however, notably the rosbag player, do not support a proper transport, making republishing necessary.
-Please use the republishing launch file (``republish.launch.py``) in this repo as a starting point for how to set the decoding map.
+Please use the republishing launch file (``republish.launch.py``) in this repo as a starting point for how to set the decoders parameter.
 
 #### Republishing raw images from rosbags in ffmpeg format
 

include/ffmpeg_image_transport/ffmpeg_publisher.hpp

@@ -64,14 +64,14 @@ class FFMPEGPublisher : public FFMPEGPublisherPlugin
     uint32_t width, uint32_t height, uint64_t pts, uint8_t flags, uint8_t * data, size_t sz);
 
   QoSType initialize(rclcpp::Node * node, const std::string & base_name, QoSType custom_qos);
-  void declareParameter(
-    rclcpp::Node * node, const std::string & base_name, const ParameterDefinition & definition);
+  void declareParameter(rclcpp::Node * node, const ParameterDefinition & definition);
   void handleAVOptions(const std::string & opt);
   // variables ---------
   rclcpp::Logger logger_;
   const PublisherTFn * publishFunction_{NULL};
   ffmpeg_encoder_decoder::Encoder encoder_;
   uint32_t frameCounter_{0};
+  std::string paramNamespace_;
   // ---------- configurable parameters
   int performanceInterval_{175};  // num frames between perf printouts
   bool measurePerformance_{false};

include/ffmpeg_image_transport/ffmpeg_subscriber.hpp

@@ -61,16 +61,15 @@ class FFMPEGSubscriber : public FFMPEGSubscriberPlugin
   void frameReady(const ImageConstPtr & img, bool /*isKeyFrame*/) const;
   void initialize(rclcpp::Node * node, const std::string & base_topic);
   std::string getDecodersFromMap(const std::string & encoding);
-  void declareParameter(
-    rclcpp::Node * node, const std::string & base_name, const ParameterDefinition & definition);
+  void declareParameter(rclcpp::Node * node, const ParameterDefinition & definition);
   void handleAVOptions(const std::string & opt);
   // -------------- variables
   rclcpp::Logger logger_;
   rclcpp::Node * node_{nullptr};
   ffmpeg_encoder_decoder::Decoder decoder_;
   std::string decoderType_;
   const Callback * userCallback_{nullptr};
-  std::string param_namespace_;
+  std::string paramNamespace_;
 };
 }  // namespace ffmpeg_image_transport
 #endif  // FFMPEG_IMAGE_TRANSPORT__FFMPEG_SUBSCRIBER_HPP_

include/ffmpeg_image_transport/parameter_definition.hpp

@@ -25,8 +25,7 @@ struct ParameterDefinition
   using ParameterDescriptor = rcl_interfaces::msg::ParameterDescriptor;
   using ParameterValue = rclcpp::ParameterValue;
 
-  rclcpp::ParameterValue declare(
-    rclcpp::Node * node, const std::string & baseName, const std::string & transportName) const;
+  rclcpp::ParameterValue declare(rclcpp::Node * node, const std::string & paramBase) const;
   // ---- variables
   ParameterValue defaultValue;
   ParameterDescriptor descriptor;

launch/republish.launch.py

@@ -40,10 +40,10 @@ def launch_setup(context, *args, **kwargs):
                     {
                         "in_transport": LaunchConfig("in_transport"),
                         "out_transport": LaunchConfig("out_transport"),
-                        ".image_raw.ffmpeg.map.h264": "h264,h264_cuvid,h264_qsv,h264_v4l2m2m",
-                        ".image_raw.ffmpeg.map.hevc": "hevc_cuvid,hevc_qsv,hevc_v4l2m2m,hevc",
-                        ".image_raw.ffmpeg.map.av1": "libaom-av1,av1_cuvid,av1,av1_qs,libdav1d",
-                        ".image_raw.ffmpeg.measure_performance": False,
+                        "image_raw.ffmpeg.decoders.h264": "h264,h264_cuvid,h264_qsv,h264_v4l2m2m",
+                        "image_raw.ffmpeg.decoders.hevc": "hevc_cuvid,hevc_qsv,hevc_v4l2m2m,hevc",
+                        "image_raw.ffmpeg.decoders.av1": "libaom-av1,av1_cuvid,av1,av1_qs,libdav1d",
+                        "image_raw.ffmpeg.decoder_measure_performance": False,
                     }
                 ],
                 # remap the 'in' topic to the topic under which the

src/ffmpeg_publisher.cpp

@@ -32,7 +32,7 @@ static const ParameterDefinition params[] = {
      .set__read_only(false)},
   {ParameterValue(""),
    ParameterDescriptor()
-     .set__name("av_options")
+     .set__name("encoder_av_options")
      .set__type(rcl_interfaces::msg::ParameterType::PARAMETER_STRING)
      .set__description("comma-separated list of AV options: profile:main,preset:ll")
      .set__read_only(false)},
@@ -80,20 +80,10 @@ static const ParameterDefinition params[] = {
                             .set__to_value(std::numeric_limits<int>::max())
                             .set__step(1)})},
   {ParameterValue(false), ParameterDescriptor()
-                            .set__name("measure_performance")
+                            .set__name("encoder_measure_performance")
                             .set__type(rcl_interfaces::msg::ParameterType::PARAMETER_BOOL)
                             .set__description("enable performance timing")
                             .set__read_only(false)},
-  {ParameterValue(static_cast<int>(175)),
-   ParameterDescriptor()
-     .set__name("performance_interval")
-     .set__type(rcl_interfaces::msg::ParameterType::PARAMETER_INTEGER)
-     .set__description("after how many frames to print perf info")
-     .set__read_only(false)
-     .set__integer_range({rcl_interfaces::msg::IntegerRange()
-                            .set__from_value(1)
-                            .set__to_value(std::numeric_limits<int>::max())
-                            .set__step(1)})},
 };
 
 FFMPEGPublisher::FFMPEGPublisher() : logger_(rclcpp::get_logger("FFMPEGPublisher")) {}
@@ -110,16 +100,15 @@ void FFMPEGPublisher::shutdown()
 
 // This code was lifted from compressed_image_transport
 
-void FFMPEGPublisher::declareParameter(
-  rclcpp::Node * node, const std::string & base_name, const ParameterDefinition & definition)
+void FFMPEGPublisher::declareParameter(rclcpp::Node * node, const ParameterDefinition & definition)
 {
   // transport scoped parameter (e.g. image_raw.compressed.format)
-  const auto v = definition.declare(node, base_name, getTransportName());
+  const auto v = definition.declare(node, paramNamespace_);
   const auto & n = definition.descriptor.name;
   if (n == "encoder") {
     encoder_.setEncoder(v.get<std::string>());
     RCLCPP_INFO_STREAM(logger_, "using libav encoder: " << v.get<std::string>());
-  } else if (n == "av_options") {
+  } else if (n == "encoder_av_options") {
     handleAVOptions(v.get<std::string>());
   } else if (n == "pixel_format") {
     encoder_.setAVSourcePixelFormat(v.get<std::string>());
@@ -131,11 +120,9 @@ void FFMPEGPublisher::declareParameter(
     encoder_.setBitRate(v.get<int>());
   } else if (n == "gop_size") {
     encoder_.setGOPSize(v.get<int>());
-  } else if (n == "measure_performance") {
+  } else if (n == "encoder_measure_performance") {
     measurePerformance_ = v.get<bool>();
     encoder_.setMeasurePerformance(v.get<bool>());
-  } else if (n == "performance_interval") {
-    performanceInterval_ = v.get<int>();
   } else {
     RCLCPP_ERROR_STREAM(logger_, "unknown parameter: " << n);
   }
@@ -196,12 +183,16 @@ FFMPEGPublisher::QoSType FFMPEGPublisher::initialize(
   rclcpp::Node * node, const std::string & base_topic, QoSType custom_qos)
 {
   // namespace handling code lifted from compressed_image_transport
-  const uint ns_len = node->get_effective_namespace().length();
-  std::string param_base_name = base_topic.substr(ns_len);
+  uint ns_len = node->get_effective_namespace().length();
+  // if a namespace is given (ns_len > 1), then strip one more
+  // character to avoid a leading "/" that will then become a "."
+  uint ns_prefix_len = ns_len > 1 ? ns_len + 1 : ns_len;
+  std::string param_base_name = base_topic.substr(ns_prefix_len);
   std::replace(param_base_name.begin(), param_base_name.end(), '/', '.');
+  paramNamespace_ = param_base_name + "." + getTransportName() + ".";
 
   for (const auto & p : params) {
-    declareParameter(node, param_base_name, p);
+    declareParameter(node, p);
   }
   // bump queue size to 2 * distance between keyframes
 #ifdef IMAGE_TRANSPORT_USE_QOS

src/ffmpeg_subscriber.cpp

@@ -30,12 +30,12 @@ using ffmpeg_encoder_decoder::utils::split_by_char;
 
 static const ParameterDefinition params[] = {
   {PValue(""), PDescriptor()
-                 .set__name("av_options")
+                 .set__name("decoder_av_options")
                  .set__type(rcl_interfaces::msg::ParameterType::PARAMETER_STRING)
                  .set__description("comma-separated list of AV options: delay:0")
                  .set__read_only(false)},
   {PValue(false), PDescriptor()
-                    .set__name("measure_performance")
+                    .set__name("decoder_measure_performance")
                     .set__type(rcl_interfaces::msg::ParameterType::PARAMETER_BOOL)
                     .set__description("enable performance timing")
                     .set__read_only(false)}};
@@ -83,28 +83,35 @@ void FFMPEGSubscriber::subscribeImpl(
 #endif
 }
 #endif
-void FFMPEGSubscriber::initialize(rclcpp::Node * node, const std::string & base_topic)
+void FFMPEGSubscriber::initialize(rclcpp::Node * node, const std::string & base_topic_o)
 {
   node_ = node;
+#ifdef IMAGE_TRANSPORT_RESOLVES_BASE_TOPIC
+  const std::string base_topic = base_topic_o;
+#else
+  const std::string base_topic =
+    node_->get_node_topics_interface()->resolve_topic_name(base_topic_o);
+#endif
   uint ns_len = node_->get_effective_namespace().length();
-  std::string param_base_name = base_topic.substr(ns_len);
+  // if a namespace is given (ns_len > 1), then strip one more
+  // character to avoid a leading "/" that will then become a "."
+  uint ns_prefix_len = ns_len > 1 ? ns_len + 1 : ns_len;
+  std::string param_base_name = base_topic.substr(ns_prefix_len);
   std::replace(param_base_name.begin(), param_base_name.end(), '/', '.');
-  param_namespace_ = param_base_name + "." + getTransportName() + ".";
+  paramNamespace_ = param_base_name + "." + getTransportName() + ".";
 
   for (const auto & p : params) {
-    declareParameter(node, param_base_name, p);
+    declareParameter(node, p);
   }
 }
 
-void FFMPEGSubscriber::declareParameter(
-  rclcpp::Node * node, const std::string & base_name, const ParameterDefinition & definition)
+void FFMPEGSubscriber::declareParameter(rclcpp::Node * node, const ParameterDefinition & definition)
 {
-  // transport scoped parameter (e.g. image_raw.compressed.format)
-  const auto v = definition.declare(node, base_name, getTransportName());
+  const auto v = definition.declare(node, paramNamespace_);
   const auto & n = definition.descriptor.name;
-  if (n == "av_options") {
+  if (n == "decoder_av_options") {
     handleAVOptions(v.get<std::string>());
-  } else if (n == "measure_performance") {
+  } else if (n == "decoder_measure_performance") {
     decoder_.setMeasurePerformance(v.get<bool>());
   } else {
     RCLCPP_ERROR_STREAM(logger_, "unknown parameter: " << n);
@@ -115,23 +122,20 @@ std::string FFMPEGSubscriber::getDecodersFromMap(const std::string & encoding)
 {
   const auto x = split_by_char(encoding, ';');
   std::string decoders;
+  // successively create parameters that are more and more generic,
+  // i.e. hevc.yuv
   for (int i = static_cast<int>(x.size()); i > 0; --i) {
     std::string p_name;
     for (int j = 0; j < i; j++) {
       p_name += "." + x[j];
     }
-    const std::string key = param_namespace_ + "map" + p_name;
-    rcl_interfaces::msg::ParameterDescriptor pd;
-    pd.set__name(p_name)
-      .set__type(rcl_interfaces::msg::ParameterType::PARAMETER_STRING)
-      .set__description("decoders for encoding: " + p_name)
-      .set__read_only(false);
-    try {
-      decoders = node_->declare_parameter(key, rclcpp::ParameterValue(""), pd).get<std::string>();
-    } catch (const rclcpp::exceptions::ParameterAlreadyDeclaredException &) {
-      RCLCPP_DEBUG_STREAM(logger_, "was previously declared: " << p_name);
-      decoders = node_->get_parameter_or<std::string>(key, "");
-    }
+    ParameterDefinition pdef{
+      PValue(""), PDescriptor()
+                    .set__name("decoders" + p_name)
+                    .set__type(rcl_interfaces::msg::ParameterType::PARAMETER_STRING)
+                    .set__description("decoders for encoding: " + p_name)
+                    .set__read_only(false)};
+    decoders = pdef.declare(node_, paramNamespace_).get<std::string>();
     if (!decoders.empty()) {
       break;
     }

src/parameter_definition.cpp

@@ -18,11 +18,12 @@
 namespace ffmpeg_image_transport
 {
 rclcpp::ParameterValue ParameterDefinition::declare(
-  rclcpp::Node * node, const std::string & baseName, const std::string & transportName) const
+  rclcpp::Node * node, const std::string & paramBase) const
 {
   // transport scoped parameter (e.g. image_raw.compressed.format)
-  const std::string paramName = baseName + "." + transportName + "." + descriptor.name;
+  const std::string paramName = paramBase + descriptor.name;
   rclcpp::ParameterValue v;
+  std::cout << "declaring parameter: " << paramName << std::endl;
   try {
     v = node->declare_parameter(paramName, defaultValue, descriptor);
   } catch (const rclcpp::exceptions::ParameterAlreadyDeclaredException &) {