Fix usage of deprecated libavcodec functions

Author: bjsowa

include/web_video_server/libav_streamer.h

@@ -34,9 +34,9 @@ class LibavStreamer : public ImageTransportImageStreamer
   virtual void initializeEncoder();
   virtual void sendImage(const cv::Mat&, const rclcpp::Time& time);
   virtual void initialize(const cv::Mat&);
-  AVOutputFormat* output_format_;
+  AVOutputFormat output_format_;
   AVFormatContext* format_context_;
-  AVCodec* codec_;
+  const AVCodec* codec_;
   AVCodecContext* codec_context_;
   AVStream* video_stream_;
 

src/libav_streamer.cpp

@@ -8,51 +8,11 @@
 namespace web_video_server
 {
 
-static int ffmpeg_boost_mutex_lock_manager(void **mutex, enum AVLockOp op)
-{
-  if (NULL == mutex)
-    return -1;
-
-  switch (op)
-  {
-    case AV_LOCK_CREATE:
-    {
-      *mutex = NULL;
-      boost::mutex *m = new boost::mutex();
-      *mutex = static_cast<void *>(m);
-      break;
-    }
-    case AV_LOCK_OBTAIN:
-    {
-      boost::mutex *m = static_cast<boost::mutex *>(*mutex);
-      m->lock();
-      break;
-    }
-    case AV_LOCK_RELEASE:
-    {
-      boost::mutex *m = static_cast<boost::mutex *>(*mutex);
-      m->unlock();
-      break;
-    }
-    case AV_LOCK_DESTROY:
-    {
-      boost::mutex *m = static_cast<boost::mutex *>(*mutex);
-      m->lock();
-      m->unlock();
-      delete m;
-      break;
-    }
-    default:
-      break;
-  }
-  return 0;
-}
-
 LibavStreamer::LibavStreamer(const async_web_server_cpp::HttpRequest &request,
                              async_web_server_cpp::HttpConnectionPtr connection, rclcpp::Node::SharedPtr nh,
                              const std::string &format_name, const std::string &codec_name,
                              const std::string &content_type) :
-    ImageTransportImageStreamer(request, connection, nh), output_format_(0), format_context_(0), codec_(0), codec_context_(0), video_stream_(
+    ImageTransportImageStreamer(request, connection, nh), format_context_(0), codec_(0), codec_context_(0), video_stream_(
         0), frame_(0), sws_context_(0), first_image_timestamp_(0), format_name_(
         format_name), codec_name_(codec_name), content_type_(content_type), opt_(0), io_buffer_(0)
 {
@@ -61,9 +21,6 @@ LibavStreamer::LibavStreamer(const async_web_server_cpp::HttpRequest &request,
   qmin_ = request.get_query_param_value_or_default<int>("qmin", 10);
   qmax_ = request.get_query_param_value_or_default<int>("qmax", 42);
   gop_ = request.get_query_param_value_or_default<int>("gop", 250);
-
-  av_lockmgr_register(&ffmpeg_boost_mutex_lock_manager);
-  av_register_all();
 }
 
 LibavStreamer::~LibavStreamer()
@@ -111,15 +68,18 @@ void LibavStreamer::initialize(const cv::Mat &img)
                                                                                                          NULL, NULL);
     throw std::runtime_error("Error allocating ffmpeg format context");
   }
-  output_format_ = av_guess_format(format_name_.c_str(), NULL, NULL);
-  if (!output_format_)
+  const AVOutputFormat* guessed_format = av_guess_format(format_name_.c_str(), NULL, NULL);
+  if (!guessed_format)
   {
     async_web_server_cpp::HttpReply::stock_reply(async_web_server_cpp::HttpReply::internal_server_error)(request_,
                                                                                                          connection_,
                                                                                                          NULL, NULL);
     throw std::runtime_error("Error looking up output format");
   }
-  format_context_->oformat = output_format_;
+
+
+  output_format_ = *guessed_format;
+  format_context_->oformat = &output_format_;
 
   // Set up custom IO callback.
   size_t io_buffer_size = 3 * 1024;    // 3M seen elsewhere and adjudged good
@@ -134,12 +94,12 @@ void LibavStreamer::initialize(const cv::Mat &img)
   }
   io_ctx->seekable = 0;                       // no seeking, it's a stream
   format_context_->pb = io_ctx;
-  output_format_->flags |= AVFMT_FLAG_CUSTOM_IO;
-  output_format_->flags |= AVFMT_NOFILE;
+  output_format_.flags |= AVFMT_FLAG_CUSTOM_IO;
+  output_format_.flags |= AVFMT_NOFILE;
 
   // Load codec
   if (codec_name_.empty()) // use default codec if none specified
-    codec_ = avcodec_find_encoder(output_format_->video_codec);
+    codec_ = avcodec_find_encoder(output_format_.video_codec);
   else
     codec_ = avcodec_find_encoder_by_name(codec_name_.c_str());
   if (!codec_)
@@ -157,11 +117,10 @@ void LibavStreamer::initialize(const cv::Mat &img)
                                                                                                          NULL, NULL);
     throw std::runtime_error("Error creating video stream");
   }
-  codec_context_ = video_stream_->codec;
 
-  // Set options
-  avcodec_get_context_defaults3(codec_context_, codec_);
+  codec_context_ = avcodec_alloc_context3(codec_); 
 
+  // Set options
   codec_context_->codec_id = codec_->id;
   codec_context_->bit_rate = bitrate_;
 
@@ -209,7 +168,7 @@ void LibavStreamer::initialize(const cv::Mat &img)
   frame_->width = output_width_;
   frame_->height = output_height_;
   frame_->format = codec_context_->pix_fmt;
-  output_format_->flags |= AVFMT_NOFILE;
+  output_format_.flags |= AVFMT_NOFILE;
 
   // Generate header
   std::vector<uint8_t> header_buffer;
@@ -289,9 +248,8 @@ void LibavStreamer::sendImage(const cv::Mat &img, const rclcpp::Time &time)
 #endif
 
   // Encode the frame
-  AVPacket pkt;
+  AVPacket* pkt = av_packet_alloc();
   int got_packet;
-  av_init_packet(&pkt);
 
 #if (LIBAVCODEC_VERSION_MAJOR < 54)
   int buf_size = 6 * output_width_ * output_height_;
@@ -306,16 +264,15 @@ void LibavStreamer::sendImage(const cv::Mat &img, const rclcpp::Time &time)
      throw std::runtime_error("Error encoding video frame");
   }
 #else
-  pkt.data = NULL; // packet data will be allocated by the encoder
-  pkt.size = 0;
   if (avcodec_send_frame(codec_context_, frame_) < 0)
   {
     throw std::runtime_error("Error encoding video frame");
   }
-  if (avcodec_receive_packet(codec_context_, &pkt) < 0)
+  if (avcodec_receive_packet(codec_context_, pkt) < 0)
   {
     throw std::runtime_error("Error retrieving encoded packet");
   }
+  got_packet = pkt->size > 0;
 #endif
 
   if (got_packet)
@@ -325,17 +282,17 @@ void LibavStreamer::sendImage(const cv::Mat &img, const rclcpp::Time &time)
 
     double seconds = (time - first_image_timestamp_).seconds();
     // Encode video at 1/0.95 to minimize delay
-    pkt.pts = (int64_t)(seconds / av_q2d(video_stream_->time_base) * 0.95);
-    if (pkt.pts <= 0)
-      pkt.pts = 1;
-    pkt.dts = AV_NOPTS_VALUE;
+    pkt->pts = (int64_t)(seconds / av_q2d(video_stream_->time_base) * 0.95);
+    if (pkt->pts <= 0)
+      pkt->pts = 1;
+    pkt->dts = AV_NOPTS_VALUE;
 
-    if (pkt.flags&AV_PKT_FLAG_KEY)
-      pkt.flags |= AV_PKT_FLAG_KEY;
+    if (pkt->flags&AV_PKT_FLAG_KEY)
+      pkt->flags |= AV_PKT_FLAG_KEY;
 
-    pkt.stream_index = video_stream_->index;
+    pkt->stream_index = video_stream_->index;
 
-    if (av_write_frame(format_context_, &pkt))
+    if (av_write_frame(format_context_, pkt))
     {
       throw std::runtime_error("Error when writing frame");
     }
@@ -351,7 +308,7 @@ void LibavStreamer::sendImage(const cv::Mat &img, const rclcpp::Time &time)
 #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(55,28,1)
   av_free_packet(&pkt);
 #else
-  av_packet_unref(&pkt);
+  av_packet_unref(pkt);
 #endif
 
   connection_->write_and_clear(encoded_frame);