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_AudioVideo_001
197 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with codec format H264
198 * @tc.type: FUNC
199 * @tc.require:
200 */
201 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideo_001, TestSize.Level2)
202 {
203 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").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 + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").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_MPEG_4;
214 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
215 AudioCodecFormat encoderAudio = AAC_LC;
216 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
217 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
218 VideoCodecFormat encoder = H264;
219 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
220 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
221 int32_t videoWidth = -1;
222 int32_t videoHeight = -1;
223 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
224 videoWidth = TRANSCODER_BUFFER_WIDTH;
225 videoHeight = TRANSCODER_BUFFER_HEIGHT;
226 } else {
227 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
228 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
229 }
230 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
231 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
232 EXPECT_EQ(MSERR_OK, transcoder_->Start());
233 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
234 EXPECT_EQ(MSERR_OK, transcoder_->Release());
235 close(dstFd);
236 close(srcFd);
237 }
238
239 /**
240 * @tc.name: transcoder_AudioVideo_002
241 * @tc.desc: transcoder audio and video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with codec format h264 pause and resume
242 * @tc.type: FUNC
243 * @tc.require:
244 */
245 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideo_002, TestSize.Level2)
246 {
247 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
248 ASSERT_TRUE(srcFd >= 0);
249 int64_t offset = TRANSCODER_FILE_OFFSET;
250 int64_t size = TRANSCODER_FILE_SIZE;
251 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
252 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
253 ASSERT_TRUE(dstFd >= 0);
254 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
255 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
256 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
257 OutputFormatType format = FORMAT_MPEG_4;
258 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
259 AudioCodecFormat encoderAudio = AAC_LC;
260 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
261 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
262 VideoCodecFormat encoder = H264;
263 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
264 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
265 int32_t videoWidth = -1;
266 int32_t videoHeight = -1;
267 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
268 videoWidth = TRANSCODER_BUFFER_WIDTH;
269 videoHeight = TRANSCODER_BUFFER_HEIGHT;
270 } else {
271 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
272 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
273 }
274 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
275 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
276 EXPECT_EQ(MSERR_OK, transcoder_->Start());
277 EXPECT_EQ(MSERR_OK, transcoder_->Pause());
278 EXPECT_EQ(MSERR_OK, transcoder_->Resume());
279 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
280 EXPECT_EQ(MSERR_OK, transcoder_->Release());
281 close(dstFd);
282 close(srcFd);
283 }
284
285 /**
286 * @tc.name: transcoder_AudioVideo_003
287 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with codec format H265
288 * @tc.type: FUNC
289 * @tc.require:
290 */
291 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideo_003, TestSize.Level2)
292 {
293 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
294 ASSERT_TRUE(srcFd >= 0);
295 int64_t offset = TRANSCODER_FILE_OFFSET;
296 int64_t size = TRANSCODER_FILE_SIZE;
297 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
298 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
299 ASSERT_TRUE(dstFd >= 0);
300 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
301 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
302 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
303 OutputFormatType format = FORMAT_MPEG_4;
304 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
305 AudioCodecFormat encoderAudio = AAC_LC;
306 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
307 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
308 VideoCodecFormat encoder = H264;
309 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
310 encoder = H265;
311 }
312 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
313 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
314 int32_t videoWidth = -1;
315 int32_t videoHeight = -1;
316 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
317 videoWidth = TRANSCODER_BUFFER_WIDTH;
318 videoHeight = TRANSCODER_BUFFER_HEIGHT;
319 } else {
320 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
321 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
322 }
323 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
324 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
325 EXPECT_EQ(MSERR_OK, transcoder_->Start());
326 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
327 EXPECT_EQ(MSERR_OK, transcoder_->Release());
328 close(dstFd);
329 close(srcFd);
330 }
331
332 /**
333 * @tc.name: transcoder_AudioVideo_004
334 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with codec format h265 pause and resume
335 * @tc.type: FUNC
336 * @tc.require:
337 */
338 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideo_004, TestSize.Level2)
339 {
340 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
341 ASSERT_TRUE(srcFd >= 0);
342 int64_t offset = TRANSCODER_FILE_OFFSET;
343 int64_t size = TRANSCODER_FILE_SIZE;
344 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
345 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
346 ASSERT_TRUE(dstFd >= 0);
347 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
348 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
349 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
350 OutputFormatType format = FORMAT_MPEG_4;
351 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
352 AudioCodecFormat encoderAudio = AAC_LC;
353 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
354 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
355 VideoCodecFormat encoder = H264;
356 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
357 encoder = H265;
358 }
359 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
360 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
361 int32_t videoWidth = -1;
362 int32_t videoHeight = -1;
363 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
364 videoWidth = TRANSCODER_BUFFER_WIDTH;
365 videoHeight = TRANSCODER_BUFFER_HEIGHT;
366 } else {
367 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
368 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
369 }
370 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
371 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
372 EXPECT_EQ(MSERR_OK, transcoder_->Start());
373 EXPECT_EQ(MSERR_OK, transcoder_->Pause());
374 EXPECT_EQ(MSERR_OK, transcoder_->Resume());
375 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
376 EXPECT_EQ(MSERR_OK, transcoder_->Release());
377 close(dstFd);
378 close(srcFd);
379 }
380
381 /**
382 * @tc.name: transcoder_PureAudioAbnormal_case_001
383 * @tc.desc: transcoder pure audio 01.mp3 with cancle before prepare
384 * @tc.type: FUNC
385 * @tc.require:
386 */
387 HWTEST_F(TransCoderUnitTest, transcoder_PureAudioAbnormal_case_001, TestSize.Level2)
388 {
389 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "01.mp3").c_str(), O_RDWR);
390 ASSERT_TRUE(srcFd >= 0);
391 int64_t offset = TRANSCODER_FILE_OFFSET;
392 int64_t size = TRANSCODER_FILE_SIZE;
393 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
394 int32_t dstFd = open((TRANSCODER_ROOT_DST + "01_dst.mp3").c_str(), O_RDWR);
395 ASSERT_TRUE(dstFd >= 0);
396 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
397 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
398 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
399 OutputFormatType format = FORMAT_M4A;
400 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
401 AudioCodecFormat encoder = AAC_LC;
402 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoder));
403 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
404 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
405 EXPECT_EQ(MSERR_OK, transcoder_->Release());
406 close(dstFd);
407 close(srcFd);
408 }
409
410 /**
411 * @tc.name: transcoder_PureAudioAbnormal_case_002
412 * @tc.desc: transcoder pure audio 01.mp3 with pause before prepare
413 * @tc.type: FUNC
414 * @tc.require:
415 */
416 HWTEST_F(TransCoderUnitTest, transcoder_PureAudioAbnormal_case_002, TestSize.Level2)
417 {
418 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "01.mp3").c_str(), O_RDWR);
419 ASSERT_TRUE(srcFd >= 0);
420 int64_t offset = TRANSCODER_FILE_OFFSET;
421 int64_t size = TRANSCODER_FILE_SIZE;
422 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
423 int32_t dstFd = open((TRANSCODER_ROOT_DST + "01_dst.mp3").c_str(), O_RDWR);
424 ASSERT_TRUE(dstFd >= 0);
425 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
426 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
427 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
428 OutputFormatType format = FORMAT_M4A;
429 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
430 AudioCodecFormat encoder = AAC_LC;
431 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoder));
432 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
433 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Pause());
434 EXPECT_EQ(MSERR_OK, transcoder_->Release());
435 close(dstFd);
436 close(srcFd);
437 }
438
439 /**
440 * @tc.name: transcoder_PureAudioAbnormal_case_003
441 * @tc.desc: transcoder pure audio 01.mp3 with resume before prepare
442 * @tc.type: FUNC
443 * @tc.require:
444 */
445 HWTEST_F(TransCoderUnitTest, transcoder_PureAudioAbnormal_case_003, TestSize.Level2)
446 {
447 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "01.mp3").c_str(), O_RDWR);
448 ASSERT_TRUE(srcFd >= 0);
449 int64_t offset = TRANSCODER_FILE_OFFSET;
450 int64_t size = TRANSCODER_FILE_SIZE;
451 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
452 int32_t dstFd = open((TRANSCODER_ROOT_DST + "01_dst.mp3").c_str(), O_RDWR);
453 ASSERT_TRUE(dstFd >= 0);
454 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
455 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
456 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
457 OutputFormatType format = FORMAT_M4A;
458 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
459 AudioCodecFormat encoder = AAC_LC;
460 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoder));
461 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
462 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Resume());
463 EXPECT_EQ(MSERR_OK, transcoder_->Release());
464 close(dstFd);
465 close(srcFd);
466 }
467
468 /**
469 * @tc.name: transcoder_PureVideoAbnormal_case_001
470 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with cancel before prepare
471 * @tc.type: FUNC
472 * @tc.require:
473 */
474 HWTEST_F(TransCoderUnitTest, transcoder_PureVideoAbnormal_case_001, TestSize.Level2)
475 {
476 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
477 ASSERT_TRUE(srcFd >= 0);
478 int64_t offset = TRANSCODER_FILE_OFFSET;
479 int64_t size = TRANSCODER_FILE_SIZE;
480 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
481 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
482 ASSERT_TRUE(dstFd >= 0);
483 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
484 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
485 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
486 OutputFormatType format = FORMAT_MPEG_4;
487 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
488 VideoCodecFormat encoder = H264;
489 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
490 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
491 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
492 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
493 EXPECT_EQ(MSERR_OK, transcoder_->Release());
494 close(dstFd);
495 close(srcFd);
496 }
497
498 /**
499 * @tc.name: transcoder_PureVideoAbnormal_case_002
500 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with cancel before prepare
501 * @tc.type: FUNC
502 * @tc.require:
503 */
504 HWTEST_F(TransCoderUnitTest, transcoder_PureVideoAbnormal_case_002, TestSize.Level2)
505 {
506 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
507 ASSERT_TRUE(srcFd >= 0);
508 int64_t offset = TRANSCODER_FILE_OFFSET;
509 int64_t size = TRANSCODER_FILE_SIZE;
510 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
511 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
512 ASSERT_TRUE(dstFd >= 0);
513 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
514 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
515 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
516 OutputFormatType format = FORMAT_MPEG_4;
517 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
518 VideoCodecFormat encoder = H264;
519 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
520 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
521 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
522 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Pause());
523 EXPECT_EQ(MSERR_OK, transcoder_->Release());
524 close(dstFd);
525 close(srcFd);
526 }
527
528 /**
529 * @tc.name: transcoder_PureVideoAbnormal_case_003
530 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with cancel before prepare
531 * @tc.type: FUNC
532 * @tc.require:
533 */
534 HWTEST_F(TransCoderUnitTest, transcoder_PureVideoAbnormal_case_003, TestSize.Level2)
535 {
536 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
537 ASSERT_TRUE(srcFd >= 0);
538 int64_t offset = TRANSCODER_FILE_OFFSET;
539 int64_t size = TRANSCODER_FILE_SIZE;
540 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
541 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
542 ASSERT_TRUE(dstFd >= 0);
543 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
544 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
545 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
546 OutputFormatType format = FORMAT_MPEG_4;
547 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
548 VideoCodecFormat encoder = H264;
549 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
550 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
551 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
552 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Resume());
553 EXPECT_EQ(MSERR_OK, transcoder_->Release());
554 close(dstFd);
555 close(srcFd);
556 }
557
558 /**
559 * @tc.name: transcoder_AudioVideoAbnormal_case_001
560 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with cancel before prepare
561 * @tc.type: FUNC
562 * @tc.require:
563 */
564 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideoAbnormal_case_001, TestSize.Level2)
565 {
566 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
567 ASSERT_TRUE(srcFd >= 0);
568 int64_t offset = TRANSCODER_FILE_OFFSET;
569 int64_t size = TRANSCODER_FILE_SIZE;
570 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
571 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
572 ASSERT_TRUE(dstFd >= 0);
573 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
574 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
575 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
576 OutputFormatType format = FORMAT_MPEG_4;
577 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
578 AudioCodecFormat encoderAudio = AAC_LC;
579 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
580 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
581 VideoCodecFormat encoder = H264;
582 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
583 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
584 int32_t videoWidth = -1;
585 int32_t videoHeight = -1;
586 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
587 videoWidth = TRANSCODER_BUFFER_WIDTH;
588 videoHeight = TRANSCODER_BUFFER_HEIGHT;
589 } else {
590 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
591 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
592 }
593 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
594 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
595 EXPECT_EQ(MSERR_OK, transcoder_->Release());
596 close(dstFd);
597 close(srcFd);
598 }
599
600 /**
601 * @tc.name: transcoder_AudioVideoAbnormal_case_002
602 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with cancel before prepare
603 * @tc.type: FUNC
604 * @tc.require:
605 */
606 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideoAbnormal_case_002, TestSize.Level2)
607 {
608 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
609 ASSERT_TRUE(srcFd >= 0);
610 int64_t offset = TRANSCODER_FILE_OFFSET;
611 int64_t size = TRANSCODER_FILE_SIZE;
612 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
613 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
614 ASSERT_TRUE(dstFd >= 0);
615 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
616 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
617 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
618 OutputFormatType format = FORMAT_MPEG_4;
619 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
620 AudioCodecFormat encoderAudio = AAC_LC;
621 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
622 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
623 VideoCodecFormat encoder = H264;
624 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
625 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
626 int32_t videoWidth = -1;
627 int32_t videoHeight = -1;
628 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
629 videoWidth = TRANSCODER_BUFFER_WIDTH;
630 videoHeight = TRANSCODER_BUFFER_HEIGHT;
631 } else {
632 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
633 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
634 }
635 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
636 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Pause());
637 EXPECT_EQ(MSERR_OK, transcoder_->Release());
638 close(dstFd);
639 close(srcFd);
640 }
641
642 /**
643 * @tc.name: transcoder_AudioVideoAbnormal_case_003
644 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with cancel before prepare
645 * @tc.type: FUNC
646 * @tc.require:
647 */
648 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideoAbnormal_case_003, TestSize.Level2)
649 {
650 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
651 ASSERT_TRUE(srcFd >= 0);
652 int64_t offset = TRANSCODER_FILE_OFFSET;
653 int64_t size = TRANSCODER_FILE_SIZE;
654 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
655 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
656 ASSERT_TRUE(dstFd >= 0);
657 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
658 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
659 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
660 OutputFormatType format = FORMAT_MPEG_4;
661 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
662 AudioCodecFormat encoderAudio = AAC_LC;
663 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
664 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
665 VideoCodecFormat encoder = H264;
666 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
667 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
668 int32_t videoWidth = -1;
669 int32_t videoHeight = -1;
670 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
671 videoWidth = TRANSCODER_BUFFER_WIDTH;
672 videoHeight = TRANSCODER_BUFFER_HEIGHT;
673 } else {
674 videoWidth = TRANSCODER_BUFFER_WIDTH_480p;
675 videoHeight = TRANSCODER_BUFFER_HEIGHT_480p;
676 }
677 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
678 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Resume());
679 EXPECT_EQ(MSERR_OK, transcoder_->Release());
680 close(dstFd);
681 close(srcFd);
682 }
683 } // namespace Media
684 } // namespace OHOS