Enable other misc checks

Author: bjsowa

.clang-tidy

@@ -3,7 +3,8 @@ Checks: >
   -clang-analyzer-*,
   clang-diagnostic-*,
   google-*,
-  misc-include-cleaner,
+  misc-*,
+  -misc-non-private-member-variables-in-classes,
   readability-*,
   -readability-identifier-length,
   -readability-magic-numbers,
@@ -18,7 +19,7 @@ CheckOptions:
   readability-identifier-naming.EnumConstantCase: CamelCase
   readability-identifier-naming.FunctionCase: lower_case
   readability-identifier-naming.GlobalConstantCase: CamelCase
-  readability-identifier-naming.StaticConstantCase: CamelCase
+  readability-identifier-naming.StaticConstantCase: lower_case
   readability-identifier-naming.StaticVariableCase: lower_case
   readability-identifier-naming.MacroDefinitionCase: UPPER_CASE
   readability-identifier-naming.MacroDefinitionIgnoredRegexp: '^[A-Z]+(_[A-Z]+)*_$'

src/multipart_stream.cpp

@@ -76,7 +76,7 @@ void MultipartStream::send_part_header(
   snprintf(
     stamp, sizeof(stamp), "%.06lf",
     std::chrono::duration_cast<std::chrono::duration<double>>(time.time_since_epoch()).count());
-  std::shared_ptr<std::vector<async_web_server_cpp::HttpHeader>> headers(
+  const std::shared_ptr<std::vector<async_web_server_cpp::HttpHeader>> headers(
     new std::vector<async_web_server_cpp::HttpHeader>());
   headers->push_back(async_web_server_cpp::HttpHeader("Content-type", type));
   headers->push_back(async_web_server_cpp::HttpHeader("X-Timestamp", stamp));
@@ -88,7 +88,7 @@ void MultipartStream::send_part_header(
 
 void MultipartStream::send_part_footer(const std::chrono::steady_clock::time_point & time)
 {
-  std::shared_ptr<std::string> str(new std::string("\r\n--" + boundary_ + "\r\n"));
+  const std::shared_ptr<std::string> str(new std::string("\r\n--" + boundary_ + "\r\n"));
   PendingFooter pf;
   pf.timestamp = time;
   pf.contents = str;

src/streamers/image_transport_streamer.cpp

@@ -118,7 +118,7 @@ void ImageTransportStreamerBase::start()
     return;
   }
 
-  image_transport::TransportHints hints(node.get(), default_transport_);
+  const image_transport::TransportHints hints(node.get(), default_transport_);
   auto tnat = node->get_topic_names_and_types();
   inactive_ = true;
   for (auto topic_and_types : tnat) {
@@ -190,8 +190,8 @@ void ImageTransportStreamerBase::image_callback(const sensor_msgs::msg::Image::C
   cv::Mat img;
   try {
     img = decode_image(msg);
-    int input_width = img.cols;
-    int input_height = img.rows;
+    const int input_width = img.cols;
+    const int input_height = img.rows;
 
     if (output_width_ == -1) {
       output_width_ = input_width;
@@ -206,10 +206,10 @@ void ImageTransportStreamerBase::image_callback(const sensor_msgs::msg::Image::C
       cv::flip(img, img, 1);
     }
 
-    std::scoped_lock lock(send_mutex_);  // protects output_size_image_
+    const std::scoped_lock lock(send_mutex_);  // protects output_size_image_
     if (output_width_ != input_width || output_height_ != input_height) {
       cv::Mat img_resized;
-      cv::Size new_size(output_width_, output_height_);
+      const cv::Size new_size(output_width_, output_height_);
       cv::resize(img, img_resized, new_size);
       output_size_image_ = img_resized;
     } else {
@@ -243,7 +243,7 @@ void ImageTransportStreamerBase::try_send_image(
   rclcpp::Node & node)
 {
   try {
-    std::scoped_lock lock(send_mutex_);
+    const std::scoped_lock lock(send_mutex_);
     send_image(img, std::chrono::steady_clock::now());
   } catch (boost::system::system_error & e) {
     // happens when client disconnects
@@ -268,7 +268,7 @@ cv::Mat ImageTransportStreamerBase::decode_image(
 {
   if (msg->encoding.find("F") != std::string::npos) {
     // scale floating point images
-    cv::Mat float_image_bridge = cv_bridge::toCvCopy(msg, msg->encoding)->image;
+    const cv::Mat float_image_bridge = cv_bridge::toCvCopy(msg, msg->encoding)->image;
     cv::Mat_<float> float_image = float_image_bridge;
     double max_val;
     cv::minMaxIdx(float_image, 0, &max_val);

src/streamers/jpeg_streamers.cpp

@@ -69,7 +69,7 @@ MjpegStreamer::MjpegStreamer(
 MjpegStreamer::~MjpegStreamer()
 {
   this->inactive_ = true;
-  std::scoped_lock lock(send_mutex_);  // protects send_image.
+  const std::scoped_lock lock(send_mutex_);  // protects send_image.
 }
 
 void MjpegStreamer::send_image(
@@ -106,7 +106,7 @@ JpegSnapshotStreamer::JpegSnapshotStreamer(
 JpegSnapshotStreamer::~JpegSnapshotStreamer()
 {
   this->inactive_ = true;
-  std::scoped_lock lock(send_mutex_);  // protects send_image.
+  const std::scoped_lock lock(send_mutex_);  // protects send_image.
 }
 
 void JpegSnapshotStreamer::send_image(

src/streamers/libav_streamer.cpp

@@ -112,20 +112,22 @@ LibavStreamerBase::~LibavStreamerBase()
   }
 }
 
+namespace {
 // output callback for ffmpeg IO context
 #if LIBAVFORMAT_VERSION_MAJOR < 61  // NOLINT(misc-include-cleaner)
-static int dispatch_output_packet(void * opaque, uint8_t * buffer, int buffer_size)
+int dispatch_output_packet(void * opaque, uint8_t * buffer, int buffer_size)
 #else
-static int dispatch_output_packet(void * opaque, const uint8_t * buffer, int buffer_size)
+int dispatch_output_packet(void * opaque, const uint8_t * buffer, int buffer_size)
 #endif
 {
-  async_web_server_cpp::HttpConnectionPtr connection =
+  const async_web_server_cpp::HttpConnectionPtr connection =
     *(static_cast<async_web_server_cpp::HttpConnectionPtr *>(opaque));
   std::vector<uint8_t> encoded_frame;
   encoded_frame.assign(buffer, buffer + buffer_size);
   connection->write_and_clear(encoded_frame);
   return 0;
 }
+}  // namespace
 
 void LibavStreamerBase::initialize(const cv::Mat & /* img */)
 {
@@ -145,7 +147,7 @@ void LibavStreamerBase::initialize(const cv::Mat & /* img */)
   }
 
   // Set up custom IO callback.
-  size_t io_buffer_size = 3 * 1024;    // 3M seen elsewhere and adjudged good
+  const size_t io_buffer_size = 3 * 1024;    // 3M seen elsewhere and adjudged good
   io_buffer_ = new unsigned char[io_buffer_size];
   AVIOContext * io_ctx = avio_alloc_context(
     io_buffer_, io_buffer_size, AVIO_FLAG_WRITE,
@@ -255,13 +257,13 @@ void LibavStreamerBase::send_image(
   const cv::Mat & img,
   const std::chrono::steady_clock::time_point & time)
 {
-  std::scoped_lock lock(encode_mutex_);
+  const std::scoped_lock lock(encode_mutex_);
   if (!first_image_received_) {
     first_image_received_ = true;
     first_image_time_ = time;
   }
 
-  AVPixelFormat input_coding_format = AV_PIX_FMT_BGR24;
+  const AVPixelFormat input_coding_format = AV_PIX_FMT_BGR24;
 
   AVFrame * raw_frame = av_frame_alloc();
   av_image_fill_arrays(
@@ -270,7 +272,7 @@ void LibavStreamerBase::send_image(
 
   // Convert from opencv to libav
   if (sws_context_ == nullptr) {
-    static int sws_flags = SWS_BICUBIC;
+    static const int sws_flags = SWS_BICUBIC;
     sws_context_ = sws_getContext(
       output_width_, output_height_, input_coding_format, output_width_,
       output_height_, codec_context_->pix_fmt, sws_flags, NULL, NULL, NULL);
@@ -310,7 +312,7 @@ void LibavStreamerBase::send_image(
   }
 
   if (got_packet) {
-    double seconds = std::chrono::duration_cast<std::chrono::duration<double>>(
+    const double seconds = std::chrono::duration_cast<std::chrono::duration<double>>(
       time - first_image_time_).count();
     // Encode video at 1/0.95 to minimize delay
     pkt->pts = static_cast<int64_t>(seconds / av_q2d(video_stream_->time_base) * 0.95);

src/streamers/png_streamers.cpp

@@ -74,7 +74,7 @@ PngStreamer::PngStreamer(
 PngStreamer::~PngStreamer()
 {
   this->inactive_ = true;
-  std::scoped_lock lock(send_mutex_);  // protects send_image.
+  const std::scoped_lock lock(send_mutex_);  // protects send_image.
 }
 
 cv::Mat PngStreamer::decode_image(const sensor_msgs::msg::Image::ConstSharedPtr & msg)
@@ -121,7 +121,7 @@ PngSnapshotStreamer::PngSnapshotStreamer(
 PngSnapshotStreamer::~PngSnapshotStreamer()
 {
   this->inactive_ = true;
-  std::scoped_lock lock(send_mutex_);  // protects send_image.
+  const std::scoped_lock lock(send_mutex_);  // protects send_image.
 }
 
 cv::Mat PngSnapshotStreamer::decode_image(const sensor_msgs::msg::Image::ConstSharedPtr & msg)

src/streamers/ros_compressed_streamer.cpp

@@ -171,7 +171,7 @@ RosCompressedStreamer::RosCompressedStreamer(
 RosCompressedStreamer::~RosCompressedStreamer()
 {
   this->inactive_ = true;
-  std::scoped_lock lock(send_mutex_);  // protects send_image.
+  const std::scoped_lock lock(send_mutex_);  // protects send_image.
 }
 
 void RosCompressedStreamer::start()
@@ -194,7 +194,7 @@ void RosCompressedStreamer::restream_frame(std::chrono::duration<double> max_age
   }
 
   if (last_frame_ + max_age < std::chrono::steady_clock::now()) {
-    std::scoped_lock lock(send_mutex_);
+    const std::scoped_lock lock(send_mutex_);
     // don't update last_frame, it may remain an old value.
     send_image(last_msg_, std::chrono::steady_clock::now());
   }
@@ -239,7 +239,7 @@ void RosCompressedStreamer::send_image(
 void RosCompressedStreamer::image_callback(
   const sensor_msgs::msg::CompressedImage::ConstSharedPtr msg)
 {
-  std::scoped_lock lock(send_mutex_);  // protects last_msg_ and last_frame_
+  const std::scoped_lock lock(send_mutex_);  // protects last_msg_ and last_frame_
   last_msg_ = msg;
   last_frame_ = std::chrono::steady_clock::now();
   send_image(last_msg_, last_frame_);
@@ -259,7 +259,7 @@ std::shared_ptr<StreamerInterface> RosCompressedStreamerFactory::create_streamer
     return nullptr;
   }
 
-  std::string topic = request.get_query_param_value_or_default("topic", "");
+  const std::string topic = request.get_query_param_value_or_default("topic", "");
   if (!has_compressed_topic(*node_locked, topic)) {
     RCLCPP_WARN(
       node_locked->get_logger().get_child("RosCompressedStreamerFactory"),
@@ -383,7 +383,7 @@ RosCompressedSnapshotStreamerFactory::create_streamer(
     return nullptr;
   }
 
-  std::string topic = request.get_query_param_value_or_default("topic", "");
+  const std::string topic = request.get_query_param_value_or_default("topic", "");
   if (!has_compressed_topic(*node_locked, topic)) {
     RCLCPP_WARN(
       node_locked->get_logger().get_child("RosCompressedSnapshotStreamerFactory"),

src/streamers/vp8_streamer.cpp

@@ -80,7 +80,7 @@ void Vp8Streamer::initialize_encoder()
   }
 
   // Buffering settings
-  int bufsize = 10;
+  const int bufsize = 10;
   codec_context_->rc_buffer_size = bufsize;
   codec_context_->rc_initial_buffer_occupancy = bufsize;  // bitrate/3;
   av_opt_set_int(codec_context_->priv_data, "bufsize", bufsize, 0);

src/web_video_server.cpp

@@ -156,7 +156,7 @@ WebVideoServer::~WebVideoServer()
 
 void WebVideoServer::restream_frames(std::chrono::duration<double> max_age)
 {
-  std::scoped_lock lock(streamers_mutex_);
+  const std::scoped_lock lock(streamers_mutex_);
 
   for (auto & streamer : streamers_) {
     streamer->restream_frame(max_age);
@@ -165,7 +165,7 @@ void WebVideoServer::restream_frames(std::chrono::duration<double> max_age)
 
 void WebVideoServer::cleanup_inactive_streams()
 {
-  std::unique_lock lock(streamers_mutex_, std::try_to_lock);
+  const std::unique_lock lock(streamers_mutex_, std::try_to_lock);
   if (lock) {
     auto new_end = std::partition(
       streamers_.begin(), streamers_.end(),
@@ -201,12 +201,12 @@ bool WebVideoServer::handle_stream(
   async_web_server_cpp::HttpConnectionPtr connection, const char * begin,
   const char * end)
 {
-  std::string type = request.get_query_param_value_or_default("type", default_stream_type_);
+  const std::string type = request.get_query_param_value_or_default("type", default_stream_type_);
   if (streamer_factories_.find(type) != streamer_factories_.end()) {
-    std::shared_ptr<StreamerInterface> streamer = streamer_factories_[type]->create_streamer(
+    const std::shared_ptr<StreamerInterface> streamer = streamer_factories_[type]->create_streamer(
       request, connection, weak_from_this());
     streamer->start();
-    std::scoped_lock lock(streamers_mutex_);
+    const std::scoped_lock lock(streamers_mutex_);
     streamers_.push_back(streamer);
   } else {
     async_web_server_cpp::HttpReply::stock_reply(async_web_server_cpp::HttpReply::not_found)(
@@ -220,13 +220,13 @@ bool WebVideoServer::handle_snapshot(
   async_web_server_cpp::HttpConnectionPtr connection, const char * begin,
   const char * end)
 {
-  std::string type = request.get_query_param_value_or_default("type", default_snapshot_type_);
+  const std::string type = request.get_query_param_value_or_default("type", default_snapshot_type_);
   if (snapshot_streamer_factories_.find(type) != snapshot_streamer_factories_.end()) {
-    std::shared_ptr<StreamerInterface> streamer =
+    const std::shared_ptr<StreamerInterface> streamer =
       snapshot_streamer_factories_[type]->create_streamer(
       request, connection, weak_from_this());
     streamer->start();
-    std::scoped_lock lock(streamers_mutex_);
+    const std::scoped_lock lock(streamers_mutex_);
     streamers_.push_back(streamer);
   } else {
     async_web_server_cpp::HttpReply::stock_reply(async_web_server_cpp::HttpReply::not_found)(
@@ -240,9 +240,9 @@ bool WebVideoServer::handle_stream_viewer(
   async_web_server_cpp::HttpConnectionPtr connection, const char * begin,
   const char * end)
 {
-  std::string type = request.get_query_param_value_or_default("type", default_stream_type_);
+  const std::string type = request.get_query_param_value_or_default("type", default_stream_type_);
   if (streamer_factories_.find(type) != streamer_factories_.end()) {
-    std::string topic = request.get_query_param_value_or_default("topic", "");
+    const std::string topic = request.get_query_param_value_or_default("topic", "");
 
     async_web_server_cpp::HttpReply::builder(async_web_server_cpp::HttpReply::ok)
     .header("Connection", "close")
@@ -274,7 +274,7 @@ bool WebVideoServer::handle_list_streams(
 
   for (const auto & factory_pair : streamer_factories_) {
     RCLCPP_DEBUG(get_logger(), "Getting topics from factory: %s", factory_pair.first.c_str());
-    std::vector<std::string> factory_topics =
+    const std::vector<std::string> factory_topics =
       factory_pair.second->get_available_topics(*this);
     RCLCPP_DEBUG(
       get_logger(), "Factory %s returned %zu topics",
@@ -288,7 +288,7 @@ bool WebVideoServer::handle_list_streams(
 
   for (const auto & factory_pair : snapshot_streamer_factories_) {
     RCLCPP_DEBUG(get_logger(), "Getting topics from factory: %s", factory_pair.first.c_str());
-    std::vector<std::string> factory_topics =
+    const std::vector<std::string> factory_topics =
       factory_pair.second->get_available_topics(*this);
     RCLCPP_DEBUG(
       get_logger(), "Factory %s returned %zu topics",