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 "transcoder_unit_test.h"
17 #include <unistd.h>
18 #include <fcntl.h>
19 #include <securec.h>
20 #include "media_errors.h"
21 #include "av_common.h"
22 #include "meta/video_types.h"
23 #include "media_errors.h"
24 #include "media_log.h"
25
26 using namespace OHOS;
27 using namespace OHOS::Media;
28 using namespace std;
29 using namespace testing::ext;
30 using namespace OHOS::Media::TranscoderTestParam;
31
32 namespace OHOS {
33 namespace Media {
34
35 const std::string HEVC_LIB_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_hevc_parser.z.so";
36 const std::string VPE_LIB_PATH = std::string(AV_CODEC_PATH) + "/libvideoprocessingengine.z.so";
37
SetUpTestCase(void)38 void TransCoderUnitTest::SetUpTestCase(void) {}
39
TearDownTestCase(void)40 void TransCoderUnitTest::TearDownTestCase(void) {}
41
SetUp(void)42 void TransCoderUnitTest::SetUp(void)
43 {
44 transcoder_ = std::make_shared<TranscoderMock>();
45 ASSERT_NE(nullptr, transcoder_);
46 ASSERT_TRUE(transcoder_->CreateTranscoder());
47 }
48
TearDown(void)49 void TransCoderUnitTest::TearDown(void)
50 {
51 if (transcoder_ != nullptr) {
52 transcoder_->Release();
53 }
54 }
55
56 /**
57 * @tc.name: transcoder_PureVideo_001
58 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with codec format H264
59 * @tc.type: FUNC
60 * @tc.require:
61 */
62 HWTEST_F(TransCoderUnitTest, transcoder_PureVideo_001, TestSize.Level2)
63 {
64 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
65 ASSERT_TRUE(srcFd >= 0);
66 int64_t offset = TRANSCODER_FILE_OFFSET;
67 int64_t size = TRANSCODER_FILE_SIZE;
68 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
69 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
70 ASSERT_TRUE(dstFd >= 0);
71 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
72 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
73 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
74 OutputFormatType format = FORMAT_MPEG_4;
75 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
76
77 VideoCodecFormat encoder = H264;
78 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
79 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
80 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
81 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
82 EXPECT_EQ(MSERR_OK, transcoder_->Start());
83 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
84 EXPECT_EQ(MSERR_OK, transcoder_->Release());
85 close(dstFd);
86 close(srcFd);
87 }
88
89 /**
90 * @tc.name: transcoder_PureVideo_002
91 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with codec format h264 pause and resume
92 * @tc.type: FUNC
93 * @tc.require:
94 */
95 HWTEST_F(TransCoderUnitTest, transcoder_PureVideo_002, TestSize.Level2)
96 {
97 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
98 ASSERT_TRUE(srcFd >= 0);
99 int64_t offset = TRANSCODER_FILE_OFFSET;
100 int64_t size = TRANSCODER_FILE_SIZE;
101 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
102 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
103 ASSERT_TRUE(dstFd >= 0);
104 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
105 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
106 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
107 OutputFormatType format = FORMAT_MPEG_4;
108 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
109 VideoCodecFormat encoder = H264;
110 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
111 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
112 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
113 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
114 EXPECT_EQ(MSERR_OK, transcoder_->Start());
115 EXPECT_EQ(MSERR_OK, transcoder_->Pause());
116 EXPECT_EQ(MSERR_OK, transcoder_->Resume());
117 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
118 EXPECT_EQ(MSERR_OK, transcoder_->Release());
119 close(dstFd);
120 close(srcFd);
121 }
122
123 /**
124 * @tc.name: transcoder_PureVideo_003
125 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with codec format H265
126 * @tc.type: FUNC
127 * @tc.require:
128 */
129 HWTEST_F(TransCoderUnitTest, transcoder_PureVideo_003, TestSize.Level2)
130 {
131 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
132 ASSERT_TRUE(srcFd >= 0);
133 int64_t offset = TRANSCODER_FILE_OFFSET;
134 int64_t size = TRANSCODER_FILE_SIZE;
135 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
136 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
137 ASSERT_TRUE(dstFd >= 0);
138 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
139 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
140 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
141 OutputFormatType format = FORMAT_MPEG_4;
142 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
143 VideoCodecFormat encoder = H264;
144 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
145 encoder = H265;
146 }
147 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
148 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
149 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
150 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
151 EXPECT_EQ(MSERR_OK, transcoder_->Start());
152 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
153 EXPECT_EQ(MSERR_OK, transcoder_->Release());
154 close(dstFd);
155 close(srcFd);
156 }
157
158 /**
159 * @tc.name: transcoder_PureVideo_004
160 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with codec format h265 pause and resume
161 * @tc.type: FUNC
162 * @tc.require:
163 */
164 HWTEST_F(TransCoderUnitTest, transcoder_PureVideo_004, TestSize.Level2)
165 {
166 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
167 ASSERT_TRUE(srcFd >= 0);
168 int64_t offset = TRANSCODER_FILE_OFFSET;
169 int64_t size = TRANSCODER_FILE_SIZE;
170 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
171 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
172 ASSERT_TRUE(dstFd >= 0);
173 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
174 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
175 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
176 OutputFormatType format = FORMAT_MPEG_4;
177 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
178 VideoCodecFormat encoder = H264;
179 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
180 encoder = H265;
181 }
182 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
183 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
184 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
185 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
186 EXPECT_EQ(MSERR_OK, transcoder_->Start());
187 EXPECT_EQ(MSERR_OK, transcoder_->Pause());
188 EXPECT_EQ(MSERR_OK, transcoder_->Resume());
189 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
190 EXPECT_EQ(MSERR_OK, transcoder_->Release());
191 close(dstFd);
192 close(srcFd);
193 }
194
195 /**
196 * @tc.name: transcoder_PureAudio_001
197 * @tc.desc: transcoder pure audio 01.mp3
198 * @tc.type: FUNC
199 * @tc.require:
200 */
201 HWTEST_F(TransCoderUnitTest, transcoder_PureAudio_001, TestSize.Level2)
202 {
203 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "01.mp3").c_str(), O_RDWR);
204 ASSERT_TRUE(srcFd >= 0);
205 int64_t offset = TRANSCODER_FILE_OFFSET;
206 int64_t size = TRANSCODER_FILE_SIZE;
207 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
208 int32_t dstFd = open((TRANSCODER_ROOT_DST + "01_dst.mp3").c_str(), O_RDWR);
209 ASSERT_TRUE(dstFd >= 0);
210 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
211 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
212 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
213 OutputFormatType format = FORMAT_M4A;
214 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
215 AudioCodecFormat encoder = AAC_LC;
216 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoder));
217 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
218 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
219 EXPECT_EQ(MSERR_OK, transcoder_->Start());
220 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
221 EXPECT_EQ(MSERR_OK, transcoder_->Release());
222 close(dstFd);
223 close(srcFd);
224 }
225
226 /**
227 * @tc.name: transcoder_PureAudio_002
228 * @tc.desc: transcoder pure audio 01.mp3 with pause resume
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(TransCoderUnitTest, transcoder_PureAudio_002, TestSize.Level2)
233 {
234 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "01.mp3").c_str(), O_RDWR);
235 ASSERT_TRUE(srcFd >= 0);
236 int64_t offset = TRANSCODER_FILE_OFFSET;
237 int64_t size = TRANSCODER_FILE_SIZE;
238 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
239 int32_t dstFd = open((TRANSCODER_ROOT_DST + "01_dst.mp3").c_str(), O_RDWR);
240 ASSERT_TRUE(dstFd >= 0);
241 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
242 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
243 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
244 OutputFormatType format = FORMAT_M4A;
245 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
246 AudioCodecFormat encoder = AAC_LC;
247 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoder));
248 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
249 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
250 EXPECT_EQ(MSERR_OK, transcoder_->Start());
251 EXPECT_EQ(MSERR_OK, transcoder_->Pause());
252 EXPECT_EQ(MSERR_OK, transcoder_->Resume());
253 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
254 EXPECT_EQ(MSERR_OK, transcoder_->Release());
255 close(dstFd);
256 close(srcFd);
257 }
258
259 /**
260 * @tc.name: transcoder_AudioVideo_001
261 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with codec format H264
262 * @tc.type: FUNC
263 * @tc.require:
264 */
265 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideo_001, TestSize.Level2)
266 {
267 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
268 ASSERT_TRUE(srcFd >= 0);
269 int64_t offset = TRANSCODER_FILE_OFFSET;
270 int64_t size = TRANSCODER_FILE_SIZE;
271 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
272 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
273 ASSERT_TRUE(dstFd >= 0);
274 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
275 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
276 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
277 OutputFormatType format = FORMAT_MPEG_4;
278 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
279 AudioCodecFormat encoderAudio = AAC_LC;
280 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
281 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
282 VideoCodecFormat encoder = H264;
283 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
284 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
285 int32_t videoWidth = -1;
286 int32_t videoHeight = -1;
287 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
288 videoWidth = TRANSCODER_BUFFER_WIDTH;
289 videoHeight = TRANSCODER_BUFFER_HEIGHT;
290 } else {
291 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
292 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
293 }
294 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
295 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
296 EXPECT_EQ(MSERR_OK, transcoder_->Start());
297 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
298 EXPECT_EQ(MSERR_OK, transcoder_->Release());
299 close(dstFd);
300 close(srcFd);
301 }
302
303 /**
304 * @tc.name: transcoder_AudioVideo_002
305 * @tc.desc: transcoder audio and video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with codec format h264 pause and resume
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideo_002, TestSize.Level2)
310 {
311 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
312 ASSERT_TRUE(srcFd >= 0);
313 int64_t offset = TRANSCODER_FILE_OFFSET;
314 int64_t size = TRANSCODER_FILE_SIZE;
315 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
316 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
317 ASSERT_TRUE(dstFd >= 0);
318 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
319 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
320 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
321 OutputFormatType format = FORMAT_MPEG_4;
322 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
323 AudioCodecFormat encoderAudio = AAC_LC;
324 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
325 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
326 VideoCodecFormat encoder = H264;
327 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
328 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
329 int32_t videoWidth = -1;
330 int32_t videoHeight = -1;
331 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
332 videoWidth = TRANSCODER_BUFFER_WIDTH;
333 videoHeight = TRANSCODER_BUFFER_HEIGHT;
334 } else {
335 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
336 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
337 }
338 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
339 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
340 EXPECT_EQ(MSERR_OK, transcoder_->Start());
341 EXPECT_EQ(MSERR_OK, transcoder_->Pause());
342 EXPECT_EQ(MSERR_OK, transcoder_->Resume());
343 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
344 EXPECT_EQ(MSERR_OK, transcoder_->Release());
345 close(dstFd);
346 close(srcFd);
347 }
348
349 /**
350 * @tc.name: transcoder_AudioVideo_003
351 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with codec format H265
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideo_003, TestSize.Level2)
356 {
357 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
358 ASSERT_TRUE(srcFd >= 0);
359 int64_t offset = TRANSCODER_FILE_OFFSET;
360 int64_t size = TRANSCODER_FILE_SIZE;
361 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
362 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
363 ASSERT_TRUE(dstFd >= 0);
364 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
365 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
366 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
367 OutputFormatType format = FORMAT_MPEG_4;
368 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
369 AudioCodecFormat encoderAudio = AAC_LC;
370 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
371 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
372 VideoCodecFormat encoder = H264;
373 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
374 encoder = H265;
375 }
376 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
377 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
378 int32_t videoWidth = -1;
379 int32_t videoHeight = -1;
380 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
381 videoWidth = TRANSCODER_BUFFER_WIDTH;
382 videoHeight = TRANSCODER_BUFFER_HEIGHT;
383 } else {
384 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
385 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
386 }
387 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
388 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
389 EXPECT_EQ(MSERR_OK, transcoder_->Start());
390 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
391 EXPECT_EQ(MSERR_OK, transcoder_->Release());
392 close(dstFd);
393 close(srcFd);
394 }
395
396 /**
397 * @tc.name: transcoder_AudioVideo_004
398 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with codec format h265 pause and resume
399 * @tc.type: FUNC
400 * @tc.require:
401 */
402 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideo_004, TestSize.Level2)
403 {
404 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
405 ASSERT_TRUE(srcFd >= 0);
406 int64_t offset = TRANSCODER_FILE_OFFSET;
407 int64_t size = TRANSCODER_FILE_SIZE;
408 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
409 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
410 ASSERT_TRUE(dstFd >= 0);
411 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
412 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
413 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
414 OutputFormatType format = FORMAT_MPEG_4;
415 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
416 AudioCodecFormat encoderAudio = AAC_LC;
417 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
418 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
419 VideoCodecFormat encoder = H264;
420 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
421 encoder = H265;
422 }
423 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
424 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
425 int32_t videoWidth = -1;
426 int32_t videoHeight = -1;
427 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
428 videoWidth = TRANSCODER_BUFFER_WIDTH;
429 videoHeight = TRANSCODER_BUFFER_HEIGHT;
430 } else {
431 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
432 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
433 }
434 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
435 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
436 EXPECT_EQ(MSERR_OK, transcoder_->Start());
437 EXPECT_EQ(MSERR_OK, transcoder_->Pause());
438 EXPECT_EQ(MSERR_OK, transcoder_->Resume());
439 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
440 EXPECT_EQ(MSERR_OK, transcoder_->Release());
441 close(dstFd);
442 close(srcFd);
443 }
444
445 /**
446 * @tc.name: transcoder_PureAudioAbnormal_case_002
447 * @tc.desc: transcoder pure audio 01.mp3 with pause before prepare
448 * @tc.type: FUNC
449 * @tc.require:
450 */
451 HWTEST_F(TransCoderUnitTest, transcoder_PureAudioAbnormal_case_002, TestSize.Level2)
452 {
453 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "01.mp3").c_str(), O_RDWR);
454 ASSERT_TRUE(srcFd >= 0);
455 int64_t offset = TRANSCODER_FILE_OFFSET;
456 int64_t size = TRANSCODER_FILE_SIZE;
457 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
458 int32_t dstFd = open((TRANSCODER_ROOT_DST + "01_dst.mp3").c_str(), O_RDWR);
459 ASSERT_TRUE(dstFd >= 0);
460 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
461 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
462 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
463 OutputFormatType format = FORMAT_M4A;
464 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
465 AudioCodecFormat encoder = AAC_LC;
466 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoder));
467 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
468 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Pause());
469 EXPECT_EQ(MSERR_OK, transcoder_->Release());
470 close(dstFd);
471 close(srcFd);
472 }
473
474 /**
475 * @tc.name: transcoder_PureAudioAbnormal_case_003
476 * @tc.desc: transcoder pure audio 01.mp3 with resume before prepare
477 * @tc.type: FUNC
478 * @tc.require:
479 */
480 HWTEST_F(TransCoderUnitTest, transcoder_PureAudioAbnormal_case_003, TestSize.Level2)
481 {
482 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "01.mp3").c_str(), O_RDWR);
483 ASSERT_TRUE(srcFd >= 0);
484 int64_t offset = TRANSCODER_FILE_OFFSET;
485 int64_t size = TRANSCODER_FILE_SIZE;
486 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
487 int32_t dstFd = open((TRANSCODER_ROOT_DST + "01_dst.mp3").c_str(), O_RDWR);
488 ASSERT_TRUE(dstFd >= 0);
489 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
490 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
491 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
492 OutputFormatType format = FORMAT_M4A;
493 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
494 AudioCodecFormat encoder = AAC_LC;
495 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoder));
496 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
497 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Resume());
498 EXPECT_EQ(MSERR_OK, transcoder_->Release());
499 close(dstFd);
500 close(srcFd);
501 }
502
503 /**
504 * @tc.name: transcoder_PureVideoAbnormal_case_002
505 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with cancel before prepare
506 * @tc.type: FUNC
507 * @tc.require:
508 */
509 HWTEST_F(TransCoderUnitTest, transcoder_PureVideoAbnormal_case_002, TestSize.Level2)
510 {
511 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
512 ASSERT_TRUE(srcFd >= 0);
513 int64_t offset = TRANSCODER_FILE_OFFSET;
514 int64_t size = TRANSCODER_FILE_SIZE;
515 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
516 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
517 ASSERT_TRUE(dstFd >= 0);
518 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
519 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
520 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
521 OutputFormatType format = FORMAT_MPEG_4;
522 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
523 VideoCodecFormat encoder = H264;
524 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
525 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
526 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
527 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Pause());
528 EXPECT_EQ(MSERR_OK, transcoder_->Release());
529 close(dstFd);
530 close(srcFd);
531 }
532
533 /**
534 * @tc.name: transcoder_PureVideoAbnormal_case_003
535 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with cancel before prepare
536 * @tc.type: FUNC
537 * @tc.require:
538 */
539 HWTEST_F(TransCoderUnitTest, transcoder_PureVideoAbnormal_case_003, TestSize.Level2)
540 {
541 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
542 ASSERT_TRUE(srcFd >= 0);
543 int64_t offset = TRANSCODER_FILE_OFFSET;
544 int64_t size = TRANSCODER_FILE_SIZE;
545 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
546 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
547 ASSERT_TRUE(dstFd >= 0);
548 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
549 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
550 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
551 OutputFormatType format = FORMAT_MPEG_4;
552 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
553 VideoCodecFormat encoder = H264;
554 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
555 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
556 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
557 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Resume());
558 EXPECT_EQ(MSERR_OK, transcoder_->Release());
559 close(dstFd);
560 close(srcFd);
561 }
562
563 /**
564 * @tc.name: transcoder_AudioVideoAbnormal_case_002
565 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with cancel before prepare
566 * @tc.type: FUNC
567 * @tc.require:
568 */
569 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideoAbnormal_case_002, TestSize.Level2)
570 {
571 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
572 ASSERT_TRUE(srcFd >= 0);
573 int64_t offset = TRANSCODER_FILE_OFFSET;
574 int64_t size = TRANSCODER_FILE_SIZE;
575 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
576 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
577 ASSERT_TRUE(dstFd >= 0);
578 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
579 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
580 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
581 OutputFormatType format = FORMAT_MPEG_4;
582 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
583 AudioCodecFormat encoderAudio = AAC_LC;
584 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
585 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
586 VideoCodecFormat encoder = H264;
587 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
588 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
589 int32_t videoWidth = -1;
590 int32_t videoHeight = -1;
591 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
592 videoWidth = TRANSCODER_BUFFER_WIDTH;
593 videoHeight = TRANSCODER_BUFFER_HEIGHT;
594 } else {
595 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
596 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
597 }
598 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
599 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Pause());
600 EXPECT_EQ(MSERR_OK, transcoder_->Release());
601 close(dstFd);
602 close(srcFd);
603 }
604
605 /**
606 * @tc.name: transcoder_AudioVideoAbnormal_case_003
607 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with cancel before prepare
608 * @tc.type: FUNC
609 * @tc.require:
610 */
611 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideoAbnormal_case_003, TestSize.Level2)
612 {
613 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
614 ASSERT_TRUE(srcFd >= 0);
615 int64_t offset = TRANSCODER_FILE_OFFSET;
616 int64_t size = TRANSCODER_FILE_SIZE;
617 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
618 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
619 ASSERT_TRUE(dstFd >= 0);
620 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
621 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
622 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
623 OutputFormatType format = FORMAT_MPEG_4;
624 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
625 AudioCodecFormat encoderAudio = AAC_LC;
626 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
627 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
628 VideoCodecFormat encoder = H264;
629 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
630 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
631 int32_t videoWidth = -1;
632 int32_t videoHeight = -1;
633 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
634 videoWidth = TRANSCODER_BUFFER_WIDTH;
635 videoHeight = TRANSCODER_BUFFER_HEIGHT;
636 } else {
637 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
638 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
639 }
640 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
641 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Resume());
642 EXPECT_EQ(MSERR_OK, transcoder_->Release());
643 close(dstFd);
644 close(srcFd);
645 }
646 } // namespace Media
647 } // namespace OHOS