1 /*
2 * Copyright (C) 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 "avmuxer_wav_pcm_unit_test.h"
17 #include <gtest/gtest.h>
18 #include <string>
19 #include <vector>
20 #include <fcntl.h>
21 #include "avmuxer.h"
22 #include "native_avbuffer.h"
23 #include "avcodec_audio_channel_layout.h"
24 #ifdef AVMUXER_UNITTEST_CAPI
25 #include "native_avmuxer.h"
26 #include "native_avformat.h"
27 #endif
28
29 using namespace testing::ext;
30 using namespace OHOS::MediaAVCodec;
31 using namespace OHOS::Media;
32 namespace {
33 const std::string TEST_FILE_PATH = "/data/test/media/";
34 constexpr int32_t TEST_CHANNEL_COUNT = 2;
35 constexpr int32_t TEST_SAMPLE_RATE = 44100;
36 constexpr int32_t TEST_BIT_RATE = 1411200;
37 constexpr int32_t TEST_SAMPLE_PER_FRAME = 1024;
38 } // namespace
39
SetUpTestCase()40 void AVMuxerWavPcmUnitTest::SetUpTestCase()
41 {}
42
TearDownTestCase()43 void AVMuxerWavPcmUnitTest::TearDownTestCase()
44 {}
45
SetUp()46 void AVMuxerWavPcmUnitTest::SetUp()
47 {
48 avmuxer_ = std::make_shared<AVMuxerSample>();
49 }
50
TearDown()51 void AVMuxerWavPcmUnitTest::TearDown()
52 {
53 if (fd_ >= 0) {
54 close(fd_);
55 fd_ = -1;
56 }
57
58 if (inputFile_ != nullptr) {
59 if (inputFile_->is_open()) {
60 inputFile_->close();
61 }
62 }
63
64 if (avmuxer_ != nullptr) {
65 avmuxer_->Destroy();
66 avmuxer_ = nullptr;
67 }
68 }
69
WritePcmSampleWithMetadata(std::shared_ptr<std::ofstream> file,const uint8_t * pcmData,uint32_t pcmSize,int64_t pts,uint32_t flags)70 static int32_t WritePcmSampleWithMetadata(std::shared_ptr<std::ofstream> file, const uint8_t *pcmData,
71 uint32_t pcmSize, int64_t pts, uint32_t flags)
72 {
73 file->write(reinterpret_cast<const char *>(&pts), sizeof(pts));
74 file->write(reinterpret_cast<const char *>(&flags), sizeof(flags));
75 file->write(reinterpret_cast<const char *>(&pcmSize), sizeof(pcmSize));
76 file->write(reinterpret_cast<const char *>(pcmData), pcmSize);
77
78 if (file->fail()) {
79 return 0;
80 }
81
82 return 0;
83 }
84
ProcessPcmFile(std::shared_ptr<std::ifstream> pcmFile,const std::string & outputFileName,int32_t trackId,uint32_t extraFlag=0)85 static int32_t ProcessPcmFile(
86 std::shared_ptr<std::ifstream> pcmFile, const std::string &outputFileName, int32_t trackId, uint32_t extraFlag = 0)
87 {
88 if (!pcmFile->is_open()) {
89 return 0;
90 }
91 pcmFile->seekg(0, std::ios::end);
92 size_t pcmSize = pcmFile->tellg();
93 pcmFile->seekg(0, std::ios::beg);
94
95 if (pcmSize == 0) {
96 return 0;
97 }
98 std::vector<uint8_t> pcmData(pcmSize);
99 pcmFile->read(reinterpret_cast<char *>(pcmData.data()), pcmSize);
100 pcmFile->close();
101
102 if (pcmFile->gcount() != static_cast<std::streamsize>(pcmSize)) {
103 return 0;
104 }
105
106 std::shared_ptr<std::ofstream> outFile = std::make_shared<std::ofstream>(outputFileName, std::ios::binary);
107 if (!outFile->is_open()) {
108 return 0;
109 }
110
111 int64_t pts = 0;
112 uint32_t flags = AVCODEC_BUFFER_FLAGS_NONE;
113 int32_t ret = WritePcmSampleWithMetadata(outFile, pcmData.data(), pcmSize, pts, flags);
114 if (ret != 0) {
115 outFile->close();
116 return ret;
117 }
118 outFile->close();
119 return 0;
120 }
121
WriteSample(int32_t trackId,std::shared_ptr<std::ifstream> file,bool & eosFlag,uint32_t flag)122 int32_t AVMuxerWavPcmUnitTest::WriteSample(
123 int32_t trackId, std::shared_ptr<std::ifstream> file, bool &eosFlag, uint32_t flag)
124 {
125 OH_AVCodecBufferAttr info;
126
127 if (file->eof()) {
128 eosFlag = true;
129 return 0;
130 }
131 file->read(reinterpret_cast<char *>(&info.pts), sizeof(info.pts));
132
133 if (file->eof()) {
134 eosFlag = true;
135 return 0;
136 }
137 file->read(reinterpret_cast<char *>(&info.flags), sizeof(info.flags));
138
139 if (file->eof()) {
140 eosFlag = true;
141 return 0;
142 }
143 file->read(reinterpret_cast<char *>(&info.size), sizeof(info.size));
144
145 if (file->eof()) {
146 eosFlag = true;
147 return 0;
148 }
149
150 if (info.flags & AVCODEC_BUFFER_FLAGS_SYNC_FRAME) {
151 info.flags |= flag;
152 }
153
154 OH_AVBuffer *buffer = OH_AVBuffer_Create(info.size);
155 file->read(reinterpret_cast<char *>(OH_AVBuffer_GetAddr(buffer)), info.size);
156 OH_AVBuffer_SetBufferAttr(buffer, &info);
157 int32_t ret = avmuxer_->WriteSampleBuffer(trackId, buffer);
158 OH_AVBuffer_Destroy(buffer);
159 return ret;
160 }
161
162 namespace {
163 /**
164 * @tc.name: Muxer_WAV_PCM_U8
165 * @tc.desc: supported bitwidth SAMPLE_U8
166 * @tc.type: FUNC
167 */
168 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_U8, TestSize.Level0)
169 {
170 int32_t trackId = -1;
171 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_2_U8.wav");
172 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
173
174 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
175 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
176 ASSERT_TRUE(isCreated);
177
178 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
179 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
180 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
181 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, TEST_CHANNEL_COUNT);
182 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_U8);
183 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
184 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
185 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
186 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
187 ASSERT_EQ(ret, 0);
188 ASSERT_GE(trackId, 0);
189 ASSERT_EQ(avmuxer_->Start(), 0);
190
191 std::shared_ptr<std::ifstream> inputFile =
192 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_2_u8.pcm", std::ios::binary);
193 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_2_u8.dat");
194
195 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
196 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
197 ASSERT_EQ(ret, 0);
198
199 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
200
201 bool eosFlag = false;
202
203 ret = WriteSample(trackId, datFile, eosFlag, flag);
204 while (!eosFlag && (ret == 0)) {
205 ret = WriteSample(trackId, datFile, eosFlag, flag);
206 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
207 }
208 ASSERT_EQ(avmuxer_->Stop(), 0);
209
210 datFile->close();
211 close(fd_);
212 }
213
214 /**
215 * @tc.name: Muxer_WAV_PCM_S16LE
216 * @tc.desc: supported bitwidth SAMPLE_S16LE
217 * @tc.type: FUNC
218 */
219 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_S16LE, TestSize.Level0)
220 {
221 int32_t trackId = -1;
222 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_2_S16LE.wav");
223 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
224
225 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
226 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
227 ASSERT_TRUE(isCreated);
228
229 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
230 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
231 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
232 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, TEST_CHANNEL_COUNT);
233 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
234 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
235 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
236 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
237 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
238 ASSERT_EQ(ret, 0);
239 ASSERT_GE(trackId, 0);
240 ASSERT_EQ(avmuxer_->Start(), 0);
241
242 std::shared_ptr<std::ifstream> inputFile =
243 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_2_s16le.pcm", std::ios::binary);
244 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_2_s16le.dat");
245
246 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
247 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
248 ASSERT_EQ(ret, 0);
249
250 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
251
252 bool eosFlag = false;
253
254 ret = WriteSample(trackId, datFile, eosFlag, flag);
255 while (!eosFlag && (ret == 0)) {
256 ret = WriteSample(trackId, datFile, eosFlag, flag);
257 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
258 }
259 ASSERT_EQ(avmuxer_->Stop(), 0);
260
261 datFile->close();
262 close(fd_);
263 }
264
265 /**
266 * @tc.name: Muxer_WAV_PCM_S24LE
267 * @tc.desc: supported bitwidth SAMPLE_S24LE
268 * @tc.type: FUNC
269 */
270 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_S24LE, TestSize.Level0)
271 {
272 int32_t trackId = -1;
273 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_2_S24LE.wav");
274 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
275
276 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
277 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
278 ASSERT_TRUE(isCreated);
279
280 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
281 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
282 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
283 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, TEST_CHANNEL_COUNT);
284 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S24LE);
285 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
286 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
287 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
288 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
289 ASSERT_EQ(ret, 0);
290 ASSERT_GE(trackId, 0);
291 ASSERT_EQ(avmuxer_->Start(), 0);
292
293 std::shared_ptr<std::ifstream> inputFile =
294 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_2_s24le.pcm", std::ios::binary);
295 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_2_s24le.dat");
296
297 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
298 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
299 ASSERT_EQ(ret, 0);
300
301 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
302
303 bool eosFlag = false;
304
305 ret = WriteSample(trackId, datFile, eosFlag, flag);
306 while (!eosFlag && (ret == 0)) {
307 ret = WriteSample(trackId, datFile, eosFlag, flag);
308 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
309 }
310 ASSERT_EQ(avmuxer_->Stop(), 0);
311
312 datFile->close();
313 close(fd_);
314 }
315
316 /**
317 * @tc.name: Muxer_WAV_PCM_S32LE
318 * @tc.desc: supported bitwidth SAMPLE_S32LE
319 * @tc.type: FUNC
320 */
321 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_S32LE, TestSize.Level0)
322 {
323 int32_t trackId = -1;
324 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_2_S32LE.wav");
325 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
326
327 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
328 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
329 ASSERT_TRUE(isCreated);
330
331 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
332 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
333 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
334 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, TEST_CHANNEL_COUNT);
335 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S32LE);
336 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
337 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
338 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
339 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
340 ASSERT_EQ(ret, 0);
341 ASSERT_GE(trackId, 0);
342 ASSERT_EQ(avmuxer_->Start(), 0);
343
344 std::shared_ptr<std::ifstream> inputFile =
345 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_2_s32le.pcm", std::ios::binary);
346 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_2_s32le.dat");
347
348 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
349 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
350 ASSERT_EQ(ret, 0);
351
352 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
353
354 bool eosFlag = false;
355
356 ret = WriteSample(trackId, datFile, eosFlag, flag);
357 while (!eosFlag && (ret == 0)) {
358 ret = WriteSample(trackId, datFile, eosFlag, flag);
359 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
360 }
361 ASSERT_EQ(avmuxer_->Stop(), 0);
362
363 datFile->close();
364 close(fd_);
365 }
366
367 /**
368 * @tc.name: Muxer_WAV_PCM_F32LE
369 * @tc.desc: supported bitwidth SAMPLE_F32LE
370 * @tc.type: FUNC
371 */
372 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_F32LE, TestSize.Level0)
373 {
374 int32_t trackId = -1;
375 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_2_F32LE.wav");
376 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
377
378 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
379 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
380 ASSERT_TRUE(isCreated);
381
382 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
383 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
384 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
385 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, TEST_CHANNEL_COUNT);
386 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_F32LE);
387 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
388 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
389 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
390 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
391 ASSERT_EQ(ret, 0);
392 ASSERT_GE(trackId, 0);
393 ASSERT_EQ(avmuxer_->Start(), 0);
394
395 std::shared_ptr<std::ifstream> inputFile =
396 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_2_f32le.pcm", std::ios::binary);
397 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_2_f32le.dat");
398
399 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
400 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
401 ASSERT_EQ(ret, 0);
402
403 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
404
405 bool eosFlag = false;
406
407 ret = WriteSample(trackId, datFile, eosFlag, flag);
408 while (!eosFlag && (ret == 0)) {
409 ret = WriteSample(trackId, datFile, eosFlag, flag);
410 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
411 }
412 ASSERT_EQ(avmuxer_->Stop(), 0);
413
414 datFile->close();
415 close(fd_);
416 }
417
418 /**
419 * @tc.name: Muxer_WAV_PCM_SAMPLE_S16P
420 * @tc.desc: unsupported bitwidth SAMPLE_S16P
421 * @tc.type: FUNC
422 */
423 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_SAMPLE_S16P, TestSize.Level0)
424 {
425 int32_t trackId = -1;
426 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_2_S16P.wav");
427 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
428
429 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
430 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
431 ASSERT_TRUE(isCreated);
432
433 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
434 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
435 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
436 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, TEST_CHANNEL_COUNT);
437 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16P);
438 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
439 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
440 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
441 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
442 ASSERT_NE(ret, 0); // unsupported sample format
443 }
444
445
446 /**
447 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_MONO
448 * @tc.desc: channel layout mono
449 * @tc.type: FUNC
450 */
451 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_MONO, TestSize.Level0)
452 {
453 int32_t trackId = -1;
454 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_MONO_S16LE.wav");
455 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
456
457 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
458 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
459 ASSERT_TRUE(isCreated);
460
461 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
462 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
463 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
464 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 1);
465 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
466 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
467 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
468 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, MONO);
469 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
470 ASSERT_EQ(ret, 0);
471 ASSERT_GE(trackId, 0);
472 ASSERT_EQ(avmuxer_->Start(), 0);
473
474 std::shared_ptr<std::ifstream> inputFile =
475 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_mono_s16le.pcm", std::ios::binary);
476 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_mono_s16le.dat");
477
478 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
479 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
480 ASSERT_EQ(ret, 0);
481
482 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
483
484 bool eosFlag = false;
485
486 ret = WriteSample(trackId, datFile, eosFlag, flag);
487 while (!eosFlag && (ret == 0)) {
488 ret = WriteSample(trackId, datFile, eosFlag, flag);
489 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
490 }
491 ASSERT_EQ(avmuxer_->Stop(), 0);
492
493 datFile->close();
494 close(fd_);
495 }
496
497 /**
498 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_2POINT1
499 * @tc.desc: channel layout 2point1
500 * @tc.type: FUNC
501 */
502 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_2POINT1, TestSize.Level0)
503 {
504 int32_t trackId = -1;
505 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_CH_2POINT1_S16LE.wav");
506 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
507
508 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
509 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
510 ASSERT_TRUE(isCreated);
511
512 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
513 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
514 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
515 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 3); // 3 channels
516 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
517 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
518 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
519 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_2POINT1);
520 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
521 ASSERT_EQ(ret, 0);
522 ASSERT_GE(trackId, 0);
523 ASSERT_EQ(avmuxer_->Start(), 0);
524
525 std::shared_ptr<std::ifstream> inputFile =
526 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_2point1_s16le.pcm", std::ios::binary);
527 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_2point1_s16le.dat");
528
529 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
530 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
531 ASSERT_EQ(ret, 0);
532
533 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
534
535 bool eosFlag = false;
536
537 ret = WriteSample(trackId, datFile, eosFlag, flag);
538 while (!eosFlag && (ret == 0)) {
539 ret = WriteSample(trackId, datFile, eosFlag, flag);
540 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
541 }
542 ASSERT_EQ(avmuxer_->Stop(), 0);
543
544 datFile->close();
545 close(fd_);
546 }
547
548 /**
549 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_2_1
550 * @tc.desc: channel layout 2_1
551 * @tc.type: FUNC
552 */
553 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_2_1, TestSize.Level0)
554 {
555 int32_t trackId = -1;
556 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_2_1_S16LE.wav");
557 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
558
559 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
560 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
561 ASSERT_TRUE(isCreated);
562
563 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
564 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
565 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
566 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 3); // 3 channels
567 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
568 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
569 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
570 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_2_1);
571 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
572 ASSERT_EQ(ret, 0);
573 ASSERT_GE(trackId, 0);
574 ASSERT_EQ(avmuxer_->Start(), 0);
575
576 std::shared_ptr<std::ifstream> inputFile =
577 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_2_1_s16le.pcm", std::ios::binary);
578 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_2_1_s16le.dat");
579
580 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
581 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
582 ASSERT_EQ(ret, 0);
583
584 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
585
586 bool eosFlag = false;
587
588 ret = WriteSample(trackId, datFile, eosFlag, flag);
589 while (!eosFlag && (ret == 0)) {
590 ret = WriteSample(trackId, datFile, eosFlag, flag);
591 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
592 }
593 ASSERT_EQ(avmuxer_->Stop(), 0);
594
595 datFile->close();
596 close(fd_);
597 }
598
599 /**
600 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_SURROUND
601 * @tc.desc: channel layout surround
602 * @tc.type: FUNC
603 */
604 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_SURROUND, TestSize.Level0)
605 {
606 int32_t trackId = -1;
607 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_SURROUND_S16LE.wav");
608 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
609
610 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
611 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
612 ASSERT_TRUE(isCreated);
613
614 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
615 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
616 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
617 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 3); // 3 channels
618 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
619 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
620 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
621 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, SURROUND);
622 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
623 ASSERT_EQ(ret, 0);
624 ASSERT_GE(trackId, 0);
625 ASSERT_EQ(avmuxer_->Start(), 0);
626
627 std::shared_ptr<std::ifstream> inputFile =
628 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_surround_s16le.pcm", std::ios::binary);
629 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_surround_s16le.dat");
630
631 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
632 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
633 ASSERT_EQ(ret, 0);
634
635 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
636
637 bool eosFlag = false;
638
639 ret = WriteSample(trackId, datFile, eosFlag, flag);
640 while (!eosFlag && (ret == 0)) {
641 ret = WriteSample(trackId, datFile, eosFlag, flag);
642 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
643 }
644 ASSERT_EQ(avmuxer_->Stop(), 0);
645
646 datFile->close();
647 close(fd_);
648 }
649
650 /**
651 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_3POINT1
652 * @tc.desc: channel layout 3point1
653 * @tc.type: FUNC
654 */
655 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_3POINT1, TestSize.Level0)
656 {
657 int32_t trackId = -1;
658 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_3POINT1_S16LE.wav");
659 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
660
661 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
662 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
663 ASSERT_TRUE(isCreated);
664
665 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
666 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
667 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
668 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 4); // 4 channels
669 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
670 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
671 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
672 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_3POINT1);
673 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
674 ASSERT_EQ(ret, 0);
675 ASSERT_GE(trackId, 0);
676 ASSERT_EQ(avmuxer_->Start(), 0);
677
678 std::shared_ptr<std::ifstream> inputFile =
679 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_3point1_s16le.pcm", std::ios::binary);
680 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_3point1_s16le.dat");
681
682 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
683 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
684 ASSERT_EQ(ret, 0);
685
686 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
687
688 bool eosFlag = false;
689
690 ret = WriteSample(trackId, datFile, eosFlag, flag);
691 while (!eosFlag && (ret == 0)) {
692 ret = WriteSample(trackId, datFile, eosFlag, flag);
693 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
694 }
695 ASSERT_EQ(avmuxer_->Stop(), 0);
696
697 datFile->close();
698 close(fd_);
699 }
700
701 /**
702 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_4POINT0
703 * @tc.desc: channel layout 4point0
704 * @tc.type: FUNC
705 */
706 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_4POINT0, TestSize.Level0)
707 {
708 int32_t trackId = -1;
709 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_4POINT0_S16LE.wav");
710 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
711
712 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
713 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
714 ASSERT_TRUE(isCreated);
715
716 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
717 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
718 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
719 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 4); // 4 channels
720 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
721 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
722 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
723 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_4POINT0);
724 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
725 ASSERT_EQ(ret, 0);
726 ASSERT_GE(trackId, 0);
727 ASSERT_EQ(avmuxer_->Start(), 0);
728
729 std::shared_ptr<std::ifstream> inputFile =
730 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_4point0_s16le.pcm", std::ios::binary);
731 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_4point0_s16le.dat");
732
733 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
734 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
735 ASSERT_EQ(ret, 0);
736
737 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
738
739 bool eosFlag = false;
740
741 ret = WriteSample(trackId, datFile, eosFlag, flag);
742 while (!eosFlag && (ret == 0)) {
743 ret = WriteSample(trackId, datFile, eosFlag, flag);
744 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
745 }
746 ASSERT_EQ(avmuxer_->Stop(), 0);
747
748 datFile->close();
749 close(fd_);
750 }
751
752 /**
753 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_4POINT1
754 * @tc.desc: channel layout 4point1
755 * @tc.type: FUNC
756 */
757 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_4POINT1, TestSize.Level0)
758 {
759 int32_t trackId = -1;
760 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_4POINT1_S16LE.wav");
761 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
762
763 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
764 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
765 ASSERT_TRUE(isCreated);
766
767 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
768 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
769 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
770 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 5); // 5 channels
771 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
772 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
773 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
774 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_4POINT1);
775 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
776 ASSERT_EQ(ret, 0);
777 ASSERT_GE(trackId, 0);
778 ASSERT_EQ(avmuxer_->Start(), 0);
779
780 std::shared_ptr<std::ifstream> inputFile =
781 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_4point1_s16le.pcm", std::ios::binary);
782 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_4point1_s16le.dat");
783
784 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
785 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
786 ASSERT_EQ(ret, 0);
787
788 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
789
790 bool eosFlag = false;
791
792 ret = WriteSample(trackId, datFile, eosFlag, flag);
793 while (!eosFlag && (ret == 0)) {
794 ret = WriteSample(trackId, datFile, eosFlag, flag);
795 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
796 }
797 ASSERT_EQ(avmuxer_->Stop(), 0);
798
799 datFile->close();
800 close(fd_);
801 }
802
803 /**
804 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_2_2
805 * @tc.desc: channel layout 2_2
806 * @tc.type: FUNC
807 */
808 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_2_2, TestSize.Level0)
809 {
810 int32_t trackId = -1;
811 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_4POINT1_S16LE.wav");
812 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
813
814 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
815 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
816 ASSERT_TRUE(isCreated);
817
818 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
819 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
820 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
821 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 4); // 4 channels
822 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
823 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
824 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
825 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_2_2);
826 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
827 ASSERT_EQ(ret, 0);
828 ASSERT_GE(trackId, 0);
829 ASSERT_EQ(avmuxer_->Start(), 0);
830
831 std::shared_ptr<std::ifstream> inputFile =
832 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_2_2_s16le.pcm", std::ios::binary);
833 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_2_2_s16le.dat");
834
835 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
836 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
837 ASSERT_EQ(ret, 0);
838
839 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
840
841 bool eosFlag = false;
842
843 ret = WriteSample(trackId, datFile, eosFlag, flag);
844 while (!eosFlag && (ret == 0)) {
845 ret = WriteSample(trackId, datFile, eosFlag, flag);
846 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
847 }
848 ASSERT_EQ(avmuxer_->Stop(), 0);
849
850 datFile->close();
851 close(fd_);
852 }
853
854 /**
855 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_QUAD
856 * @tc.desc: channel layout quad
857 * @tc.type: FUNC
858 */
859 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_QUAD, TestSize.Level0)
860 {
861 int32_t trackId = -1;
862 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_QUAD_S16LE.wav");
863 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
864
865 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
866 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
867 ASSERT_TRUE(isCreated);
868
869 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
870 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
871 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
872 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 4); // 4 channels
873 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
874 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
875 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
876 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, QUAD);
877 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
878 ASSERT_EQ(ret, 0);
879 ASSERT_GE(trackId, 0);
880 ASSERT_EQ(avmuxer_->Start(), 0);
881
882 std::shared_ptr<std::ifstream> inputFile =
883 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_quad_s16le.pcm", std::ios::binary);
884 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_quad_s16le.dat");
885
886 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
887 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
888 ASSERT_EQ(ret, 0);
889
890 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
891
892 bool eosFlag = false;
893
894 ret = WriteSample(trackId, datFile, eosFlag, flag);
895 while (!eosFlag && (ret == 0)) {
896 ret = WriteSample(trackId, datFile, eosFlag, flag);
897 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
898 }
899 ASSERT_EQ(avmuxer_->Stop(), 0);
900
901 datFile->close();
902 close(fd_);
903 }
904
905 /**
906 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_5POINT0
907 * @tc.desc: channel layout 5point0
908 * @tc.type: FUNC
909 */
910 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_5POINT0, TestSize.Level0)
911 {
912 int32_t trackId = -1;
913 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_5POINT0_S16LE.wav");
914 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
915
916 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
917 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
918 ASSERT_TRUE(isCreated);
919
920 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
921 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
922 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
923 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 5); // 5 channels
924 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
925 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
926 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
927 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_5POINT0);
928 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
929 ASSERT_EQ(ret, 0);
930 ASSERT_GE(trackId, 0);
931 ASSERT_EQ(avmuxer_->Start(), 0);
932
933 std::shared_ptr<std::ifstream> inputFile =
934 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_5point0_s16le.pcm", std::ios::binary);
935 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_5point0_s16le.dat");
936
937 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
938 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
939 ASSERT_EQ(ret, 0);
940
941 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
942
943 bool eosFlag = false;
944
945 ret = WriteSample(trackId, datFile, eosFlag, flag);
946 while (!eosFlag && (ret == 0)) {
947 ret = WriteSample(trackId, datFile, eosFlag, flag);
948 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
949 }
950 ASSERT_EQ(avmuxer_->Stop(), 0);
951
952 datFile->close();
953 close(fd_);
954 }
955
956 /**
957 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_5POINT1
958 * @tc.desc: channel layout 5point1
959 * @tc.type: FUNC
960 */
961 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_5POINT1, TestSize.Level0)
962 {
963 int32_t trackId = -1;
964 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_5POINT1_S16LE.wav");
965 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
966
967 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
968 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
969 ASSERT_TRUE(isCreated);
970
971 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
972 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
973 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
974 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 6); // 6 channels
975 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
976 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
977 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
978 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_5POINT1);
979 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
980 ASSERT_EQ(ret, 0);
981 ASSERT_GE(trackId, 0);
982 ASSERT_EQ(avmuxer_->Start(), 0);
983
984 std::shared_ptr<std::ifstream> inputFile =
985 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_5point1_s16le.pcm", std::ios::binary);
986 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_5point1_s16le.dat");
987
988 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
989 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
990 ASSERT_EQ(ret, 0);
991
992 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
993
994 bool eosFlag = false;
995
996 ret = WriteSample(trackId, datFile, eosFlag, flag);
997 while (!eosFlag && (ret == 0)) {
998 ret = WriteSample(trackId, datFile, eosFlag, flag);
999 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1000 }
1001 ASSERT_EQ(avmuxer_->Stop(), 0);
1002
1003 datFile->close();
1004 close(fd_);
1005 }
1006
1007 /**
1008 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_5POINT0_BACK
1009 * @tc.desc: channel layout 5point0back
1010 * @tc.type: FUNC
1011 */
1012 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_5POINT0_BACK, TestSize.Level0)
1013 {
1014 int32_t trackId = -1;
1015 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_CH_5POINT0_BACK_S16LE.wav");
1016 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1017
1018 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1019 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1020 ASSERT_TRUE(isCreated);
1021
1022 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1023 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1024 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1025 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 5); // 5 channels
1026 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1027 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1028 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1029 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_5POINT0_BACK);
1030 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1031 ASSERT_EQ(ret, 0);
1032 ASSERT_GE(trackId, 0);
1033 ASSERT_EQ(avmuxer_->Start(), 0);
1034
1035 std::shared_ptr<std::ifstream> inputFile =
1036 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_5point0back_s16le.pcm", std::ios::binary);
1037 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_5point0back_s16le.dat");
1038
1039 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1040 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1041 ASSERT_EQ(ret, 0);
1042
1043 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1044
1045 bool eosFlag = false;
1046
1047 ret = WriteSample(trackId, datFile, eosFlag, flag);
1048 while (!eosFlag && (ret == 0)) {
1049 ret = WriteSample(trackId, datFile, eosFlag, flag);
1050 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1051 }
1052 ASSERT_EQ(avmuxer_->Stop(), 0);
1053
1054 datFile->close();
1055 close(fd_);
1056 }
1057
1058 /**
1059 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_5POINT1_BACK
1060 * @tc.desc: channel layout 5point1back
1061 * @tc.type: FUNC
1062 */
1063 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_5POINT1_BACK, TestSize.Level0)
1064 {
1065 int32_t trackId = -1;
1066 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_5POINT1_BACK_S16LE.wav");
1067 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1068
1069 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1070 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1071 ASSERT_TRUE(isCreated);
1072
1073 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1074 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1075 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1076 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 6); // 6 channels
1077 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1078 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1079 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1080 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_5POINT1_BACK);
1081 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1082 ASSERT_EQ(ret, 0);
1083 ASSERT_GE(trackId, 0);
1084 ASSERT_EQ(avmuxer_->Start(), 0);
1085
1086 std::shared_ptr<std::ifstream> inputFile =
1087 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_5point1back_s16le.pcm", std::ios::binary);
1088 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_5point1back_s16le.dat");
1089
1090 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1091 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1092 ASSERT_EQ(ret, 0);
1093
1094 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1095
1096 bool eosFlag = false;
1097
1098 ret = WriteSample(trackId, datFile, eosFlag, flag);
1099 while (!eosFlag && (ret == 0)) {
1100 ret = WriteSample(trackId, datFile, eosFlag, flag);
1101 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1102 }
1103 ASSERT_EQ(avmuxer_->Stop(), 0);
1104
1105 datFile->close();
1106 close(fd_);
1107 }
1108
1109 /**
1110 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_6POINT0
1111 * @tc.desc: channel layout 6point0
1112 * @tc.type: FUNC
1113 */
1114 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_6POINT0, TestSize.Level0)
1115 {
1116 int32_t trackId = -1;
1117 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_5POINT1_BACK_S16LE.wav");
1118 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1119
1120 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1121 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1122 ASSERT_TRUE(isCreated);
1123
1124 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1125 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1126 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1127 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 6); // 6 channels
1128 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1129 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1130 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1131 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_6POINT0);
1132 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1133 ASSERT_EQ(ret, 0);
1134 ASSERT_GE(trackId, 0);
1135 ASSERT_EQ(avmuxer_->Start(), 0);
1136
1137 std::shared_ptr<std::ifstream> inputFile =
1138 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_6point0_s16le.pcm", std::ios::binary);
1139 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_6point0_s16le.dat");
1140
1141 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1142 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1143 ASSERT_EQ(ret, 0);
1144
1145 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1146
1147 bool eosFlag = false;
1148
1149 ret = WriteSample(trackId, datFile, eosFlag, flag);
1150 while (!eosFlag && (ret == 0)) {
1151 ret = WriteSample(trackId, datFile, eosFlag, flag);
1152 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1153 }
1154 ASSERT_EQ(avmuxer_->Stop(), 0);
1155
1156 datFile->close();
1157 close(fd_);
1158 }
1159
1160 /**
1161 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_6POINT0_FRONT
1162 * @tc.desc: channel layout 6point0front
1163 * @tc.type: FUNC
1164 */
1165 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_6POINT0_FRONT, TestSize.Level0)
1166 {
1167 int32_t trackId = -1;
1168 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_CH_6POINT0_FRONT_S16LE.wav");
1169 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1170
1171 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1172 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1173 ASSERT_TRUE(isCreated);
1174
1175 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1176 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1177 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1178 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 6); // 6 channels
1179 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1180 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1181 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1182 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_6POINT0_FRONT);
1183 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1184 ASSERT_EQ(ret, 0);
1185 ASSERT_GE(trackId, 0);
1186 ASSERT_EQ(avmuxer_->Start(), 0);
1187
1188 std::shared_ptr<std::ifstream> inputFile =
1189 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_6point0front_s16le.pcm", std::ios::binary);
1190 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_6point0front_s16le.dat");
1191
1192 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1193 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1194 ASSERT_EQ(ret, 0);
1195
1196 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1197
1198 bool eosFlag = false;
1199
1200 ret = WriteSample(trackId, datFile, eosFlag, flag);
1201 while (!eosFlag && (ret == 0)) {
1202 ret = WriteSample(trackId, datFile, eosFlag, flag);
1203 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1204 }
1205 ASSERT_EQ(avmuxer_->Stop(), 0);
1206
1207 datFile->close();
1208 close(fd_);
1209 }
1210
1211 /**
1212 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_HEXAGONAL
1213 * @tc.desc: channel layout hexagonal
1214 * @tc.type: FUNC
1215 */
1216 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_HEXAGONAL, TestSize.Level0)
1217 {
1218 int32_t trackId = -1;
1219 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_HEXAGONAL_S16LE.wav");
1220 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1221
1222 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1223 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1224 ASSERT_TRUE(isCreated);
1225
1226 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1227 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1228 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1229 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 6); // 6 channels
1230 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1231 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1232 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1233 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, HEXAGONAL);
1234 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1235 ASSERT_EQ(ret, 0);
1236 ASSERT_GE(trackId, 0);
1237 ASSERT_EQ(avmuxer_->Start(), 0);
1238
1239 std::shared_ptr<std::ifstream> inputFile =
1240 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_hexagonal_s16le.pcm", std::ios::binary);
1241 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_hexagonal_s16le.dat");
1242
1243 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1244 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1245 ASSERT_EQ(ret, 0);
1246
1247 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1248
1249 bool eosFlag = false;
1250
1251 ret = WriteSample(trackId, datFile, eosFlag, flag);
1252 while (!eosFlag && (ret == 0)) {
1253 ret = WriteSample(trackId, datFile, eosFlag, flag);
1254 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1255 }
1256 ASSERT_EQ(avmuxer_->Stop(), 0);
1257
1258 datFile->close();
1259 close(fd_);
1260 }
1261
1262 /**
1263 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_6POINT1
1264 * @tc.desc: channel layout 6point1
1265 * @tc.type: FUNC
1266 */
1267 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_6POINT1, TestSize.Level0)
1268 {
1269 int32_t trackId = -1;
1270 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_CH_6POINT1_S16LE.wav");
1271 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1272
1273 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1274 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1275 ASSERT_TRUE(isCreated);
1276
1277 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1278 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1279 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1280 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 7); // 7 channels
1281 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1282 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1283 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1284 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_6POINT1);
1285 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1286 ASSERT_EQ(ret, 0);
1287 ASSERT_GE(trackId, 0);
1288 ASSERT_EQ(avmuxer_->Start(), 0);
1289
1290 std::shared_ptr<std::ifstream> inputFile =
1291 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_6point1_s16le.pcm", std::ios::binary);
1292 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_6point1_s16le.dat");
1293
1294 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1295 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1296 ASSERT_EQ(ret, 0);
1297
1298 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1299
1300 bool eosFlag = false;
1301
1302 ret = WriteSample(trackId, datFile, eosFlag, flag);
1303 while (!eosFlag && (ret == 0)) {
1304 ret = WriteSample(trackId, datFile, eosFlag, flag);
1305 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1306 }
1307 ASSERT_EQ(avmuxer_->Stop(), 0);
1308
1309 datFile->close();
1310 close(fd_);
1311 }
1312
1313 /**
1314 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_6POINT1_BACK
1315 * @tc.desc: channel layout 6point1back
1316 * @tc.type: FUNC
1317 */
1318 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_6POINT1_BACK, TestSize.Level0)
1319 {
1320 int32_t trackId = -1;
1321 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_CH_6POINT1_BACK_S16LE.wav");
1322 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1323
1324 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1325 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1326 ASSERT_TRUE(isCreated);
1327
1328 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1329 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1330 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1331 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 7); // 7 channels
1332 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1333 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1334 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1335 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_6POINT1_BACK);
1336 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1337 ASSERT_EQ(ret, 0);
1338 ASSERT_GE(trackId, 0);
1339 ASSERT_EQ(avmuxer_->Start(), 0);
1340
1341 std::shared_ptr<std::ifstream> inputFile =
1342 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_6point1back_s16le.pcm", std::ios::binary);
1343 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_6point1back_s16le.dat");
1344
1345 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1346 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1347 ASSERT_EQ(ret, 0);
1348
1349 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1350
1351 bool eosFlag = false;
1352
1353 ret = WriteSample(trackId, datFile, eosFlag, flag);
1354 while (!eosFlag && (ret == 0)) {
1355 ret = WriteSample(trackId, datFile, eosFlag, flag);
1356 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1357 }
1358 ASSERT_EQ(avmuxer_->Stop(), 0);
1359
1360 datFile->close();
1361 close(fd_);
1362 }
1363
1364 /**
1365 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_6POINT1_FRONT
1366 * @tc.desc: channel layout 6point1front
1367 * @tc.type: FUNC
1368 */
1369 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_6POINT1_FRONT, TestSize.Level0)
1370 {
1371 int32_t trackId = -1;
1372 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_CH_6POINT1_FRONT_S16LE.wav");
1373 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1374
1375 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1376 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1377 ASSERT_TRUE(isCreated);
1378
1379 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1380 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1381 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1382 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 7); // 7 channels
1383 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1384 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1385 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1386 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_6POINT1_FRONT);
1387 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1388 ASSERT_EQ(ret, 0);
1389 ASSERT_GE(trackId, 0);
1390 ASSERT_EQ(avmuxer_->Start(), 0);
1391
1392 std::shared_ptr<std::ifstream> inputFile =
1393 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_6point1front_s16le.pcm", std::ios::binary);
1394 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_6point1front_s16le.dat");
1395
1396 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1397 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1398 ASSERT_EQ(ret, 0);
1399
1400 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1401
1402 bool eosFlag = false;
1403
1404 ret = WriteSample(trackId, datFile, eosFlag, flag);
1405 while (!eosFlag && (ret == 0)) {
1406 ret = WriteSample(trackId, datFile, eosFlag, flag);
1407 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1408 }
1409 ASSERT_EQ(avmuxer_->Stop(), 0);
1410
1411 datFile->close();
1412 close(fd_);
1413 }
1414
1415 /**
1416 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_7POINT0
1417 * @tc.desc: channel layout 7point0
1418 * @tc.type: FUNC
1419 */
1420 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_7POINT0, TestSize.Level0)
1421 {
1422 int32_t trackId = -1;
1423 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_CH_7POINT0_S16LE.wav");
1424 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1425
1426 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1427 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1428 ASSERT_TRUE(isCreated);
1429
1430 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1431 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1432 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1433 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 7); // 7 channels
1434 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1435 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1436 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1437 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_7POINT0);
1438 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1439 ASSERT_EQ(ret, 0);
1440 ASSERT_GE(trackId, 0);
1441 ASSERT_EQ(avmuxer_->Start(), 0);
1442
1443 std::shared_ptr<std::ifstream> inputFile =
1444 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_7point0_s16le.pcm", std::ios::binary);
1445 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_7point0_s16le.dat");
1446
1447 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1448 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1449 ASSERT_EQ(ret, 0);
1450
1451 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1452
1453 bool eosFlag = false;
1454
1455 ret = WriteSample(trackId, datFile, eosFlag, flag);
1456 while (!eosFlag && (ret == 0)) {
1457 ret = WriteSample(trackId, datFile, eosFlag, flag);
1458 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1459 }
1460 ASSERT_EQ(avmuxer_->Stop(), 0);
1461
1462 datFile->close();
1463 close(fd_);
1464 }
1465
1466 /**
1467 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_7POINT0_FRONT
1468 * @tc.desc: channel layout 7point0front
1469 * @tc.type: FUNC
1470 */
1471 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_7POINT0_FRONT, TestSize.Level0)
1472 {
1473 int32_t trackId = -1;
1474 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_CH_7POINT0_FRONT_S16LE.wav");
1475 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1476
1477 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1478 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1479 ASSERT_TRUE(isCreated);
1480
1481 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1482 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1483 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1484 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 7); // 7 channels
1485 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1486 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1487 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1488 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_7POINT0_FRONT);
1489 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1490 ASSERT_EQ(ret, 0);
1491 ASSERT_GE(trackId, 0);
1492 ASSERT_EQ(avmuxer_->Start(), 0);
1493
1494 std::shared_ptr<std::ifstream> inputFile =
1495 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_7point0front_s16le.pcm", std::ios::binary);
1496 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_7point0front_s16le.dat");
1497
1498 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1499 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1500 ASSERT_EQ(ret, 0);
1501
1502 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1503
1504 bool eosFlag = false;
1505
1506 ret = WriteSample(trackId, datFile, eosFlag, flag);
1507 while (!eosFlag && (ret == 0)) {
1508 ret = WriteSample(trackId, datFile, eosFlag, flag);
1509 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1510 }
1511 ASSERT_EQ(avmuxer_->Stop(), 0);
1512
1513 datFile->close();
1514 close(fd_);
1515 }
1516
1517 /**
1518 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_7POINT1
1519 * @tc.desc: channel layout 7point1
1520 * @tc.type: FUNC
1521 */
1522 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_7POINT1, TestSize.Level0)
1523 {
1524 int32_t trackId = -1;
1525 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_CH_7POINT1_S16LE.wav");
1526 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1527
1528 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1529 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1530 ASSERT_TRUE(isCreated);
1531
1532 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1533 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1534 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1535 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 8); // 8 channels
1536 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1537 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1538 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1539 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_7POINT1);
1540 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1541 ASSERT_EQ(ret, 0);
1542 ASSERT_GE(trackId, 0);
1543 ASSERT_EQ(avmuxer_->Start(), 0);
1544
1545 std::shared_ptr<std::ifstream> inputFile =
1546 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_7point1_s16le.pcm", std::ios::binary);
1547 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_7point1_s16le.dat");
1548
1549 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1550 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1551 ASSERT_EQ(ret, 0);
1552
1553 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1554
1555 bool eosFlag = false;
1556
1557 ret = WriteSample(trackId, datFile, eosFlag, flag);
1558 while (!eosFlag && (ret == 0)) {
1559 ret = WriteSample(trackId, datFile, eosFlag, flag);
1560 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1561 }
1562 ASSERT_EQ(avmuxer_->Stop(), 0);
1563
1564 datFile->close();
1565 close(fd_);
1566 }
1567
1568 /**
1569 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_7POINT1_WIDE
1570 * @tc.desc: channel layout 7point1wide
1571 * @tc.type: FUNC
1572 */
1573 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_7POINT1_WIDE, TestSize.Level0)
1574 {
1575 int32_t trackId = -1;
1576 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_CH_7POINT1_WIDE_S16LE.wav");
1577 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1578
1579 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1580 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1581 ASSERT_TRUE(isCreated);
1582
1583 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1584 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1585 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1586 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 8); // 8 channels
1587 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1588 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1589 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1590 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_7POINT1_WIDE);
1591 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1592 ASSERT_EQ(ret, 0);
1593 ASSERT_GE(trackId, 0);
1594 ASSERT_EQ(avmuxer_->Start(), 0);
1595
1596 std::shared_ptr<std::ifstream> inputFile =
1597 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_7point1wide_s16le.pcm", std::ios::binary);
1598 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_7point1wide_s16le.dat");
1599
1600 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1601 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1602 ASSERT_EQ(ret, 0);
1603
1604 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1605
1606 bool eosFlag = false;
1607
1608 ret = WriteSample(trackId, datFile, eosFlag, flag);
1609 while (!eosFlag && (ret == 0)) {
1610 ret = WriteSample(trackId, datFile, eosFlag, flag);
1611 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1612 }
1613 ASSERT_EQ(avmuxer_->Stop(), 0);
1614
1615 datFile->close();
1616 close(fd_);
1617 }
1618
1619 /**
1620 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_7POINT1_WIDE_BACK
1621 * @tc.desc: channel layout 7point1wideback
1622 * @tc.type: FUNC
1623 */
1624 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_CH_7POINT1_WIDE_BACK, TestSize.Level0)
1625 {
1626 int32_t trackId = -1;
1627 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_CH_7POINT1_WIDE_BACK_S16LE.wav");
1628 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1629
1630 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1631 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1632 ASSERT_TRUE(isCreated);
1633
1634 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1635 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1636 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1637 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 8); // 8 channels
1638 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1639 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1640 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1641 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_7POINT1_WIDE_BACK);
1642 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1643 ASSERT_EQ(ret, 0);
1644 ASSERT_GE(trackId, 0);
1645 ASSERT_EQ(avmuxer_->Start(), 0);
1646
1647 std::shared_ptr<std::ifstream> inputFile =
1648 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_7point1wideback_s16le.pcm", std::ios::binary);
1649 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_7point1wideback_s16le.dat");
1650
1651 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1652 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1653 ASSERT_EQ(ret, 0);
1654
1655 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1656
1657 bool eosFlag = false;
1658
1659 ret = WriteSample(trackId, datFile, eosFlag, flag);
1660 while (!eosFlag && (ret == 0)) {
1661 ret = WriteSample(trackId, datFile, eosFlag, flag);
1662 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1663 }
1664 ASSERT_EQ(avmuxer_->Stop(), 0);
1665
1666 datFile->close();
1667 close(fd_);
1668 }
1669
1670 /**
1671 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_OCTAGONAL
1672 * @tc.desc: channel layout octagonal
1673 * @tc.type: FUNC
1674 */
1675 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_OCTAGONAL, TestSize.Level0)
1676 {
1677 int32_t trackId = -1;
1678 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_OCTAGONAL_S16LE.wav");
1679 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1680
1681 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1682 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1683 ASSERT_TRUE(isCreated);
1684
1685 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1686 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1687 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1688 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 8); // 8 channels
1689 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1690 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1691 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1692 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, OCTAGONAL);
1693 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1694 ASSERT_EQ(ret, 0);
1695 ASSERT_GE(trackId, 0);
1696 ASSERT_EQ(avmuxer_->Start(), 0);
1697
1698 std::shared_ptr<std::ifstream> inputFile =
1699 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_octagonal_s16le.pcm", std::ios::binary);
1700 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_octagonal_s16le.dat");
1701
1702 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1703 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1704 ASSERT_EQ(ret, 0);
1705
1706 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1707
1708 bool eosFlag = false;
1709
1710 ret = WriteSample(trackId, datFile, eosFlag, flag);
1711 while (!eosFlag && (ret == 0)) {
1712 ret = WriteSample(trackId, datFile, eosFlag, flag);
1713 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1714 }
1715 ASSERT_EQ(avmuxer_->Stop(), 0);
1716
1717 datFile->close();
1718 close(fd_);
1719 }
1720
1721 /**
1722 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_HEXADECAGONAL
1723 * @tc.desc: channel layout hexadecagonal
1724 * @tc.type: FUNC
1725 */
1726 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_HEXADECAGONAL, TestSize.Level0)
1727 {
1728 int32_t trackId = -1;
1729 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_HEXADECAGONAL_S16LE.wav");
1730 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1731
1732 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1733 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1734 ASSERT_TRUE(isCreated);
1735
1736 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1737 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1738 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1739 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 16); // 16 channels
1740 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1741 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1742 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1743 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, HEXADECAGONAL);
1744 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1745 ASSERT_EQ(ret, 0);
1746 ASSERT_GE(trackId, 0);
1747 ASSERT_EQ(avmuxer_->Start(), 0);
1748
1749 std::shared_ptr<std::ifstream> inputFile =
1750 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_hexadecagonal_s16le.pcm", std::ios::binary);
1751 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_hexadecagonal_s16le.dat");
1752
1753 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1754 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1755 ASSERT_EQ(ret, 0);
1756
1757 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1758
1759 bool eosFlag = false;
1760
1761 ret = WriteSample(trackId, datFile, eosFlag, flag);
1762 while (!eosFlag && (ret == 0)) {
1763 ret = WriteSample(trackId, datFile, eosFlag, flag);
1764 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1765 }
1766 ASSERT_EQ(avmuxer_->Stop(), 0);
1767
1768 datFile->close();
1769 close(fd_);
1770 }
1771
1772 /**
1773 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_STEREO_DOWNMIX
1774 * @tc.desc: channel layout stereo downmix
1775 * @tc.type: FUNC
1776 */
1777 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_STEREO_DOWNMIX, TestSize.Level0)
1778 {
1779 int32_t trackId = -1;
1780 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_stereodownmix_S16LE.wav");
1781 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1782
1783 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1784 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1785 ASSERT_TRUE(isCreated);
1786
1787 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1788 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1789 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1790 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, TEST_CHANNEL_COUNT);
1791 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1792 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1793 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1794 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, STEREO_DOWNMIX);
1795 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1796 ASSERT_EQ(ret, 0);
1797 ASSERT_GE(trackId, 0);
1798 ASSERT_EQ(avmuxer_->Start(), 0);
1799
1800 std::shared_ptr<std::ifstream> inputFile =
1801 std::make_shared<std::ifstream>("/data/test/media/wav_pcm_44100_stereodownmix_s16le.pcm", std::ios::binary);
1802 std::string outputDat_ = TEST_FILE_PATH + std::string("pcm_44100_stereodownmix_s16le.dat");
1803
1804 uint32_t flag = AVCODEC_BUFFER_FLAGS_SYNC_FRAME;
1805 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1806 ASSERT_EQ(ret, 0);
1807
1808 std::shared_ptr<std::ifstream> datFile = std::make_shared<std::ifstream>(outputDat_, std::ios::binary);
1809
1810 bool eosFlag = false;
1811
1812 ret = WriteSample(trackId, datFile, eosFlag, flag);
1813 while (!eosFlag && (ret == 0)) {
1814 ret = WriteSample(trackId, datFile, eosFlag, flag);
1815 ret = ProcessPcmFile(inputFile, outputDat_, trackId, flag);
1816 }
1817 ASSERT_EQ(avmuxer_->Stop(), 0);
1818
1819 datFile->close();
1820 close(fd_);
1821 }
1822
1823 /**
1824 * @tc.name: Muxer_WAV_PCM_CHANNEL_LAYOUT_3POINT1POINT2
1825 * @tc.desc: unsupported channel layout 3.1.2
1826 * @tc.type: FUNC
1827 */
1828 HWTEST_F(AVMuxerWavPcmUnitTest, Muxer_WAV_PCM_CHANNEL_LAYOUT_3POINT1POINT2, TestSize.Level0)
1829 {
1830 int32_t trackId = -1;
1831 std::string outputFile = TEST_FILE_PATH + std::string("Muxer_PCM_44100_3point1point2_S16LE.wav");
1832 OH_AVOutputFormat outputFormat = AV_OUTPUT_FORMAT_WAV;
1833
1834 fd_ = open(outputFile.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
1835 bool isCreated = avmuxer_->CreateMuxer(fd_, outputFormat);
1836 ASSERT_TRUE(isCreated);
1837
1838 std::shared_ptr<FormatMock> audioParams = FormatMockFactory::CreateFormat();
1839 audioParams->PutStringValue(OH_MD_KEY_CODEC_MIME, "audio/raw");
1840 audioParams->PutIntValue(OH_MD_KEY_AUD_SAMPLE_RATE, TEST_SAMPLE_RATE);
1841 audioParams->PutIntValue(OH_MD_KEY_AUD_CHANNEL_COUNT, 6); // 6 channels
1842 audioParams->PutIntValue(OH_MD_KEY_AUDIO_SAMPLE_FORMAT, SAMPLE_S16LE);
1843 audioParams->PutLongValue(OH_MD_KEY_BITRATE, TEST_BIT_RATE);
1844 audioParams->PutIntValue("audio_samples_per_frame", TEST_SAMPLE_PER_FRAME);
1845 audioParams->PutLongValue(OH_MD_KEY_CHANNEL_LAYOUT, CH_3POINT1POINT2); // not supported
1846 int32_t ret = avmuxer_->AddTrack(trackId, audioParams);
1847 ASSERT_NE(ret, 0); // channel layout not supported
1848 }
1849 } // namespace