.. _program_listing_file_include_broll_frame_decoder.hpp:

Program Listing for File frame_decoder.hpp
==========================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_broll_frame_decoder.hpp>` (``include/broll/frame_decoder.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   // Copyright 2023 Bonsai Robotics, Inc - All Rights Reserved
   //
   // Licensed under the Apache License, Version 2.0 (the "License");
   // you may not use this file except in compliance with the License.
   // You may obtain a copy of the License at
   //
   //     http://www.apache.org/licenses/LICENSE-2.0
   //
   // Unless required by applicable law or agreed to in writing, software
   // distributed under the License is distributed on an "AS IS" BASIS,
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   // See the License for the specific language governing permissions and
   // limitations under the License.
   
   #ifndef BROLL__FRAME_DECODER_HPP_
   #define BROLL__FRAME_DECODER_HPP_
   
   extern "C" {
   #include <libavcodec/avcodec.h>
   #include <libavformat/avformat.h>
   #include <libavutil/pixdesc.h>
   #include <libswscale/swscale.h>
   }
   
   #include <atomic>
   
   #include "sensor_msgs/msg/compressed_image.hpp"
   #include "sensor_msgs/msg/image.hpp"
   
   namespace broll
   {
   
   class FrameDecoder
   {
   public:
     FrameDecoder(
       AVCodecID codec_id,
       AVPixelFormat target_fmt = AV_PIX_FMT_NONE,
       double scale = 1.0f,
       AVHWDeviceType hw_device_type = AV_HWDEVICE_TYPE_NONE,
       bool dbg_print = false);
     virtual ~FrameDecoder();
   
     bool decode(const AVPacket & in, sensor_msgs::msg::Image & out);
   
     bool decode(const sensor_msgs::msg::CompressedImage & in, sensor_msgs::msg::Image & out);
   
   protected:
     bool decodeFrame(const AVPacket & packet_in, AVFrame & frame_out);
   
     static void avLogCallbackWrapper(void * ptr, int level, const char * fmt, va_list vargs);
   
     void startSkippingPFrames();
   
     static AVPixelFormat getHardwarePixelFormat(AVCodecContext * ctx, const AVPixelFormat * pix_fmts);
   
     AVPacket * packet_ = nullptr;
     const AVCodec * codec_ = nullptr;
     AVCodecContext * codecCtx_ = nullptr;
     AVPixelFormat targetPixFmt_ = AV_PIX_FMT_NONE;
     SwsContext * swsCtx_ = nullptr;
     AVFrame * decodedFrame_ = nullptr;
     AVFrame * convertedFrame_ = nullptr;
   
     // Hardware decoding extras
     // Pixel format reported for an on-hardware DMA frame, such as "cuda", which isn't
     // a real pixel format but how the frame reports that it isn't in CPU memory.
     AVPixelFormat hwPixFmt_ = AV_PIX_FMT_NONE;
     // Pixel format to convert to when transferring the frame from hardware into CPU memory.
     // Hardware devices offer several options, but not all that we might want so this
     // is the pre-conversion format before sws.
     AVPixelFormat hwSoftwarePixFmt_ = AV_PIX_FMT_NONE;
     AVBufferRef * hwDeviceCtx_ = nullptr;
     AVFrame * hwFrame_ = nullptr;
   
     float scale_ = 1.0f;
     uint scaled_width_ = 0u;
     uint scaled_height_ = 0u;
     uint consecutive_receive_failures_ = 0;
     bool dbg_print_ = false;
   
     std::atomic<bool> skip_pframes_{false};
     std::atomic<uint> skipped_pframes_{0};
   };
   
   }  // namespace broll
   
   #endif  // BROLL__FRAME_DECODER_HPP_