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