1 /* 2 * Copyright (C) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "gtest/gtest.h" 17 #include "codec/audio/encoder/audio_encoder.h" 18 #include <native_avcodec_audioencoder.h> 19 #include <avcodec_mime_type.h> 20 #include "ut_common_data.h" 21 22 using namespace testing; 23 using namespace testing::ext; 24 25 namespace OHOS { 26 namespace Media { 27 28 class AudioEncoderTest : public testing::Test { 29 protected: SetUp()30 void SetUp() override 31 { 32 audioEncoder_ = new AudioEncoder(1, encodeCallback_); 33 codec_ = OH_AudioEncoder_CreateByMime((MediaAVCodec::AVCodecMimeType::MEDIA_MIMETYPE_AUDIO_AAC).data()); 34 uint32_t buffersize = 1024 * 1024; 35 sampleMem_ = OH_AVMemory_Create(buffersize); 36 format_ = OH_AVFormat_Create(); 37 } 38 TearDown()39 void TearDown() override 40 { 41 if (audioEncoder_ != nullptr) { 42 delete audioEncoder_; 43 audioEncoder_ = nullptr; 44 } 45 if (codec_ != nullptr) { 46 OH_AudioEncoder_Destroy(codec_); 47 codec_ = nullptr; 48 } 49 if (sampleMem_ != nullptr) { 50 OH_AVMemory_Destroy(sampleMem_); 51 sampleMem_ = nullptr; 52 } 53 if (format_ != nullptr) { 54 OH_AVFormat_Destroy(format_); 55 format_ = nullptr; 56 } 57 } 58 59 private: 60 AudioEncoder* audioEncoder_ = nullptr; 61 CodecOnOutData encodeCallback_; 62 OH_AVCodec* codec_ = nullptr; 63 OH_AVMemory* sampleMem_ = nullptr; 64 OH_AVFormat* format_ = nullptr; 65 }; 66 67 // test AudioEncoder Start method 68 HWTEST_F(AudioEncoderTest, AudioEncoder_Start, TestSize.Level0) 69 { 70 EXPECT_EQ(audioEncoder_->Start(), VEFError::ERR_INTERNAL_ERROR); 71 } 72 73 // test AudioEncoder Stop method 74 HWTEST_F(AudioEncoderTest, AudioEncoder_Stop, TestSize.Level0) 75 { 76 EXPECT_EQ(audioEncoder_->Stop(), VEFError::ERR_INTERNAL_ERROR); 77 } 78 79 80 // test AudioEncoder Finish method 81 HWTEST_F(AudioEncoderTest, AudioEncoder_Finish, TestSize.Level0) 82 { 83 EXPECT_EQ(audioEncoder_->Flush(), VEFError::ERR_INTERNAL_ERROR); 84 } 85 86 // test AudioEncoder CreateDecoder method 87 HWTEST_F(AudioEncoderTest, AudioEncoder_CreateDecoder, TestSize.Level0) 88 { 89 EXPECT_EQ(audioEncoder_->CreateEncoder(), VEFError::ERR_INTERNAL_ERROR); 90 } 91 92 HWTEST_F(AudioEncoderTest, AudioEncoder_CodecOnErrorInner, TestSize.Level0) 93 { 94 audioEncoder_->CodecOnErrorInner(codec_, 0); 95 audioEncoder_->CodecOnErrorInner(nullptr, 0); 96 EXPECT_EQ(audioEncoder_->Start(), VEFError::ERR_INTERNAL_ERROR); 97 } 98 99 HWTEST_F(AudioEncoderTest, AudioEncoder_CodecOnStreamChangedInner, TestSize.Level0) 100 { 101 audioEncoder_->CodecOnStreamChangedInner(format_); 102 audioEncoder_->CodecOnStreamChangedInner(nullptr); 103 EXPECT_EQ(audioEncoder_->Start(), VEFError::ERR_INTERNAL_ERROR); 104 } 105 106 HWTEST_F(AudioEncoderTest, AudioEncoder_CodecOnNewOutputDataInner, TestSize.Level0) 107 { 108 OH_AVCodecBufferAttr attr; 109 attr.size = 1024 * 1024; 110 attr.pts = 100; 111 attr.flags = 1; 112 audioEncoder_->CodecOnNewOutputDataInner(nullptr, 1, nullptr, nullptr); 113 audioEncoder_->CodecOnNewOutputDataInner(codec_, 1, nullptr, nullptr); 114 audioEncoder_->CodecOnNewOutputDataInner(codec_, 1, sampleMem_, nullptr); 115 audioEncoder_->CodecOnNewOutputDataInner(nullptr, 1, sampleMem_, &attr); 116 audioEncoder_->CodecOnNewOutputDataInner(codec_, 1, nullptr, &attr); 117 EXPECT_EQ(audioEncoder_->Start(), VEFError::ERR_INTERNAL_ERROR); 118 } 119 120 HWTEST_F(AudioEncoderTest, AudioEncoder_CodecOnNeedInputDataInnerr, TestSize.Level0) 121 { 122 audioEncoder_->CodecOnNeedInputDataInner(nullptr, 1, nullptr); 123 audioEncoder_->CodecOnNeedInputDataInner(nullptr, 1, sampleMem_); 124 audioEncoder_->CodecOnNeedInputDataInner(codec_, 1, nullptr); 125 EXPECT_EQ(audioEncoder_->Start(), VEFError::ERR_INTERNAL_ERROR); 126 } 127 128 HWTEST_F(AudioEncoderTest, AudioEncoder_CodecOnNeedInputDataInnerr_1, TestSize.Level0) 129 { 130 std::string fileName = "H264_AAC_multi_track.mp4"; 131 int32_t srcFd = VideoResource::instance().getFileResource(fileName); 132 VideoDecodeCallbackTester* deCb = new VideoDecodeCallbackTester(); 133 auto decoderEngine = IVideoDecoderEngine::Create(srcFd, deCb); 134 ASSERT_NE(decoderEngine, nullptr); 135 VideoEncodeParam enCodeParam = VideoResource::instance().getEncodeParam(srcFd, decoderEngine); 136 VideoEncodeCallbackTester* enCb = new VideoEncodeCallbackTester(); 137 auto encoderEngine = IVideoEncoderEngine::Create(enCodeParam, enCb); 138 ASSERT_NE(encoderEngine, nullptr); 139 std::shared_ptr<PcmData> pcmData = std::make_shared<PcmData>(); 140 pcmData->flags = 12; 141 pcmData->pts = 100; 142 pcmData->dataSize = 0; 143 pcmData->data = nullptr; 144 audioEncoder_->pcmInputBufferQueue_->Enqueue(pcmData); 145 EXPECT_EQ(audioEncoder_->pcmInputBufferQueue_->queue_.size(), 1); 146 audioEncoder_->CodecOnNeedInputDataInner(codec_, 1, sampleMem_); 147 EXPECT_EQ(audioEncoder_->pcmInputBufferQueue_->queue_.size(), 0); 148 (void)close(srcFd); 149 } 150 151 HWTEST_F(AudioEncoderTest, AudioEncoder_CodecOnNeedInputDataInnerr_flag_one, TestSize.Level0) 152 { 153 std::string fileName = "H264_AAC_multi_track.mp4"; 154 int32_t srcFd = VideoResource::instance().getFileResource(fileName); 155 VideoDecodeCallbackTester* deCb = new VideoDecodeCallbackTester(); 156 auto decoderEngine = IVideoDecoderEngine::Create(srcFd, deCb); 157 ASSERT_NE(decoderEngine, nullptr); 158 VideoEncodeParam enCodeParam = VideoResource::instance().getEncodeParam(srcFd, decoderEngine); 159 VideoEncodeCallbackTester* enCb = new VideoEncodeCallbackTester(); 160 auto encoderEngine = IVideoEncoderEngine::Create(enCodeParam, enCb); 161 ASSERT_NE(encoderEngine, nullptr); 162 std::shared_ptr<PcmData> pcmData = std::make_shared<PcmData>(); 163 pcmData->flags = 1; 164 pcmData->pts = 100; 165 pcmData->dataSize = 0; 166 pcmData->data = nullptr; 167 audioEncoder_->pcmInputBufferQueue_->Enqueue(pcmData); 168 EXPECT_EQ(audioEncoder_->pcmInputBufferQueue_->queue_.size(), 1); 169 audioEncoder_->CodecOnNeedInputDataInner(codec_, 1, sampleMem_); 170 EXPECT_EQ(audioEncoder_->pcmInputBufferQueue_->queue_.size(), 0); 171 (void)close(srcFd); 172 } 173 174 HWTEST_F(AudioEncoderTest, AudioEncoder_CodecOnNeedInputDataInnerr_dataSize_9, TestSize.Level0) 175 { 176 std::string fileName = "H264_AAC_multi_track.mp4"; 177 int32_t srcFd = VideoResource::instance().getFileResource(fileName); 178 VideoDecodeCallbackTester* deCb = new VideoDecodeCallbackTester(); 179 auto decoderEngine = IVideoDecoderEngine::Create(srcFd, deCb); 180 ASSERT_NE(decoderEngine, nullptr); 181 VideoEncodeParam enCodeParam = VideoResource::instance().getEncodeParam(srcFd, decoderEngine); 182 VideoEncodeCallbackTester* enCb = new VideoEncodeCallbackTester(); 183 auto encoderEngine = IVideoEncoderEngine::Create(enCodeParam, enCb); 184 ASSERT_NE(encoderEngine, nullptr); 185 std::shared_ptr<PcmData> pcmData = std::make_shared<PcmData>(); 186 pcmData->flags = 12; 187 pcmData->pts = 100; 188 pcmData->dataSize = 9; 189 pcmData->data = nullptr; 190 audioEncoder_->pcmInputBufferQueue_->Enqueue(pcmData); 191 EXPECT_EQ(audioEncoder_->pcmInputBufferQueue_->queue_.size(), 1); 192 audioEncoder_->CodecOnNeedInputDataInner(codec_, 1, sampleMem_); 193 EXPECT_EQ(audioEncoder_->pcmInputBufferQueue_->queue_.size(), 0); 194 (void)close(srcFd); 195 } 196 197 HWTEST_F(AudioEncoderTest, AudioEncoder_PushPcmData, TestSize.Level0) 198 { 199 OH_AVCodecBufferAttr attr; 200 attr.size = 1024 * 1024; 201 attr.pts = 100; 202 attr.flags = 1; 203 EXPECT_EQ(audioEncoder_->PushPcmData(1, attr), VEFError::ERR_INTERNAL_ERROR); 204 } 205 } // namespace Media 206 } // namespace OHOS