1 /*
2 * Copyright (c) 2024-2025 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 #include <thread>
26 #include <chrono>
27
28 using namespace OHOS;
29 using namespace OHOS::Media;
30 using namespace std;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Media {
35 namespace TranscoderTestParam {
36 constexpr uint32_t TRASCODER_AUDIO_ENCODING_BIT_RATE = 20000;
37 constexpr uint32_t TRASCODER_VIDEO_ENCODING_BIT_RATE = 30000;
38 constexpr int32_t TRANSCODER_BUFFER_WIDTH = 320;
39 constexpr int32_t TRANSCODER_BUFFER_HEIGHT = 240;
40 constexpr int32_t TRANSCODER_BUFFER_WIDTH_480P = 640;
41 constexpr int32_t TRANSCODER_BUFFER_HEIGHT_480P = 480;
42 constexpr uint64_t TRANSCODER_FILE_OFFSET = 37508084;
43 constexpr uint64_t TRANSCODER_FILE_SIZE = 2735029;
44 const std::string TRANSCODER_ROOT_SRC = "/data/test/media/transcoder_src/";
45 const std::string TRANSCODER_ROOT_DST = "/data/test/media/transcoder_dst/";
46 constexpr int32_t RETRY_TIMES = 5;
47 constexpr int32_t CHECK_INTERVAL_MS = 100;
48 } // namespace TranscoderTestParam
49 using namespace TranscoderTestParam;
50 const std::string HEVC_LIB_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_hevc_parser.z.so";
51 const std::string VPE_LIB_PATH = std::string(AV_CODEC_PATH) + "/libvideoprocessingengine.z.so";
52
SetUpTestCase(void)53 void TransCoderUnitTest::SetUpTestCase(void) {}
54
TearDownTestCase(void)55 void TransCoderUnitTest::TearDownTestCase(void) {}
56
SetUp(void)57 void TransCoderUnitTest::SetUp(void)
58 {
59 transcoder_ = TransCoderServer::Create();
60 ASSERT_NE(nullptr, transcoder_);
61 }
62
TearDown(void)63 void TransCoderUnitTest::TearDown(void)
64 {
65 if (transcoder_ != nullptr) {
66 transcoder_->Release();
67 }
68 }
69
OnError(int32_t errorCode,const std::string & errorMsg)70 void TransCoderCallbackTest::OnError(int32_t errorCode, const std::string &errorMsg)
71 {
72 status_ = TransCoderServer::REC_ERROR;
73 cout << "Error received, errorType:" << errorCode << " errorCode:" << errorMsg << endl;
74 }
75
OnInfo(int32_t type,int32_t extra)76 void TransCoderCallbackTest::OnInfo(int32_t type, int32_t extra)
77 {
78 cout << "Info received, Infotype:" << type << " Infocode:" << extra << endl;
79 }
80
CheckStateChange()81 bool TransCoderCallbackTest::CheckStateChange()
82 {
83 int retryTimes = RETRY_TIMES;
84 while (retryTimes--) {
85 if (status_ == TransCoderServer::REC_ERROR) {
86 return true;
87 }
88 std::this_thread::sleep_for(std::chrono::milliseconds(CHECK_INTERVAL_MS));
89 }
90 return false;
91 }
92
93 /**
94 * @tc.name: transcoder_PureVideo_001
95 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with codec format H264
96 * @tc.type: FUNC
97 * @tc.require:
98 */
99 HWTEST_F(TransCoderUnitTest, transcoder_PureVideo_001, TestSize.Level2)
100 {
101 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
102 ASSERT_TRUE(srcFd >= 0);
103 int64_t offset = TRANSCODER_FILE_OFFSET;
104 int64_t size = TRANSCODER_FILE_SIZE;
105 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
106 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
107 ASSERT_TRUE(dstFd >= 0);
108 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
109 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
110 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
111 OutputFormatType format = FORMAT_MPEG_4;
112 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
113
114 VideoCodecFormat encoder = H264;
115 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
116 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
117 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
118 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
119 EXPECT_EQ(MSERR_OK, transcoder_->Start());
120 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
121 EXPECT_EQ(MSERR_OK, transcoder_->Release());
122 close(dstFd);
123 close(srcFd);
124 }
125
126 /**
127 * @tc.name: transcoder_PureVideo_002
128 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with codec format h264 pause and resume
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(TransCoderUnitTest, transcoder_PureVideo_002, TestSize.Level2)
133 {
134 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
135 ASSERT_TRUE(srcFd >= 0);
136 int64_t offset = TRANSCODER_FILE_OFFSET;
137 int64_t size = TRANSCODER_FILE_SIZE;
138 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
139 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
140 ASSERT_TRUE(dstFd >= 0);
141 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
142 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
143 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
144 OutputFormatType format = FORMAT_MPEG_4;
145 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
146 VideoCodecFormat encoder = H264;
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_->Pause());
153 EXPECT_EQ(MSERR_OK, transcoder_->Resume());
154 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
155 EXPECT_EQ(MSERR_OK, transcoder_->Release());
156 close(dstFd);
157 close(srcFd);
158 }
159
160 /**
161 * @tc.name: transcoder_PureVideo_003
162 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with codec format H265
163 * @tc.type: FUNC
164 * @tc.require:
165 */
166 HWTEST_F(TransCoderUnitTest, transcoder_PureVideo_003, TestSize.Level2)
167 {
168 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
169 ASSERT_TRUE(srcFd >= 0);
170 int64_t offset = TRANSCODER_FILE_OFFSET;
171 int64_t size = TRANSCODER_FILE_SIZE;
172 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
173 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
174 ASSERT_TRUE(dstFd >= 0);
175 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
176 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
177 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
178 OutputFormatType format = FORMAT_MPEG_4;
179 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
180 VideoCodecFormat encoder = H264;
181 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
182 encoder = H265;
183 }
184 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
185 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
186 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
187 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
188 EXPECT_EQ(MSERR_OK, transcoder_->Start());
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_PureVideo_004
197 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with codec format h265 pause and resume
198 * @tc.type: FUNC
199 * @tc.require:
200 */
201 HWTEST_F(TransCoderUnitTest, transcoder_PureVideo_004, TestSize.Level2)
202 {
203 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.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 + "AVC_Baseline@L1.2_81.0Kbps_320x240_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 VideoCodecFormat encoder = H264;
216 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
217 encoder = H265;
218 }
219 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
220 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
221 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
222 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
223 EXPECT_EQ(MSERR_OK, transcoder_->Start());
224 EXPECT_EQ(MSERR_OK, transcoder_->Pause());
225 EXPECT_EQ(MSERR_OK, transcoder_->Resume());
226 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
227 EXPECT_EQ(MSERR_OK, transcoder_->Release());
228 close(dstFd);
229 close(srcFd);
230 }
231
232 /**
233 * @tc.name: transcoder_AudioVideo_001
234 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with codec format H264
235 * @tc.type: FUNC
236 * @tc.require:
237 */
238 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideo_001, TestSize.Level2)
239 {
240 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
241 ASSERT_TRUE(srcFd >= 0);
242 int64_t offset = TRANSCODER_FILE_OFFSET;
243 int64_t size = TRANSCODER_FILE_SIZE;
244 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
245 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
246 ASSERT_TRUE(dstFd >= 0);
247 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
248 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
249 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
250 OutputFormatType format = FORMAT_MPEG_4;
251 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
252 AudioCodecFormat encoderAudio = AAC_LC;
253 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
254 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
255 VideoCodecFormat encoder = H264;
256 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
257 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
258 int32_t videoWidth = -1;
259 int32_t videoHeight = -1;
260 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
261 videoWidth = TRANSCODER_BUFFER_WIDTH;
262 videoHeight = TRANSCODER_BUFFER_HEIGHT;
263 } else {
264 videoWidth = TRANSCODER_BUFFER_WIDTH_480P;
265 videoHeight = TRANSCODER_BUFFER_HEIGHT_480P;
266 }
267 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
268 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
269 EXPECT_EQ(MSERR_OK, transcoder_->Start());
270 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
271 EXPECT_EQ(MSERR_OK, transcoder_->Release());
272 close(dstFd);
273 close(srcFd);
274 }
275
276 /**
277 * @tc.name: transcoder_SetColorSpace_001
278 * @tc.desc: transcode ChineseColor_H264_AAC_480p_15fps.mp4 with different color space settings
279 * @tc.type: FUNC
280 * @tc.require:
281 */
282 HWTEST_F(TransCoderUnitTest, transcoder_SetColorSpace_001, TestSize.Level2)
283 {
284 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
285 ASSERT_TRUE(srcFd >= 0);
286 int64_t offset = TRANSCODER_FILE_OFFSET;
287 int64_t size = TRANSCODER_FILE_SIZE;
288 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
289 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
290 ASSERT_TRUE(dstFd >= 0);
291 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
292 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
293 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
294 OutputFormatType format = FORMAT_MPEG_4;
295 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
296 TranscoderColorSpace colorSpaceFmt = TRANSCODER_COLORSPACE_BT709_LIMIT;
297 EXPECT_EQ(MSERR_OK, transcoder_->SetColorSpace(colorSpaceFmt));
298 int32_t videoWidth = -1;
299 int32_t videoHeight = -1;
300 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
301 videoWidth = TRANSCODER_BUFFER_WIDTH;
302 videoHeight = TRANSCODER_BUFFER_HEIGHT;
303 } else {
304 videoWidth = TRANSCODER_BUFFER_WIDTH_480P;
305 videoHeight = TRANSCODER_BUFFER_HEIGHT_480P;
306 }
307 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
308
309 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
310 EXPECT_EQ(MSERR_OK, transcoder_->Start());
311 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
312 EXPECT_EQ(MSERR_OK, transcoder_->Release());
313 close(dstFd);
314 close(srcFd);
315 }
316
317 /**
318 * @tc.name: transcoder_SetColorSpace_002
319 * @tc.desc: transcode ChineseColor_H264_AAC_480p_15fps.mp4 with different color space settings
320 * @tc.type: FUNC
321 * @tc.require:
322 */
323 HWTEST_F(TransCoderUnitTest, transcoder_SetColorSpace_002, TestSize.Level2)
324 {
325 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
326 ASSERT_TRUE(srcFd >= 0);
327 int64_t offset = TRANSCODER_FILE_OFFSET;
328 int64_t size = TRANSCODER_FILE_SIZE;
329 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
330 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
331 ASSERT_TRUE(dstFd >= 0);
332 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
333 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
334 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
335 OutputFormatType format = FORMAT_MPEG_4;
336 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
337 TranscoderColorSpace colorSpaceFmt = TRANSCODER_COLORSPACE_P3_FULL;
338 EXPECT_EQ(MSERR_OK, transcoder_->SetColorSpace(colorSpaceFmt));
339 int32_t videoWidth = -1;
340 int32_t videoHeight = -1;
341 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
342 videoWidth = TRANSCODER_BUFFER_WIDTH;
343 videoHeight = TRANSCODER_BUFFER_HEIGHT;
344 } else {
345 videoWidth = TRANSCODER_BUFFER_WIDTH_480P;
346 videoHeight = TRANSCODER_BUFFER_HEIGHT_480P;
347 }
348 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
349
350 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
351 EXPECT_EQ(MSERR_OK, transcoder_->Start());
352 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
353 EXPECT_EQ(MSERR_OK, transcoder_->Release());
354 close(dstFd);
355 close(srcFd);
356 }
357
358 /**
359 * @tc.name: transcoder_SetColorSpace_003
360 * @tc.desc: transcode ChineseColor_H264_AAC_480p_15fps.mp4 with different color space settings
361 * @tc.type: FUNC
362 * @tc.require:
363 */
364 HWTEST_F(TransCoderUnitTest, transcoder_SetColorSpace_003, TestSize.Level2)
365 {
366 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
367 ASSERT_TRUE(srcFd >= 0);
368 int64_t offset = TRANSCODER_FILE_OFFSET;
369 int64_t size = TRANSCODER_FILE_SIZE;
370 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
371 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
372 ASSERT_TRUE(dstFd >= 0);
373 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
374 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
375 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
376 OutputFormatType format = FORMAT_MPEG_4;
377 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
378 TranscoderColorSpace colorSpaceFmt = TRANSCODER_COLORSPACE_BT709_LIMIT;
379 EXPECT_EQ(MSERR_OK, transcoder_->SetColorSpace(colorSpaceFmt));
380 int32_t videoWidth = TRANSCODER_BUFFER_WIDTH_480P;
381 int32_t videoHeight = TRANSCODER_BUFFER_HEIGHT_480P;
382 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
383
384 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
385 EXPECT_EQ(MSERR_OK, transcoder_->Start());
386 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
387 EXPECT_EQ(MSERR_OK, transcoder_->Release());
388 close(dstFd);
389 close(srcFd);
390 }
391
392 /**
393 * @tc.name: transcoder_SetColorSpace_004
394 * @tc.desc: transcode ChineseColor_H264_AAC_480p_15fps.mp4 with different color space settings
395 * @tc.type: FUNC
396 * @tc.require:
397 */
398 HWTEST_F(TransCoderUnitTest, transcoder_SetColorSpace_004, TestSize.Level2)
399 {
400 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
401 ASSERT_TRUE(srcFd >= 0);
402 int64_t offset = TRANSCODER_FILE_OFFSET;
403 int64_t size = TRANSCODER_FILE_SIZE;
404 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
405 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
406 ASSERT_TRUE(dstFd >= 0);
407 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
408 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
409 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
410 OutputFormatType format = FORMAT_MPEG_4;
411 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
412 TranscoderColorSpace colorSpaceFmt = TRANSCODER_COLORSPACE_P3_FULL;
413 EXPECT_EQ(MSERR_OK, transcoder_->SetColorSpace(colorSpaceFmt));
414 int32_t videoWidth = TRANSCODER_BUFFER_WIDTH_480P;
415 int32_t videoHeight = TRANSCODER_BUFFER_HEIGHT_480P;
416 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
417
418 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
419 EXPECT_EQ(MSERR_OK, transcoder_->Start());
420 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
421 EXPECT_EQ(MSERR_OK, transcoder_->Release());
422 close(dstFd);
423 close(srcFd);
424 }
425
426 /**
427 * @tc.name: transcoder_SetColorSpace_010
428 * @tc.desc: transcode ChineseColor_H264_AAC_480p_15fps.mp4 with different color space settings
429 * @tc.type: FUNC
430 * @tc.require:
431 */
432 HWTEST_F(TransCoderUnitTest, transcoder_SetColorSpace_010, TestSize.Level2)
433 {
434 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
435 ASSERT_TRUE(srcFd >= 0);
436 int64_t offset = TRANSCODER_FILE_OFFSET;
437 int64_t size = TRANSCODER_FILE_SIZE;
438 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
439 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
440 ASSERT_TRUE(dstFd >= 0);
441 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
442 OutputFormatType format = FORMAT_MPEG_4;
443 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
444 TranscoderColorSpace colorSpaceFmt = TRANSCODER_COLORSPACE_NONE;
445 EXPECT_EQ(MSERR_INVALID_VAL, transcoder_->SetColorSpace(colorSpaceFmt));
446
447 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
448 EXPECT_EQ(MSERR_OK, transcoder_->Start());
449 EXPECT_EQ(MSERR_OK, transcoder_->Release());
450 close(dstFd);
451 close(srcFd);
452 }
453
454 /**
455 * @tc.name: transcoder_SetColorSpace_011
456 * @tc.desc: transcode ChineseColor_H264_AAC_480p_15fps.mp4 with different color space settings
457 * @tc.type: FUNC
458 * @tc.require:
459 */
460 HWTEST_F(TransCoderUnitTest, transcoder_SetColorSpace_011, TestSize.Level2)
461 {
462 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
463 ASSERT_TRUE(srcFd >= 0);
464 int64_t offset = TRANSCODER_FILE_OFFSET;
465 int64_t size = TRANSCODER_FILE_SIZE;
466 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
467 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
468 ASSERT_TRUE(dstFd >= 0);
469 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
470 OutputFormatType format = FORMAT_MPEG_4;
471 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
472 TranscoderColorSpace colorSpaceFmt = TRANSCODER_COLORSPACE_BT601_EBU_FULL;
473 EXPECT_EQ(MSERR_OK, transcoder_->SetColorSpace(colorSpaceFmt));
474
475 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
476 EXPECT_EQ(MSERR_OK, transcoder_->Start());
477 EXPECT_EQ(MSERR_OK, transcoder_->Release());
478 close(dstFd);
479 close(srcFd);
480 }
481
482 /**
483 * @tc.name: transcoder_SetColorSpace_012
484 * @tc.desc: transcode ChineseColor_H264_AAC_480p_15fps.mp4 with different color space settings
485 * @tc.type: FUNC
486 * @tc.require:
487 */
488 HWTEST_F(TransCoderUnitTest, transcoder_SetColorSpace_012, TestSize.Level2)
489 {
490 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
491 ASSERT_TRUE(srcFd >= 0);
492 int64_t offset = TRANSCODER_FILE_OFFSET;
493 int64_t size = TRANSCODER_FILE_SIZE;
494 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
495 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
496 ASSERT_TRUE(dstFd >= 0);
497 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
498 OutputFormatType format = FORMAT_MPEG_4;
499 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
500 TranscoderColorSpace colorSpaceFmt = TRANSCODER_COLORSPACE_BT601_SMPTE_C_FULL;
501 EXPECT_EQ(MSERR_OK, transcoder_->SetColorSpace(colorSpaceFmt));
502
503 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
504 EXPECT_EQ(MSERR_OK, transcoder_->Start());
505 EXPECT_EQ(MSERR_OK, transcoder_->Release());
506 close(dstFd);
507 close(srcFd);
508 }
509
510 /**
511 * @tc.name: transcoder_SetColorSpace_013
512 * @tc.desc: transcode ChineseColor_H264_AAC_480p_15fps.mp4 with different color space settings
513 * @tc.type: FUNC
514 * @tc.require:
515 */
516 HWTEST_F(TransCoderUnitTest, transcoder_SetColorSpace_013, TestSize.Level2)
517 {
518 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
519 ASSERT_TRUE(srcFd >= 0);
520 int64_t offset = TRANSCODER_FILE_OFFSET;
521 int64_t size = TRANSCODER_FILE_SIZE;
522 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
523 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
524 ASSERT_TRUE(dstFd >= 0);
525 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
526 OutputFormatType format = FORMAT_MPEG_4;
527 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
528 TranscoderColorSpace colorSpaceFmt = TRANSCODER_COLORSPACE_BT709_FULL;
529 EXPECT_EQ(MSERR_OK, transcoder_->SetColorSpace(colorSpaceFmt));
530
531 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
532 EXPECT_EQ(MSERR_OK, transcoder_->Start());
533 EXPECT_EQ(MSERR_OK, transcoder_->Release());
534 close(dstFd);
535 close(srcFd);
536 }
537
538 /**
539 * @tc.name: transcoder_SetColorSpace_014
540 * @tc.desc: transcode ChineseColor_H264_AAC_480p_15fps.mp4 with different color space settings
541 * @tc.type: FUNC
542 * @tc.require:
543 */
544 HWTEST_F(TransCoderUnitTest, transcoder_SetColorSpace_014, TestSize.Level2)
545 {
546 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
547 ASSERT_TRUE(srcFd >= 0);
548 int64_t offset = TRANSCODER_FILE_OFFSET;
549 int64_t size = TRANSCODER_FILE_SIZE;
550 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
551 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
552 ASSERT_TRUE(dstFd >= 0);
553 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
554 OutputFormatType format = FORMAT_MPEG_4;
555 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
556 TranscoderColorSpace colorSpaceFmt = TRANSCODER_COLORSPACE_P3_LIMIT;
557 EXPECT_EQ(MSERR_OK, transcoder_->SetColorSpace(colorSpaceFmt));
558
559 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
560 EXPECT_EQ(MSERR_OK, transcoder_->Start());
561 EXPECT_EQ(MSERR_OK, transcoder_->Release());
562 close(dstFd);
563 close(srcFd);
564 }
565
566 /**
567 * @tc.name: transcoder_AudioVideo_002
568 * @tc.desc: transcoder audio and video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with codec format h264 pause and resume
569 * @tc.type: FUNC
570 * @tc.require:
571 */
572 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideo_002, TestSize.Level2)
573 {
574 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
575 ASSERT_TRUE(srcFd >= 0);
576 int64_t offset = TRANSCODER_FILE_OFFSET;
577 int64_t size = TRANSCODER_FILE_SIZE;
578 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
579 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
580 ASSERT_TRUE(dstFd >= 0);
581 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
582 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
583 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
584 OutputFormatType format = FORMAT_MPEG_4;
585 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
586 AudioCodecFormat encoderAudio = AAC_LC;
587 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
588 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
589 VideoCodecFormat encoder = H264;
590 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
591 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
592 int32_t videoWidth = -1;
593 int32_t videoHeight = -1;
594 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
595 videoWidth = TRANSCODER_BUFFER_WIDTH;
596 videoHeight = TRANSCODER_BUFFER_HEIGHT;
597 } else {
598 videoWidth = TRANSCODER_BUFFER_WIDTH_480P;
599 videoHeight = TRANSCODER_BUFFER_HEIGHT_480P;
600 }
601 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
602 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
603 EXPECT_EQ(MSERR_OK, transcoder_->Start());
604 EXPECT_EQ(MSERR_OK, transcoder_->Pause());
605 EXPECT_EQ(MSERR_OK, transcoder_->Resume());
606 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
607 EXPECT_EQ(MSERR_OK, transcoder_->Release());
608 close(dstFd);
609 close(srcFd);
610 }
611
612 /**
613 * @tc.name: transcoder_AudioVideo_003
614 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with codec format H265
615 * @tc.type: FUNC
616 * @tc.require:
617 */
618 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideo_003, TestSize.Level2)
619 {
620 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
621 ASSERT_TRUE(srcFd >= 0);
622 int64_t offset = TRANSCODER_FILE_OFFSET;
623 int64_t size = TRANSCODER_FILE_SIZE;
624 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
625 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
626 ASSERT_TRUE(dstFd >= 0);
627 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
628 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
629 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
630 OutputFormatType format = FORMAT_MPEG_4;
631 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
632 AudioCodecFormat encoderAudio = AAC_LC;
633 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
634 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
635 VideoCodecFormat encoder = H264;
636 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
637 encoder = H265;
638 }
639 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
640 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
641 int32_t videoWidth = -1;
642 int32_t videoHeight = -1;
643 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
644 videoWidth = TRANSCODER_BUFFER_WIDTH;
645 videoHeight = TRANSCODER_BUFFER_HEIGHT;
646 } else {
647 videoWidth = TRANSCODER_BUFFER_WIDTH_480P;
648 videoHeight = TRANSCODER_BUFFER_HEIGHT_480P;
649 }
650 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
651 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
652 EXPECT_EQ(MSERR_OK, transcoder_->Start());
653 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
654 EXPECT_EQ(MSERR_OK, transcoder_->Release());
655 close(dstFd);
656 close(srcFd);
657 }
658
659 /**
660 * @tc.name: transcoder_AudioVideo_004
661 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with codec format h265 pause and resume
662 * @tc.type: FUNC
663 * @tc.require:
664 */
665 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideo_004, TestSize.Level2)
666 {
667 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
668 ASSERT_TRUE(srcFd >= 0);
669 int64_t offset = TRANSCODER_FILE_OFFSET;
670 int64_t size = TRANSCODER_FILE_SIZE;
671 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
672 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
673 ASSERT_TRUE(dstFd >= 0);
674 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
675 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
676 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
677 OutputFormatType format = FORMAT_MPEG_4;
678 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
679 AudioCodecFormat encoderAudio = AAC_LC;
680 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
681 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
682 VideoCodecFormat encoder = H264;
683 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
684 encoder = H265;
685 }
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_OK, transcoder_->Prepare());
699 EXPECT_EQ(MSERR_OK, transcoder_->Start());
700 EXPECT_EQ(MSERR_OK, transcoder_->Pause());
701 EXPECT_EQ(MSERR_OK, transcoder_->Resume());
702 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
703 EXPECT_EQ(MSERR_OK, transcoder_->Release());
704 close(dstFd);
705 close(srcFd);
706 }
707
708 /**
709 * @tc.name: transcoder_PureAudioAbnormal_case_001
710 * @tc.desc: transcoder pure audio 01.mp3 with cancle before prepare
711 * @tc.type: FUNC
712 * @tc.require:
713 */
714 HWTEST_F(TransCoderUnitTest, transcoder_PureAudioAbnormal_case_001, TestSize.Level2)
715 {
716 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
717 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
718 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "01.mp3").c_str(), O_RDWR);
719 ASSERT_TRUE(srcFd >= 0);
720 int64_t offset = TRANSCODER_FILE_OFFSET;
721 int64_t size = TRANSCODER_FILE_SIZE;
722 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
723 int32_t dstFd = open((TRANSCODER_ROOT_DST + "01_dst.mp3").c_str(), O_RDWR);
724 ASSERT_TRUE(dstFd >= 0);
725 EXPECT_TRUE(cb->CheckStateChange());
726 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->SetOutputFile(dstFd));
727 OutputFormatType format = FORMAT_M4A;
728 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->SetOutputFormat(format));
729 AudioCodecFormat encoder = AAC_LC;
730 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->SetAudioEncoder(encoder));
731 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
732 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Cancel());
733 EXPECT_EQ(MSERR_OK, transcoder_->Release());
734 close(dstFd);
735 close(srcFd);
736 }
737
738 /**
739 * @tc.name: transcoder_PureAudioAbnormal_case_002
740 * @tc.desc: transcoder pure audio 01.mp3 with pause before prepare
741 * @tc.type: FUNC
742 * @tc.require:
743 */
744 HWTEST_F(TransCoderUnitTest, transcoder_PureAudioAbnormal_case_002, TestSize.Level2)
745 {
746 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
747 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
748 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "01.mp3").c_str(), O_RDWR);
749 ASSERT_TRUE(srcFd >= 0);
750 int64_t offset = TRANSCODER_FILE_OFFSET;
751 int64_t size = TRANSCODER_FILE_SIZE;
752 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
753 int32_t dstFd = open((TRANSCODER_ROOT_DST + "01_dst.mp3").c_str(), O_RDWR);
754 ASSERT_TRUE(dstFd >= 0);
755 EXPECT_TRUE(cb->CheckStateChange());
756 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->SetOutputFile(dstFd));
757 OutputFormatType format = FORMAT_M4A;
758 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->SetOutputFormat(format));
759 AudioCodecFormat encoder = AAC_LC;
760 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->SetAudioEncoder(encoder));
761 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
762 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Pause());
763 EXPECT_EQ(MSERR_OK, transcoder_->Release());
764 close(dstFd);
765 close(srcFd);
766 }
767
768 /**
769 * @tc.name: transcoder_PureAudioAbnormal_case_003
770 * @tc.desc: transcoder pure audio 01.mp3 with resume before prepare
771 * @tc.type: FUNC
772 * @tc.require:
773 */
774 HWTEST_F(TransCoderUnitTest, transcoder_PureAudioAbnormal_case_003, TestSize.Level2)
775 {
776 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
777 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
778 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "01.mp3").c_str(), O_RDWR);
779 ASSERT_TRUE(srcFd >= 0);
780 int64_t offset = TRANSCODER_FILE_OFFSET;
781 int64_t size = TRANSCODER_FILE_SIZE;
782 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
783 int32_t dstFd = open((TRANSCODER_ROOT_DST + "01_dst.mp3").c_str(), O_RDWR);
784 ASSERT_TRUE(dstFd >= 0);
785 EXPECT_TRUE(cb->CheckStateChange());
786 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->SetOutputFile(dstFd));
787 OutputFormatType format = FORMAT_M4A;
788 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->SetOutputFormat(format));
789 AudioCodecFormat encoder = AAC_LC;
790 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->SetAudioEncoder(encoder));
791 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
792 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Resume());
793 EXPECT_EQ(MSERR_OK, transcoder_->Release());
794 close(dstFd);
795 close(srcFd);
796 }
797
798 /**
799 * @tc.name: transcoder_PureVideoAbnormal_case_001
800 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with cancel before prepare
801 * @tc.type: FUNC
802 * @tc.require:
803 */
804 HWTEST_F(TransCoderUnitTest, transcoder_PureVideoAbnormal_case_001, TestSize.Level2)
805 {
806 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
807 ASSERT_TRUE(srcFd >= 0);
808 int64_t offset = TRANSCODER_FILE_OFFSET;
809 int64_t size = TRANSCODER_FILE_SIZE;
810 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
811 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
812 ASSERT_TRUE(dstFd >= 0);
813 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
814 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
815 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
816 OutputFormatType format = FORMAT_MPEG_4;
817 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
818 VideoCodecFormat encoder = H264;
819 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
820 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
821 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
822 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
823 EXPECT_EQ(MSERR_OK, transcoder_->Release());
824 close(dstFd);
825 close(srcFd);
826 }
827
828 /**
829 * @tc.name: transcoder_PureVideoAbnormal_case_002
830 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with cancel before prepare
831 * @tc.type: FUNC
832 * @tc.require:
833 */
834 HWTEST_F(TransCoderUnitTest, transcoder_PureVideoAbnormal_case_002, TestSize.Level2)
835 {
836 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
837 ASSERT_TRUE(srcFd >= 0);
838 int64_t offset = TRANSCODER_FILE_OFFSET;
839 int64_t size = TRANSCODER_FILE_SIZE;
840 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
841 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
842 ASSERT_TRUE(dstFd >= 0);
843 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
844 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
845 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
846 OutputFormatType format = FORMAT_MPEG_4;
847 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
848 VideoCodecFormat encoder = H264;
849 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
850 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
851 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
852 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Pause());
853 EXPECT_EQ(MSERR_OK, transcoder_->Release());
854 close(dstFd);
855 close(srcFd);
856 }
857
858 /**
859 * @tc.name: transcoder_PureVideoAbnormal_case_003
860 * @tc.desc: transcoder pure video AVC_Baseline@L1.2_81.0Kbps_320x240.mp4 with cancel before prepare
861 * @tc.type: FUNC
862 * @tc.require:
863 */
864 HWTEST_F(TransCoderUnitTest, transcoder_PureVideoAbnormal_case_003, TestSize.Level2)
865 {
866 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "AVC_Baseline@L1.2_81.0Kbps_320x240.mp4").c_str(), O_RDWR);
867 ASSERT_TRUE(srcFd >= 0);
868 int64_t offset = TRANSCODER_FILE_OFFSET;
869 int64_t size = TRANSCODER_FILE_SIZE;
870 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
871 int32_t dstFd = open((TRANSCODER_ROOT_DST + "AVC_Baseline@L1.2_81.0Kbps_320x240_dst.mp4").c_str(), O_RDWR);
872 ASSERT_TRUE(dstFd >= 0);
873 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
874 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
875 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
876 OutputFormatType format = FORMAT_MPEG_4;
877 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
878 VideoCodecFormat encoder = H264;
879 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
880 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
881 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(TRANSCODER_BUFFER_WIDTH, TRANSCODER_BUFFER_HEIGHT));
882 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Resume());
883 EXPECT_EQ(MSERR_OK, transcoder_->Release());
884 close(dstFd);
885 close(srcFd);
886 }
887
888 /**
889 * @tc.name: transcoder_AudioVideoAbnormal_case_001
890 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with cancel before prepare
891 * @tc.type: FUNC
892 * @tc.require:
893 */
894 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideoAbnormal_case_001, TestSize.Level2)
895 {
896 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
897 ASSERT_TRUE(srcFd >= 0);
898 int64_t offset = TRANSCODER_FILE_OFFSET;
899 int64_t size = TRANSCODER_FILE_SIZE;
900 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
901 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
902 ASSERT_TRUE(dstFd >= 0);
903 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
904 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
905 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
906 OutputFormatType format = FORMAT_MPEG_4;
907 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
908 AudioCodecFormat encoderAudio = AAC_LC;
909 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
910 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
911 VideoCodecFormat encoder = H264;
912 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
913 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
914 int32_t videoWidth = -1;
915 int32_t videoHeight = -1;
916 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
917 videoWidth = TRANSCODER_BUFFER_WIDTH;
918 videoHeight = TRANSCODER_BUFFER_HEIGHT;
919 } else {
920 videoWidth = TRANSCODER_BUFFER_WIDTH_480P;
921 videoHeight = TRANSCODER_BUFFER_HEIGHT_480P;
922 }
923 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
924 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
925 EXPECT_EQ(MSERR_OK, transcoder_->Release());
926 close(dstFd);
927 close(srcFd);
928 }
929
930 /**
931 * @tc.name: transcoder_AudioVideoAbnormal_case_002
932 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with cancel before prepare
933 * @tc.type: FUNC
934 * @tc.require:
935 */
936 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideoAbnormal_case_002, TestSize.Level2)
937 {
938 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
939 ASSERT_TRUE(srcFd >= 0);
940 int64_t offset = TRANSCODER_FILE_OFFSET;
941 int64_t size = TRANSCODER_FILE_SIZE;
942 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
943 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
944 ASSERT_TRUE(dstFd >= 0);
945 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
946 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
947 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
948 OutputFormatType format = FORMAT_MPEG_4;
949 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
950 AudioCodecFormat encoderAudio = AAC_LC;
951 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
952 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
953 VideoCodecFormat encoder = H264;
954 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
955 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
956 int32_t videoWidth = -1;
957 int32_t videoHeight = -1;
958 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
959 videoWidth = TRANSCODER_BUFFER_WIDTH;
960 videoHeight = TRANSCODER_BUFFER_HEIGHT;
961 } else {
962 videoWidth = TRANSCODER_BUFFER_WIDTH_480P;
963 videoHeight = TRANSCODER_BUFFER_HEIGHT_480P;
964 }
965 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
966 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Pause());
967 EXPECT_EQ(MSERR_OK, transcoder_->Release());
968 close(dstFd);
969 close(srcFd);
970 }
971
972 /**
973 * @tc.name: transcoder_AudioVideoAbnormal_case_003
974 * @tc.desc: transcoder audio and video ChineseColor_H264_AAC_480p_15fps.mp4 with cancel before prepare
975 * @tc.type: FUNC
976 * @tc.require:
977 */
978 HWTEST_F(TransCoderUnitTest, transcoder_AudioVideoAbnormal_case_003, TestSize.Level2)
979 {
980 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
981 ASSERT_TRUE(srcFd >= 0);
982 int64_t offset = TRANSCODER_FILE_OFFSET;
983 int64_t size = TRANSCODER_FILE_SIZE;
984 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
985 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
986 ASSERT_TRUE(dstFd >= 0);
987 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
988 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
989 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
990 OutputFormatType format = FORMAT_MPEG_4;
991 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
992 AudioCodecFormat encoderAudio = AAC_LC;
993 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
994 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
995 VideoCodecFormat encoder = H264;
996 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
997 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
998 int32_t videoWidth = -1;
999 int32_t videoHeight = -1;
1000 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
1001 videoWidth = TRANSCODER_BUFFER_WIDTH;
1002 videoHeight = TRANSCODER_BUFFER_HEIGHT;
1003 } else {
1004 videoWidth = TRANSCODER_BUFFER_WIDTH_480P;
1005 videoHeight = TRANSCODER_BUFFER_HEIGHT_480P;
1006 }
1007 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
1008 EXPECT_EQ(MSERR_INVALID_OPERATION, transcoder_->Resume());
1009 EXPECT_EQ(MSERR_OK, transcoder_->Release());
1010 close(dstFd);
1011 close(srcFd);
1012 }
1013
1014 /**
1015 * @tc.name: transcoder_SetEnableBFrame_001
1016 * @tc.desc: transcode ChineseColor_H264_AAC_480p_15fps.mp4 with enable b frame encoding settings
1017 * @tc.type: FUNC
1018 * @tc.require:
1019 */
1020 HWTEST_F(TransCoderUnitTest, transcoder_SetEnableBFrame_001, TestSize.Level2)
1021 {
1022 int32_t srcFd = open((TRANSCODER_ROOT_SRC + "ChineseColor_H264_AAC_480p_15fps.mp4").c_str(), O_RDWR);
1023 ASSERT_TRUE(srcFd >= 0);
1024 int64_t offset = TRANSCODER_FILE_OFFSET;
1025 int64_t size = TRANSCODER_FILE_SIZE;
1026 EXPECT_EQ(MSERR_OK, transcoder_->SetInputFile(srcFd, offset, size));
1027 int32_t dstFd = open((TRANSCODER_ROOT_DST + "ChineseColor_H264_AAC_480p_15fps_dst.mp4").c_str(), O_RDWR);
1028 ASSERT_TRUE(dstFd >= 0);
1029 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFile(dstFd));
1030 std::shared_ptr<TransCoderCallbackTest> cb = std::make_shared<TransCoderCallbackTest>();
1031 EXPECT_EQ(MSERR_OK, transcoder_->SetTransCoderCallback(cb));
1032 OutputFormatType format = FORMAT_MPEG_4;
1033 EXPECT_EQ(MSERR_OK, transcoder_->SetOutputFormat(format));
1034 AudioCodecFormat encoderAudio = AAC_LC;
1035 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncoder(encoderAudio));
1036 EXPECT_EQ(MSERR_OK, transcoder_->SetAudioEncodingBitRate(TRASCODER_AUDIO_ENCODING_BIT_RATE));
1037 VideoCodecFormat encoder = H264;
1038 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncoder(encoder));
1039 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoEncodingBitRate(TRASCODER_VIDEO_ENCODING_BIT_RATE));
1040 bool enableBFrame = true;
1041 EXPECT_EQ(MSERR_OK, transcoder_->SetEnableBFrame(enableBFrame));
1042 int32_t videoWidth = -1;
1043 int32_t videoHeight = -1;
1044 if (access(VPE_LIB_PATH.c_str(), F_OK) == 0) {
1045 videoWidth = TRANSCODER_BUFFER_WIDTH;
1046 videoHeight = TRANSCODER_BUFFER_HEIGHT;
1047 } else {
1048 videoWidth = TRANSCODER_BUFFER_WIDTH_480P;
1049 videoHeight = TRANSCODER_BUFFER_HEIGHT_480P;
1050 }
1051 EXPECT_EQ(MSERR_OK, transcoder_->SetVideoSize(videoWidth, videoHeight));
1052 EXPECT_EQ(MSERR_OK, transcoder_->Prepare());
1053 EXPECT_EQ(MSERR_OK, transcoder_->Start());
1054 EXPECT_EQ(MSERR_OK, transcoder_->Cancel());
1055 EXPECT_EQ(MSERR_OK, transcoder_->Release());
1056 close(dstFd);
1057 close(srcFd);
1058 }
1059 } // namespace Media
1060 } // namespace OHOS