mirror of
https://gitee.com/openharmony/multimedia_av_codec
synced 2024-10-07 06:04:54 +00:00
!3333 split and add temporal scalability test case
Merge pull request !3333 from wangyongkai/split-and-add-temporal-scalability-test-case
This commit is contained in:
openharmony_ci
Gitee
commit
ac77a4057a
@ -116,11 +116,11 @@ void SetFormatBasicParam(bool isDecoder)
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: ENCODE_KEY_WIDTH_INVAILD_TEST_0101
|
||||
* @tc.name: ENCODE_KEY_WIDTH_INVALID_TEST_0101
|
||||
* @tc.desc: codec video configure not exsit width
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_F(AVCodecParamCheckerTest, ENCODE_KEY_WIDTH_INVAILD_TEST_0101, TestSize.Level3)
|
||||
HWTEST_F(AVCodecParamCheckerTest, ENCODE_KEY_WIDTH_INVALID_TEST_0101, TestSize.Level3)
|
||||
{
|
||||
ASSERT_EQ(true, OH_AVFormat_SetIntValue(g_format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT));
|
||||
ASSERT_EQ(true, OH_AVFormat_SetIntValue(g_format, OH_MD_KEY_PIXEL_FORMAT, ENCODER_PIXEL_FORMAT));
|
||||
@ -143,11 +143,11 @@ HWTEST_F(AVCodecParamCheckerTest, ENCODE_KEY_WIDTH_INVALID_TEST_0102, TestSize.L
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: ENCODE_KEY_WIDTH_INVAILD_TEST_0103
|
||||
* @tc.name: ENCODE_KEY_WIDTH_INVALID_TEST_0103
|
||||
* @tc.desc: codec video configure width out of range
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_F(AVCodecParamCheckerTest, ENCODE_KEY_WIDTH_INVAILD_TEST_0103, TestSize.Level3)
|
||||
HWTEST_F(AVCodecParamCheckerTest, ENCODE_KEY_WIDTH_INVALID_TEST_0103, TestSize.Level3)
|
||||
{
|
||||
ASSERT_EQ(true, OH_AVFormat_SetIntValue(g_format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT));
|
||||
ASSERT_EQ(true, OH_AVFormat_SetIntValue(g_format, OH_MD_KEY_PIXEL_FORMAT, ENCODER_PIXEL_FORMAT));
|
||||
|
||||
@ -59,6 +59,8 @@ group("vcodec_framework_test") {
|
||||
":videoenc_capi_unit_test",
|
||||
":videoenc_inner_unit_test",
|
||||
":videoenc_stable_unit_test",
|
||||
":videoenc_temporal_scalability_capi_unit_test",
|
||||
":videoenc_temporal_scalability_inner_unit_test",
|
||||
]
|
||||
}
|
||||
}
|
||||
@ -266,6 +268,104 @@ ohos_unittest("videoenc_inner_unit_test") {
|
||||
"$av_codec_root_dir/test/unittest/resources/ohos_test.xml"
|
||||
}
|
||||
|
||||
#################################################################################################################
|
||||
ohos_unittest("videoenc_temporal_scalability_capi_unit_test") {
|
||||
sanitize = av_codec_test_sanitize
|
||||
module_out_path = module_output_path
|
||||
include_dirs = [
|
||||
"./",
|
||||
"./common/include",
|
||||
"./func_sample/mock",
|
||||
"./func_sample/mock/capi",
|
||||
"./func_sample/sample",
|
||||
"$av_codec_root_dir/test/unittest/codeclist_test",
|
||||
"$av_codec_root_dir/test/unittest/codeclist_test/capi",
|
||||
"$av_codec_root_dir/test/unittest/common/",
|
||||
"$av_codec_root_dir/frameworks/native/capi/common",
|
||||
"$av_codec_root_dir/../../../third_party/openssl/ohos_lite/include",
|
||||
]
|
||||
|
||||
defines = [ "VIDEOENC_CAPI_UNIT_TEST" ]
|
||||
if (target_cpu == "arm64") {
|
||||
defines += [ "HMOS_TEST" ]
|
||||
}
|
||||
|
||||
cflags = vcodec_unittest_cflags
|
||||
|
||||
sources = [
|
||||
"$av_codec_root_dir/test/unittest/codeclist_test/capi/codeclist_capi_mock.cpp",
|
||||
"$av_codec_root_dir/test/unittest/codeclist_test/capi/codeclist_capi_mock_factory.cpp",
|
||||
"./common/unittest_utils.cpp",
|
||||
"./func_sample/mock/capi/vcodec_capi_mock_factory.cpp",
|
||||
"./func_sample/mock/capi/videoenc_capi_mock.cpp",
|
||||
"./func_sample/sample/venc_sample.cpp",
|
||||
"./videoenc_temporal_scalability_unit_test.cpp",
|
||||
]
|
||||
|
||||
public_deps =
|
||||
[ "$av_codec_root_dir/test/unittest/common:av_codec_capi_unit_test" ]
|
||||
|
||||
external_deps = [
|
||||
"c_utils:utils",
|
||||
"graphic_surface:surface",
|
||||
"graphic_surface:sync_fence",
|
||||
"hilog:libhilog",
|
||||
"window_manager:libwm",
|
||||
]
|
||||
|
||||
resource_config_file =
|
||||
"$av_codec_root_dir/test/unittest/resources/ohos_test.xml"
|
||||
}
|
||||
|
||||
#################################################################################################################
|
||||
ohos_unittest("videoenc_temporal_scalability_inner_unit_test") {
|
||||
sanitize = av_codec_test_sanitize
|
||||
module_out_path = module_output_path
|
||||
include_dirs = [
|
||||
"./",
|
||||
"./common/include",
|
||||
"./func_sample/mock",
|
||||
"./func_sample/mock/inner",
|
||||
"./func_sample/sample",
|
||||
"$av_codec_root_dir/test/unittest/codeclist_test",
|
||||
"$av_codec_root_dir/test/unittest/codeclist_test/codeclist_test",
|
||||
"$av_codec_root_dir/test/unittest/common/",
|
||||
"$av_codec_root_dir/../../../third_party/openssl/ohos_lite/include",
|
||||
]
|
||||
|
||||
defines = [ "VIDEOENC_INNER_UNIT_TEST" ]
|
||||
if (target_cpu == "arm64") {
|
||||
defines += [ "HMOS_TEST" ]
|
||||
}
|
||||
|
||||
cflags = vcodec_unittest_cflags
|
||||
|
||||
sources = [
|
||||
"$av_codec_root_dir/test/unittest/codeclist_test/inner/codeclist_inner_mock.cpp",
|
||||
"$av_codec_root_dir/test/unittest/codeclist_test/inner/codeclist_inner_mock_factory.cpp",
|
||||
"./common/unittest_utils.cpp",
|
||||
"./func_sample/mock/inner/vcodec_inner_mock_factory.cpp",
|
||||
"./func_sample/mock/inner/videoenc_inner_mock.cpp",
|
||||
"./func_sample/sample/venc_sample.cpp",
|
||||
"./videoenc_temporal_scalability_unit_test.cpp",
|
||||
]
|
||||
|
||||
public_deps =
|
||||
[ "$av_codec_root_dir/test/unittest/common:av_codec_inner_unit_test" ]
|
||||
|
||||
external_deps = [
|
||||
"c_utils:utils",
|
||||
"drm_framework:drm_framework",
|
||||
"graphic_surface:surface",
|
||||
"graphic_surface:sync_fence",
|
||||
"hilog:libhilog",
|
||||
"window_manager:libwm",
|
||||
]
|
||||
|
||||
resource_config_file =
|
||||
"$av_codec_root_dir/test/unittest/resources/ohos_test.xml"
|
||||
}
|
||||
|
||||
#################################################################################################################hevcdec
|
||||
ohos_unittest("videodec_hevcdec_unit_test") {
|
||||
sanitize = av_codec_test_sanitize
|
||||
|
||||
@ -629,6 +629,30 @@ void VideoEncSample::PrepareInner()
|
||||
time_ = chrono::time_point_cast<chrono::milliseconds>(chrono::system_clock::now()).time_since_epoch().count();
|
||||
}
|
||||
|
||||
void VideoEncSample::InputLtrParam(std::shared_ptr<FormatMock> format, int32_t frameInputCount,
|
||||
std::shared_ptr<AVBufferMock> buffer)
|
||||
{
|
||||
if (!ltrParam.enableUseLtr) {
|
||||
return;
|
||||
}
|
||||
int32_t interval = ltrParam.ltrInterval;
|
||||
static int32_t useLtrIndex = 0;
|
||||
if (frameInputCount % interval == 0) {
|
||||
format->PutIntValue(Media::Tag::VIDEO_ENCODER_PER_FRAME_MARK_LTR, 1);
|
||||
}
|
||||
if (interval > 0 && (frameInputCount % interval == 0)) {
|
||||
useLtrIndex = frameInputCount;
|
||||
}
|
||||
if (frameInputCount > useLtrIndex) {
|
||||
format->PutIntValue(Media::Tag::VIDEO_ENCODER_PER_FRAME_USE_LTR, useLtrIndex);
|
||||
} else if (frameInputCount == useLtrIndex && frameInputCount > 0) {
|
||||
format->PutIntValue(Media::Tag::VIDEO_ENCODER_PER_FRAME_USE_LTR, frameInputCount - interval);
|
||||
}
|
||||
if (buffer) {
|
||||
buffer->SetParameter(format);
|
||||
}
|
||||
}
|
||||
|
||||
void VideoEncSample::InputParamLoopFunc()
|
||||
{
|
||||
ASSERT_NE(signal_, nullptr);
|
||||
@ -657,6 +681,9 @@ void VideoEncSample::InputParamLoopFunc()
|
||||
if (isDiscardFrame_ && (frameInputCount_ % 2) == 0) { // 2: encode half frames
|
||||
format->PutIntValue(Media::Tag::VIDEO_ENCODER_PER_FRAME_DISCARD, 1);
|
||||
}
|
||||
|
||||
InputLtrParam(format, frameInputCount_, nullptr);
|
||||
|
||||
UNITTEST_INFO_LOG("parameter: %s", format->DumpInfo());
|
||||
int32_t ret = PushInputParameter(index);
|
||||
UNITTEST_CHECK_AND_BREAK_LOG(ret == AV_ERR_OK, "Fatal: PushInputData fail, exit");
|
||||
@ -827,8 +854,8 @@ void VideoEncSample::OutputLoopFuncExt()
|
||||
|
||||
void VideoEncSample::CheckFormatKey(OH_AVCodecBufferAttr attr, std::shared_ptr<AVBufferMock> buffer)
|
||||
{
|
||||
std::shared_ptr<FormatMock> format = buffer->GetParameter();
|
||||
if (!(attr.flags & AVCODEC_BUFFER_FLAG_CODEC_DATA) && !(attr.flags & AVCODEC_BUFFER_FLAG_EOS)) {
|
||||
std::shared_ptr<FormatMock> format = buffer->GetParameter();
|
||||
int32_t qpAverage = 60;
|
||||
if (format->GetIntValue(Media::Tag::VIDEO_ENCODER_QP_AVERAGE, qpAverage)) {
|
||||
UNITTEST_INFO_LOG("qpAverage is:%d", qpAverage);
|
||||
@ -839,8 +866,18 @@ void VideoEncSample::CheckFormatKey(OH_AVCodecBufferAttr attr, std::shared_ptr<A
|
||||
UNITTEST_INFO_LOG("mse is:%lf", mse);
|
||||
}
|
||||
}
|
||||
format->Destroy();
|
||||
}
|
||||
if (ltrParam.enableUseLtr && (attr.flags == AVCODEC_BUFFER_FLAG_NONE)) {
|
||||
int32_t isLtr = 0;
|
||||
int32_t framePoc = 0;
|
||||
if (format->GetIntValue(Media::Tag::VIDEO_PER_FRAME_IS_LTR, isLtr)) {
|
||||
UNITTEST_INFO_LOG("isLtr is:%d", isLtr);
|
||||
}
|
||||
if (format->GetIntValue(Media::Tag::VIDEO_PER_FRAME_POC, framePoc)) {
|
||||
UNITTEST_INFO_LOG("framePoc is:%d", framePoc);
|
||||
}
|
||||
}
|
||||
format->Destroy();
|
||||
}
|
||||
|
||||
int32_t VideoEncSample::OutputLoopInnerExt()
|
||||
@ -936,6 +973,7 @@ int32_t VideoEncSample::InputLoopInnerExt()
|
||||
for (int32_t i = 0; i < attr.size; i += stride) {
|
||||
(void)inFile_->read(dst + i, DEFAULT_WIDTH_VENC);
|
||||
}
|
||||
InputLtrParam(format, frameInputCount_, buffer);
|
||||
}
|
||||
|
||||
if (attr.flags & AVCODEC_BUFFER_FLAG_EOS) {
|
||||
|
||||
@ -55,6 +55,11 @@ public:
|
||||
std::atomic<bool> isPreparing_ = true;
|
||||
};
|
||||
|
||||
struct LtrParam {
|
||||
bool enableUseLtr = false;
|
||||
int32_t ltrInterval;
|
||||
};
|
||||
|
||||
class VEncCallbackTest : public AVCodecCallbackMock {
|
||||
public:
|
||||
explicit VEncCallbackTest(std::shared_ptr<VEncSignal> signal);
|
||||
@ -166,6 +171,8 @@ private:
|
||||
int32_t OutputLoopInnerExt();
|
||||
int32_t InputLoopInnerExt();
|
||||
void CheckFormatKey(OH_AVCodecBufferAttr attr, std::shared_ptr<AVBufferMock> buffer);
|
||||
void InputLtrParam(std::shared_ptr<FormatMock> format, int32_t frameInputCount,
|
||||
std::shared_ptr<AVBufferMock> buffer);
|
||||
void CheckSHA();
|
||||
void PerformEosFrameAndVerifiedSHA();
|
||||
std::shared_ptr<VideoEncMock> videoEnc_ = nullptr;
|
||||
@ -187,6 +194,7 @@ private:
|
||||
sptr<Surface> consumer_ = nullptr;
|
||||
sptr<Surface> producer_ = nullptr;
|
||||
OHNativeWindow *nativeWindow_ = nullptr;
|
||||
LtrParam ltrParam;
|
||||
};
|
||||
} // namespace MediaAVCodec
|
||||
} // namespace OHOS
|
||||
|
||||
@ -1803,436 +1803,6 @@ HWTEST_P(TEST_SUIT, VideoEncoder_GetOutputDescription_001, TestSize.Level1)
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_001
|
||||
* @tc.desc: unable temporal scalability encode, buffer mode
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_001, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 0);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_002
|
||||
* @tc.desc: unable temporal scalability encode, but set temporal gop parameter, buffer mode
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_002, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, -1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE, 3);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_003
|
||||
* @tc.desc: enable temporal scalability encode, adjacent reference mode, buffer mode
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_003, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
videoEnc_->isAVBufferMode_ = true;
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 2);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 2);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::ADJACENT_REFERENCE));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_004
|
||||
* @tc.desc: enable temporal scalability encode, jump reference mode, buffer mode
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_004, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
videoEnc_->isAVBufferMode_ = true;
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 2);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::JUMP_REFERENCE));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_005
|
||||
* @tc.desc: set invalid temporal gop size 1
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_005, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::ADJACENT_REFERENCE));
|
||||
EXPECT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_006
|
||||
* @tc.desc: set invalid temporal gop size: gop size.(default gop size 60)
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_006, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 60);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE, 1);
|
||||
EXPECT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_007
|
||||
* @tc.desc: set invalid temporal reference mode: 3
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_007, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 4);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE, 3);
|
||||
EXPECT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_008
|
||||
* @tc.desc: set unsupport gop size: 2
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_008, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutDoubleValue(Media::Tag::VIDEO_FRAME_RATE, 2.0);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_I_FRAME_INTERVAL, 1000);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 4);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::ADJACENT_REFERENCE));
|
||||
EXPECT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_009
|
||||
* @tc.desc: set int framerate and enalbe temporal scalability encode, use default framerate 30.0
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_009, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
videoEnc_->isAVBufferMode_ = true;
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_FRAME_RATE, 25);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_I_FRAME_INTERVAL, 2000);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_010
|
||||
* @tc.desc: set invalid framerate 0.0 and enalbe temporal scalability encode, configure fail
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_010, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutDoubleValue(Media::Tag::VIDEO_FRAME_RATE, 0.0);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_I_FRAME_INTERVAL, 2000);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
EXPECT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_011
|
||||
* @tc.desc: gopsize 3 and enalbe temporal scalability encode
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_011, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutDoubleValue(Media::Tag::VIDEO_FRAME_RATE, 3.0);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_I_FRAME_INTERVAL, 1000);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_012
|
||||
* @tc.desc: set i frame interval 0 and enalbe temporal scalability encode, configure fail
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_012, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutDoubleValue(Media::Tag::VIDEO_FRAME_RATE, 60.0);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_I_FRAME_INTERVAL, 0);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
EXPECT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_013
|
||||
* @tc.desc: set i frame interval -1 and enalbe temporal scalability encode
|
||||
* expect level stream only one idr frame
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_013, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_I_FRAME_INTERVAL, -1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_014
|
||||
* @tc.desc: enable temporal scalability encode on surface mode without set parametercallback
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_014, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_015
|
||||
* @tc.desc: enable temporal scalability encode on surface mode with set parametercallback
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_015, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->SetCallback(vencParamCallback_));
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::JUMP_REFERENCE));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_016
|
||||
* @tc.desc: enable temporal scalability encode on buffer mode and request i frame at 13th frame
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_016, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
videoEnc_->isAVBufferMode_ = true;
|
||||
videoEnc_->isTemporalScalabilitySyncIdr_ = true;
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_017
|
||||
* @tc.desc: enable temporal scalability encode on surface mode and request i frame at 13th frame
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_017, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
videoEnc_->isTemporalScalabilitySyncIdr_ = true;
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->SetCallback(vencParamCallback_));
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::JUMP_REFERENCE));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_UNIFORMLY_01, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::UNIFORMLY_SCALED_REFERENCE));
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 3);
|
||||
ASSERT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_UNIFORMLY_02, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::UNIFORMLY_SCALED_REFERENCE));
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 8);
|
||||
ASSERT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_UNIFORMLY_03, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::UNIFORMLY_SCALED_REFERENCE));
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 2);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_UNIFORMLY_04, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam())) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::UNIFORMLY_SCALED_REFERENCE));
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 4);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_HRDVivid2SDR_001
|
||||
* @tc.desc: set key output_color_space, value is INT32_MIN
|
||||
|
||||
@ -0,0 +1,727 @@
|
||||
/*
|
||||
* Copyright (c) 2024 Huawei Device Co., Ltd.
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include "meta/meta_key.h"
|
||||
#include "unittest_utils.h"
|
||||
#include "codeclist_mock.h"
|
||||
#include "venc_sample.h"
|
||||
#include "native_avmagic.h"
|
||||
#ifdef VIDEOENC_CAPI_UNIT_TEST
|
||||
#include "native_avmagic.h"
|
||||
#include "videoenc_capi_mock.h"
|
||||
#define TEST_SUIT VideoEncTemporalScalabilityCapiTest
|
||||
#else
|
||||
#define TEST_SUIT VideoEncTemporalScalabilityInnerTest
|
||||
#endif
|
||||
|
||||
using namespace std;
|
||||
using namespace OHOS;
|
||||
using namespace OHOS::MediaAVCodec;
|
||||
using namespace testing::ext;
|
||||
using namespace OHOS::MediaAVCodec::VCodecTestParam;
|
||||
using namespace OHOS::Media;
|
||||
|
||||
namespace {
|
||||
constexpr int32_t DEFAULT_LTR_COUNT = 4;
|
||||
constexpr int32_t DEFAULT_INVALID_LTR_COUNT = 1000;
|
||||
constexpr int32_t DEFAULT_LTR_INTERVAL = 4;
|
||||
class TEST_SUIT : public testing::TestWithParam<int32_t> {
|
||||
public:
|
||||
static void SetUpTestCase(void);
|
||||
static void TearDownTestCase(void);
|
||||
void SetUp(void);
|
||||
void TearDown(void);
|
||||
|
||||
bool CreateVideoCodecByName(const std::string &decName);
|
||||
bool CreateVideoCodecByMime(const std::string &decMime);
|
||||
void CreateByNameWithParam(int32_t param);
|
||||
void SetFormatWithParam(int32_t param);
|
||||
void PrepareSource(int32_t param);
|
||||
bool GetTemporalScalabilityCapability(int32_t param, bool isTemporalScalability);
|
||||
|
||||
protected:
|
||||
std::shared_ptr<CodecListMock> capability_ = nullptr;
|
||||
std::shared_ptr<VideoEncSample> videoEnc_ = nullptr;
|
||||
std::shared_ptr<FormatMock> format_ = nullptr;
|
||||
std::shared_ptr<VEncCallbackTest> vencCallback_ = nullptr;
|
||||
std::shared_ptr<VEncCallbackTestExt> vencCallbackExt_ = nullptr;
|
||||
std::shared_ptr<VEncParamCallbackTest> vencParamCallback_ = nullptr;
|
||||
std::shared_ptr<VEncParamWithAttrCallbackTest> vencParamWithAttrCallback_ = nullptr;
|
||||
};
|
||||
|
||||
void TEST_SUIT::SetUpTestCase(void)
|
||||
{
|
||||
auto capability = CodecListMockFactory::GetCapabilityByCategory((CodecMimeType::VIDEO_AVC).data(), true,
|
||||
AVCodecCategory::AVCODEC_HARDWARE);
|
||||
ASSERT_NE(nullptr, capability) << (CodecMimeType::VIDEO_AVC).data() << " can not found!" << std::endl;
|
||||
}
|
||||
|
||||
void TEST_SUIT::TearDownTestCase(void) {}
|
||||
|
||||
void TEST_SUIT::SetUp(void)
|
||||
{
|
||||
std::shared_ptr<VEncSignal> vencSignal = std::make_shared<VEncSignal>();
|
||||
vencCallback_ = std::make_shared<VEncCallbackTest>(vencSignal);
|
||||
ASSERT_NE(nullptr, vencCallback_);
|
||||
|
||||
vencCallbackExt_ = std::make_shared<VEncCallbackTestExt>(vencSignal);
|
||||
ASSERT_NE(nullptr, vencCallbackExt_);
|
||||
|
||||
vencParamCallback_ = std::make_shared<VEncParamCallbackTest>(vencSignal);
|
||||
ASSERT_NE(nullptr, vencParamCallback_);
|
||||
|
||||
vencParamWithAttrCallback_ = std::make_shared<VEncParamWithAttrCallbackTest>(vencSignal);
|
||||
ASSERT_NE(nullptr, vencParamWithAttrCallback_);
|
||||
|
||||
videoEnc_ = std::make_shared<VideoEncSample>(vencSignal);
|
||||
ASSERT_NE(nullptr, videoEnc_);
|
||||
|
||||
format_ = FormatMockFactory::CreateFormat();
|
||||
ASSERT_NE(nullptr, format_);
|
||||
}
|
||||
|
||||
void TEST_SUIT::TearDown(void)
|
||||
{
|
||||
if (format_ != nullptr) {
|
||||
format_->Destroy();
|
||||
}
|
||||
videoEnc_ = nullptr;
|
||||
}
|
||||
|
||||
bool TEST_SUIT::CreateVideoCodecByMime(const std::string &encMime)
|
||||
{
|
||||
if (videoEnc_->CreateVideoEncMockByMime(encMime) == false || videoEnc_->SetCallback(vencCallback_) != AV_ERR_OK) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TEST_SUIT::CreateVideoCodecByName(const std::string &name)
|
||||
{
|
||||
if (videoEnc_->isAVBufferMode_) {
|
||||
if (videoEnc_->CreateVideoEncMockByName(name) == false ||
|
||||
videoEnc_->SetCallback(vencCallbackExt_) != AV_ERR_OK) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
if (videoEnc_->CreateVideoEncMockByName(name) == false || videoEnc_->SetCallback(vencCallback_) != AV_ERR_OK) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void TEST_SUIT::CreateByNameWithParam(int32_t param)
|
||||
{
|
||||
std::string codecName = "";
|
||||
switch (param) {
|
||||
case VCodecTestCode::HW_AVC:
|
||||
capability_ = CodecListMockFactory::GetCapabilityByCategory(CodecMimeType::VIDEO_AVC.data(), true,
|
||||
AVCodecCategory::AVCODEC_HARDWARE);
|
||||
break;
|
||||
case VCodecTestCode::HW_HEVC:
|
||||
capability_ = CodecListMockFactory::GetCapabilityByCategory(CodecMimeType::VIDEO_HEVC.data(), true,
|
||||
AVCodecCategory::AVCODEC_HARDWARE);
|
||||
break;
|
||||
default:
|
||||
capability_ = CodecListMockFactory::GetCapabilityByCategory(CodecMimeType::VIDEO_AVC.data(), true,
|
||||
AVCodecCategory::AVCODEC_SOFTWARE);
|
||||
break;
|
||||
}
|
||||
codecName = capability_->GetName();
|
||||
std::cout << "CodecName: " << codecName << "\n";
|
||||
ASSERT_TRUE(CreateVideoCodecByName(codecName));
|
||||
}
|
||||
|
||||
void TEST_SUIT::PrepareSource(int32_t param)
|
||||
{
|
||||
const ::testing::TestInfo *testInfo_ = ::testing::UnitTest::GetInstance()->current_test_info();
|
||||
string prefix = "/data/test/media/";
|
||||
string fileName = testInfo_->name();
|
||||
auto check = [](char it) { return it == '/'; };
|
||||
(void)fileName.erase(std::remove_if(fileName.begin(), fileName.end(), check), fileName.end());
|
||||
videoEnc_->SetOutPath(prefix + fileName);
|
||||
}
|
||||
|
||||
void TEST_SUIT::SetFormatWithParam(int32_t param)
|
||||
{
|
||||
(void)param;
|
||||
format_->PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH_VENC);
|
||||
format_->PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_HEIGHT_VENC);
|
||||
format_->PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
|
||||
}
|
||||
|
||||
bool TEST_SUIT::GetTemporalScalabilityCapability(int32_t param, bool isTemporalScalability)
|
||||
{
|
||||
std::string codecName = "";
|
||||
std::shared_ptr<AVCodecList> codecCapability = AVCodecListFactory::CreateAVCodecList();
|
||||
CapabilityData *capabilityData = nullptr;
|
||||
switch (param) {
|
||||
case VCodecTestCode::HW_AVC:
|
||||
capabilityData = codecCapability->GetCapability(CodecMimeType::VIDEO_AVC.data(), true,
|
||||
AVCodecCategory::AVCODEC_HARDWARE);
|
||||
break;
|
||||
case VCodecTestCode::HW_HEVC:
|
||||
capabilityData = codecCapability->GetCapability(CodecMimeType::VIDEO_HEVC.data(), true,
|
||||
AVCodecCategory::AVCODEC_HARDWARE);
|
||||
break;
|
||||
default:
|
||||
capabilityData = codecCapability->GetCapability(CodecMimeType::VIDEO_AVC.data(), true,
|
||||
AVCodecCategory::AVCODEC_SOFTWARE);
|
||||
break;
|
||||
}
|
||||
if (capabilityData == nullptr) {
|
||||
std::cout << "capabilityData is nullptr" << std::endl;
|
||||
return false;
|
||||
}
|
||||
if (isTemporalScalability && capabilityData->featuresMap.count(
|
||||
static_cast<int32_t>(AVCapabilityFeature::VIDEO_ENCODER_TEMPORAL_SCALABILITY))) {
|
||||
std::cout << "Support TemporalScalability" << std::endl;
|
||||
return true;
|
||||
} else if (!isTemporalScalability) {
|
||||
auto ltrCap =
|
||||
capabilityData->featuresMap.find(
|
||||
static_cast<int32_t>(AVCapabilityFeature::VIDEO_ENCODER_LONG_TERM_REFERENCE));
|
||||
if (ltrCap == capabilityData->featuresMap.end()) {
|
||||
return false;
|
||||
}
|
||||
int32_t maxLTRFrameCount = 0;
|
||||
bool maxLTRFrameCountExist =
|
||||
ltrCap->second.GetIntValue(Tag::FEATURE_PROPERTY_VIDEO_ENCODER_MAX_LTR_FRAME_COUNT, maxLTRFrameCount);
|
||||
if (!maxLTRFrameCountExist || maxLTRFrameCount < DEFAULT_LTR_COUNT) {
|
||||
return false;
|
||||
}
|
||||
std::cout << "Support LongTermReference" << std::endl;
|
||||
return true;
|
||||
} else {
|
||||
std::cout << "Not support TemporalScalability" << std::endl;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(, TEST_SUIT, testing::Values(HW_AVC, HW_HEVC));
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_001
|
||||
* @tc.desc: unable temporal scalability encode, buffer mode
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_001, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 0);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_002
|
||||
* @tc.desc: unable temporal scalability encode, but set temporal gop parameter, buffer mode
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_002, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, -1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE, 3);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_003
|
||||
* @tc.desc: enable temporal scalability encode, adjacent reference mode, buffer mode
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_003, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
videoEnc_->isAVBufferMode_ = true;
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 2);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 2);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::ADJACENT_REFERENCE));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_004
|
||||
* @tc.desc: enable temporal scalability encode, jump reference mode, buffer mode
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_004, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
videoEnc_->isAVBufferMode_ = true;
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 2);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::JUMP_REFERENCE));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_005
|
||||
* @tc.desc: set invalid temporal gop size 1
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_005, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::ADJACENT_REFERENCE));
|
||||
EXPECT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_006
|
||||
* @tc.desc: set invalid temporal gop size: gop size.(default gop size 60)
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_006, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 60);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE, 1);
|
||||
EXPECT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_007
|
||||
* @tc.desc: set invalid temporal reference mode: 3
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_007, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 4);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE, 3);
|
||||
EXPECT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_008
|
||||
* @tc.desc: set unsupport gop size: 2
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_008, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutDoubleValue(Media::Tag::VIDEO_FRAME_RATE, 2.0);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_I_FRAME_INTERVAL, 1000);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 4);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::ADJACENT_REFERENCE));
|
||||
EXPECT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_009
|
||||
* @tc.desc: set int framerate and enalbe temporal scalability encode, use default framerate 30.0
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_009, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
videoEnc_->isAVBufferMode_ = true;
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_FRAME_RATE, 25);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_I_FRAME_INTERVAL, 2000);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_010
|
||||
* @tc.desc: set invalid framerate 0.0 and enalbe temporal scalability encode, configure fail
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_010, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutDoubleValue(Media::Tag::VIDEO_FRAME_RATE, 0.0);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_I_FRAME_INTERVAL, 2000);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
EXPECT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_011
|
||||
* @tc.desc: gopsize 3 and enalbe temporal scalability encode
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_011, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutDoubleValue(Media::Tag::VIDEO_FRAME_RATE, 3.0);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_I_FRAME_INTERVAL, 1000);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_012
|
||||
* @tc.desc: set i frame interval 0 and enalbe temporal scalability encode, configure fail
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_012, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutDoubleValue(Media::Tag::VIDEO_FRAME_RATE, 60.0);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_I_FRAME_INTERVAL, 0);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
EXPECT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_013
|
||||
* @tc.desc: set i frame interval -1 and enalbe temporal scalability encode
|
||||
* expect level stream only one idr frame
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_013, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_I_FRAME_INTERVAL, -1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_014
|
||||
* @tc.desc: enable temporal scalability encode on surface mode without set parametercallback
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_014, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_015
|
||||
* @tc.desc: enable temporal scalability encode on surface mode with set parametercallback
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_015, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->SetCallback(vencParamCallback_));
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::JUMP_REFERENCE));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_016
|
||||
* @tc.desc: enable temporal scalability encode on buffer mode and request i frame at 13th frame
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_016, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
videoEnc_->isAVBufferMode_ = true;
|
||||
videoEnc_->isTemporalScalabilitySyncIdr_ = true;
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_TemporalScalability_017
|
||||
* @tc.desc: enable temporal scalability encode on surface mode and request i frame at 13th frame
|
||||
* expect level stream
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_017, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
videoEnc_->isTemporalScalabilitySyncIdr_ = true;
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->SetCallback(vencParamCallback_));
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::JUMP_REFERENCE));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_UNIFORMLY_01, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::UNIFORMLY_SCALED_REFERENCE));
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 3);
|
||||
ASSERT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_UNIFORMLY_02, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::UNIFORMLY_SCALED_REFERENCE));
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 8);
|
||||
ASSERT_NE(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
}
|
||||
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_UNIFORMLY_03, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::UNIFORMLY_SCALED_REFERENCE));
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 2);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_TemporalScalability_UNIFORMLY_04, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), true)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE,
|
||||
static_cast<int32_t>(OH_TemporalGopReferenceMode::UNIFORMLY_SCALED_REFERENCE));
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 4);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_Feature_Long_Term_Reference_001
|
||||
* @tc.desc: enable feature long term reference by buffer mode
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_Feature_Long_Term_Reference_001, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), false)) {
|
||||
return;
|
||||
};
|
||||
videoEnc_->isAVBufferMode_ = true;
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
videoEnc_->ltrParam.enableUseLtr = true;
|
||||
videoEnc_->ltrParam.ltrInterval = DEFAULT_LTR_INTERVAL;
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_LTR_FRAME_COUNT, DEFAULT_LTR_COUNT);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_Feature_Long_Term_Reference_002
|
||||
* @tc.desc: enable feature long term reference by surface mode
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_Feature_Long_Term_Reference_002, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), false)) {
|
||||
return;
|
||||
};
|
||||
videoEnc_->isAVBufferMode_ = true;
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->SetCallback(vencParamCallback_));
|
||||
videoEnc_->ltrParam.enableUseLtr = true;
|
||||
videoEnc_->ltrParam.ltrInterval = DEFAULT_LTR_INTERVAL;
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_LTR_FRAME_COUNT, DEFAULT_LTR_COUNT);
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->Configure(format_));
|
||||
ASSERT_EQ(AV_ERR_OK, videoEnc_->CreateInputSurface());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Start());
|
||||
EXPECT_EQ(AV_ERR_OK, videoEnc_->Stop());
|
||||
}
|
||||
|
||||
/**
|
||||
* @tc.name: VideoEncoder_Feature_Long_Term_Reference_003
|
||||
* @tc.desc: ltr frame count is invalid
|
||||
* @tc.type: FUNC
|
||||
*/
|
||||
HWTEST_P(TEST_SUIT, VideoEncoder_Feature_Long_Term_Reference_003, TestSize.Level1)
|
||||
{
|
||||
if (!GetTemporalScalabilityCapability(GetParam(), false)) {
|
||||
return;
|
||||
};
|
||||
CreateByNameWithParam(GetParam());
|
||||
SetFormatWithParam(GetParam());
|
||||
PrepareSource(GetParam());
|
||||
format_->PutIntValue(Media::Tag::VIDEO_ENCODER_LTR_FRAME_COUNT, DEFAULT_INVALID_LTR_COUNT);
|
||||
#ifdef VIDEOENC_CAPI_UNIT_TEST
|
||||
ASSERT_EQ(AV_ERR_INVALID_VAL, videoEnc_->Configure(format_));
|
||||
#else
|
||||
ASSERT_EQ(AVCS_ERR_INVALID_VAL, videoEnc_->Configure(format_));
|
||||
#endif
|
||||
}
|
||||
} // namespace
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
testing::GTEST_FLAG(output) = "xml:./";
|
||||
for (int i = 0; i < argc; ++i) {
|
||||
cout << argv[i] << endl;
|
||||
if (strcmp(argv[i], "--need_dump") == 0) {
|
||||
VideoEncSample::needDump_ = true;
|
||||
DecArgv(i, argc, argv);
|
||||
}
|
||||
}
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user