diff --git a/multimedia/media/media_cpp_standard/BUILD.gn b/multimedia/media/media_cpp_standard/BUILD.gn
index 464df229a1a2db8d1099b2ccba48391657783723..703afd9249e2e85b7b2d971751e2aaba4509feba 100644
--- a/multimedia/media/media_cpp_standard/BUILD.gn
+++ b/multimedia/media/media_cpp_standard/BUILD.gn
@@ -14,12 +14,14 @@
 import("//test/xts/tools/build/suite.gni")
 
 module_output_path = "acts/ActsAvcodecNdkTest"
+MEDIA_ROOT_DIR = "//foundation/multimedia/player_framework/"
 
 ohos_moduletest_suite("ActsAvcodecNdkTest") {
   module_out_path = module_output_path
   sources = [
     "audioDecEncNdk/src/ADecEncNdkSample.cpp",
     "audioDecEncNdk/src/ActsAudioDecEncNdkTest.cpp",
+    "codecFormatNdk/ActsCodecFormatNdkTest.cpp",
     "videoDecEncNdk/src/ActsVideoDecEncNdkTest.cpp",
     "videoDecEncNdk/src/VDecEncNdkSample.cpp",
   ]
@@ -28,13 +30,17 @@ ohos_moduletest_suite("ActsAvcodecNdkTest") {
     "audioDecEncNdk/include",
     "videoDecEncNdk/include",
     "//foundation/multimedia/audio_framework/interfaces/inner_api/native/audiocommon/include",
-    "//foundation/multimedia/player_framework/interfaces/inner_api/native",
-    "//foundation/multimedia/player_framework/interfaces/kits/c",
-    "//foundation/multimedia/player_framework/frameworks/native/capi/common",
-    "//commonlibrary/c_utils/base/include",
+    "//foundation/graphic/graphic_2d/frameworks/surface/include",
+    "//foundation/graphic/graphic_2d/interfaces/inner_api/surface",
+    "//foundation/graphic/graphic_2d/interfaces/inner_api/common",
+    "//foundation//window/window_manager/interfaces/innerkits/wm",
     "//graphic/graphic_2d/interfaces/kits/surface",
     "//graphic/graphic_2d/interfaces/inner_api/surface",
-    "//foundation/graphic/graphic_2d/frameworks/surface/include",
+    "$MEDIA_ROOT_DIR/interfaces/inner_api/native",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c",
+    "$MEDIA_ROOT_DIR/frameworks/native/capi/common",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c",
+    "$MEDIA_ROOT_DIR/interfaces/inner_api/native",
   ]
 
   cflags = [
@@ -56,14 +62,17 @@ ohos_moduletest_suite("ActsAvcodecNdkTest") {
   ]
 
   deps = [
+    "$MEDIA_ROOT_DIR/interfaces/inner_api/native:media_client",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c:native_media_adec",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c:native_media_aenc",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c:native_media_codecbase",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c:native_media_core",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c:native_media_vdec",
+    "$MEDIA_ROOT_DIR/interfaces/kits/c:native_media_venc",
     "//foundation/graphic/graphic_2d:libsurface",
     "//foundation/graphic/graphic_2d/frameworks/surface:surface",
-    "//foundation/multimedia/player_framework/interfaces/kits/c:native_media_adec",
-    "//foundation/multimedia/player_framework/interfaces/kits/c:native_media_aenc",
-    "//foundation/multimedia/player_framework/interfaces/kits/c:native_media_codecbase",
-    "//foundation/multimedia/player_framework/interfaces/kits/c:native_media_core",
-    "//foundation/multimedia/player_framework/interfaces/kits/c:native_media_vdec",
-    "//foundation/multimedia/player_framework/interfaces/kits/c:native_media_venc",
+    "//foundation/graphic/graphic_2d/rosen/modules/render_service_client:librender_service_client",
+    "//foundation/window/window_manager/wm:libwm",
   ]
   external_deps = [
     "c_utils:utils",
diff --git a/multimedia/media/media_cpp_standard/audioDecEncNdk/include/ADecEncNdkSample.h b/multimedia/media/media_cpp_standard/audioDecEncNdk/include/ADecEncNdkSample.h
index ea8bc106c1b3657d19d0530f6e9471ac18d3218f..672ea072e13634f4656d71768aacd5e03cfa88e8 100644
--- a/multimedia/media/media_cpp_standard/audioDecEncNdk/include/ADecEncNdkSample.h
+++ b/multimedia/media/media_cpp_standard/audioDecEncNdk/include/ADecEncNdkSample.h
@@ -64,8 +64,10 @@ public:
     ADecEncNdkSample() = default;
     ~ADecEncNdkSample();
 
-    struct OH_AVCodec* CreateAudioDecoder(std::string mimetype);
+    struct OH_AVCodec* CreateAudioDecoderByMime(std::string mimetype);
+    struct OH_AVCodec* CreateAudioDecoderByName(std::string name);
     int32_t ConfigureDec(struct OH_AVFormat *format);
+    int32_t SetParameterDec(struct OH_AVFormat *format);
     int32_t PrepareDec();
     int32_t StartDec();
     int32_t StopDec();
@@ -73,8 +75,10 @@ public:
     int32_t ResetDec();
     int32_t ReleaseDec();
 
-    struct OH_AVCodec* CreateAudioEncoder(std::string mimetype);
+    struct OH_AVCodec* CreateAudioEncoderByMime(std::string mimetype);
+    struct OH_AVCodec* CreateAudioEncoderByName(std::string name);
     int32_t ConfigureEnc(struct OH_AVFormat *format);
+    int32_t SetParameterEnc(struct OH_AVFormat *format);
     int32_t PrepareEnc();
     int32_t StartEnc();
     int32_t StopEnc();
diff --git a/multimedia/media/media_cpp_standard/audioDecEncNdk/src/ADecEncNdkSample.cpp b/multimedia/media/media_cpp_standard/audioDecEncNdk/src/ADecEncNdkSample.cpp
index 9b542b4ac87b604ba8befc7d7c309c37d054b472..895c4683efe24babe0b07a4297d20bff50b52dc8 100644
--- a/multimedia/media/media_cpp_standard/audioDecEncNdk/src/ADecEncNdkSample.cpp
+++ b/multimedia/media/media_cpp_standard/audioDecEncNdk/src/ADecEncNdkSample.cpp
@@ -16,6 +16,8 @@
 #include "ADecEncNdkSample.h"
 #include "native_avmemory.h"
 #include "native_averrors.h"
+#include "native_avcodec_base.h"
+
 using namespace OHOS;
 using namespace OHOS::Media;
 using namespace std;
@@ -124,9 +126,13 @@ ADecEncNdkSample::~ADecEncNdkSample()
     acodecSignal_ = nullptr;
 }
 
-struct OH_AVCodec* ADecEncNdkSample::CreateAudioDecoder(std::string mimetype)
+struct OH_AVCodec* ADecEncNdkSample::CreateAudioDecoderByMime(std::string mimetype)
 {
-    adec_ = OH_AudioDecoder_CreateByMime(mimetype.c_str());
+    if (mimetype == "audio/mp4a-latm") {
+        adec_ = OH_AudioDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
+    } else {
+        adec_ = OH_AudioDecoder_CreateByMime(mimetype.c_str());
+    }
     NDK_CHECK_AND_RETURN_RET_LOG(adec_ != nullptr, nullptr, "Fatal: OH_AudioDecoder_CreateByMime");
 
     acodecSignal_ = new ADecEncSignal();
@@ -141,11 +147,33 @@ struct OH_AVCodec* ADecEncNdkSample::CreateAudioDecoder(std::string mimetype)
     return adec_;
 }
 
+struct OH_AVCodec* ADecEncNdkSample::CreateAudioDecoderByName(std::string name)
+{
+    adec_ = OH_AudioDecoder_CreateByName(name.c_str());
+    NDK_CHECK_AND_RETURN_RET_LOG(adec_ != nullptr, nullptr, "Fatal: OH_AudioDecoder_CreateByName");
+
+    acodecSignal_ = new ADecEncSignal();
+    NDK_CHECK_AND_RETURN_RET_LOG(acodecSignal_ != nullptr, nullptr, "Fatal: No Memory");
+
+    cbDec_.onError = AdecAsyncError;
+    cbDec_.onStreamChanged = AdecAsyncStreamChanged;
+    cbDec_.onNeedInputData = AdecAsyncNeedInputData;
+    cbDec_.onNeedOutputData = AdecAsyncNewOutputData;
+    int32_t ret = OH_AudioDecoder_SetCallback(adec_, cbDec_, static_cast<void *>(acodecSignal_));
+    NDK_CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, NULL, "Fatal: OH_AudioDecoder_SetCallback");
+    return adec_;
+}
+
 int32_t ADecEncNdkSample::ConfigureDec(struct OH_AVFormat *format)
 {
     return OH_AudioDecoder_Configure(adec_, format);
 }
 
+int32_t ADecEncNdkSample::SetParameterDec(struct OH_AVFormat *format)
+{
+    return OH_AudioDecoder_SetParameter(adec_, format);
+}
+
 int32_t ADecEncNdkSample::PrepareDec()
 {
     return OH_AudioDecoder_Prepare(adec_);
@@ -385,9 +413,13 @@ void ADecEncNdkSample::InputFuncDec()
     }
 }
 
-struct OH_AVCodec* ADecEncNdkSample::CreateAudioEncoder(std::string mimetype)
+struct OH_AVCodec* ADecEncNdkSample::CreateAudioEncoderByMime(std::string mimetype)
 {
-    aenc_ = OH_AudioEncoder_CreateByMime(mimetype.c_str());
+    if (mimetype == "audio/mp4a-latm") {
+        aenc_ = OH_AudioEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC);
+    } else {
+        aenc_ = OH_AudioEncoder_CreateByMime(mimetype.c_str());
+    }
     NDK_CHECK_AND_RETURN_RET_LOG(aenc_ != nullptr, nullptr, "Fatal: OH_AudioEncoder_CreateByMime");
     cbEnc_.onError = AencAsyncError;
     cbEnc_.onStreamChanged = AencAsyncStreamChanged;
@@ -398,11 +430,28 @@ struct OH_AVCodec* ADecEncNdkSample::CreateAudioEncoder(std::string mimetype)
     return aenc_;
 }
 
+struct OH_AVCodec* ADecEncNdkSample::CreateAudioEncoderByName(std::string name)
+{
+    aenc_ = OH_AudioEncoder_CreateByName(name.c_str());
+    NDK_CHECK_AND_RETURN_RET_LOG(aenc_ != nullptr, nullptr, "Fatal: OH_AudioEncoder_CreateByName");
+    cbEnc_.onError = AencAsyncError;
+    cbEnc_.onStreamChanged = AencAsyncStreamChanged;
+    cbEnc_.onNeedInputData = AencAsyncNeedInputData;
+    cbEnc_.onNeedOutputData = AencAsyncNewOutputData;
+    int32_t ret = OH_AudioEncoder_SetCallback(aenc_, cbEnc_, static_cast<void *>(acodecSignal_));
+    NDK_CHECK_AND_RETURN_RET_LOG(ret == AV_ERR_OK, NULL, "Fatal: OH_AudioEncoder_SetCallback");
+    return aenc_;
+}
+
 int32_t ADecEncNdkSample::ConfigureEnc(struct OH_AVFormat *format)
 {
     return OH_AudioEncoder_Configure(aenc_, format);
 }
 
+int32_t ADecEncNdkSample::SetParameterEnc(struct OH_AVFormat *format)
+{
+    return OH_AudioEncoder_SetParameter(aenc_, format);
+}
 
 int32_t ADecEncNdkSample::PrepareEnc()
 {
diff --git a/multimedia/media/media_cpp_standard/audioDecEncNdk/src/ActsAudioDecEncNdkTest.cpp b/multimedia/media/media_cpp_standard/audioDecEncNdk/src/ActsAudioDecEncNdkTest.cpp
index 5ff9818d6e4f3985e7610bad6da392decbb914fb..ac0479f4c69f0217616511c40a6e60260a3d6275 100644
--- a/multimedia/media/media_cpp_standard/audioDecEncNdk/src/ActsAudioDecEncNdkTest.cpp
+++ b/multimedia/media/media_cpp_standard/audioDecEncNdk/src/ActsAudioDecEncNdkTest.cpp
@@ -48,8 +48,11 @@ uint32_t ES_AAC_48000_32_1[] = {
     381, 375, 373, 349, 391, 357, 384, 395, 384, 380, 386, 372, 386, 383, 378, 385, 385, 
     384, 342, 390, 379, 387, 386, 393, 397, 362, 393, 394, 391, 383, 385, 377, 379, 381, 
     369, 375, 379, 346, 382, 356, 361, 366, 394, 393, 385, 362, 406, 399, 384, 377, 385};
+
 constexpr uint32_t ES_AAC_48000_32_1_Length = sizeof(ES_AAC_48000_32_1) / sizeof(uint32_t);
 const string MIME_TYPE_AAC = "audio/mp4a-latm";
+const string DECODER_AAC = "avdec_aac";
+const string ENCODER_AAC = "avenc_aac";
 constexpr uint32_t DEFAULT_SAMPLE_RATE = 44100;
 constexpr uint32_t DEFAULT_CHANNELS = 2;
 const char* READPATH = "/data/media/AAC_48000_32_1.aac";
@@ -107,8 +110,9 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_010
     OH_AVFormat *AudioFormat = OH_AVFormat_Create();
     ASSERT_NE(nullptr, AudioFormat);
     ASSERT_EQ(true, SetFormat(AudioFormat, AudioParam));
+    OH_AVFormat_SetStringValue(AudioFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_AUDIO_AAC);
 
-    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByName(DECODER_AAC);
     ASSERT_NE(nullptr, audDec);
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
     OH_AVFormat *OutDescDec = OH_AudioDecoder_GetOutputDescription(audDec);
@@ -116,7 +120,7 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_010
     ASSERT_EQ(true, CheckDecDesc(AudioParam, OutDescDec));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
 
-    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByName(ENCODER_AAC);
     ASSERT_NE(nullptr, audEnc);
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
     OH_AVFormat *OutDescEnc = OH_AudioEncoder_GetOutputDescription(audEnc);
@@ -127,7 +131,9 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_010
     aDecEncSample->SetReadPath(READPATH, ES_AAC_48000_32_1, ES_AAC_48000_32_1_Length);
     aDecEncSample->SetSavePath("/data/media/AAC_48000_32_1_out1.aac");
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
+    ASSERT_EQ(AV_ERR_OK, aDecEncSample->SetParameterEnc(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
+    ASSERT_EQ(AV_ERR_OK, aDecEncSample->SetParameterDec(AudioFormat));
 
     while (!aDecEncSample->GetEncEosState()) {};
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->StopDec());
@@ -150,17 +156,19 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_020
 {
     ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
 
-    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByMime(MIME_TYPE_AAC);
     ASSERT_NE(nullptr, audDec);
     OH_AVFormat *AudioFormat = OH_AVFormat_Create();
     ASSERT_NE(nullptr, AudioFormat);
     OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, DEFAULT_CHANNELS);
     OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
     OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, AudioStandard::SAMPLE_S16LE);
+    OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_TRACK_TYPE, MEDIA_TYPE_AUD);
+
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
 
-    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByMime(MIME_TYPE_AAC);
     ASSERT_NE(nullptr, audEnc);
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
@@ -190,17 +198,19 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_030
 {
     ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
 
-    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByMime(MIME_TYPE_AAC);
     ASSERT_NE(nullptr, audDec);
     OH_AVFormat *AudioFormat = OH_AVFormat_Create();
     ASSERT_NE(nullptr, AudioFormat);
     OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, DEFAULT_CHANNELS);
     OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUD_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
     OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, AudioStandard::SAMPLE_S16LE);
+    OH_AVFormat_SetIntValue(AudioFormat, OH_MD_KEY_PROFILE, AAC_PROFILE_LC);
+
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
 
-    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByMime(MIME_TYPE_AAC);
     ASSERT_NE(nullptr, audEnc);
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
@@ -228,7 +238,7 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_040
 {
     ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
 
-    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByMime(MIME_TYPE_AAC);
     ASSERT_NE(nullptr, audDec);
     OH_AVFormat *AudioFormat = OH_AVFormat_Create();
     ASSERT_NE(nullptr, AudioFormat);
@@ -238,7 +248,7 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_040
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
 
-    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByMime(MIME_TYPE_AAC);
     ASSERT_NE(nullptr, audEnc);
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
@@ -248,7 +258,7 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_040
 
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
-    while (aDecEncSample->GetFrameCount() < 50) {};
+    while (aDecEncSample->GetFrameCount() < 350) {};
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->FlushDec());
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->FlushEnc());
     aDecEncSample->ReRead();
@@ -278,7 +288,7 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_050
 {
     ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
 
-    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByMime(MIME_TYPE_AAC);
     ASSERT_NE(nullptr, audDec);
     OH_AVFormat *AudioFormat = OH_AVFormat_Create();
     ASSERT_NE(nullptr, AudioFormat);
@@ -288,7 +298,7 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_050
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
 
-    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByMime(MIME_TYPE_AAC);
     ASSERT_NE(nullptr, audEnc);
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
@@ -310,8 +320,6 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_050
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
     aDecEncSample->SetEosState(true);
-    sleep(2);
-    ASSERT_EQ(AV_ERR_OK, aDecEncSample->CalcuError());
 
     while (!aDecEncSample->GetEncEosState()) {};
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ReleaseDec());
@@ -333,7 +341,7 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_060
 {
     ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
 
-    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByMime(MIME_TYPE_AAC);
     ASSERT_NE(nullptr, audDec);
     OH_AVFormat *AudioFormat = OH_AVFormat_Create();
     ASSERT_NE(nullptr, AudioFormat);
@@ -343,7 +351,7 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_060
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
 
-    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByMime(MIME_TYPE_AAC);
     ASSERT_NE(nullptr, audEnc);
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
@@ -353,7 +361,7 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_060
 
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartEnc());
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->StartDec());
-    while (aDecEncSample->GetFrameCount() < 50) {};
+    while (aDecEncSample->GetFrameCount() < 350) {};
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->StopDec());
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->StopEnc());
     aDecEncSample->ReRead();
@@ -385,7 +393,7 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_070
 {
     ADecEncNdkSample *aDecEncSample = new ADecEncNdkSample();
 
-    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audDec = aDecEncSample->CreateAudioDecoderByMime(MIME_TYPE_AAC);
     ASSERT_NE(nullptr, audDec);
     OH_AVFormat *AudioFormat = OH_AVFormat_Create();
     ASSERT_NE(nullptr, AudioFormat);
@@ -395,7 +403,7 @@ HWTEST_F(ActsAudioDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_AUDIO_DEC_ENC_FUNCTION_070
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureDec(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareDec());
 
-    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoder(MIME_TYPE_AAC);
+    struct OH_AVCodec* audEnc = aDecEncSample->CreateAudioEncoderByMime(MIME_TYPE_AAC);
     ASSERT_NE(nullptr, audEnc);
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->ConfigureEnc(AudioFormat));
     ASSERT_EQ(AV_ERR_OK, aDecEncSample->PrepareEnc());
diff --git a/multimedia/media/media_cpp_standard/codecFormatNdk/ActsCodecFormatNdkTest.cpp b/multimedia/media/media_cpp_standard/codecFormatNdk/ActsCodecFormatNdkTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f900b00c378c093af69b0289f362bba4d22b7123
--- /dev/null
+++ b/multimedia/media/media_cpp_standard/codecFormatNdk/ActsCodecFormatNdkTest.cpp
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2022 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 <string>
+#include "securec.h"
+#include "gtest/gtest.h"
+#include "audio_info.h"
+#include "native_avcodec_base.h"
+#include "native_avformat.h"
+
+using namespace std;
+using namespace testing::ext;
+
+namespace {
+class ActsCodecFormatNdkTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+    static void TearDownTestCase();
+    void SetUp() override;
+    void TearDown() override;
+};
+
+void ActsCodecFormatNdkTest::SetUpTestCase() {}
+void ActsCodecFormatNdkTest::TearDownTestCase() {}
+void ActsCodecFormatNdkTest::SetUp() {}
+void ActsCodecFormatNdkTest::TearDown() {}
+
+const int32_t intValue = 1;
+const int64_t longValue = 1;
+const float floatValue = 1.0;
+const double doubleValue = 1.0;
+const char *stringValue = "string_value";
+const char *intKey = "int value key";
+const char *longKey = "long value key";
+const char *floatKey = "float value key";
+const char *doubleKey = "double value key";
+const char *stringKey = "string value key";
+const char *bufferKey = "buffer value key";
+
+bool CheckDecDesc(map<string, int> InDesc, OH_AVFormat* OutDesc)
+{
+    int32_t out ;
+    for (const auto& t: InDesc) {
+        bool res = OH_AVFormat_GetIntValue(OutDesc, t.first.c_str(), &out);
+        cout << "key: " << t.first << "; out: " << out <<endl;
+        if (!res) {
+            cout << "OH_AVFormat_GetIntValue Fail. key:" << t.first << endl;
+            return false;
+        }
+        if (out != t.second) {
+            cout << "OH_AVFormat_GetIntValue error. key: " << t.first
+            << "; expect: "<< t.second
+            << ", actual: "<< out << endl;
+            return false;
+        }
+        out = 0;
+    }
+    return true;
+}
+
+bool SetFormat(struct OH_AVFormat *format, map<string, int> mediaDescription)
+{
+    const char *key;
+    for (const auto& t: mediaDescription) {
+        key = t.first.c_str();
+        if (not OH_AVFormat_SetIntValue(format, key, t.second)) {
+            cout << "OH_AV_FormatPutIntValue Fail. format key: " << t.first
+            << ", value: "<< t.second << endl;
+            return false;
+        }
+    }
+    return true;
+}
+}
+
+/**
+ * @tc.number    : SUB_MULTIMEDIA_MEDIA_CODEC_FORMAT_0100
+ * @tc.name      : test codec format set key
+ * @tc.desc      : Basic function test
+ */
+HWTEST_F(ActsCodecFormatNdkTest, SUB_MULTIMEDIA_MEDIA_CODEC_FORMAT_0100, TestSize.Level1)
+{
+    OH_AVFormat *codecFormatIn = OH_AVFormat_Create();
+    ASSERT_NE(nullptr, codecFormatIn);
+    OH_AVFormat *codecFormatOut = OH_AVFormat_Create();
+    ASSERT_NE(nullptr, codecFormatOut);
+    map<string, int> CodecParam = {
+        {OH_ED_KEY_TIME_STAMP, 200}, // set timestamp 200ms
+        {OH_ED_KEY_EOS, 1}, // set end of stream
+        {OH_MD_KEY_TRACK_TYPE, 1}, // set track type video
+        {OH_MD_KEY_DURATION, 200}, // set key duration 200ms
+        {OH_MD_KEY_BITRATE, 48000}, // set key bitrate 48000
+        {OH_MD_KEY_MAX_INPUT_SIZE, 2000}, // set key max input size 2000
+        {OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, 0}, // set videoencoder bitrate mode CBR
+        {OH_MD_KEY_PROFILE, 1}, // set encode profile AVC_PROFILE_BASELINE
+        {OH_MD_KEY_I_FRAME_INTERVAL, 1}, // set key i frame 1ms
+        {OH_MD_KEY_ROTATION, 90}, // set key rotation 0 degree
+    };
+    ASSERT_EQ(true, SetFormat(codecFormatIn, CodecParam));
+    OH_AVFormat_Copy(codecFormatOut, codecFormatIn);
+    ASSERT_EQ(true, CheckDecDesc(CodecParam, codecFormatOut));
+    ASSERT_NE(nullptr, OH_AVFormat_DumpInfo(codecFormatOut));
+    cout << OH_AVFormat_DumpInfo(codecFormatIn) << endl;
+    OH_AVFormat_Destroy(codecFormatIn);
+    codecFormatIn = nullptr;
+    OH_AVFormat_Destroy(codecFormatOut);
+    codecFormatIn = nullptr;
+}
+
+/**
+ * @tc.number    : SUB_MULTIMEDIA_MEDIA_CODEC_FORMAT_0200
+ * @tc.name      : test codec format set and get value
+ * @tc.desc      : Basic function test
+ */
+HWTEST_F(ActsCodecFormatNdkTest, SUB_MULTIMEDIA_MEDIA_CODEC_FORMAT_0200, TestSize.Level1)
+{
+    OH_AVFormat *codecFormatIn = OH_AVFormat_Create();
+    ASSERT_NE(nullptr, codecFormatIn);
+    OH_AVFormat *codecFormatOut = OH_AVFormat_Create();
+    ASSERT_NE(nullptr, codecFormatOut);
+    OH_AVFormat_SetIntValue(codecFormatIn, intKey, intValue);
+    OH_AVFormat_SetLongValue(codecFormatIn, longKey, longValue);
+    OH_AVFormat_SetFloatValue(codecFormatIn, floatKey, floatValue);
+    OH_AVFormat_SetDoubleValue(codecFormatIn, doubleKey, doubleValue);
+    OH_AVFormat_SetStringValue(codecFormatIn, stringKey, stringValue);
+
+    OH_AVFormat_Copy(codecFormatOut, codecFormatIn);
+    int32_t intValueOut;
+    OH_AVFormat_GetIntValue(codecFormatOut, intKey, &intValueOut);
+    ASSERT_EQ(intValueOut, intValue);
+    int64_t longValueOut;
+    OH_AVFormat_GetLongValue(codecFormatOut, longKey, &longValueOut);
+    ASSERT_EQ(longValueOut, longValue);
+    float floatValueOut;
+    OH_AVFormat_GetFloatValue(codecFormatOut, floatKey, &floatValueOut);
+    ASSERT_EQ(floatValueOut, floatValue);
+    double doubleValueOut;
+    OH_AVFormat_GetDoubleValue(codecFormatOut, doubleKey, &doubleValueOut);
+    ASSERT_EQ(doubleValueOut, doubleValue);
+    const char *stringValueOut;
+    OH_AVFormat_GetStringValue(codecFormatOut, stringKey, &stringValueOut);
+    ASSERT_EQ(*stringValueOut, *stringValue);
+
+    OH_AVFormat_Destroy(codecFormatIn);
+    codecFormatIn = nullptr;
+    OH_AVFormat_Destroy(codecFormatOut);
+    codecFormatOut = nullptr;
+}
+
+/**
+ * @tc.number    : SUB_MULTIMEDIA_MEDIA_CODEC_FORMAT_0300
+ * @tc.name      : test codec format set and get buffer
+ * @tc.desc      : Basic function test
+ */
+HWTEST_F(ActsCodecFormatNdkTest, SUB_MULTIMEDIA_MEDIA_CODEC_FORMAT_0300, TestSize.Level1)
+{
+    OH_AVFormat *codecFormatIn = OH_AVFormat_Create();
+    ASSERT_NE(nullptr, codecFormatIn);
+    OH_AVFormat *codecFormatOut = OH_AVFormat_Create();
+    ASSERT_NE(nullptr, codecFormatOut);
+    int32_t buffernum = 10;
+    size_t sizeIn = buffernum * sizeof(uint8_t);
+    uint8_t *buffer = reinterpret_cast<uint8_t *>(malloc(sizeIn));
+    (void)memset_s(buffer, sizeIn, 1, sizeIn);
+    OH_AVFormat_SetBuffer(codecFormatIn, bufferKey, buffer, sizeIn);
+
+    OH_AVFormat_Copy(codecFormatOut, codecFormatIn);
+    uint8_t *addrout;
+    size_t sizeOut;
+    OH_AVFormat_GetBuffer(codecFormatOut, bufferKey, &addrout, &sizeOut);
+    ASSERT_EQ(sizeIn, sizeOut);
+    for (int32_t i = 0; i < buffernum; i++) {
+        ASSERT_EQ(buffer[i], addrout[i]);
+    }
+    OH_AVFormat_Destroy(codecFormatIn);
+    codecFormatIn = nullptr;
+    OH_AVFormat_Destroy(codecFormatOut);
+    codecFormatOut = nullptr;
+}
\ No newline at end of file
diff --git a/multimedia/media/media_cpp_standard/videoDecEncNdk/include/VDecEncNdkSample.h b/multimedia/media/media_cpp_standard/videoDecEncNdk/include/VDecEncNdkSample.h
index 83accef2f5d46d4929ed1813b1d09e78c6eed3b1..ef641f94a2ea42a22675b79f4c4fed80f6226150 100644
--- a/multimedia/media/media_cpp_standard/videoDecEncNdk/include/VDecEncNdkSample.h
+++ b/multimedia/media/media_cpp_standard/videoDecEncNdk/include/VDecEncNdkSample.h
@@ -30,6 +30,7 @@
 #include "ndktest_log.h"
 #include "native_avmagic.h"
 #include "surface.h"
+#include "native_avcodec_base.h"
 #include "native_avcodec_videodecoder.h"
 #include "native_avcodec_videoencoder.h"
 
@@ -69,6 +70,7 @@ public:
     struct OH_AVCodec* CreateVideoDecoderByMime(std::string mimetype);
     struct OH_AVCodec* CreateVideoDecoderByName(std::string name);
     int32_t ConfigureDec(struct OH_AVFormat *format);
+    int32_t SetParameterDec(struct OH_AVFormat *format);
     int32_t SetOutputSurface();
     int32_t PrepareDec();
     int32_t StartDec();
@@ -80,6 +82,7 @@ public:
     struct OH_AVCodec* CreateVideoEncoderByMime(std::string mimetype);
     struct OH_AVCodec* CreateVideoEncoderByName(std::string name);
     int32_t ConfigureEnc(struct OH_AVFormat *format);
+    int32_t SetParameterEnc(struct OH_AVFormat *format);
     int32_t GetSurface();
     int32_t PrepareEnc();
     int32_t StartEnc();
@@ -108,6 +111,7 @@ public:
     bool isDecOutputEOS = false;
     bool isEncOutputEOS = false;
     bool setEos = true;
+    bool needRender = true;
 
 private:
     OHNativeWindow *nativeWindow_;
diff --git a/multimedia/media/media_cpp_standard/videoDecEncNdk/src/ActsVideoDecEncNdkTest.cpp b/multimedia/media/media_cpp_standard/videoDecEncNdk/src/ActsVideoDecEncNdkTest.cpp
index 4c3d29349dbabd2c6392ff39c6d344fba360a427..27c3db1cc1abd866b8228b1cc07dc94682bb1750 100644
--- a/multimedia/media/media_cpp_standard/videoDecEncNdk/src/ActsVideoDecEncNdkTest.cpp
+++ b/multimedia/media/media_cpp_standard/videoDecEncNdk/src/ActsVideoDecEncNdkTest.cpp
@@ -89,6 +89,7 @@ struct OH_AVFormat* createFormat()
     OH_AVFormat_SetIntValue(DefaultFormat, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
     OH_AVFormat_SetIntValue(DefaultFormat, OH_MD_KEY_PIXEL_FORMAT, DEFAULT_PIXELFORMAT);
     OH_AVFormat_SetIntValue(DefaultFormat, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAMERATE);
+    OH_AVFormat_SetStringValue(DefaultFormat, OH_MD_KEY_CODEC_MIME, OH_AVCODEC_MIMETYPE_VIDEO_AVC);
     return DefaultFormat;
 }
 }
@@ -101,13 +102,13 @@ struct OH_AVFormat* createFormat()
 HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0100, TestSize.Level1)
 {
     VDecEncNdkSample *vDecEncSample = new VDecEncNdkSample();
-
     struct OH_AVCodec* videoDec = vDecEncSample->CreateVideoDecoderByMime(MIME_TYPE_AVC);
     ASSERT_NE(nullptr, videoDec);
+
     struct OH_AVCodec* videoEnc = vDecEncSample->CreateVideoEncoderByMime(MIME_TYPE_MPEG4);
     ASSERT_NE(nullptr, videoEnc);
     vDecEncSample->SetReadPath(READPATH);
-    vDecEncSample->SetSavePath("/data/media/video_001.es");
+    vDecEncSample->SetSavePath("/data/media/video_001.h264");
     
     OH_AVFormat *VideoFormat = OH_AVFormat_Create();
     ASSERT_NE(nullptr, VideoFormat);
@@ -118,6 +119,8 @@ HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_010
         {OH_MD_KEY_FRAME_RATE, DEFAULT_FRAMERATE},
     };
     ASSERT_EQ(true, SetFormat(VideoFormat, VideoParam));
+    OH_AVFormat_SetIntValue(VideoFormat, OH_MD_KEY_TRACK_TYPE, MEDIA_TYPE_VID);
+
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
     OH_AVFormat *OutDescDec = OH_VideoDecoder_GetOutputDescription(videoDec);
     ASSERT_NE(nullptr, OutDescDec);
@@ -161,17 +164,20 @@ HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_020
     struct OH_AVCodec* videoEnc = vDecEncSample->CreateVideoEncoderByMime(MIME_TYPE_AVC);
     ASSERT_NE(nullptr, videoEnc);
     vDecEncSample->SetReadPath(READPATH);
-    vDecEncSample->SetSavePath("/data/media/video_002.es");
+    vDecEncSample->SetSavePath("/data/media/video_002.h264");
     
     OH_AVFormat *VideoFormat = createFormat();
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
+    OH_AVFormat_SetIntValue(VideoFormat, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CBR);
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureEnc(VideoFormat));
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->GetSurface());
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->SetOutputSurface());
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareEnc());
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->PrepareDec());
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
+    ASSERT_EQ(AV_ERR_OK, vDecEncSample->SetParameterDec(VideoFormat));
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
+    ASSERT_EQ(AV_ERR_OK, vDecEncSample->SetParameterEnc(VideoFormat));
 
     while (!vDecEncSample->GetEncEosState()) {};
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->ResetDec());
@@ -185,7 +191,6 @@ HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_020
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->CalcuError());
 }
 
-
  /**
  * @tc.number    : SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_0300
  * @tc.name      : release at end of stream
@@ -200,9 +205,11 @@ HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_030
     struct OH_AVCodec* videoEnc = vDecEncSample->CreateVideoEncoderByMime(MIME_TYPE_AVC);
     ASSERT_NE(nullptr, videoEnc);
     vDecEncSample->SetReadPath(READPATH);
-    vDecEncSample->SetSavePath("/data/media/video_003.es");
+    vDecEncSample->SetSavePath("/data/media/video_003.h264");
     
     OH_AVFormat *VideoFormat = createFormat();
+    OH_AVFormat_SetIntValue(VideoFormat, OH_MD_KEY_PROFILE, AVC_PROFILE_BASELINE);
+
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureEnc(VideoFormat));
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->GetSurface());
@@ -237,9 +244,11 @@ HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_040
     ASSERT_NE(nullptr, videoEnc);
     vDecEncSample->SetReadPath(READPATH);
     vDecEncSample->SetEosState(false);
-    vDecEncSample->SetSavePath("/data/media/video_004.es");
+    vDecEncSample->SetSavePath("/data/media/video_004.h264");
     
     OH_AVFormat *VideoFormat = createFormat();
+    OH_AVFormat_SetIntValue(VideoFormat, OH_MD_KEY_PROFILE, AVC_PROFILE_HIGH);
+
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureEnc(VideoFormat));
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->GetSurface());
@@ -256,7 +265,7 @@ HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_040
     vDecEncSample->ResetDecParam();
     vDecEncSample->ResetEncParam();
     vDecEncSample->SetEosState(true);
-    vDecEncSample->SetSavePath("/data/media/video_004_2.es");
+    vDecEncSample->SetSavePath("/data/media/video_004_2.h264");
 
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
@@ -287,9 +296,11 @@ HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_050
     ASSERT_NE(nullptr, videoEnc);
     vDecEncSample->SetReadPath(READPATH);
     vDecEncSample->SetEosState(false);
-    vDecEncSample->SetSavePath("/data/media/video_005.es");
+    vDecEncSample->SetSavePath("/data/media/video_005.h264");
     
     OH_AVFormat *VideoFormat = createFormat();
+    OH_AVFormat_SetIntValue(VideoFormat, OH_MD_KEY_PROFILE, AVC_PROFILE_MAIN);
+
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureEnc(VideoFormat));
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->GetSurface());
@@ -306,7 +317,7 @@ HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_050
     vDecEncSample->ReRead();
     vDecEncSample->ResetDecParam();
     vDecEncSample->ResetEncParam();
-    vDecEncSample->SetSavePath("/data/media/video_005_2.es");
+    vDecEncSample->SetSavePath("/data/media/video_005_2.h264");
     vDecEncSample->SetEosState(true);
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->CalcuError());
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
@@ -338,7 +349,7 @@ HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_060
     ASSERT_NE(nullptr, videoEnc);
     vDecEncSample->SetReadPath(READPATH);
     vDecEncSample->SetEosState(false);
-    vDecEncSample->SetSavePath("/data/media/video_006.es");
+    vDecEncSample->SetSavePath("/data/media/video_006.h264");
     
     OH_AVFormat *VideoFormat = createFormat();
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
@@ -357,7 +368,7 @@ HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_060
     vDecEncSample->ResetDecParam();
     vDecEncSample->ResetEncParam();
     vDecEncSample->SetEosState(true);
-    vDecEncSample->SetSavePath("/data/media/video_006_2.es");
+    vDecEncSample->SetSavePath("/data/media/video_006_2.h264");
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
 
@@ -389,7 +400,7 @@ HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_070
     ASSERT_NE(nullptr, videoEnc);
     vDecEncSample->SetReadPath(READPATH);
     vDecEncSample->SetEosState(false);
-    vDecEncSample->SetSavePath("/data/media/video_007.es");
+    vDecEncSample->SetSavePath("/data/media/video_007.h264");
     
     OH_AVFormat *VideoFormat = createFormat();
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->ConfigureDec(VideoFormat));
@@ -408,7 +419,7 @@ HWTEST_F(ActsVideoDecEncNdkTest, SUB_MULTIMEDIA_MEDIA_VIDEO_DEC_ENC_FUNCTION_070
     vDecEncSample->ReRead();
     vDecEncSample->ResetDecParam();
     vDecEncSample->ResetEncParam();
-    vDecEncSample->SetSavePath("/data/media/video_007_2.es");
+    vDecEncSample->SetSavePath("/data/media/video_007_2.h264");
     vDecEncSample->SetEosState(true);
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartEnc());
     ASSERT_EQ(AV_ERR_OK, vDecEncSample->StartDec());
diff --git a/multimedia/media/media_cpp_standard/videoDecEncNdk/src/VDecEncNdkSample.cpp b/multimedia/media/media_cpp_standard/videoDecEncNdk/src/VDecEncNdkSample.cpp
index 432a636faf9700e38a92b6853130bc86a28f019a..e66e203a04ba8f0aeb2741fab58d5eb220fded12 100644
--- a/multimedia/media/media_cpp_standard/videoDecEncNdk/src/VDecEncNdkSample.cpp
+++ b/multimedia/media/media_cpp_standard/videoDecEncNdk/src/VDecEncNdkSample.cpp
@@ -16,6 +16,7 @@
 #include "gtest/gtest.h"
 #include "audio_info.h"
 #include "av_common.h"
+#include "native_avcodec_base.h"
 #include "avcodec_video_encoder.h"
 #include "avcodec_video_decoder.h"
 #include "native_avmemory.h"
@@ -196,7 +197,12 @@ void VDecEncNdkSample::ResetEncParam()
 
 struct OH_AVCodec* VDecEncNdkSample::CreateVideoDecoderByMime(std::string mimetype)
 {
-    vdec_ = OH_VideoDecoder_CreateByMime(mimetype.c_str());
+    if (mimetype == "video/avc") {
+        cout << "mimetype == 'video/avc'" << endl;
+        vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
+    } else {
+        vdec_ = OH_VideoDecoder_CreateByMime(mimetype.c_str());
+    }
     NDK_CHECK_AND_RETURN_RET_LOG(vdec_ != nullptr, nullptr, "Fatal: OH_VideoDecoder_CreateByMime");
     if (vcodecSignal_ == nullptr) {
         vcodecSignal_ = new VDecEncSignal();
@@ -233,6 +239,11 @@ int32_t VDecEncNdkSample::ConfigureDec(struct OH_AVFormat *format)
     return OH_VideoDecoder_Configure(vdec_, format);
 }
 
+int32_t VDecEncNdkSample::SetParameterDec(struct OH_AVFormat *format)
+{
+    return OH_VideoDecoder_SetParameter(vdec_, format);
+}
+
 int32_t VDecEncNdkSample::PrepareDec()
 {
     return OH_VideoDecoder_Prepare(vdec_);
@@ -485,7 +496,12 @@ void VDecEncNdkSample::OutputFuncDec()
         uint32_t index = vcodecSignal_->outQueueDec_.front();
         uint32_t outflag = vcodecSignal_->flagQueueDec_.front();
         if (outflag == 0) {
-            uint32_t ret = OH_VideoDecoder_RenderOutputData(vdec_, index);
+            uint32_t ret;
+            if (needRender) {
+                ret = OH_VideoDecoder_RenderOutputData(vdec_, index);
+            } else {
+                ret = OH_VideoDecoder_FreeOutputData(vdec_, index);
+            }
             if (ret == 0) {
                 decOutCnt_ += 1;
                 cout << "DEC OUT.: render output success, decOutCnt_ is " << decOutCnt_ << endl;
@@ -505,7 +521,11 @@ void VDecEncNdkSample::OutputFuncDec()
 
 struct OH_AVCodec* VDecEncNdkSample::CreateVideoEncoderByMime(std::string mimetype)
 {
-    venc_ = OH_VideoEncoder_CreateByMime(mimetype.c_str());
+    if (mimetype == "video/avc") {
+        venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
+    } else {
+        venc_ = OH_VideoEncoder_CreateByMime(mimetype.c_str());
+    }
     NDK_CHECK_AND_RETURN_RET_LOG(venc_ != nullptr, nullptr, "Fatal: OH_VideoEncoder_CreateByMime");
     
     if (vcodecSignal_ == nullptr) {
@@ -542,6 +562,11 @@ int32_t VDecEncNdkSample::ConfigureEnc(struct OH_AVFormat *format)
     return OH_VideoEncoder_Configure(venc_, format);
 }
 
+int32_t VDecEncNdkSample::SetParameterEnc(struct OH_AVFormat *format)
+{
+    return OH_VideoEncoder_SetParameter(venc_, format);
+}
+
 struct VEncObject : public OH_AVCodec {
     explicit VEncObject(const std::shared_ptr<AVCodecVideoEncoder> &encoder)
         : OH_AVCodec(AVMagic::MEDIA_MAGIC_VIDEO_ENCODER), videoEncoder_(encoder) {}