Aryan Salmanpour
1122 строки
53 KiB
C++
1122 строки
53 KiB
C++
/*
|
|
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.
|
|
*/
|
|
|
|
#include "roc_video_dec.h"
|
|
|
|
RocVideoDecoder::RocVideoDecoder(int device_id, OutputSurfaceMemoryType out_mem_type, rocDecVideoCodec codec, bool force_zero_latency,
|
|
const Rect *p_crop_rect, bool extract_user_sei_Message, uint32_t disp_delay, int max_width, int max_height, uint32_t clk_rate, bool skip_init) :
|
|
device_id_{device_id}, out_mem_type_(out_mem_type), codec_id_(codec), b_force_zero_latency_(force_zero_latency),
|
|
b_extract_sei_message_(extract_user_sei_Message), disp_delay_(disp_delay), max_width_ (max_width), max_height_(max_height) {
|
|
|
|
if (p_crop_rect) crop_rect_ = *p_crop_rect;
|
|
if (b_extract_sei_message_) {
|
|
fp_sei_ = fopen("rocdec_sei_message.txt", "wb");
|
|
curr_sei_message_ptr_ = new RocdecSeiMessageInfo;
|
|
memset(&sei_message_display_q_, 0, sizeof(sei_message_display_q_));
|
|
}
|
|
// derived class can skip the following initialization by setting skip_init flag
|
|
if (!skip_init) {
|
|
if (!InitHIP(device_id_)) {
|
|
ROCDEC_THROW("Failed to initilize the HIP", ROCDEC_DEVICE_INVALID);
|
|
}
|
|
// create rocdec videoparser
|
|
RocdecParserParams parser_params = {};
|
|
parser_params.codec_type = codec_id_;
|
|
parser_params.max_num_decode_surfaces = 1; // let the parser to determine the decode buffer pool size
|
|
parser_params.clock_rate = clk_rate;
|
|
parser_params.max_display_delay = disp_delay_;
|
|
parser_params.user_data = this;
|
|
parser_params.pfn_sequence_callback = HandleVideoSequenceProc;
|
|
parser_params.pfn_decode_picture = HandlePictureDecodeProc;
|
|
parser_params.pfn_display_picture = b_force_zero_latency_ ? NULL : HandlePictureDisplayProc;
|
|
parser_params.pfn_get_sei_msg = b_extract_sei_message_ ? HandleSEIMessagesProc : NULL;
|
|
ROCDEC_API_CALL(rocDecCreateVideoParser(&rocdec_parser_, &parser_params));
|
|
}
|
|
}
|
|
|
|
|
|
RocVideoDecoder::~RocVideoDecoder() {
|
|
auto start_time = StartTimer();
|
|
if (curr_sei_message_ptr_) {
|
|
delete curr_sei_message_ptr_;
|
|
curr_sei_message_ptr_ = nullptr;
|
|
}
|
|
|
|
if (fp_sei_) {
|
|
fclose(fp_sei_);
|
|
fp_sei_ = nullptr;
|
|
}
|
|
|
|
if (rocdec_parser_) {
|
|
rocDecDestroyVideoParser(rocdec_parser_);
|
|
rocdec_parser_ = nullptr;
|
|
}
|
|
|
|
if (roc_decoder_) {
|
|
rocDecDestroyDecoder(roc_decoder_);
|
|
roc_decoder_ = nullptr;
|
|
}
|
|
|
|
if (curr_video_format_ptr_) {
|
|
delete curr_video_format_ptr_;
|
|
curr_video_format_ptr_ = nullptr;
|
|
}
|
|
std::lock_guard<std::mutex> lock(mtx_vp_frame_);
|
|
if (out_mem_type_ != OUT_SURFACE_MEM_DEV_INTERNAL) {
|
|
for (auto &p_frame : vp_frames_) {
|
|
if (p_frame.frame_ptr) {
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_COPIED) {
|
|
hipError_t hip_status = hipFree(p_frame.frame_ptr);
|
|
if (hip_status != hipSuccess) {
|
|
std::cerr << "ERROR: hipFree failed! (" << hip_status << ")" << std::endl;
|
|
}
|
|
}
|
|
else
|
|
delete[] (p_frame.frame_ptr);
|
|
p_frame.frame_ptr = nullptr;
|
|
}
|
|
}
|
|
}
|
|
if (hip_stream_) {
|
|
hipError_t hip_status = hipSuccess;
|
|
hip_status = hipStreamDestroy(hip_stream_);
|
|
if (hip_status != hipSuccess) {
|
|
std::cerr << "ERROR: hipStream_Destroy failed! (" << hip_status << ")" << std::endl;
|
|
}
|
|
}
|
|
|
|
if (fp_out_) {
|
|
fclose(fp_out_);
|
|
fp_out_ = nullptr;
|
|
}
|
|
double elapsed_time = StopTimer(start_time);
|
|
AddDecoderSessionOverHead(std::this_thread::get_id(), elapsed_time);
|
|
}
|
|
|
|
static const char * GetVideoCodecString(rocDecVideoCodec e_codec) {
|
|
static struct {
|
|
rocDecVideoCodec e_codec;
|
|
const char *name;
|
|
} aCodecName [] = {
|
|
{ rocDecVideoCodec_MPEG1, "MPEG-1" },
|
|
{ rocDecVideoCodec_MPEG2, "MPEG-2" },
|
|
{ rocDecVideoCodec_MPEG4, "MPEG-4 (ASP)" },
|
|
{ rocDecVideoCodec_AVC, "AVC/H.264" },
|
|
{ rocDecVideoCodec_HEVC, "H.265/HEVC" },
|
|
{ rocDecVideoCodec_AV1, "AV1" },
|
|
{ rocDecVideoCodec_VP8, "VP8" },
|
|
{ rocDecVideoCodec_VP9, "VP9" },
|
|
{ rocDecVideoCodec_JPEG, "M-JPEG" },
|
|
{ rocDecVideoCodec_NumCodecs, "Invalid" },
|
|
};
|
|
|
|
if (e_codec >= 0 && e_codec <= rocDecVideoCodec_NumCodecs) {
|
|
return aCodecName[e_codec].name;
|
|
}
|
|
for (int i = rocDecVideoCodec_NumCodecs + 1; i < sizeof(aCodecName) / sizeof(aCodecName[0]); i++) {
|
|
if (e_codec == aCodecName[i].e_codec) {
|
|
return aCodecName[e_codec].name;
|
|
}
|
|
}
|
|
return "Unknown";
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief function to return the name from codec_id
|
|
*
|
|
* @param codec_id
|
|
* @return const char*
|
|
*/
|
|
const char *RocVideoDecoder::GetCodecFmtName(rocDecVideoCodec codec_id)
|
|
{
|
|
return GetVideoCodecString(codec_id);
|
|
}
|
|
|
|
static const char * GetSurfaceFormatString(rocDecVideoSurfaceFormat surface_format_id) {
|
|
static struct {
|
|
rocDecVideoSurfaceFormat surf_fmt;
|
|
const char *name;
|
|
} SurfName [] = {
|
|
{ rocDecVideoSurfaceFormat_NV12, "NV12" },
|
|
{ rocDecVideoSurfaceFormat_P016, "P016" },
|
|
{ rocDecVideoSurfaceFormat_YUV444, "YUV444" },
|
|
{ rocDecVideoSurfaceFormat_YUV444_16Bit, "YUV444_16Bit" },
|
|
};
|
|
|
|
if (surface_format_id >= rocDecVideoSurfaceFormat_NV12 && surface_format_id <= rocDecVideoSurfaceFormat_YUV444_16Bit)
|
|
return SurfName[surface_format_id].name;
|
|
else
|
|
return "Unknown";
|
|
}
|
|
|
|
/**
|
|
* @brief function to return the name from surface_format_id
|
|
*
|
|
* @param surface_format_id - enum for surface format
|
|
* @return const char*
|
|
*/
|
|
const char *RocVideoDecoder::GetSurfaceFmtName(rocDecVideoSurfaceFormat surface_format_id)
|
|
{
|
|
return GetSurfaceFormatString(surface_format_id);
|
|
}
|
|
|
|
static const char * GetVideoChromaFormatName(rocDecVideoChromaFormat e_chroma_format) {
|
|
static struct {
|
|
rocDecVideoChromaFormat chroma_fmt;
|
|
const char *name;
|
|
} ChromaFormatName[] = {
|
|
{ rocDecVideoChromaFormat_Monochrome, "YUV 400 (Monochrome)" },
|
|
{ rocDecVideoChromaFormat_420, "YUV 420" },
|
|
{ rocDecVideoChromaFormat_422, "YUV 422" },
|
|
{ rocDecVideoChromaFormat_444, "YUV 444" },
|
|
};
|
|
|
|
if (e_chroma_format >= 0 && e_chroma_format <= rocDecVideoChromaFormat_444) {
|
|
return ChromaFormatName[e_chroma_format].name;
|
|
}
|
|
return "Unknown";
|
|
}
|
|
|
|
static void GetSurfaceStrideInternal(rocDecVideoSurfaceFormat surface_format, uint32_t width, uint32_t height, uint32_t *pitch, uint32_t *vstride) {
|
|
|
|
switch (surface_format) {
|
|
case rocDecVideoSurfaceFormat_NV12:
|
|
*pitch = align(width, 256);
|
|
*vstride = align(height, 16);
|
|
break;
|
|
case rocDecVideoSurfaceFormat_P016:
|
|
*pitch = align(width, 128) * 2;
|
|
*vstride = align(height, 16);
|
|
break;
|
|
case rocDecVideoSurfaceFormat_YUV444:
|
|
*pitch = align(width, 256);
|
|
*vstride = align(height, 16);
|
|
break;
|
|
case rocDecVideoSurfaceFormat_YUV444_16Bit:
|
|
*pitch = align(width, 128) * 2;
|
|
*vstride = align(height, 16);
|
|
break;
|
|
case rocDecVideoSurfaceFormat_YUV420:
|
|
*pitch = align(width, 256);
|
|
*vstride = align(height, 16);
|
|
break;
|
|
case rocDecVideoSurfaceFormat_YUV420_16Bit:
|
|
*pitch = align(width, 128) * 2;
|
|
*vstride = align(height, 16);
|
|
break;
|
|
case rocDecVideoSurfaceFormat_YUV422:
|
|
*pitch = align(width, 256);
|
|
*vstride = align(height, 16);
|
|
break;
|
|
case rocDecVideoSurfaceFormat_YUV422_16Bit:
|
|
*pitch = align(width, 128) * 2;
|
|
*vstride = align(height, 16);
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* Return value from HandleVideoSequence() are interpreted as :
|
|
* 0: fail, 1: succeeded, > 1: override dpb size of parser (set by RocdecParserParams::max_num_decode_surfaces while creating parser)
|
|
*/
|
|
int RocVideoDecoder::HandleVideoSequence(RocdecVideoFormat *p_video_format) {
|
|
if (p_video_format == nullptr) {
|
|
ROCDEC_THROW("Rocdec:: Invalid video format in HandleVideoSequence: ", ROCDEC_INVALID_PARAMETER);
|
|
return 0;
|
|
}
|
|
auto start_time = StartTimer();
|
|
input_video_info_str_.str("");
|
|
input_video_info_str_.clear();
|
|
input_video_info_str_ << "Input Video Information" << std::endl
|
|
<< "\tCodec : " << GetCodecFmtName(p_video_format->codec) << std::endl;
|
|
if (p_video_format->frame_rate.numerator && p_video_format->frame_rate.denominator) {
|
|
input_video_info_str_ << "\tFrame rate : " << p_video_format->frame_rate.numerator << "/" << p_video_format->frame_rate.denominator << " = " << 1.0 * p_video_format->frame_rate.numerator / p_video_format->frame_rate.denominator << " fps" << std::endl;
|
|
}
|
|
input_video_info_str_ << "\tSequence : " << (p_video_format->progressive_sequence ? "Progressive" : "Interlaced") << std::endl
|
|
<< "\tCoded size : [" << p_video_format->coded_width << ", " << p_video_format->coded_height << "]" << std::endl
|
|
<< "\tDisplay area : [" << p_video_format->display_area.left << ", " << p_video_format->display_area.top << ", "
|
|
<< p_video_format->display_area.right << ", " << p_video_format->display_area.bottom << "]" << std::endl
|
|
<< "\tChroma : " << GetVideoChromaFormatName(p_video_format->chroma_format) << std::endl
|
|
<< "\tBit depth : " << p_video_format->bit_depth_luma_minus8 + 8
|
|
;
|
|
input_video_info_str_ << std::endl;
|
|
|
|
RocdecDecodeCaps decode_caps;
|
|
memset(&decode_caps, 0, sizeof(decode_caps));
|
|
decode_caps.codec_type = p_video_format->codec;
|
|
decode_caps.chroma_format = p_video_format->chroma_format;
|
|
decode_caps.bit_depth_minus_8 = p_video_format->bit_depth_luma_minus8;
|
|
|
|
rocDecGetDecoderCaps(&decode_caps);
|
|
if(!decode_caps.is_supported) {
|
|
ROCDEC_THROW("rocDecode:: Codec not supported on this GPU ", ROCDEC_NOT_SUPPORTED);
|
|
return 0;
|
|
}
|
|
if ((p_video_format->coded_width > decode_caps.max_width) || (p_video_format->coded_height > decode_caps.max_height)) {
|
|
std::ostringstream errorString;
|
|
errorString << std::endl
|
|
<< "Resolution : " << p_video_format->coded_width << "x" << p_video_format->coded_height << std::endl
|
|
<< "Max Supported (wxh) : " << decode_caps.max_width << "x" << decode_caps.max_height << std::endl
|
|
<< "Resolution not supported on this GPU ";
|
|
const std::string cErr = errorString.str();
|
|
ROCDEC_THROW(cErr, ROCDEC_NOT_SUPPORTED);
|
|
return 0;
|
|
}
|
|
if (curr_video_format_ptr_ == nullptr) {
|
|
curr_video_format_ptr_ = new RocdecVideoFormat();
|
|
}
|
|
// store current video format: this is required to call reconfigure from application in case of random seek
|
|
if (curr_video_format_ptr_) memcpy(curr_video_format_ptr_, p_video_format, sizeof(RocdecVideoFormat));
|
|
|
|
if (coded_width_ && coded_height_) {
|
|
// rocdecCreateDecoder() has been called before, and now there's possible config change
|
|
return ReconfigureDecoder(p_video_format);
|
|
}
|
|
// e_codec has been set in the constructor (for parser). Here it's set again for potential correction
|
|
codec_id_ = p_video_format->codec;
|
|
video_chroma_format_ = p_video_format->chroma_format;
|
|
bitdepth_minus_8_ = p_video_format->bit_depth_luma_minus8;
|
|
byte_per_pixel_ = bitdepth_minus_8_ > 0 ? 2 : 1;
|
|
|
|
// Set the output surface format same as chroma format
|
|
if (video_chroma_format_ == rocDecVideoChromaFormat_420 || rocDecVideoChromaFormat_Monochrome)
|
|
video_surface_format_ = bitdepth_minus_8_ ? rocDecVideoSurfaceFormat_P016 : rocDecVideoSurfaceFormat_NV12;
|
|
else if (video_chroma_format_ == rocDecVideoChromaFormat_444)
|
|
video_surface_format_ = bitdepth_minus_8_ ? rocDecVideoSurfaceFormat_YUV444_16Bit : rocDecVideoSurfaceFormat_YUV444;
|
|
else if (video_chroma_format_ == rocDecVideoChromaFormat_422)
|
|
video_surface_format_ = bitdepth_minus_8_ ? rocDecVideoSurfaceFormat_YUV422_16Bit : rocDecVideoSurfaceFormat_YUV422;
|
|
|
|
// Check if output format supported. If not, check falback options
|
|
if (!(decode_caps.output_format_mask & (1 << video_surface_format_))){
|
|
if (decode_caps.output_format_mask & (1 << rocDecVideoSurfaceFormat_NV12))
|
|
video_surface_format_ = rocDecVideoSurfaceFormat_NV12;
|
|
else if (decode_caps.output_format_mask & (1 << rocDecVideoSurfaceFormat_P016))
|
|
video_surface_format_ = rocDecVideoSurfaceFormat_P016;
|
|
else if (decode_caps.output_format_mask & (1 << rocDecVideoSurfaceFormat_YUV444))
|
|
video_surface_format_ = rocDecVideoSurfaceFormat_YUV444;
|
|
else if (decode_caps.output_format_mask & (1 << rocDecVideoSurfaceFormat_YUV444_16Bit))
|
|
video_surface_format_ = rocDecVideoSurfaceFormat_YUV444_16Bit;
|
|
else
|
|
ROCDEC_THROW("No supported output format found", ROCDEC_NOT_SUPPORTED);
|
|
}
|
|
|
|
coded_width_ = p_video_format->coded_width;
|
|
coded_height_ = p_video_format->coded_height;
|
|
disp_rect_.top = p_video_format->display_area.top;
|
|
disp_rect_.bottom = p_video_format->display_area.bottom;
|
|
disp_rect_.left = p_video_format->display_area.left;
|
|
disp_rect_.right = p_video_format->display_area.right;
|
|
disp_width_ = p_video_format->display_area.right - p_video_format->display_area.left;
|
|
disp_height_ = p_video_format->display_area.bottom - p_video_format->display_area.top;
|
|
num_decode_surfaces_ = p_video_format->min_num_decode_surfaces;
|
|
|
|
// AV1 has max width/height of sequence in sequence header
|
|
if (codec_id_ == rocDecVideoCodec_AV1 && p_video_format->seqhdr_data_length > 0) {
|
|
// dont overwrite if it is already set from cmdline or reconfig.txt
|
|
if (!(max_width_ > p_video_format->coded_width || max_height_ > p_video_format->coded_height)) {
|
|
RocdecVideoFormatEx *vidFormatEx = (RocdecVideoFormatEx *)p_video_format;
|
|
max_width_ = vidFormatEx->max_width;
|
|
max_height_ = vidFormatEx->max_height;
|
|
}
|
|
}
|
|
if (max_width_ < (int)p_video_format->coded_width)
|
|
max_width_ = p_video_format->coded_width;
|
|
if (max_height_ < (int)p_video_format->coded_height)
|
|
max_height_ = p_video_format->coded_height;
|
|
|
|
RocDecoderCreateInfo videoDecodeCreateInfo = { 0 };
|
|
videoDecodeCreateInfo.device_id = device_id_;
|
|
videoDecodeCreateInfo.codec_type = codec_id_;
|
|
videoDecodeCreateInfo.chroma_format = video_chroma_format_;
|
|
videoDecodeCreateInfo.output_format = video_surface_format_;
|
|
videoDecodeCreateInfo.bit_depth_minus_8 = bitdepth_minus_8_;
|
|
videoDecodeCreateInfo.num_decode_surfaces = num_decode_surfaces_;
|
|
videoDecodeCreateInfo.width = coded_width_;
|
|
videoDecodeCreateInfo.height = coded_height_;
|
|
videoDecodeCreateInfo.max_width = max_width_;
|
|
videoDecodeCreateInfo.max_height = max_height_;
|
|
if (!(crop_rect_.right && crop_rect_.bottom)) {
|
|
videoDecodeCreateInfo.display_rect.top = disp_rect_.top;
|
|
videoDecodeCreateInfo.display_rect.bottom = disp_rect_.bottom;
|
|
videoDecodeCreateInfo.display_rect.left = disp_rect_.left;
|
|
videoDecodeCreateInfo.display_rect.right = disp_rect_.right;
|
|
target_width_ = (disp_width_ + 1) & ~1;
|
|
target_height_ = (disp_height_ + 1) & ~1;
|
|
} else {
|
|
videoDecodeCreateInfo.display_rect.top = crop_rect_.top;
|
|
videoDecodeCreateInfo.display_rect.bottom = crop_rect_.bottom;
|
|
videoDecodeCreateInfo.display_rect.left = crop_rect_.left;
|
|
videoDecodeCreateInfo.display_rect.right = crop_rect_.right;
|
|
target_width_ = (crop_rect_.right - crop_rect_.left + 1) & ~1;
|
|
target_height_ = (crop_rect_.bottom - crop_rect_.top + 1) & ~1;
|
|
}
|
|
videoDecodeCreateInfo.target_width = target_width_;
|
|
videoDecodeCreateInfo.target_height = target_height_;
|
|
|
|
chroma_height_ = (int)(ceil(target_height_ * GetChromaHeightFactor(video_surface_format_)));
|
|
num_chroma_planes_ = GetChromaPlaneCount(video_surface_format_);
|
|
if (video_chroma_format_ == rocDecVideoChromaFormat_Monochrome) num_chroma_planes_ = 0;
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_INTERNAL || out_mem_type_ == OUT_SURFACE_MEM_NOT_MAPPED)
|
|
GetSurfaceStrideInternal(video_surface_format_, p_video_format->coded_width, p_video_format->coded_height, &surface_stride_, &surface_vstride_);
|
|
else {
|
|
surface_stride_ = videoDecodeCreateInfo.target_width * byte_per_pixel_; // todo:: check if we need pitched memory for faster copy
|
|
}
|
|
chroma_vstride_ = (int)(ceil(surface_vstride_ * GetChromaHeightFactor(video_surface_format_)));
|
|
// fill output_surface_info_
|
|
output_surface_info_.output_width = target_width_;
|
|
output_surface_info_.output_height = target_height_;
|
|
output_surface_info_.output_pitch = surface_stride_;
|
|
output_surface_info_.output_vstride = (out_mem_type_ == OUT_SURFACE_MEM_DEV_INTERNAL) ? surface_vstride_ : videoDecodeCreateInfo.target_height;
|
|
output_surface_info_.disp_rect.top = videoDecodeCreateInfo.display_rect.top;
|
|
output_surface_info_.disp_rect.bottom = videoDecodeCreateInfo.display_rect.bottom;
|
|
output_surface_info_.disp_rect.left = videoDecodeCreateInfo.display_rect.left;
|
|
output_surface_info_.disp_rect.right = videoDecodeCreateInfo.display_rect.right;
|
|
output_surface_info_.chroma_height = chroma_height_;
|
|
output_surface_info_.bit_depth = bitdepth_minus_8_ + 8;
|
|
output_surface_info_.bytes_per_pixel = byte_per_pixel_;
|
|
output_surface_info_.surface_format = video_surface_format_;
|
|
output_surface_info_.num_chroma_planes = num_chroma_planes_;
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_INTERNAL) {
|
|
output_surface_info_.output_surface_size_in_bytes = surface_stride_ * (surface_vstride_ + (chroma_vstride_ * num_chroma_planes_));
|
|
output_surface_info_.mem_type = OUT_SURFACE_MEM_DEV_INTERNAL;
|
|
} else if (out_mem_type_ == OUT_SURFACE_MEM_DEV_COPIED) {
|
|
output_surface_info_.output_surface_size_in_bytes = GetFrameSize();
|
|
output_surface_info_.mem_type = OUT_SURFACE_MEM_DEV_COPIED;
|
|
} else if (out_mem_type_ == OUT_SURFACE_MEM_HOST_COPIED){
|
|
output_surface_info_.output_surface_size_in_bytes = GetFrameSize();
|
|
output_surface_info_.mem_type = OUT_SURFACE_MEM_HOST_COPIED;
|
|
} else {
|
|
output_surface_info_.output_surface_size_in_bytes = surface_stride_ * (surface_vstride_ + (chroma_vstride_ * num_chroma_planes_));
|
|
output_surface_info_.mem_type = OUT_SURFACE_MEM_NOT_MAPPED;
|
|
}
|
|
|
|
input_video_info_str_ << "Video Decoding Params:" << std::endl
|
|
<< "\tNum Surfaces : " << videoDecodeCreateInfo.num_decode_surfaces << std::endl
|
|
<< "\tCrop : [" << videoDecodeCreateInfo.display_rect.left << ", " << videoDecodeCreateInfo.display_rect.top << ", "
|
|
<< videoDecodeCreateInfo.display_rect.right << ", " << videoDecodeCreateInfo.display_rect.bottom << "]" << std::endl
|
|
<< "\tResize : " << videoDecodeCreateInfo.target_width << "x" << videoDecodeCreateInfo.target_height << std::endl
|
|
;
|
|
input_video_info_str_ << std::endl;
|
|
std::cout << input_video_info_str_.str();
|
|
|
|
ROCDEC_API_CALL(rocDecCreateDecoder(&roc_decoder_, &videoDecodeCreateInfo));
|
|
double elapsed_time = StopTimer(start_time);
|
|
AddDecoderSessionOverHead(std::this_thread::get_id(), elapsed_time);
|
|
return num_decode_surfaces_;
|
|
}
|
|
|
|
/**
|
|
* @brief Function to set the Reconfig Params object
|
|
*
|
|
* @param p_reconfig_params: pointer to reconfig params struct
|
|
* @return true : success
|
|
* @return false : fail
|
|
*/
|
|
bool RocVideoDecoder::SetReconfigParams(ReconfigParams *p_reconfig_params, bool b_force_reconfig_flush) {
|
|
if (!p_reconfig_params) {
|
|
std::cerr << "ERROR: Invalid reconfig struct passed! "<< std::endl;
|
|
return false;
|
|
}
|
|
//save it
|
|
p_reconfig_params_ = p_reconfig_params;
|
|
b_force_recofig_flush_ = b_force_reconfig_flush;
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Function to force Reconfigure Flush: needed for random seeking to key frames
|
|
*
|
|
* @return int 1: Success 0: Fail
|
|
*/
|
|
int RocVideoDecoder::FlushAndReconfigure() {
|
|
if (!p_reconfig_params_) {
|
|
std::cerr << "ERROR: Reconfig params is not set! "<< std::endl;
|
|
return 0;
|
|
}
|
|
if (!curr_video_format_ptr_ ) {
|
|
std::cerr << "ERROR: video format is not initialized! "<< std::endl;
|
|
return 0;
|
|
}
|
|
//call reconfigure
|
|
b_force_recofig_flush_ = true; // if not already set to force reconfigure
|
|
ReconfigureDecoder(curr_video_format_ptr_);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @brief function to reconfigure decoder if there is a change in sequence params.
|
|
*
|
|
* @param p_video_format
|
|
* @return int 1: success 0: fail
|
|
*/
|
|
int RocVideoDecoder::ReconfigureDecoder(RocdecVideoFormat *p_video_format) {
|
|
if (p_video_format->codec != codec_id_) {
|
|
ROCDEC_THROW("Reconfigure Not supported for codec change", ROCDEC_NOT_SUPPORTED);
|
|
return 0;
|
|
}
|
|
if (p_video_format->chroma_format != video_chroma_format_) {
|
|
ROCDEC_THROW("Reconfigure Not supported for chroma format change", ROCDEC_NOT_SUPPORTED);
|
|
return 0;
|
|
}
|
|
|
|
bool is_decode_res_changed = !(p_video_format->coded_width == coded_width_ && p_video_format->coded_height == coded_height_);
|
|
bool is_display_rect_changed = !(p_video_format->display_area.bottom == disp_rect_.bottom &&
|
|
p_video_format->display_area.top == disp_rect_.top &&
|
|
p_video_format->display_area.left == disp_rect_.left &&
|
|
p_video_format->display_area.right == disp_rect_.right);
|
|
bool is_bit_depth_changed = p_video_format->bit_depth_luma_minus8 != bitdepth_minus_8_;
|
|
bool is_dec_surface_num_changed = p_video_format->min_num_decode_surfaces != num_decode_surfaces_;
|
|
|
|
// Flush and clear internal frame store to reconfigure when either coded size or display size has changed.
|
|
if (p_reconfig_params_ && p_reconfig_params_->p_fn_reconfigure_flush)
|
|
num_frames_flushed_during_reconfig_ += p_reconfig_params_->p_fn_reconfigure_flush(this, p_reconfig_params_->reconfig_flush_mode, static_cast<void *>(p_reconfig_params_->p_reconfig_user_struct));
|
|
|
|
if (!is_decode_res_changed && !is_display_rect_changed && !is_bit_depth_changed && !is_dec_surface_num_changed && !b_force_recofig_flush_) {
|
|
return 1;
|
|
}
|
|
|
|
// clear the existing output buffers of different size
|
|
// note that app lose the remaining frames in the vp_frames/vp_frames_q in case application didn't set p_fn_reconfigure_flush_ callback
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_INTERNAL) {
|
|
ReleaseInternalFrames();
|
|
} else {
|
|
std::lock_guard<std::mutex> lock(mtx_vp_frame_);
|
|
while(!vp_frames_.empty()) {
|
|
DecFrameBuffer *p_frame = &vp_frames_.back();
|
|
// pop decoded frame
|
|
vp_frames_.pop_back();
|
|
if (p_frame->frame_ptr) {
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_COPIED) {
|
|
hipError_t hip_status = hipFree(p_frame->frame_ptr);
|
|
if (hip_status != hipSuccess) std::cerr << "ERROR: hipFree failed! (" << hip_status << ")" << std::endl;
|
|
}
|
|
else
|
|
delete [] (p_frame->frame_ptr);
|
|
}
|
|
}
|
|
}
|
|
output_frame_cnt_ = 0; // reset frame_count
|
|
if (is_decode_res_changed) {
|
|
coded_width_ = p_video_format->coded_width;
|
|
coded_height_ = p_video_format->coded_height;
|
|
}
|
|
if (is_display_rect_changed) {
|
|
disp_rect_.left = p_video_format->display_area.left;
|
|
disp_rect_.right = p_video_format->display_area.right;
|
|
disp_rect_.top = p_video_format->display_area.top;
|
|
disp_rect_.bottom = p_video_format->display_area.bottom;
|
|
disp_width_ = p_video_format->display_area.right - p_video_format->display_area.left;
|
|
disp_height_ = p_video_format->display_area.bottom - p_video_format->display_area.top;
|
|
chroma_height_ = static_cast<int>(std::ceil(target_height_ * GetChromaHeightFactor(video_surface_format_)));
|
|
if (!(crop_rect_.right && crop_rect_.bottom)) {
|
|
target_width_ = (disp_width_ + 1) & ~1;
|
|
target_height_ = (disp_height_ + 1) & ~1;
|
|
} else {
|
|
target_width_ = (crop_rect_.right - crop_rect_.left + 1) & ~1;
|
|
target_height_ = (crop_rect_.bottom - crop_rect_.top + 1) & ~1;
|
|
}
|
|
}
|
|
if (is_bit_depth_changed) {
|
|
bitdepth_minus_8_ = p_video_format->bit_depth_luma_minus8;
|
|
byte_per_pixel_ = bitdepth_minus_8_ > 0 ? 2 : 1;
|
|
|
|
// Set the output surface format same as chroma format
|
|
if (video_chroma_format_ == rocDecVideoChromaFormat_420 || video_chroma_format_ == rocDecVideoChromaFormat_Monochrome)
|
|
video_surface_format_ = bitdepth_minus_8_ ? rocDecVideoSurfaceFormat_P016 : rocDecVideoSurfaceFormat_NV12;
|
|
else if (video_chroma_format_ == rocDecVideoChromaFormat_444)
|
|
video_surface_format_ = bitdepth_minus_8_ ? rocDecVideoSurfaceFormat_YUV444_16Bit : rocDecVideoSurfaceFormat_YUV444;
|
|
else if (video_chroma_format_ == rocDecVideoChromaFormat_422)
|
|
video_surface_format_ = bitdepth_minus_8_ ? rocDecVideoSurfaceFormat_YUV422_16Bit : rocDecVideoSurfaceFormat_YUV422;
|
|
}
|
|
num_decode_surfaces_ = p_video_format->min_num_decode_surfaces;
|
|
|
|
if (p_video_format->reconfig_options == ROCDEC_RECONFIG_NEW_SURFACES) {
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_INTERNAL || out_mem_type_ == OUT_SURFACE_MEM_NOT_MAPPED) {
|
|
GetSurfaceStrideInternal(video_surface_format_, coded_width_, coded_height_, &surface_stride_, &surface_vstride_);
|
|
} else {
|
|
surface_stride_ = target_width_ * byte_per_pixel_;
|
|
}
|
|
}
|
|
chroma_height_ = static_cast<int>(ceil(target_height_ * GetChromaHeightFactor(video_surface_format_)));
|
|
num_chroma_planes_ = GetChromaPlaneCount(video_surface_format_);
|
|
if (p_video_format->chroma_format == rocDecVideoChromaFormat_Monochrome) num_chroma_planes_ = 0;
|
|
if (p_video_format->reconfig_options == ROCDEC_RECONFIG_NEW_SURFACES) {
|
|
chroma_vstride_ = static_cast<int>(std::ceil(surface_vstride_ * GetChromaHeightFactor(video_surface_format_)));
|
|
}
|
|
// Fill output_surface_info_
|
|
output_surface_info_.output_width = target_width_;
|
|
output_surface_info_.output_height = target_height_;
|
|
output_surface_info_.output_pitch = surface_stride_;
|
|
output_surface_info_.output_vstride = (out_mem_type_ == OUT_SURFACE_MEM_DEV_INTERNAL) ? surface_vstride_ : target_height_;
|
|
if (!(crop_rect_.right && crop_rect_.bottom)) {
|
|
output_surface_info_.disp_rect = disp_rect_;
|
|
} else {
|
|
output_surface_info_.disp_rect = crop_rect_;
|
|
}
|
|
output_surface_info_.chroma_height = chroma_height_;
|
|
output_surface_info_.bit_depth = bitdepth_minus_8_ + 8;
|
|
output_surface_info_.bytes_per_pixel = byte_per_pixel_;
|
|
output_surface_info_.surface_format = video_surface_format_;
|
|
output_surface_info_.num_chroma_planes = num_chroma_planes_;
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_INTERNAL) {
|
|
output_surface_info_.output_surface_size_in_bytes = surface_stride_ * (surface_vstride_ + (chroma_vstride_ * num_chroma_planes_));
|
|
output_surface_info_.mem_type = OUT_SURFACE_MEM_DEV_INTERNAL;
|
|
} else if (out_mem_type_ == OUT_SURFACE_MEM_DEV_COPIED) {
|
|
output_surface_info_.output_surface_size_in_bytes = GetFrameSize();
|
|
output_surface_info_.mem_type = OUT_SURFACE_MEM_DEV_COPIED;
|
|
} else if (out_mem_type_ == OUT_SURFACE_MEM_HOST_COPIED) {
|
|
output_surface_info_.output_surface_size_in_bytes = GetFrameSize();
|
|
output_surface_info_.mem_type = OUT_SURFACE_MEM_HOST_COPIED;
|
|
} else {
|
|
output_surface_info_.output_surface_size_in_bytes = surface_stride_ * (surface_vstride_ + (chroma_vstride_ * num_chroma_planes_));
|
|
output_surface_info_.mem_type = OUT_SURFACE_MEM_NOT_MAPPED;
|
|
}
|
|
|
|
// If the coded_width or coded_height hasn't changed but display resolution has changed, then need to update width and height for
|
|
// correct output with cropping. There is no need to reconfigure the decoder.
|
|
if (!is_decode_res_changed && is_display_rect_changed && !is_bit_depth_changed && !is_dec_surface_num_changed) {
|
|
is_output_surface_changed_ = true;
|
|
return 1;
|
|
}
|
|
|
|
RocdecReconfigureDecoderInfo reconfig_params = {0};
|
|
reconfig_params.width = coded_width_;
|
|
reconfig_params.height = coded_height_;
|
|
reconfig_params.target_width = target_width_;
|
|
reconfig_params.target_height = target_height_;
|
|
reconfig_params.bit_depth_minus_8 = bitdepth_minus_8_;
|
|
reconfig_params.num_decode_surfaces = p_video_format->min_num_decode_surfaces;
|
|
if (!(crop_rect_.right && crop_rect_.bottom)) {
|
|
reconfig_params.display_rect.top = disp_rect_.top;
|
|
reconfig_params.display_rect.bottom = disp_rect_.bottom;
|
|
reconfig_params.display_rect.left = disp_rect_.left;
|
|
reconfig_params.display_rect.right = disp_rect_.right;
|
|
} else {
|
|
reconfig_params.display_rect.top = crop_rect_.top;
|
|
reconfig_params.display_rect.bottom = crop_rect_.bottom;
|
|
reconfig_params.display_rect.left = crop_rect_.left;
|
|
reconfig_params.display_rect.right = crop_rect_.right;
|
|
}
|
|
|
|
if (roc_decoder_ == nullptr) {
|
|
ROCDEC_THROW("Reconfigurition of the decoder detected but the decoder was not initialized previoulsy!", ROCDEC_NOT_SUPPORTED);
|
|
return 0;
|
|
}
|
|
if (p_video_format->reconfig_options == ROCDEC_RECONFIG_NEW_SURFACES) {
|
|
if (rocDecReconfigureDecoder(roc_decoder_, &reconfig_params) != ROCDEC_SUCCESS) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
input_video_info_str_.str("");
|
|
input_video_info_str_.clear();
|
|
if (is_decode_res_changed) {
|
|
input_video_info_str_ << "Input Video Resolution Changed:" << std::endl;
|
|
}
|
|
if (is_bit_depth_changed) {
|
|
input_video_info_str_ << "Input Video Bit Depth Changed:" << std::endl;
|
|
}
|
|
if (is_dec_surface_num_changed) {
|
|
input_video_info_str_ << "Number of decoded surfaces Changed:" << std::endl;
|
|
}
|
|
input_video_info_str_ << "\tCoded size : [" << p_video_format->coded_width << ", " << p_video_format->coded_height << "]" << std::endl
|
|
<< "\tDisplay area : [" << p_video_format->display_area.left << ", " << p_video_format->display_area.top << ", "
|
|
<< p_video_format->display_area.right << ", " << p_video_format->display_area.bottom << "]" << std::endl;
|
|
input_video_info_str_ << "\tBit depth : " << reconfig_params.bit_depth_minus_8 + 8 << std::endl;
|
|
input_video_info_str_ << std::endl;
|
|
input_video_info_str_ << "Video Decoding Params:" << std::endl
|
|
<< "\tNum Surfaces : " << reconfig_params.num_decode_surfaces << std::endl
|
|
<< "\tResize : " << reconfig_params.target_width << "x" << reconfig_params.target_height << std::endl
|
|
;
|
|
input_video_info_str_ << std::endl;
|
|
std::cout << input_video_info_str_.str();
|
|
|
|
if (is_display_rect_changed || is_bit_depth_changed) {
|
|
is_output_surface_changed_ = true;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* @brief
|
|
*
|
|
* @param pPicParams
|
|
* @return int 1: success 0: fail
|
|
*/
|
|
int RocVideoDecoder::HandlePictureDecode(RocdecPicParams *pPicParams) {
|
|
if (!roc_decoder_) {
|
|
ROCDEC_THROW("RocDecoder not initialized: failed with ErrCode: " + TOSTR(ROCDEC_NOT_INITIALIZED), ROCDEC_NOT_INITIALIZED);
|
|
}
|
|
pic_num_in_dec_order_[pPicParams->curr_pic_idx] = decode_poc_++;
|
|
ROCDEC_API_CALL(rocDecDecodeFrame(roc_decoder_, pPicParams));
|
|
last_decode_surf_idx_ = pPicParams->curr_pic_idx;
|
|
decoded_pic_cnt_++;
|
|
if (b_force_zero_latency_ && ((!pPicParams->field_pic_flag) || (pPicParams->second_field))) {
|
|
RocdecParserDispInfo disp_info;
|
|
memset(&disp_info, 0, sizeof(disp_info));
|
|
disp_info.picture_index = pPicParams->curr_pic_idx;
|
|
disp_info.progressive_frame = !pPicParams->field_pic_flag;
|
|
disp_info.top_field_first = pPicParams->bottom_field_flag ^ 1;
|
|
HandlePictureDisplay(&disp_info);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* @brief function to handle display picture
|
|
*
|
|
* @param pDispInfo
|
|
* @return int 0:fail 1: success
|
|
*/
|
|
int RocVideoDecoder::HandlePictureDisplay(RocdecParserDispInfo *pDispInfo) {
|
|
RocdecProcParams video_proc_params = {};
|
|
video_proc_params.progressive_frame = pDispInfo->progressive_frame;
|
|
video_proc_params.top_field_first = pDispInfo->top_field_first;
|
|
|
|
if (b_extract_sei_message_) {
|
|
if (sei_message_display_q_[pDispInfo->picture_index].sei_data) {
|
|
// Write SEI Message
|
|
uint8_t *sei_buffer = (uint8_t *)(sei_message_display_q_[pDispInfo->picture_index].sei_data);
|
|
uint32_t sei_num_messages = sei_message_display_q_[pDispInfo->picture_index].sei_message_count;
|
|
RocdecSeiMessage *sei_message = sei_message_display_q_[pDispInfo->picture_index].sei_message;
|
|
if (fp_sei_) {
|
|
for (uint32_t i = 0; i < sei_num_messages; i++) {
|
|
if (codec_id_ == rocDecVideoCodec_AVC || codec_id_ == rocDecVideoCodec_HEVC) {
|
|
switch (sei_message[i].sei_message_type) {
|
|
case SEI_TYPE_TIME_CODE: {
|
|
//todo:: check if we need to write timecode
|
|
}
|
|
break;
|
|
case SEI_TYPE_USER_DATA_UNREGISTERED: {
|
|
fwrite(sei_buffer, sei_message[i].sei_message_size, 1, fp_sei_);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (codec_id_ == rocDecVideoCodec_AV1) {
|
|
fwrite(sei_buffer, sei_message[i].sei_message_size, 1, fp_sei_);
|
|
}
|
|
sei_buffer += sei_message[i].sei_message_size;
|
|
}
|
|
}
|
|
free(sei_message_display_q_[pDispInfo->picture_index].sei_data);
|
|
sei_message_display_q_[pDispInfo->picture_index].sei_data = NULL; // to avoid double free
|
|
free(sei_message_display_q_[pDispInfo->picture_index].sei_message);
|
|
sei_message_display_q_[pDispInfo->picture_index].sei_message = NULL; // to avoid double free
|
|
}
|
|
}
|
|
if (out_mem_type_ != OUT_SURFACE_MEM_NOT_MAPPED) {
|
|
void * src_dev_ptr[3] = { 0 };
|
|
uint32_t src_pitch[3] = { 0 };
|
|
ROCDEC_API_CALL(rocDecGetVideoFrame(roc_decoder_, pDispInfo->picture_index, src_dev_ptr, src_pitch, &video_proc_params));
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_INTERNAL) {
|
|
DecFrameBuffer dec_frame = { 0 };
|
|
dec_frame.frame_ptr = (uint8_t *)(src_dev_ptr[0]);
|
|
dec_frame.pts = pDispInfo->pts;
|
|
dec_frame.picture_index = pDispInfo->picture_index;
|
|
std::lock_guard<std::mutex> lock(mtx_vp_frame_);
|
|
vp_frames_q_.push(dec_frame);
|
|
output_frame_cnt_++;
|
|
} else {
|
|
// copy the decoded surface info device or host
|
|
uint8_t *p_dec_frame = nullptr;
|
|
{
|
|
std::lock_guard<std::mutex> lock(mtx_vp_frame_);
|
|
// if not enough frames in stock, allocate
|
|
if ((unsigned)++output_frame_cnt_ > vp_frames_.size()) {
|
|
num_alloced_frames_++;
|
|
DecFrameBuffer dec_frame = { 0 };
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_COPIED) {
|
|
// allocate device memory
|
|
HIP_API_CALL(hipMalloc((void **)&dec_frame.frame_ptr, GetFrameSize()));
|
|
} else {
|
|
dec_frame.frame_ptr = new uint8_t[GetFrameSize()];
|
|
}
|
|
dec_frame.pts = pDispInfo->pts;
|
|
dec_frame.picture_index = pDispInfo->picture_index;
|
|
vp_frames_.push_back(dec_frame);
|
|
}
|
|
p_dec_frame = vp_frames_[output_frame_cnt_ - 1].frame_ptr;
|
|
}
|
|
// Copy luma data
|
|
int dst_pitch = disp_width_ * byte_per_pixel_;
|
|
uint8_t *p_src_ptr_y = static_cast<uint8_t *>(src_dev_ptr[0]) + (disp_rect_.top + crop_rect_.top) * src_pitch[0] + (disp_rect_.left + crop_rect_.left) * byte_per_pixel_;
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_COPIED) {
|
|
if (src_pitch[0] == dst_pitch) {
|
|
int luma_size = src_pitch[0] * coded_height_;
|
|
HIP_API_CALL(hipMemcpyDtoDAsync(p_dec_frame, p_src_ptr_y, luma_size, hip_stream_));
|
|
} else {
|
|
// use 2d copy to copy an ROI
|
|
HIP_API_CALL(hipMemcpy2DAsync(p_dec_frame, dst_pitch, p_src_ptr_y, src_pitch[0], dst_pitch, disp_height_, hipMemcpyDeviceToDevice, hip_stream_));
|
|
}
|
|
} else
|
|
HIP_API_CALL(hipMemcpy2DAsync(p_dec_frame, dst_pitch, p_src_ptr_y, src_pitch[0], dst_pitch, disp_height_, hipMemcpyDeviceToHost, hip_stream_));
|
|
|
|
// Copy chroma plane ( )
|
|
// rocDec output gives pointer to luma and chroma pointers seperated for the decoded frame
|
|
uint8_t *p_frame_uv = p_dec_frame + dst_pitch * disp_height_;
|
|
uint8_t *p_src_ptr_uv = (num_chroma_planes_ == 1) ? static_cast<uint8_t *>(src_dev_ptr[1]) + ((disp_rect_.top + crop_rect_.top) >> 1) * src_pitch[1] + (disp_rect_.left + crop_rect_.left) * byte_per_pixel_ :
|
|
static_cast<uint8_t *>(src_dev_ptr[1]) + (disp_rect_.top + crop_rect_.top) * src_pitch[1] + (disp_rect_.left + crop_rect_.left) * byte_per_pixel_;
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_COPIED) {
|
|
if (src_pitch[1] == dst_pitch) {
|
|
int chroma_size = chroma_height_ * dst_pitch;
|
|
HIP_API_CALL(hipMemcpyDtoDAsync(p_frame_uv, p_src_ptr_uv, chroma_size, hip_stream_));
|
|
} else {
|
|
// use 2d copy to copy an ROI
|
|
HIP_API_CALL(hipMemcpy2DAsync(p_frame_uv, dst_pitch, p_src_ptr_uv, src_pitch[1], dst_pitch, chroma_height_, hipMemcpyDeviceToDevice, hip_stream_));
|
|
}
|
|
} else
|
|
HIP_API_CALL(hipMemcpy2DAsync(p_frame_uv, dst_pitch, p_src_ptr_uv, src_pitch[1], dst_pitch, chroma_height_, hipMemcpyDeviceToHost, hip_stream_));
|
|
|
|
if (num_chroma_planes_ == 2) {
|
|
uint8_t *p_frame_v = p_dec_frame + dst_pitch * (disp_height_ + chroma_height_);
|
|
uint8_t *p_src_ptr_v = static_cast<uint8_t *>(src_dev_ptr[2]) + (disp_rect_.top + crop_rect_.top) * src_pitch[2] + (disp_rect_.left + crop_rect_.left) * byte_per_pixel_;
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_COPIED) {
|
|
if (src_pitch[2] == dst_pitch) {
|
|
int chroma_size = chroma_height_ * dst_pitch;
|
|
HIP_API_CALL(hipMemcpyDtoDAsync(p_frame_v, p_src_ptr_v, chroma_size, hip_stream_));
|
|
} else {
|
|
// use 2d copy to copy an ROI
|
|
HIP_API_CALL(hipMemcpy2DAsync(p_frame_v, dst_pitch, p_src_ptr_v, src_pitch[2], dst_pitch, chroma_height_, hipMemcpyDeviceToDevice, hip_stream_));
|
|
}
|
|
} else
|
|
HIP_API_CALL(hipMemcpy2DAsync(p_frame_v, dst_pitch, p_src_ptr_v, src_pitch[2], dst_pitch, chroma_height_, hipMemcpyDeviceToHost, hip_stream_));
|
|
}
|
|
|
|
HIP_API_CALL(hipStreamSynchronize(hip_stream_));
|
|
}
|
|
} else {
|
|
output_frame_cnt_++;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int RocVideoDecoder::GetSEIMessage(RocdecSeiMessageInfo *pSEIMessageInfo) {
|
|
uint32_t sei_num_mesages = pSEIMessageInfo->sei_message_count;
|
|
if (sei_num_mesages) {
|
|
RocdecSeiMessage *p_sei_msg_info = pSEIMessageInfo->sei_message;
|
|
size_t total_SEI_buff_size = 0;
|
|
if ((pSEIMessageInfo->picIdx < 0) || (pSEIMessageInfo->picIdx >= MAX_FRAME_NUM)) {
|
|
ROCDEC_ERR("Invalid picture index for SEI message: " + TOSTR(pSEIMessageInfo->picIdx));
|
|
return 0;
|
|
}
|
|
for (uint32_t i = 0; i < sei_num_mesages; i++) {
|
|
total_SEI_buff_size += p_sei_msg_info[i].sei_message_size;
|
|
}
|
|
if (!curr_sei_message_ptr_) {
|
|
ROCDEC_ERR("Out of Memory, Allocation failed for m_pCurrSEIMessage");
|
|
return 0;
|
|
}
|
|
curr_sei_message_ptr_->sei_data = malloc(total_SEI_buff_size);
|
|
if (!curr_sei_message_ptr_->sei_data) {
|
|
ROCDEC_ERR("Out of Memory, Allocation failed for SEI Buffer");
|
|
return 0;
|
|
}
|
|
memcpy(curr_sei_message_ptr_->sei_data, pSEIMessageInfo->sei_data, total_SEI_buff_size);
|
|
curr_sei_message_ptr_->sei_message = (RocdecSeiMessage *)malloc(sizeof(RocdecSeiMessage) * sei_num_mesages);
|
|
if (!curr_sei_message_ptr_->sei_message) {
|
|
free(curr_sei_message_ptr_->sei_data);
|
|
curr_sei_message_ptr_->sei_data = NULL;
|
|
return 0;
|
|
}
|
|
memcpy(curr_sei_message_ptr_->sei_message, pSEIMessageInfo->sei_message, sizeof(RocdecSeiMessage) * sei_num_mesages);
|
|
curr_sei_message_ptr_->sei_message_count = pSEIMessageInfo->sei_message_count;
|
|
sei_message_display_q_[pSEIMessageInfo->picIdx] = *curr_sei_message_ptr_;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
int RocVideoDecoder::DecodeFrame(const uint8_t *data, size_t size, int pkt_flags, int64_t pts, int *num_decoded_pics) {
|
|
output_frame_cnt_ = 0, output_frame_cnt_ret_ = 0;
|
|
decoded_pic_cnt_ = 0;
|
|
RocdecSourceDataPacket packet = { 0 };
|
|
packet.payload = data;
|
|
packet.payload_size = size;
|
|
packet.flags = pkt_flags | ROCDEC_PKT_TIMESTAMP;
|
|
packet.pts = pts;
|
|
if (!data || size == 0) {
|
|
packet.flags |= ROCDEC_PKT_ENDOFSTREAM;
|
|
}
|
|
if (rocDecParseVideoData(rocdec_parser_, &packet) != ROCDEC_SUCCESS) {
|
|
ROCDEC_ERR("Error occurred in rocDecParseVideoData().");
|
|
}
|
|
if (num_decoded_pics) {
|
|
*num_decoded_pics = decoded_pic_cnt_;
|
|
}
|
|
return output_frame_cnt_;
|
|
}
|
|
|
|
uint8_t* RocVideoDecoder::GetFrame(int64_t *pts) {
|
|
if (output_frame_cnt_ > 0) {
|
|
std::lock_guard<std::mutex> lock(mtx_vp_frame_);
|
|
output_frame_cnt_--;
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_INTERNAL && !vp_frames_q_.empty()) {
|
|
DecFrameBuffer *fb = &vp_frames_q_.front();
|
|
if (pts) *pts = fb->pts;
|
|
return fb->frame_ptr;
|
|
} else if (vp_frames_.size() > 0){
|
|
if (pts) *pts = vp_frames_[output_frame_cnt_ret_].pts;
|
|
return vp_frames_[output_frame_cnt_ret_++].frame_ptr;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @brief function to release frame after use by the application: Only used with "OUT_SURFACE_MEM_DEV_INTERNAL"
|
|
*
|
|
* @param pTimestamp - timestamp of the frame to be released (unmapped)
|
|
* @return true - success
|
|
* @return false - falied
|
|
*/
|
|
|
|
bool RocVideoDecoder::ReleaseFrame(int64_t pTimestamp, bool b_flushing) {
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_NOT_MAPPED)
|
|
return true; // nothing to do
|
|
if (out_mem_type_ != OUT_SURFACE_MEM_DEV_INTERNAL) {
|
|
if (!b_flushing) // if not flushing the buffers are re-used, so keep them
|
|
return true; // nothing to do
|
|
else {
|
|
DecFrameBuffer *fb = &vp_frames_[0];
|
|
if (pTimestamp != fb->pts) {
|
|
std::cerr << "Decoded Frame is released out of order" << std::endl;
|
|
return false;
|
|
}
|
|
vp_frames_.erase(vp_frames_.begin()); // get rid of the frames from the framestore
|
|
}
|
|
}
|
|
// only needed when using internal mapped buffer
|
|
if (!vp_frames_q_.empty()) {
|
|
std::lock_guard<std::mutex> lock(mtx_vp_frame_);
|
|
DecFrameBuffer *fb = &vp_frames_q_.front();
|
|
|
|
if (pTimestamp != fb->pts) {
|
|
std::cerr << "Decoded Frame is released out of order" << std::endl;
|
|
return false;
|
|
}
|
|
// pop decoded frame
|
|
vp_frames_q_.pop();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief function to release all internal frames and clear the q (used with reconfigure): Only used with "OUT_SURFACE_MEM_DEV_INTERNAL"
|
|
*
|
|
* @return true - success
|
|
* @return false - falied
|
|
*/
|
|
bool RocVideoDecoder::ReleaseInternalFrames() {
|
|
if (out_mem_type_ != OUT_SURFACE_MEM_DEV_INTERNAL || out_mem_type_ == OUT_SURFACE_MEM_NOT_MAPPED)
|
|
return true; // nothing to do
|
|
// only needed when using internal mapped buffer
|
|
while (!vp_frames_q_.empty()) {
|
|
std::lock_guard<std::mutex> lock(mtx_vp_frame_);
|
|
// pop decoded frame
|
|
vp_frames_q_.pop();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void RocVideoDecoder::SaveFrameToFile(std::string output_file_name, void *surf_mem, OutputSurfaceInfo *surf_info, size_t rgb_image_size) {
|
|
uint8_t *hst_ptr = nullptr;
|
|
bool is_rgb = (rgb_image_size != 0);
|
|
uint64_t output_image_size = is_rgb ? rgb_image_size : surf_info->output_surface_size_in_bytes;
|
|
if (surf_info->mem_type == OUT_SURFACE_MEM_DEV_INTERNAL || surf_info->mem_type == OUT_SURFACE_MEM_DEV_COPIED) {
|
|
if (hst_ptr == nullptr) {
|
|
hst_ptr = new uint8_t [output_image_size];
|
|
}
|
|
hipError_t hip_status = hipSuccess;
|
|
hip_status = hipMemcpyDtoH((void *)hst_ptr, surf_mem, output_image_size);
|
|
if (hip_status != hipSuccess) {
|
|
std::cerr << "ERROR: hipMemcpyDtoH failed! (" << hipGetErrorName(hip_status) << ")" << std::endl;
|
|
delete [] hst_ptr;
|
|
return;
|
|
}
|
|
} else
|
|
hst_ptr = static_cast<uint8_t *> (surf_mem);
|
|
|
|
if (hst_ptr == nullptr) {
|
|
ROCDEC_ERR("Null surface pointer.");
|
|
return;
|
|
}
|
|
|
|
if (current_output_filename.empty()) {
|
|
current_output_filename = output_file_name;
|
|
}
|
|
|
|
// don't overwrite to the same file if reconfigure is detected for a resolution/bit depth changes.
|
|
if (is_output_surface_changed_) {
|
|
if (fp_out_) {
|
|
fclose(fp_out_);
|
|
fp_out_ = nullptr;
|
|
}
|
|
// Append the width and height of the new sequence to the old file name to create a file name to save the new frames
|
|
// Do this only if resolution/bit depth changes within a stream (e.g., decoding a multi-resolution stream using the videoDecode app)
|
|
// Don't append to the output_file_name if multiple output file name is provided (e.g., decoding multi-files using the videDecodeMultiFiles)
|
|
if (!current_output_filename.compare(output_file_name)) {
|
|
std::string::size_type const pos(output_file_name.find_last_of('.'));
|
|
extra_output_file_count_++;
|
|
std::string to_append = "_" + std::to_string(surf_info->output_width) + "_" + std::to_string(surf_info->output_height) + "_" + std::to_string(surf_info->bit_depth) + "bit" + "_" + std::to_string(extra_output_file_count_);
|
|
if (pos != std::string::npos) {
|
|
output_file_name.insert(pos, to_append);
|
|
} else {
|
|
output_file_name += to_append;
|
|
}
|
|
}
|
|
is_output_surface_changed_ = false;
|
|
}
|
|
|
|
if (fp_out_ == nullptr) {
|
|
fp_out_ = fopen(output_file_name.c_str(), "wb");
|
|
}
|
|
if (fp_out_) {
|
|
if (!is_rgb) {
|
|
uint8_t *tmp_hst_ptr = hst_ptr;
|
|
if (surf_info->mem_type == OUT_SURFACE_MEM_DEV_INTERNAL) {
|
|
tmp_hst_ptr += ((disp_rect_.top + crop_rect_.top) * surf_info->output_pitch) + (disp_rect_.left + crop_rect_.left) * surf_info->bytes_per_pixel;
|
|
}
|
|
int img_width = surf_info->output_width;
|
|
int img_height = surf_info->output_height;
|
|
int output_stride = surf_info->output_pitch;
|
|
if (img_width * surf_info->bytes_per_pixel == output_stride && img_height == surf_info->output_vstride) {
|
|
fwrite(hst_ptr, 1, output_image_size, fp_out_);
|
|
} else {
|
|
uint32_t width = surf_info->output_width * surf_info->bytes_per_pixel;
|
|
if (surf_info->bit_depth <= 16) {
|
|
for (int i = 0; i < surf_info->output_height; i++) {
|
|
fwrite(tmp_hst_ptr, 1, width, fp_out_);
|
|
tmp_hst_ptr += output_stride;
|
|
}
|
|
// dump chroma
|
|
uint8_t *uv_hst_ptr = hst_ptr + output_stride * surf_info->output_vstride;
|
|
if (surf_info->mem_type == OUT_SURFACE_MEM_DEV_INTERNAL) {
|
|
uv_hst_ptr += (num_chroma_planes_ == 1) ? (((disp_rect_.top + crop_rect_.top) >> 1) * surf_info->output_pitch) + ((disp_rect_.left + crop_rect_.left) * surf_info->bytes_per_pixel):
|
|
((disp_rect_.top + crop_rect_.top) * surf_info->output_pitch) + ((disp_rect_.left + crop_rect_.left) * surf_info->bytes_per_pixel);
|
|
}
|
|
for (int i = 0; i < chroma_height_; i++) {
|
|
fwrite(uv_hst_ptr, 1, width, fp_out_);
|
|
uv_hst_ptr += output_stride;
|
|
}
|
|
if (num_chroma_planes_ == 2) {
|
|
uv_hst_ptr = hst_ptr + output_stride * (surf_info->output_vstride + chroma_vstride_);
|
|
if (surf_info->mem_type == OUT_SURFACE_MEM_DEV_INTERNAL) {
|
|
uv_hst_ptr += ((disp_rect_.top + crop_rect_.top) * surf_info->output_pitch) + ((disp_rect_.left + crop_rect_.left) * surf_info->bytes_per_pixel);
|
|
}
|
|
for (int i = 0; i < chroma_height_; i++) {
|
|
fwrite(uv_hst_ptr, 1, width, fp_out_);
|
|
uv_hst_ptr += output_stride;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
fwrite(hst_ptr, 1, rgb_image_size, fp_out_);
|
|
}
|
|
}
|
|
|
|
if (hst_ptr && (surf_info->mem_type != OUT_SURFACE_MEM_HOST_COPIED)) {
|
|
delete [] hst_ptr;
|
|
}
|
|
}
|
|
|
|
void RocVideoDecoder::ResetSaveFrameToFile() {
|
|
if (fp_out_) {
|
|
fclose(fp_out_);
|
|
fp_out_ = nullptr;
|
|
}
|
|
}
|
|
|
|
void RocVideoDecoder::GetDeviceinfo(std::string &device_name, std::string &gcn_arch_name, int &pci_bus_id, int &pci_domain_id, int &pci_device_id) {
|
|
device_name = hip_dev_prop_.name;
|
|
gcn_arch_name = hip_dev_prop_.gcnArchName;
|
|
pci_bus_id = hip_dev_prop_.pciBusID;
|
|
pci_domain_id = hip_dev_prop_.pciDomainID;
|
|
pci_device_id = hip_dev_prop_.pciDeviceID;
|
|
}
|
|
|
|
|
|
bool RocVideoDecoder::GetOutputSurfaceInfo(OutputSurfaceInfo **surface_info) {
|
|
if (!disp_width_ || !disp_height_) {
|
|
std::cerr << "ERROR: RocVideoDecoder is not initialized" << std::endl;
|
|
return false;
|
|
}
|
|
*surface_info = &output_surface_info_;
|
|
return true;
|
|
}
|
|
|
|
bool RocVideoDecoder::InitHIP(int device_id) {
|
|
HIP_API_CALL(hipGetDeviceCount(&num_devices_));
|
|
if (num_devices_ < 1) {
|
|
std::cerr << "ERROR: didn't find any GPU!" << std::endl;
|
|
return false;
|
|
}
|
|
HIP_API_CALL(hipSetDevice(device_id));
|
|
HIP_API_CALL(hipGetDeviceProperties(&hip_dev_prop_, device_id));
|
|
if (out_mem_type_ == OUT_SURFACE_MEM_DEV_INTERNAL || out_mem_type_ == OUT_SURFACE_MEM_NOT_MAPPED) {
|
|
hip_stream_ = 0; // Null stream. For internal device or unmapped memory, we don't need to create a hip stream.
|
|
} else {
|
|
HIP_API_CALL(hipStreamCreate(&hip_stream_));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::chrono::_V2::system_clock::time_point RocVideoDecoder::StartTimer() {
|
|
return std::chrono::_V2::system_clock::now();
|
|
}
|
|
|
|
double RocVideoDecoder::StopTimer(const std::chrono::_V2::system_clock::time_point &start_time) {
|
|
return std::chrono::duration<double, std::milli>(std::chrono::_V2::system_clock::now() - start_time).count();
|
|
}
|
|
|
|
bool RocVideoDecoder::CodecSupported(int device_id, rocDecVideoCodec codec_id, uint32_t bit_depth) {
|
|
RocdecDecodeCaps decode_caps;
|
|
decode_caps.device_id = device_id;
|
|
decode_caps.codec_type = codec_id;
|
|
decode_caps.chroma_format = rocDecVideoChromaFormat_420;
|
|
decode_caps.bit_depth_minus_8 = bit_depth - 8;
|
|
if((rocDecGetDecoderCaps(&decode_caps) != ROCDEC_SUCCESS) || !decode_caps.is_supported) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void RocVideoDecoder::WaitForDecodeCompletion() {
|
|
RocdecDecodeStatus dec_status;
|
|
memset(&dec_status, 0, sizeof(dec_status));
|
|
do {
|
|
rocDecStatus result = rocDecGetDecodeStatus(roc_decoder_, last_decode_surf_idx_, &dec_status);
|
|
if (result != ROCDEC_SUCCESS) {
|
|
std::cerr << "rocDecGetDecodeStatus failed for picture_index: " << last_decode_surf_idx_ << std::endl;
|
|
return;
|
|
}
|
|
} while (dec_status.decode_status == rocDecodeStatus_InProgress);
|
|
} |