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 #include <string>
16 #include <sys/stat.h>
17 #include <fcntl.h>
18 #include <cinttypes>
19 #include "gtest/gtest.h"
20 #include "avcodec_errors.h"
21 #include "avcodec_info.h"
22 #include "media_description.h"
23 #include "audio_encoder_filter_unitest.h"
24 #include "common/log.h"
25 #include "parameters.h"
26 #include "filter/filter.h"
27
28 using namespace OHOS;
29 using namespace OHOS::Media;
30 using namespace std;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Media {
35 namespace Pipeline {
36
37 class EventReceiverTest : public EventReceiver {
38 public:
39 EventReceiverTest() = default;
40 ~EventReceiverTest() = default;
OnEvent(const Event & event)41 void OnEvent(const Event &event) override
42 {
43 (void)event;
44 }
45 };
46
47 class FilterCallbackTest : public FilterCallback {
48 public:
49 FilterCallbackTest() = default;
50 ~FilterCallbackTest() = default;
OnCallback(const std::shared_ptr<Filter> & filter,FilterCallBackCommand cmd,StreamType outType)51 Status OnCallback(const std::shared_ptr<Filter>& filter, FilterCallBackCommand cmd, StreamType outType) override
52 {
53 (void)filter;
54 (void)cmd;
55 (void)outType;
56 return Status::OK;
57 }
58 };
59
60 class MediaCodecMock : public OHOS::Media::MediaCodec {
61 public:
62
Init(const std::string & mime,bool isEncoder)63 int32_t Init(const std::string &mime, bool isEncoder)
64 {
65 (void)mime;
66 (void)isEncoder;
67 return 0;
68 }
Configure(const std::shared_ptr<Meta> & meta)69 int32_t Configure(const std::shared_ptr<Meta> &meta)
70 {
71 (void)meta;
72 return configure_;
73 }
Start()74 int32_t Start()
75 {
76 return start_;
77 }
Stop()78 int32_t Stop()
79 {
80 return stop_;
81 }
Flush()82 int32_t Flush()
83 {
84 return flush_;
85 }
Release()86 int32_t Release()
87 {
88 return release_;
89 }
NotifyEos()90 int32_t NotifyEos()
91 {
92 return notifyEos_;
93 }
SetParameter(const std::shared_ptr<Meta> & parameter)94 int32_t SetParameter(const std::shared_ptr<Meta> ¶meter)
95 {
96 (void)parameter;
97 return 0;
98 }
GetOutputFormat(std::shared_ptr<Meta> & parameter)99 int32_t GetOutputFormat(std::shared_ptr<Meta> ¶meter)
100 {
101 int32_t ret = 0;
102 if (getOutputFormat_) {
103 int32_t frameSize = 1024;
104 parameter->Set<Tag::AUDIO_SAMPLE_PER_FRAME>(frameSize);
105 } else {
106 ret = -1;
107 }
108 return ret;
109 }
SetOutputBufferQueue(const sptr<AVBufferQueueProducer> & bufferQueueProducer)110 int32_t SetOutputBufferQueue(const sptr<AVBufferQueueProducer> &bufferQueueProducer)
111 {
112 (void)bufferQueueProducer;
113 return 0;
114 }
Prepare()115 int32_t Prepare()
116 {
117 return 0;
118 }
GetInputBufferQueue()119 sptr<AVBufferQueueProducer> GetInputBufferQueue()
120 {
121 uint32_t size = 8;
122 inputBufferQueue_ = AVBufferQueue::Create(size);
123 if (inputBufferQueue_ == nullptr) {
124 return nullptr;
125 }
126 inputBufferQueueProducer_ = inputBufferQueue_->GetProducer();
127 return inputBufferQueueProducer_;
128 }
129 protected:
130 int32_t configure_ = 0;
131 int32_t start_ = 0;
132 int32_t stop_ = 0;
133 int32_t flush_ = 0;
134 int32_t release_ = 0;
135 int32_t notifyEos_ = 0;
136 bool getOutputFormat_ = false;
137 std::shared_ptr<AVBufferQueue> inputBufferQueue_ = nullptr;
138 sptr<AVBufferQueueProducer> inputBufferQueueProducer_ = nullptr;
139 };
140
141 class FilterMock : public Filter {
142 public:
FilterMock()143 FilterMock():Filter("filterMock", FilterType::FILTERTYPE_SOURCE) {}
144 ~FilterMock() = default;
OnLinked(StreamType inType,const std::shared_ptr<Meta> & meta,const std::shared_ptr<FilterLinkCallback> & callback)145 Status OnLinked(StreamType inType, const std::shared_ptr<Meta>& meta,
146 const std::shared_ptr<FilterLinkCallback>& callback)
147 {
148 (void)inType;
149 (void)meta;
150 (void)callback;
151 return onLinked_;
152 }
153 protected:
154 Status onLinked_;
155 };
156
157 class FilterLinkCallbackTest : public FilterLinkCallback {
158 public:
159 FilterLinkCallbackTest() = default;
160 ~FilterLinkCallbackTest() = default;
OnLinkedResult(const sptr<AVBufferQueueProducer> & queue,std::shared_ptr<Meta> & meta)161 void OnLinkedResult(const sptr<AVBufferQueueProducer>& queue, std::shared_ptr<Meta>& meta) override
162 {
163 (void)queue;
164 (void)meta;
165 }
OnUnlinkedResult(std::shared_ptr<Meta> & meta)166 void OnUnlinkedResult(std::shared_ptr<Meta>& meta) override
167 {
168 (void)meta;
169 }
OnUpdatedResult(std::shared_ptr<Meta> & meta)170 void OnUpdatedResult(std::shared_ptr<Meta>& meta) override
171 {
172 (void)meta;
173 }
174 };
175
SetUpTestCase(void)176 void AudioEncoderFilterUnitest::SetUpTestCase(void) {}
177
TearDownTestCase(void)178 void AudioEncoderFilterUnitest::TearDownTestCase(void) {}
179
SetUp(void)180 void AudioEncoderFilterUnitest::SetUp(void)
181 {
182 audioEncoderFilter_ =
183 std::make_shared<AudioEncoderFilter>("testAudioEncoderFilter", FilterType::FILTERTYPE_AENC);
184 ASSERT_NE(audioEncoderFilter_, nullptr);
185 }
186
TearDown(void)187 void AudioEncoderFilterUnitest::TearDown(void)
188 {
189 audioEncoderFilter_ = nullptr;
190 }
191
192
193 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_Destructor_0100, TestSize.Level1)
194 {
195 audioEncoderFilter_ =
196 std::make_shared<AudioEncoderFilter>("testAudioEncoderFilter", FilterType::FILTERTYPE_AENC);
197 EXPECT_NE(audioEncoderFilter_, nullptr);
198 }
199
200 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_SetCodecFormat_0100, TestSize.Level1)
201 {
202 // format == nulllptr
203 std::shared_ptr<Meta> format = std::make_shared<Meta>();
204 EXPECT_EQ(audioEncoderFilter_->SetCodecFormat(format), Status::ERROR_INVALID_PARAMETER);
205
206 // format != nullptr
207 format->Set<Tag::MIME_TYPE>(std::string("audio/mp3"));
208 EXPECT_EQ(audioEncoderFilter_->SetCodecFormat(format), Status::OK);
209 }
210
211 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_Init_0100, TestSize.Level1)
212 {
213 auto mediaCodecMock = std::make_shared<MediaCodecMock>();
214 audioEncoderFilter_->mediaCodec_ = mediaCodecMock;
215 ASSERT_NE(audioEncoderFilter_->mediaCodec_, nullptr);
216 std::shared_ptr<EventReceiver> receiver = std::make_shared<EventReceiverTest>();
217 std::shared_ptr<FilterCallback> callback = std::make_shared<FilterCallbackTest>();
218 audioEncoderFilter_->Init(receiver, callback);
219 }
220
221 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_Configure_0100, TestSize.Level1)
222 {
223 auto mediaCodecMock = std::make_shared<MediaCodecMock>();
224 audioEncoderFilter_->mediaCodec_ = mediaCodecMock;
225 std::shared_ptr<Meta> parameter = std::make_shared<Meta>();
226 //ret = 0
227 EXPECT_NE(audioEncoderFilter_->Configure(parameter), Status::OK);
228 //ret != 0
229 mediaCodecMock->configure_ = 1;
230 EXPECT_NE(audioEncoderFilter_->Configure(parameter), Status::OK);
231 }
232
233 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_DoPrepare_0100, TestSize.Level1)
234 {
235 auto mediaCodecMock = std::make_shared<MediaCodecMock>();
236 audioEncoderFilter_->mediaCodec_ = mediaCodecMock;
237 auto filterCallback = std::make_shared<FilterCallbackTest>();
238
239 // filterType_ == FilterType::FILTERTYPE_AENC
240 audioEncoderFilter_->filterType_ = FilterType::FILTERTYPE_AENC;
241 audioEncoderFilter_->filterCallback_ = filterCallback;
242 EXPECT_EQ(audioEncoderFilter_->DoPrepare(), Status::OK);
243
244 // filterType_ != FilterType::FILTERTYPE_AENC
245 audioEncoderFilter_->filterType_ = FilterType::FILTERTYPE_ADEC;
246 EXPECT_EQ(audioEncoderFilter_->DoPrepare(), Status::OK);
247 }
248
249 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_DoStart_0100, TestSize.Level1)
250 {
251 auto mediaCodecMock = std::make_shared<MediaCodecMock>();
252 audioEncoderFilter_->mediaCodec_ = mediaCodecMock;
253
254 // ret != 0
255 mediaCodecMock->start_ = 1;
256 EXPECT_NE(audioEncoderFilter_->DoStart(), Status::OK);
257
258 // ret == 0
259 mediaCodecMock->start_ = 0;
260 EXPECT_NE(audioEncoderFilter_->DoStart(), Status::OK);
261 }
262
263 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_DoPause_0100, TestSize.Level1)
264 {
265 EXPECT_EQ(audioEncoderFilter_->DoPause(), Status::OK);
266 }
267
268 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_DoResume_0100, TestSize.Level1)
269 {
270 EXPECT_EQ(audioEncoderFilter_->DoResume(), Status::OK);
271 }
272
273 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_DoStop_0100, TestSize.Level1)
274 {
275 auto mediaCodecMock = std::make_shared<MediaCodecMock>();
276 audioEncoderFilter_->mediaCodec_ = mediaCodecMock;
277
278 // ret != 0
279 mediaCodecMock->stop_ = 1;
280 EXPECT_EQ(audioEncoderFilter_->DoStop(), Status::OK);
281
282 // ret == 0
283 mediaCodecMock->stop_ = 0;
284 EXPECT_EQ(audioEncoderFilter_->DoStop(), Status::OK);
285 }
286
287 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_DoFlush_0100, TestSize.Level1)
288 {
289 auto mediaCodecMock = std::make_shared<MediaCodecMock>();
290 audioEncoderFilter_->mediaCodec_ = mediaCodecMock;
291
292 // ret != 0
293 mediaCodecMock->flush_ = 1;
294 EXPECT_NE(audioEncoderFilter_->DoFlush(), Status::OK);
295
296 // ret == 0
297 mediaCodecMock->flush_ = 0;
298 EXPECT_NE(audioEncoderFilter_->DoFlush(), Status::OK);
299 }
300
301 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_DoRelease_0100, TestSize.Level1)
302 {
303 auto mediaCodecMock = std::make_shared<MediaCodecMock>();
304 audioEncoderFilter_->mediaCodec_ = mediaCodecMock;
305
306 // ret != 0
307 mediaCodecMock->release_ = 1;
308 EXPECT_EQ(audioEncoderFilter_->DoRelease(), Status::OK);
309
310 // ret == 0
311 mediaCodecMock->release_ = 0;
312 EXPECT_EQ(audioEncoderFilter_->DoRelease(), Status::OK);
313 }
314
315 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_NotifyEos_0100, TestSize.Level1)
316 {
317 auto mediaCodecMock = std::make_shared<MediaCodecMock>();
318 audioEncoderFilter_->mediaCodec_ = mediaCodecMock;
319
320 // ret != 0
321 mediaCodecMock->notifyEos_ = 1;
322 EXPECT_NE(audioEncoderFilter_->NotifyEos(), Status::OK);
323
324 // ret == 0
325 mediaCodecMock->notifyEos_ = 0;
326 EXPECT_NE(audioEncoderFilter_->NotifyEos(), Status::OK);
327 }
328
329 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_SetParameter_0100, TestSize.Level1)
330 {
331 auto mediaCodecMock = std::make_shared<MediaCodecMock>();
332 audioEncoderFilter_->mediaCodec_ = mediaCodecMock;
333 std::shared_ptr<Meta> parameter = std::make_shared<Meta>();
334 ASSERT_NE(parameter, nullptr);
335 audioEncoderFilter_->SetParameter(parameter);
336 }
337
338 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_GetParameter_0100, TestSize.Level1)
339 {
340 std::shared_ptr<Meta> parameter = std::make_shared<Meta>();
341 ASSERT_NE(parameter, nullptr);
342 audioEncoderFilter_->GetParameter(parameter);
343 }
344
345 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_LinkNext_0100, TestSize.Level1)
346 {
347 auto mediaCodecMock = std::make_shared<MediaCodecMock>();
348 auto filterMock = std::make_shared<FilterMock>();
349 std::shared_ptr<Filter> nextFilter = filterMock;
350
351 // mediaCodec_ == nullptr && ret != Status::OK
352 audioEncoderFilter_->mediaCodec_ = nullptr;
353 filterMock->onLinked_ = Status::ERROR_INVALID_PARAMETER;
354 EXPECT_NE(audioEncoderFilter_->LinkNext(nextFilter, StreamType::STREAMTYPE_ENCODED_VIDEO), Status::OK);
355
356 // mediaCodec_ == nullptr && ret == Status::OK
357 audioEncoderFilter_->mediaCodec_ = nullptr;
358 filterMock->onLinked_ = Status::OK;
359 EXPECT_EQ(audioEncoderFilter_->LinkNext(nextFilter, StreamType::STREAMTYPE_ENCODED_VIDEO), Status::OK);
360
361 // mediaCodec_ != nullptr && parameter->Find(Tag::AUDIO_SAMPLE_PER_FRAME) != parameter->end() &&
362 // parameter->Get<Tag::AUDIO_SAMPLE_PER_FRAME>(frameSize) && ret != Status::OK
363 audioEncoderFilter_->mediaCodec_ = mediaCodecMock;
364 mediaCodecMock->getOutputFormat_ = true;
365 filterMock->onLinked_ = Status::ERROR_INVALID_PARAMETER;
366 EXPECT_NE(audioEncoderFilter_->LinkNext(nextFilter, StreamType::STREAMTYPE_ENCODED_VIDEO), Status::OK);
367
368 // mediaCodec_ != nullptr && parameter->Find(Tag::AUDIO_SAMPLE_PER_FRAME) != parameter->end() &&
369 // parameter->Get<Tag::AUDIO_SAMPLE_PER_FRAME>(frameSize) && ret != Status::OK
370 audioEncoderFilter_->mediaCodec_ = mediaCodecMock;
371 mediaCodecMock->getOutputFormat_ = false;
372 filterMock->onLinked_ = Status::ERROR_INVALID_PARAMETER;
373 EXPECT_NE(audioEncoderFilter_->LinkNext(nextFilter, StreamType::STREAMTYPE_ENCODED_VIDEO), Status::OK);
374 }
375
376 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_UpdateNext_0100, TestSize.Level1)
377 {
378 auto filterMock = std::make_shared<FilterMock>();
379 std::shared_ptr<Filter> nextFilter = filterMock;
380 EXPECT_EQ(audioEncoderFilter_->UpdateNext(nextFilter, StreamType::STREAMTYPE_ENCODED_VIDEO), Status::OK);
381 }
382
383 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_UnLinkNext_0100, TestSize.Level1)
384 {
385 auto filterMock = std::make_shared<FilterMock>();
386 std::shared_ptr<Filter> nextFilter = filterMock;
387 EXPECT_EQ(audioEncoderFilter_->UnLinkNext(nextFilter, StreamType::STREAMTYPE_ENCODED_VIDEO), Status::OK);
388 }
389
390 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_GetFilterType_0100, TestSize.Level1)
391 {
392 audioEncoderFilter_->filterType_ = FilterType::FILTERTYPE_AENC;
393 EXPECT_EQ(audioEncoderFilter_->GetFilterType(), FilterType::FILTERTYPE_AENC);
394 }
395
396 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_OnLinked_0100, TestSize.Level1)
397 {
398 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
399 std::shared_ptr<FilterLinkCallback> callback = std::make_shared<FilterLinkCallbackTest>();
400 EXPECT_EQ(audioEncoderFilter_->OnLinked(StreamType::STREAMTYPE_ENCODED_VIDEO, meta, callback), Status::OK);
401 }
402
403 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_OnUpdated_0100, TestSize.Level1)
404 {
405 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
406 std::shared_ptr<FilterLinkCallback> callback = std::make_shared<FilterLinkCallbackTest>();
407 EXPECT_EQ(audioEncoderFilter_->OnUpdated(StreamType::STREAMTYPE_ENCODED_VIDEO, meta, callback), Status::OK);
408 }
409
410 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_OnUnLinked_0100, TestSize.Level1)
411 {
412 std::shared_ptr<FilterLinkCallback> callback = std::make_shared<FilterLinkCallbackTest>();
413 EXPECT_EQ(audioEncoderFilter_->OnUnLinked(StreamType::STREAMTYPE_ENCODED_VIDEO, callback), Status::OK);
414 }
415
416 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_OnLinkedResult_0100, TestSize.Level1)
417 {
418 auto mediaCodecMock = std::make_shared<MediaCodecMock>();
419 ASSERT_NE(mediaCodecMock, nullptr);
420 audioEncoderFilter_->mediaCodec_ = mediaCodecMock;
421
422 audioEncoderFilter_->onLinkedResultCallback_ = std::make_shared<FilterLinkCallbackTest>();
423 ASSERT_NE(audioEncoderFilter_->onLinkedResultCallback_, nullptr);
424
425 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
426 ASSERT_NE(meta, nullptr);
427 sptr<AVBufferQueueProducer> outputBufferQueue = nullptr;
428 audioEncoderFilter_->OnLinkedResult(outputBufferQueue, meta);
429 }
430
431 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_OnUpdatedResult_0100, TestSize.Level1)
432 {
433 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
434 ASSERT_NE(meta, nullptr);
435 audioEncoderFilter_->OnUpdatedResult(meta);
436 }
437
438 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_OnUnlinkedResult_0100, TestSize.Level1)
439 {
440 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
441 ASSERT_NE(meta, nullptr);
442 audioEncoderFilter_->OnUnlinkedResult(meta);
443 }
444
445 HWTEST_F(AudioEncoderFilterUnitest, AudioEncoderFilter_SetCallingInfo_0100, TestSize.Level1)
446 {
447 int32_t appUid = 1000;
448 int32_t appPid = 1001;
449 uint64_t instanceId = 1002;
450 std::string bundleName = "bundleName";
451 audioEncoderFilter_->SetCallingInfo(appUid, appPid, bundleName, instanceId);
452 }
453
454 }
455 }
456 }