use comma-separated decoder list now, use semi-colon to separate encodings

Author: berndpfrommer

include/ffmpeg_encoder_decoder/decoder.hpp

@@ -105,30 +105,13 @@ class Decoder
    * \brief Initializes the decoder for a given codec and libav decoder.
    *
    * Initializes the decoder, with multiple decoders to pick from.
-   * If the name of the libav decoder string is empty, a suitable libav decoder
-   * will be picked, or the initialization will fail if none is available.
    * \param codec  the codec (encoding) from the first packet. Can never change!
    * \param callback the function to call when frame has been decoded.
-   * \param decoder the name of the libav decoder to use. If empty string,
-   *                 the decoder will try to find a suitable one based on the encoding.
+   * \param decoder the name of the libav decoder to use.
    * \return true if initialized successfully.
    */
   bool initialize(const std::string & codec, Callback callback, const std::string & decoder);
 
-  /**
-   * \ brief initializes the decoder, trying different libavdecoders in order.
-   *
-   * Initialize decoder with multiple libav decoders to pick from.
-   * If decoders.empty() a default decoder will be chosen (if available).
-   * \param codec the codec (encoding) from the first packet. Can never change!
-   * \param callback the function to call when frame has been decoded.
-   * \param decoders names of the libav decoders to try sequentially. If empty()
-   *                 the decoder will try to find a suitable one based on the codec.
-   * \return true if successful
-   */
-  bool initialize(
-    const std::string & codec, Callback callback, const std::vector<std::string> & decoders);
-
   /**
    * \brief Sets the ROS output message encoding format.
    *
@@ -197,9 +180,9 @@ class Decoder
    * Finds the name of all hardware and software decoders (combined)
    * that match a certain codec (or encoder).
    * \param codec name of the codec, i.e. h264, hevc etc
-   * \return vector with names of matching libav decoders
+   * \return string with comma-separated list of libav decoders
    */
-  static std::vector<std::string> findDecoders(const std::string & codec);
+  static std::string findDecoders(const std::string & codec);
 
   /**
    * \brief Enables or disables performance measurements. Poorly tested, may be broken.
@@ -236,15 +219,12 @@ class Decoder
   getDefaultEncoderToDecoderMap();
 
 private:
-  bool initSingleDecoder(const std::string & decoder);
-  bool initDecoder(const std::vector<std::string> & decoders);
-  std::vector<std::string> filterDecoders(
-    const std::string & encoding, const std::vector<std::string> & decoders,
-    const std::vector<std::string> & valid_decoders);
+  bool doInitDecoder(const std::string & encoding, const std::string & decoder);
+  bool initDecoder(const std::string & encoding, const std::string & decoders);
   int receiveFrame();
   int convertFrameToMessage(const AVFrame * frame, const ImagePtr & image);
   void setAVOption(const std::string & field, const std::string & value);
-
+  void setEncoding(const std::string & encoding);
   // --------------- variables
   rclcpp::Logger logger_;
   Callback callback_;

include/ffmpeg_encoder_decoder/encoder.hpp

@@ -269,7 +269,8 @@ class Encoder
    * \param callback the function to call for handling encoded packets
    * \param encoding the ros encoding string, e.g. bayer_rggb8, rgb8 ...
    */
-  bool initialize(int width, int height, Callback callback, const std::string & encoding);
+  bool initialize(
+    int width, int height, Callback callback, const std::string & encoding = std::string());
   /**
    * \brief sets ROS logger to use for info/error messages
    * \param logger the logger to use for messages
@@ -383,6 +384,7 @@ class Encoder
   AVRational timeBase_{1, 100};
   AVRational frameRate_{100, 1};
   bool usesHardwareFrames_{false};
+  std::string avSourcePixelFormat_;
   // ------ libav state
   AVCodecContext * codecContext_{nullptr};
   AVBufferRef * hwDeviceContext_{nullptr};

include/ffmpeg_encoder_decoder/utils.hpp

@@ -112,6 +112,23 @@ void find_decoders(
   const std::string & codec, std::vector<std::string> * hw_decoders,
   std::vector<std::string> * sw_decoders);
 
+/**
+ * \brief finds the names of all available decoders
+ *        for a given codec (or encoder)
+ * \param codec the codec / encoding to find decoders for
+ * \return string with comma separated list of libav decoder names
+ */
+
+std::string find_decoders(const std::string & codec);
+/**
+ * \brief filters a string with comma-separated decoders and
+ *
+ * \param codec the codec / encoding to filter for
+ * \param decoders string with comma-separated list of decoder names
+ * \return string with comma separated list of libav decoder names
+ */
+std::string filter_decoders(const std::string & codec, const std::string & decoders);
+
 /**
  * \brief gets list of names of all libav supported device types
  *

src/decoder.cpp

@@ -50,6 +50,7 @@ void Decoder::reset()
   outputFrame_ = NULL;
   hwPixFormat_ = AV_PIX_FMT_NONE;
   outputMsgEncoding_ = "";
+  packetEncoding_ = "";
 }
 
 void Decoder::setOutputMessageEncoding(const std::string & output_encoding)
@@ -58,61 +59,29 @@ void Decoder::setOutputMessageEncoding(const std::string & output_encoding)
   outputMsgEncoding_ = output_encoding;
 }
 
-bool Decoder::initialize(
-  const std::string & encoding, Callback callback, const std::string & decoder)
+static std::vector<std::string> splitEncoding(const std::string & encoding)
 {
-  return (initialize(
-    encoding, callback,
-    decoder.empty() ? std::vector<std::string>() : std::vector<std::string>{decoder}));
+  return (utils::split_by_char(encoding, ';'));
 }
 
-bool Decoder::initialize(
-  const std::string & encoding, Callback callback, const std::vector<std::string> & decoders)
+void Decoder::setEncoding(const std::string & encoding)
 {
-  callback_ = callback;
   packetEncoding_ = encoding;
-  const auto split = utils::split_by_char(encoding, '/');
+  const auto split = splitEncoding(encoding);
   if (outputMsgEncoding_.empty()) {
     // assume orig was bgr8
-    outputMsgEncoding_ = split.size() > 1 ? split[1] : "bgr8";
+    outputMsgEncoding_ = split.size() == 4 ? split[3] : "bgr8";
     RCLCPP_INFO_STREAM(
       logger_,
-      "output image encoding: " << outputMsgEncoding_ << ((split.size() > 1) ? "" : " (default)"));
-  }
-  const auto all_decoders = findDecoders(split[0]);
-  if (all_decoders.empty()) {
-    RCLCPP_ERROR_STREAM(logger_, "no decoders discovered for code:c " << split[0]);
-    throw(std::runtime_error("no decoders discovered for codec: " + split[0]));
-  }
-  if (decoders.empty()) {  // try all libav-discovered decoders
-    std::string decoders_str;
-    for (const auto & decoder : all_decoders) {
-      decoders_str += " " + decoder;
-    }
-    RCLCPP_INFO_STREAM(logger_, "trying discovered decoders in order:" << decoders_str);
-    return (initDecoder(all_decoders));
-  }
-  const auto good_decoders = filterDecoders(encoding, decoders, all_decoders);
-  if (good_decoders.empty()) {
-    return (false);
+      "output image encoding: " << outputMsgEncoding_ << ((split.size() == 4) ? "" : " (default)"));
   }
-  return (initDecoder(good_decoders));
 }
 
-std::vector<std::string> Decoder::filterDecoders(
-  const std::string & encoding, const std::vector<std::string> & decoders,
-  const std::vector<std::string> & valid_decoders)
+bool Decoder::initialize(
+  const std::string & encoding, Callback callback, const std::string & decoder)
 {
-  std::vector<std::string> good_decoders;
-  for (const auto & dec : decoders) {  // filter for decoders matching codec
-    if (std::find(valid_decoders.begin(), valid_decoders.end(), dec) != valid_decoders.end()) {
-      good_decoders.push_back(dec);
-    } else {
-      RCLCPP_WARN_STREAM(
-        logger_, "configured decoder: " << dec << " cannot handle encoding: " << encoding);
-    }
-  }
-  return (good_decoders);
+  callback_ = callback;
+  return (initDecoder(encoding, decoder));
 }
 
 static AVBufferRef * hw_decoder_init(
@@ -232,46 +201,32 @@ enum AVPixelFormat get_format(struct AVCodecContext * avctx, const enum AVPixelF
   return AV_PIX_FMT_NONE;
 }
 
-bool Decoder::initDecoder(const std::vector<std::string> & decoders)
+bool Decoder::initDecoder(const std::string & encoding, const std::string & decoder)
 {
-  if (decoders.empty()) {
-    RCLCPP_ERROR_STREAM(logger_, "no decoders configured for this encoding!");
-    throw(std::runtime_error("no decoders configured for this encoding!"));
+  const AVCodec * codec = avcodec_find_decoder_by_name(decoder.c_str());
+  if (!codec) {
+    RCLCPP_WARN_STREAM(logger_, "decoder " << decoder << " cannot decode " << encoding);
+    return (false);
   }
-  for (const auto & decoder : decoders) {
-    const AVCodec * codec = avcodec_find_decoder_by_name(decoder.c_str());
-    if (codec) {
-      // use the decoder if it either is software, or has working
-      // hardware support
-      if (codec->capabilities & AV_CODEC_CAP_HARDWARE) {
-        const AVCodecHWConfig * hwConfig = avcodec_get_hw_config(codec, 0);
-        if (hwConfig) {
-          if (initSingleDecoder(decoder)) {
-            return (true);
-          }
-        } else {
-          RCLCPP_INFO_STREAM(logger_, "ignoring decoder with no hardware config: " << decoder);
-        }
-      } else {
-        if (initSingleDecoder(decoder)) {
-          return (true);
-        }
-      }
-    } else {
-      RCLCPP_WARN_STREAM(logger_, "unknown decoder: " << decoder);
+  // use the decoder if it either is software, or has working
+  // hardware support
+  const AVCodecHWConfig * hwConfig = nullptr;
+  if (codec->capabilities & AV_CODEC_CAP_HARDWARE) {
+    hwConfig = avcodec_get_hw_config(codec, 0);
+    if (!hwConfig) {
+      RCLCPP_INFO_STREAM(logger_, "ignoring decoder with no hardware config: " << decoder);
+      return (false);
     }
   }
-  if (decoders.size() > 1) {
-    RCLCPP_ERROR_STREAM(logger_, "none of these requested decoders works: ");
-    for (const auto & decoder : decoders) {
-      RCLCPP_ERROR_STREAM(logger_, "  " << decoder);
-    }
+  if (!doInitDecoder(encoding, decoder)) {
+    return (false);
   }
-  throw(std::runtime_error("cannot find matching decoder!"));
+  return (true);
 }
 
-bool Decoder::initSingleDecoder(const std::string & decoder)
+bool Decoder::doInitDecoder(const std::string & encoding, const std::string & decoder)
 {
+  setEncoding(encoding);
   try {
     const AVCodec * codec = avcodec_find_decoder_by_name(decoder.c_str());
     if (!codec) {
@@ -373,7 +328,6 @@ int Decoder::receiveFrame()
     }
   }
   AVFrame * frame = isAcc ? cpuFrame_ : swFrame_;
-
   if (frame->width == ctx->width && frame->height == ctx->height) {
     // prepare the decoded message
     ImagePtr image(new Image());
@@ -504,26 +458,28 @@ void Decoder::setAVOption(const std::string & field, const std::string & value)
   }
 }
 
-const std::unordered_map<std::string, std::string> & Decoder::getDefaultEncoderToDecoderMap()
-{
-  RCLCPP_INFO_STREAM(
-    rclcpp::get_logger("ffmpeg_decoder"),
-    "default map is deprecated, use findDecoders() or pass empty string instead!");
-  throw(std::runtime_error("default map is deprecated!"));
-}
-
 void Decoder::findDecoders(
   const std::string & codec, std::vector<std::string> * hw_decoders,
   std::vector<std::string> * sw_decoders)
 {
   utils::find_decoders(codec, hw_decoders, sw_decoders);
 }
 
-std::vector<std::string> Decoder::findDecoders(const std::string & codec)
+std::string Decoder::findDecoders(const std::string & codec)
 {
-  std::vector<std::string> sw_decoders, all_decoders;
-  utils::find_decoders(codec, &all_decoders, &sw_decoders);
-  all_decoders.insert(all_decoders.end(), sw_decoders.begin(), sw_decoders.end());
-  return (all_decoders);
+  return (utils::find_decoders(codec));
 }
+
+// -------------- deprecated, DO NOT USE ------------------
+const std::unordered_map<std::string, std::string> & Decoder::getDefaultEncoderToDecoderMap()
+{
+  static const std::unordered_map<std::string, std::string> defaultMap{
+    {{"h264_nvenc", "h264"},
+     {"libx264", "h264"},
+     {"hevc_nvenc", "hevc_cuvid"},
+     {"h264_nvmpi", "h264"},
+     {"h264_vaapi", "h264"}}};
+  return (defaultMap);
+}
+
 }  // namespace ffmpeg_encoder_decoder

src/encoder.cpp

@@ -144,9 +144,6 @@ void Encoder::openHardwareDevice(
         logger_, "user overriding software pix fmt " << utils::pix(frames_ctx->sw_format));
       RCLCPP_INFO_STREAM(logger_, "with " << utils::pix(pixFormat_));
       frames_ctx->sw_format = pixFormat_;  // override default at your own risk!
-    } else {
-      RCLCPP_INFO_STREAM(
-        logger_, "using software pixel format: " << utils::pix(frames_ctx->sw_format));
     }
     if (frames_ctx->sw_format == AV_PIX_FMT_NONE) {
       av_buffer_unref(&hwframe_ctx_ref);
@@ -198,10 +195,9 @@ enum AVPixelFormat Encoder::findMatchingSourceFormat(
   return (utils::ros_to_av_pix_format(rosSrcFormat));
 }
 
-void Encoder::doOpenCodec(int width, int height, const std::string &)
+void Encoder::doOpenCodec(int width, int height, const std::string & origEncoding)
 {
   int err = 0;
-  encoding_ = codec_ + "/" + cvBridgeTargetFormat_;
 
   codecContext_ = nullptr;
   if (encoder_.empty()) {
@@ -255,6 +251,9 @@ void Encoder::doOpenCodec(int width, int height, const std::string &)
                                : utils::get_preferred_pixel_format(usesHardwareFrames_, pixFmts);
     codecContext_->sw_pix_fmt = codecContext_->pix_fmt;
   }
+  avSourcePixelFormat_ = utils::pix(codecContext_->sw_pix_fmt);
+  RCLCPP_INFO_STREAM(logger_, "using av_source_pixel_format: " << avSourcePixelFormat_);
+
   std::stringstream ss;
   for (const auto & kv : avOptions_) {
     setAVOption(kv.first, kv.second);
@@ -322,6 +321,8 @@ void Encoder::doOpenCodec(int width, int height, const std::string &)
       throw(std::runtime_error("cannot allocate sws context"));
     }
   }
+  encoding_ = codec_ + ";" + avSourcePixelFormat_ + ";" + cvBridgeTargetFormat_ + ";" +
+              (origEncoding.empty() ? cvBridgeTargetFormat_ : origEncoding);
 }
 
 void Encoder::setAVOption(const std::string & field, const std::string & value)

src/utils.cpp

@@ -294,6 +294,35 @@ void find_decoders(
   find_decoders(real_encoding, sw_decoders, false);
 }
 
+std::string find_decoders(const std::string & codec)
+{
+  std::string decoders;
+  std::vector<std::string> hw_dec;
+  std::vector<std::string> sw_dec;
+  find_decoders(codec, &hw_dec, &sw_dec);
+  for (const auto & s : hw_dec) {
+    decoders += (decoders.empty() ? "" : ",") + s;
+  }
+  for (const auto & s : sw_dec) {
+    decoders += (decoders.empty() ? "" : ",") + s;
+  }
+  return decoders;
+}
+
+std::string filter_decoders(const std::string & codec, const std::string & decoders)
+{
+  std::string filtered;
+  const auto valid_decoders = split_by_char(find_decoders(codec), ',');
+  for (const auto & dec : split_by_char(decoders, ',')) {
+    for (const auto & valid : valid_decoders) {
+      if (dec == valid) {
+        filtered += (filtered.empty() ? "" : ",") + dec;
+      }
+    }
+  }
+  return (filtered);
+}
+
 std::string find_codec(const std::string & encoder)
 {
   const AVCodec * c = find_by_name(encoder);