Trowbridge, Ian
316 строки
12 KiB
C++
316 строки
12 KiB
C++
// MIT License
|
|
//
|
|
// Copyright (c) 2025 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 <rocprofiler-sdk/rocdecode/api_args.h>
|
|
|
|
#include "fmt/core.h"
|
|
|
|
#define ROCP_SDK_ROCDECODE_FORMATTER(TYPE, ...) \
|
|
template <> \
|
|
struct formatter<TYPE> : rocprofiler::rocdecode::details::base_formatter \
|
|
{ \
|
|
template <typename Ctx> \
|
|
auto format(const TYPE& v, Ctx& ctx) const \
|
|
{ \
|
|
return fmt::format_to(ctx.out(), __VA_ARGS__); \
|
|
} \
|
|
};
|
|
|
|
#define ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(PREFIX, SUFFIX) \
|
|
case PREFIX##_##SUFFIX: return fmt::format_to(ctx.out(), #SUFFIX)
|
|
|
|
namespace rocprofiler
|
|
{
|
|
namespace rocdecode
|
|
{
|
|
namespace details
|
|
{
|
|
struct base_formatter
|
|
{
|
|
template <typename ParseContext>
|
|
constexpr auto parse(ParseContext& ctx)
|
|
{
|
|
return ctx.begin();
|
|
}
|
|
};
|
|
} // namespace details
|
|
} // namespace rocdecode
|
|
} // namespace rocprofiler
|
|
|
|
namespace fmt
|
|
{
|
|
template <>
|
|
struct formatter<rocDecStatus> : rocprofiler::rocdecode::details::base_formatter
|
|
{
|
|
template <typename Ctx>
|
|
auto format(rocDecStatus v, Ctx& ctx) const
|
|
{
|
|
switch(v)
|
|
{
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(ROCDEC, DEVICE_INVALID);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(ROCDEC, CONTEXT_INVALID);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(ROCDEC, RUNTIME_ERROR);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(ROCDEC, OUTOF_MEMORY);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(ROCDEC, INVALID_PARAMETER);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(ROCDEC, NOT_IMPLEMENTED);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(ROCDEC, NOT_INITIALIZED);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(ROCDEC, NOT_SUPPORTED);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(ROCDEC, SUCCESS);
|
|
}
|
|
return fmt::format_to(ctx.out(), "Unknown");
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct formatter<rocDecDecodeStatus> : rocprofiler::rocdecode::details::base_formatter
|
|
{
|
|
template <typename Ctx>
|
|
auto format(rocDecDecodeStatus v, Ctx& ctx) const
|
|
{
|
|
switch(v)
|
|
{
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecodeStatus, Invalid);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecodeStatus, InProgress);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecodeStatus, Success);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecodeStatus, Error);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecodeStatus, Error_Concealed);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecodeStatus, Displaying);
|
|
}
|
|
return fmt::format_to(ctx.out(), "Unknown");
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct formatter<rocDecVideoCodec> : rocprofiler::rocdecode::details::base_formatter
|
|
{
|
|
template <typename Ctx>
|
|
auto format(rocDecVideoCodec v, Ctx& ctx) const
|
|
{
|
|
switch(v)
|
|
{
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, MPEG1);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, MPEG2);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, MPEG4);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, AVC);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, HEVC);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, AV1);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, VP8);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, VP9);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, JPEG);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, NumCodecs);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, YUV420);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, YV12);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, NV12);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, YUYV);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoCodec, UYVY);
|
|
}
|
|
return fmt::format_to(ctx.out(), "Unknown");
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct formatter<rocDecVideoChromaFormat> : rocprofiler::rocdecode::details::base_formatter
|
|
{
|
|
template <typename Ctx>
|
|
auto format(rocDecVideoChromaFormat v, Ctx& ctx) const
|
|
{
|
|
switch(v)
|
|
{
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoChromaFormat, Monochrome);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoChromaFormat, 420);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoChromaFormat, 422);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoChromaFormat, 444);
|
|
}
|
|
return fmt::format_to(ctx.out(), "Unknown");
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct formatter<rocDecVideoSurfaceFormat> : rocprofiler::rocdecode::details::base_formatter
|
|
{
|
|
template <typename Ctx>
|
|
auto format(rocDecVideoSurfaceFormat v, Ctx& ctx) const
|
|
{
|
|
switch(v)
|
|
{
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoSurfaceFormat, NV12);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoSurfaceFormat, P016);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoSurfaceFormat, YUV444);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoSurfaceFormat, YUV444_16Bit);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoSurfaceFormat, YUV420);
|
|
ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT(rocDecVideoSurfaceFormat, YUV420_16Bit);
|
|
}
|
|
return fmt::format_to(ctx.out(), "Unknown");
|
|
}
|
|
};
|
|
|
|
ROCP_SDK_ROCDECODE_FORMATTER(
|
|
_RocdecParserParams,
|
|
"{}codec_type={},max_num_decode_surfaces={}, clock_rate={}, error_threshold={}, "
|
|
"max_display_delay={}, annex_b={}, reserved={}, user_data={}, ext_video_info={}{}",
|
|
'{',
|
|
v.codec_type,
|
|
v.max_num_decode_surfaces,
|
|
v.clock_rate,
|
|
v.error_threshold,
|
|
v.max_display_delay,
|
|
v.annex_b,
|
|
v.reserved,
|
|
v.user_data,
|
|
static_cast<void*>(v.ext_video_info),
|
|
'}')
|
|
|
|
ROCP_SDK_ROCDECODE_FORMATTER(RocdecTimeStamp, "{}RocdecTimeStamp={}{}", '{', v, '}')
|
|
|
|
ROCP_SDK_ROCDECODE_FORMATTER(_RocdecSourceDataPacket,
|
|
"{}flags={}, payload_size={}, payload={}, pts={}{}",
|
|
'{',
|
|
v.flags,
|
|
v.payload_size,
|
|
static_cast<const void*>(v.payload),
|
|
v.pts,
|
|
'}')
|
|
|
|
ROCP_SDK_ROCDECODE_FORMATTER(
|
|
_RocDecoderCreateInfo,
|
|
"{}device_id={}, width={}, height={}, num_decode_surfaces={}, codec_type={}, chroma_format={}, "
|
|
"bit_depth_minus_8={}, intra_decode_only={}, max_width={}, max_height={}, "
|
|
"display_rect={}left={}, right={}, top={}, bottom={}{}, target_width={}, target_height={}, "
|
|
"num_output_surfaces={}, target_rect={}left={}, right={}, top={}, bottom={}{}{}",
|
|
'{',
|
|
v.device_id,
|
|
v.width,
|
|
v.height,
|
|
v.num_decode_surfaces,
|
|
v.codec_type,
|
|
v.chroma_format,
|
|
v.bit_depth_minus_8,
|
|
v.intra_decode_only,
|
|
v.max_width,
|
|
v.max_height,
|
|
'{',
|
|
v.display_rect.left,
|
|
v.display_rect.right,
|
|
v.display_rect.top,
|
|
v.display_rect.bottom,
|
|
'}',
|
|
v.target_width,
|
|
v.target_height,
|
|
v.num_output_surfaces,
|
|
'{',
|
|
v.target_rect.left,
|
|
v.target_rect.right,
|
|
v.target_rect.top,
|
|
v.target_rect.bottom,
|
|
'}',
|
|
'}')
|
|
|
|
ROCP_SDK_ROCDECODE_FORMATTER(_RocdecReconfigureDecoderInfo,
|
|
"{}width={}, height={}, target_width={}, target_height={}, "
|
|
"num_decode_surfaces={}, display_rect={}left={}, right={}, top={}, "
|
|
"bottom={}{}, target_rect={}left={}, right={}, top={}, bottom={}{}{}",
|
|
'{',
|
|
v.width,
|
|
v.height,
|
|
v.target_width,
|
|
v.target_height,
|
|
v.num_decode_surfaces,
|
|
'{',
|
|
v.display_rect.left,
|
|
v.display_rect.right,
|
|
v.display_rect.top,
|
|
v.display_rect.bottom,
|
|
'}',
|
|
'{',
|
|
v.target_rect.left,
|
|
v.target_rect.right,
|
|
v.target_rect.top,
|
|
v.target_rect.bottom,
|
|
'}',
|
|
'}')
|
|
|
|
ROCP_SDK_ROCDECODE_FORMATTER(_RocdecDecodeStatus,
|
|
"{}decode_status={}, p_reserved={}{}",
|
|
'{',
|
|
v.decode_status,
|
|
v.p_reserved,
|
|
'}')
|
|
|
|
ROCP_SDK_ROCDECODE_FORMATTER(
|
|
_RocdecPicParams,
|
|
"{}pic_width={}, pic_height={}, curr_pic_idx={}, field_pic_flag={}, bottom_field_flag={}, "
|
|
"second_field={}, bitstream_data_len={}, bitstream_data={}, num_slices={}, ref_pic_flag={}, "
|
|
"intra_pic_flag={}{}",
|
|
'{',
|
|
v.pic_width,
|
|
v.pic_height,
|
|
v.curr_pic_idx,
|
|
v.field_pic_flag,
|
|
v.bottom_field_flag,
|
|
v.second_field,
|
|
v.bitstream_data_len,
|
|
static_cast<const void*>(v.bitstream_data),
|
|
v.num_slices,
|
|
v.ref_pic_flag,
|
|
v.intra_pic_flag,
|
|
'}')
|
|
|
|
ROCP_SDK_ROCDECODE_FORMATTER(
|
|
_RocdecDecodeCaps,
|
|
"{}device_id={}, codec_type={}, chroma_format={}, bit_depth_minus_8={}, is_supported={}, "
|
|
"num_decoders={}, output_format_mask={}, max_width={}, max_height={}, min_width={}, "
|
|
"min_height={}{}",
|
|
'{',
|
|
v.device_id,
|
|
v.codec_type,
|
|
v.chroma_format,
|
|
v.bit_depth_minus_8,
|
|
v.is_supported,
|
|
v.num_decoders,
|
|
v.output_format_mask,
|
|
v.max_width,
|
|
v.max_height,
|
|
v.min_width,
|
|
v.min_height,
|
|
'}')
|
|
|
|
ROCP_SDK_ROCDECODE_FORMATTER(
|
|
_RocdecProcParams,
|
|
"{}progressive_frame={}, top_field_first={}, raw_input_dptr={}, raw_input_pitch={}, "
|
|
"raw_input_format={}, raw_output_dptr={}, raw_output_pitch={}, raw_output_format={}{}",
|
|
'{',
|
|
v.progressive_frame,
|
|
v.top_field_first,
|
|
v.raw_input_dptr,
|
|
v.raw_input_pitch,
|
|
v.raw_input_format,
|
|
v.raw_output_dptr,
|
|
v.raw_output_pitch,
|
|
v.raw_output_format,
|
|
'}')
|
|
} // namespace fmt
|
|
|
|
#undef ROCP_SDK_ROCDECODE_FORMATTER
|
|
#undef ROCP_SDK_ROCDECODE_FORMAT_CASE_STMT
|