/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rocdecode/checkouts/develop/projects/rocdecode/utils/rocvideodecode/roc_video_dec.h Source File

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rocdecode/checkouts/develop/projects/rocdecode/utils/rocvideodecode/roc_video_dec.h Source File#

15 min read time
Applies to Linux
rocDecode: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-rocdecode/checkouts/develop/projects/rocdecode/utils/rocvideodecode/roc_video_dec.h Source File
Go to the documentation of this file.
 /*
 Copyright (c) 2023 - 2026 Advanced Micro Devices, Inc. All rights reserved.
  
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
  
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
  
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 */
  
 #pragma once
  
 #include <stdint.h>
 #include <mutex>
 #include <vector>
 #include <string>
 #include <iostream>
 #include <sstream>
 #include <iomanip>
 #include <string.h>
 #include <queue>
 #include <stdexcept>
 #include <exception>
 #include <cstring>
 #include <unordered_map>
 #include <chrono>
 #include <thread>
 #include <ctime>
 #include <time.h>
 #ifndef _WIN32
 #include <unistd.h>
 #include <sys/syscall.h>
 #else
 #include <process.h>
 #include <windows.h>
 #endif
 #include <hip/hip_runtime.h>
 #include "rocdecode/rocdecode.h"
 #include "rocdecode/rocparser.h"
  
 // Select the output surface format for a chroma format + bit depth. Monochrome
 // selects the same format as 4:2:0 (NV12/P016). Unrecognized chroma formats
 // return rocDecVideoSurfaceFormat_Native (the "decoder chooses" sentinel), which
 // callers must not use as a bit position (see rocdecode.h).
 inline rocDecVideoSurfaceFormat SelectSurfaceFormat(rocDecVideoChromaFormat chroma_format, uint8_t bitdepth_minus_8) {
     switch (chroma_format) {
     case rocDecVideoChromaFormat_420:
     case rocDecVideoChromaFormat_Monochrome:
         return bitdepth_minus_8 ? rocDecVideoSurfaceFormat_P016
                                 : rocDecVideoSurfaceFormat_NV12;
     case rocDecVideoChromaFormat_444:
         return bitdepth_minus_8 ? rocDecVideoSurfaceFormat_YUV444_16Bit
                                 : rocDecVideoSurfaceFormat_YUV444;
     case rocDecVideoChromaFormat_422:
         return bitdepth_minus_8 ? rocDecVideoSurfaceFormat_YUV422_16Bit
                                 : rocDecVideoSurfaceFormat_YUV422;
     default:
         return rocDecVideoSurfaceFormat_Native;  // unrecognized chroma format
     }
 }
  
 #define ROCVIDEODEC_TOSTR(X) std::to_string(X)
 #define ROCVIDEODEC_STR(X) std::string(X)
  
 // Simple logging macros - format matches src/commons.h:
 //   [0, Critical] filename:line: timestamp_us us: [pid:X tid:Y hashid:0xZZZZZ] func(): message
 #ifndef _WIN32
 #define RocVideoDecCriticalLog(msg) \
     do { \
         struct timespec _ts_; \
         clock_gettime(CLOCK_MONOTONIC, &_ts_); \
         uint64_t _us_ = static_cast<uint64_t>(_ts_.tv_sec) * 1000000ULL + _ts_.tv_nsec / 1000ULL; \
         const char *_f_ = strrchr(__FILE__, '/'); \
         pid_t _tid_ = static_cast<pid_t>(syscall(SYS_gettid)); \
         std::ostringstream _htid_oss_; \
         _htid_oss_ << "0x" << std::hex << std::setw(5) << std::setfill('0') \
                   << (std::hash<std::thread::id>{}(std::this_thread::get_id()) & 0xFFFFF); \
         std::cerr << "[0, Critical] " << (_f_ ? _f_ + 1 : __FILE__) \
                   << ":" << __LINE__ << ": " << _us_ << " us: [pid:" \
                   << getpid() << " tid:" << _tid_ << " hashid:" << _htid_oss_.str() << "] " \
                   << __func__ << "(): " << (msg) << std::endl; \
     } while (0)
 #else
 #define RocVideoDecCriticalLog(msg) \
     do { \
  /* function-local static: the runtime initializes it exactly once, even when \
            several decode threads reach their first log at the same time */ \
         static const LARGE_INTEGER _freq_ = [] { LARGE_INTEGER _f_ = {}; QueryPerformanceFrequency(&_f_); return _f_; }(); \
         LARGE_INTEGER _cnt_; QueryPerformanceCounter(&_cnt_); \
  /* split the division to keep the counter from overflowing when scaled to us */ \
         uint64_t _us_ = static_cast<uint64_t>(_cnt_.QuadPart / _freq_.QuadPart) * 1000000ULL \
                       + static_cast<uint64_t>(_cnt_.QuadPart % _freq_.QuadPart) * 1000000ULL / _freq_.QuadPart; \
         const char *_f_ = strrchr(__FILE__, '\\'); \
         if (!_f_) _f_ = strrchr(__FILE__, '/'); \
         uint32_t _tid_ = GetCurrentThreadId(); \
         std::ostringstream _htid_oss_; \
         _htid_oss_ << "0x" << std::hex << std::setw(5) << std::setfill('0') \
                   << (std::hash<std::thread::id>{}(std::this_thread::get_id()) & 0xFFFFF); \
         std::cerr << "[0, Critical] " << (_f_ ? _f_ + 1 : __FILE__) \
                   << ":" << __LINE__ << ": " << _us_ << " us: [pid:" \
                   << _getpid() << " tid:" << _tid_ << " hashid:" << _htid_oss_.str() << "] " \
                   << __func__ << "(): " << (msg) << std::endl; \
     } while (0)
 #endif
  
 #define MAX_FRAME_NUM       16
  
 typedef int (ROCDECAPI *PFNRECONFIGUEFLUSHCALLBACK)(void *, uint32_t, void *);
  
 typedef enum SeiAvcHevcPayloadType_enum {
     SEI_TYPE_TIME_CODE = 136,
     SEI_TYPE_USER_DATA_UNREGISTERED = 5
 } SeiAvcHevcPayloadType;
  
 typedef enum OutputSurfaceMemoryType_enum {
     OUT_SURFACE_MEM_DEV_INTERNAL = 0,      
     OUT_SURFACE_MEM_DEV_COPIED = 1,        
     OUT_SURFACE_MEM_HOST_COPIED = 2,        
     OUT_SURFACE_MEM_NOT_MAPPED  = 3         
 } OutputSurfaceMemoryType;
  
 inline int GetChromaPlaneCount(rocDecVideoSurfaceFormat surface_format) {
     int num_planes = 1;
     switch (surface_format) {
     case rocDecVideoSurfaceFormat_NV12:
     case rocDecVideoSurfaceFormat_P016:
     default:
         num_planes = 1;
         break;
     case rocDecVideoSurfaceFormat_YUV444:
     case rocDecVideoSurfaceFormat_YUV444_16Bit:
     case rocDecVideoSurfaceFormat_YUV420:
     case rocDecVideoSurfaceFormat_YUV420_16Bit:
     case rocDecVideoSurfaceFormat_YUV422:
     case rocDecVideoSurfaceFormat_YUV422_16Bit:
         num_planes = 2;
         break;
     }
  
     return num_planes;
 };
  
 inline float GetChromaHeightFactor(rocDecVideoSurfaceFormat surface_format) {
     float factor = 0.5;
     switch (surface_format) {
     case rocDecVideoSurfaceFormat_NV12:
     case rocDecVideoSurfaceFormat_P016:
     case rocDecVideoSurfaceFormat_YUV420:
     case rocDecVideoSurfaceFormat_YUV420_16Bit:
     default:
         factor = 0.5;
         break;
     case rocDecVideoSurfaceFormat_YUV422:
     case rocDecVideoSurfaceFormat_YUV422_16Bit:
     case rocDecVideoSurfaceFormat_YUV444:
     case rocDecVideoSurfaceFormat_YUV444_16Bit:
         factor = 1.0;
         break;
     }
  
     return factor;
 };
  
 class RocVideoDecodeException : public std::exception {
 public:
  
     explicit RocVideoDecodeException(const std::string& message, const int err_code):_message(message), _err_code(err_code) {}
     explicit RocVideoDecodeException(const std::string& message):_message(message), _err_code(-1) {}
     virtual const char* what() const throw() override {
         return _message.c_str();
     }
     int Geterror_code() const { return _err_code; }
 private:
     std::string _message;
     int _err_code;
 };
  
 #define ROCDEC_THROW(X, CODE) throw RocVideoDecodeException(" { " + std::string(__func__) + " } " + X , CODE);
  
 #define ROCDEC_API_CALL( rocDecAPI )                                                                         \
     do {                                                                                                     \
         rocDecStatus error_code = rocDecAPI;                                                                 \
         if( error_code != ROCDEC_SUCCESS) {                                                                  \
             std::ostringstream error_log;                                                                    \
             error_log << #rocDecAPI << " returned " << rocDecGetErrorName(error_code) << " at " <<__FILE__ <<":" << __LINE__;\
             ROCDEC_THROW(error_log.str(), error_code); \
         }                                                                                                     \
     } while (0)
  
 #define HIP_API_CALL( call )                                                                                  \
     do {                                                                                                      \
         hipError_t hip_status = call;                                                                         \
         if (hip_status != hipSuccess) {                                                                       \
             const char *sz_err_name = NULL;                                                                     \
             sz_err_name = hipGetErrorName(hip_status);                                                          \
             std::ostringstream error_log;                                                                     \
             error_log << "hip API error " << sz_err_name ;                                                      \
             ROCDEC_THROW(error_log.str(), hip_status);                   \
         }                                                                                                     \
     }                                                                                                         \
     while (0)
  
 #define CHECK_ZERO(str, value)              \
     do {                                   \
         if (value == 0) {                  \
             RocVideoDecCriticalLog(ROCVIDEODEC_STR(str) + " is 0.");    \
         }                                  \
     } while (0)
  
 struct Rect {
     int left;
     int top;
     int right;
     int bottom;
 };
  
 struct Dim {
     int w, h;
 };
  
 static inline int align(int value, int alignment) {
    return (value + alignment - 1) & ~(alignment - 1);
 }
  
 typedef struct DecFrameBuffer_ {
     uint8_t *frame_ptr;       
     int64_t  pts;             
     int picture_index;         
 } DecFrameBuffer;
  
  
 typedef struct OutputSurfaceInfoType {
     uint32_t output_width;                      
     uint32_t output_height;                     
     uint32_t output_pitch;                      
     uint32_t output_vstride;                    
     uint32_t chroma_height;                     
     Rect disp_rect;                         
     uint32_t bytes_per_pixel;                   
     uint32_t bit_depth;                         
     uint32_t num_chroma_planes;                 
     uint64_t output_surface_size_in_bytes;      
     rocDecVideoSurfaceFormat surface_format;    
     OutputSurfaceMemoryType mem_type;           
 } OutputSurfaceInfo;
  
 typedef struct ReconfigParams_t {
     PFNRECONFIGUEFLUSHCALLBACK p_fn_reconfigure_flush;
     void *p_reconfig_user_struct;
     uint32_t reconfig_flush_mode;
 } ReconfigParams;
  
 class RocVideoDecoder {
     public:
         RocVideoDecoder(int device_id,  OutputSurfaceMemoryType out_mem_type, rocDecVideoCodec codec, bool force_zero_latency = false,
                           const Rect *p_crop_rect = nullptr, bool extract_user_SEI_Message = false, uint32_t disp_delay = 0, int max_width = 0, int max_height = 0,
                           uint32_t clk_rate = 1000, bool skip_init = false);
  
         virtual ~RocVideoDecoder();
  
         rocDecVideoCodec GetCodecId() { return codec_id_; }
  
         uint32_t GetWidth() {CHECK_ZERO("Display width", disp_width_); return disp_width_;}
  
         int GetDecodeWidth() {CHECK_ZERO("Coded width", coded_width_); return coded_width_; }
  
         uint32_t GetHeight() {CHECK_ZERO("Display height", disp_height_); return disp_height_; }
  
         int GetChromaHeight() {CHECK_ZERO("Chroma height", chroma_height_); return chroma_height_; }
  
         int GetNumChromaPlanes() {return num_chroma_planes_; }
  
         virtual int GetFrameSize() {CHECK_ZERO("Display width", disp_width_); return disp_width_ * (disp_height_ + (chroma_height_ * num_chroma_planes_)) * byte_per_pixel_; }
  
  
         uint32_t GetBitDepth() {return (bitdepth_minus_8_ + 8); }
         uint32_t GetBytePerPixel() {CHECK_ZERO("Bytes per pixel", byte_per_pixel_); return byte_per_pixel_; }
         size_t GetSurfaceSize() {CHECK_ZERO("Surface size", surface_size_); return surface_size_; }
         uint32_t GetSurfaceStride() {CHECK_ZERO("Surface stride", surface_stride_); return surface_stride_; }
         //RocDecImageFormat GetSubsampling() { return subsampling_; }
  const char *GetCodecFmtName(rocDecVideoCodec codec_id);
  
         const char *GetSurfaceFmtName(rocDecVideoSurfaceFormat surface_format_id);
  
         virtual bool GetOutputSurfaceInfo(OutputSurfaceInfo **surface_info);
  
         bool SetReconfigParams(ReconfigParams *p_reconfig_params, bool b_force_reconfig_flush = false);
         
         int FlushAndReconfigure();
         virtual int DecodeFrame(const uint8_t *data, size_t size, int pkt_flags, int64_t pts = 0, int *num_decoded_pics = nullptr);
         virtual uint8_t* GetFrame(int64_t *pts);
  
         virtual bool ReleaseFrame(int64_t pTimestamp, bool b_flushing = false);
  
         //void SaveImage(std::string output_file_name, void* dev_mem, OutputImageInfo* image_info, bool is_output_RGB = 0);
  
         void GetDeviceinfo(std::string &device_name, std::string &gcn_arch_name, int &pci_bus_id, int &pci_domain_id, int &pci_device_id);
         
         virtual void SaveFrameToFile(std::string output_file_name, void *surf_mem, OutputSurfaceInfo *surf_info, size_t rgb_image_size = 0);
  
         virtual void ResetSaveFrameToFile();
  
         int32_t GetNumOfFlushedFrames() { return num_frames_flushed_during_reconfig_;}
  
         void WaitForDecodeCompletion();
  
         // Session overhead refers to decoder initialization and deinitialization time
         void AddDecoderSessionOverHead(std::thread::id session_id, double duration) { session_overhead_[session_id] += duration; }
         double GetDecoderSessionOverHead(std::thread::id session_id) {
             if (session_overhead_.find(session_id) != session_overhead_.end()) {
                 return session_overhead_[session_id];
             } else {
                 return 0;
             }
          }
  
         bool CodecSupported(int device_id, rocDecVideoCodec codec_id, uint32_t bit_depth);
  
         virtual int ReconfigureDecoder(RocdecVideoFormat *p_video_format);
  
     protected:
         static int ROCDECAPI HandleVideoSequenceProc(void *p_user_data, RocdecVideoFormat *p_video_format) { return ((RocVideoDecoder *)p_user_data)->HandleVideoSequence(p_video_format); }
  
         static int ROCDECAPI HandlePictureDecodeProc(void *p_user_data, RocdecPicParams *p_pic_params) { return ((RocVideoDecoder *)p_user_data)->HandlePictureDecode(p_pic_params); }
  
         static int ROCDECAPI HandlePictureDisplayProc(void *p_user_data, RocdecParserDispInfo *p_disp_info) { return ((RocVideoDecoder *)p_user_data)->HandlePictureDisplay(p_disp_info); }
  
         static int ROCDECAPI HandleSEIMessagesProc(void *p_user_data, RocdecSeiMessageInfo *p_sei_message_info) { return ((RocVideoDecoder *)p_user_data)->GetSEIMessage(p_sei_message_info); } 
  
         int HandleVideoSequence(RocdecVideoFormat *p_video_format);
  
         int HandlePictureDecode(RocdecPicParams *p_pic_params);
  
         int HandlePictureDisplay(RocdecParserDispInfo *p_disp_info);
         int GetSEIMessage(RocdecSeiMessageInfo *p_sei_message_info);
         
         bool ReleaseInternalFrames();
  
         bool InitHIP(int device_id);
  
         std::chrono::system_clock::time_point StartTimer();
  
         double StopTimer(const std::chrono::system_clock::time_point &start_time);
  
         int num_devices_;
         int device_id_;
         RocdecVideoParser rocdec_parser_ = nullptr;
         rocDecDecoderHandle roc_decoder_ = nullptr;
         OutputSurfaceMemoryType out_mem_type_ = OUT_SURFACE_MEM_DEV_INTERNAL;
         rocDecVideoCodec codec_id_ = rocDecVideoCodec_NumCodecs;
         bool b_force_zero_latency_ = false;
         bool b_extract_sei_message_ = false;
         uint32_t disp_delay_;
         ReconfigParams *p_reconfig_params_ = nullptr;
         bool b_force_recofig_flush_ = false;
         int32_t num_frames_flushed_during_reconfig_ = 0;
         hipDeviceProp_t hip_dev_prop_;
         hipStream_t hip_stream_ = nullptr;
         rocDecVideoChromaFormat video_chroma_format_ = rocDecVideoChromaFormat_420;
         rocDecVideoSurfaceFormat video_surface_format_ = rocDecVideoSurfaceFormat_NV12;
         RocdecSeiMessageInfo *curr_sei_message_ptr_ = nullptr;
         RocdecSeiMessageInfo sei_message_display_q_[MAX_FRAME_NUM];
         RocdecVideoFormat *curr_video_format_ptr_ = nullptr;
         int output_frame_cnt_ = 0, output_frame_cnt_ret_ = 0;
         int decoded_pic_cnt_ = 0;
         int decode_poc_ = 0, pic_num_in_dec_order_[MAX_FRAME_NUM];
         int num_alloced_frames_ = 0;
         int last_decode_surf_idx_ = 0;
         std::ostringstream input_video_info_str_;
         int bitdepth_minus_8_ = 0;
         uint32_t byte_per_pixel_ = 1;
         uint32_t coded_width_ = 0;
         uint32_t disp_width_ = 0;
         uint32_t coded_height_ = 0;
         uint32_t disp_height_ = 0;
         uint32_t target_width_ = 0;
         uint32_t target_height_ = 0;
         int max_width_ = 0, max_height_ = 0;
         uint32_t chroma_height_ = 0, chroma_width_ = 0;
         uint32_t num_decode_surfaces_ = 0;
         uint32_t num_chroma_planes_ = 0;
         uint32_t num_components_ = 0;
         uint32_t surface_stride_ = 0;
         uint32_t surface_vstride_ = 0, chroma_vstride_ = 0;      // vertical stride between planes: used when using internal dev memory
         size_t surface_size_ = 0;
         OutputSurfaceInfo output_surface_info_ = {};
         std::mutex mtx_vp_frame_;
         std::vector<DecFrameBuffer> vp_frames_;      // vector of decoded frames
         std::queue<DecFrameBuffer> vp_frames_q_;
         Rect disp_rect_ = {}; // displayable area specified in the bitstream
         Rect crop_rect_ = {}; // user specified region of interest within diplayable area disp_rect_
         FILE *fp_sei_ = NULL;
         FILE *fp_out_ = NULL;
         bool is_output_surface_changed_ = false;
         std::string current_output_filename = "";
         uint32_t extra_output_file_count_ = 0;
         std::thread::id decoder_session_id_; // Decoder session identifier. Used to gather session level stats.
         std::unordered_map<std::thread::id, double> session_overhead_; // Records session overhead of initialization+deinitialization time. Format is (thread id, duration)
 };