1 /*
2  * Copyright (C) 2023 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 <string>
17 #include <sys/stat.h>
18 #include <fcntl.h>
19 #include <cinttypes>
20 #include "gtest/gtest.h"
21 #include "avcodec_errors.h"
22 #include "avcodec_audio_common.h"
23 #include "avcodec_info.h"
24 #include "media_description.h"
25 #include "file_server_demo.h"
26 #include "avsource_unit_test.h"
27 
28 using namespace OHOS;
29 using namespace OHOS::MediaAVCodec;
30 using namespace testing::ext;
31 using namespace std;
32 
33 namespace {
34 unique_ptr<FileServerDemo> server = nullptr;
35 static const string TEST_FILE_PATH = "/data/test/media/";
36 static const string TEST_URI_PATH = "http://127.0.0.1:46666/";
37 string g_mp4Uri = TEST_URI_PATH + string("test_264_B_Gop25_4sec_cover.mp4");
38 string g_mp4Uri3 = TEST_URI_PATH + string("test_mpeg2_B_Gop25_4sec.mp4");
39 string g_mp4Uri5 = TEST_URI_PATH + string("test_suffix_mismatch.mp4");
40 string g_mp4Uri6 = TEST_URI_PATH + string("test_empty_file.mp4");
41 string g_mp4Uri7 = TEST_URI_PATH + string("test_error.mp4");
42 string g_mp4Uri8 = TEST_URI_PATH + string("zero_track.mp4");
43 string g_mkvUri2 = TEST_URI_PATH + string("h264_opus_4sec.mkv");
44 string g_tsUri = TEST_URI_PATH + string("test_mpeg2_Gop25_4sec.ts");
45 string g_aacUri = TEST_URI_PATH + string("audio/aac_44100_1.aac");
46 string g_flacUri = TEST_URI_PATH + string("audio/flac_48000_1_cover.flac");
47 string g_m4aUri = TEST_URI_PATH + string("audio/m4a_48000_1.m4a");
48 string g_mp3Uri = TEST_URI_PATH + string("audio/mp3_48000_1_cover.mp3");
49 string g_oggUri = TEST_URI_PATH + string("audio/ogg_48000_1.ogg");
50 string g_wavUri = TEST_URI_PATH + string("audio/wav_48000_1.wav");
51 string g_amrUri = TEST_URI_PATH + string("audio/amr_nb_8000_1.amr");
52 string g_amrUri2 = TEST_URI_PATH + string("audio/amr_wb_16000_1.amr");
53 string g_audioVividUri = TEST_URI_PATH + string("2obj_44100Hz_16bit_32k.m4a");
54 string g_fmp4AvcUri = TEST_URI_PATH + string("h264_fmp4.mp4");
55 string g_fmp4m4vUri = TEST_URI_PATH + string("h264_fmp4.m4v");
56 string g_fmp4m4aUri = TEST_URI_PATH + string("audio/h264_fmp4.m4a");
57 string g_srt = TEST_URI_PATH + string("subtitle.srt");
58 string g_mp4VvcUri = TEST_URI_PATH + string("vvc.mp4");
59 string g_mp4VvcPath = TEST_FILE_PATH + string("vvc.mp4");
60 
61 /**********************************source URI**************************************/
62 /**
63  * @tc.name: AVSource_CreateSourceWithURI_1000
64  * @tc.desc: create source with uri, mp4
65  * @tc.type: FUNC
66  */
HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1000, TestSize.Level1)67 HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1000, TestSize.Level1)
68 {
69     printf("---- %s ------\n", g_mp4Uri.data());
70     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri.data()));
71     ASSERT_NE(source_, nullptr);
72 }
73 
74 /**
75  * @tc.name: AVSource_CreateSourceWithURI_1020
76  * @tc.desc: create source with uri, but file is abnormal
77  * @tc.type: FUNC
78  */
HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1020, TestSize.Level1)79 HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1020, TestSize.Level1)
80 {
81     printf("---- %s ------\n", g_mp4Uri5.data());
82     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri5.data()));
83     ASSERT_EQ(source_, nullptr);
84 }
85 
86 /**
87  * @tc.name: AVSource_CreateSourceWithURI_1030
88  * @tc.desc: create source with uri, but file is empty
89  * @tc.type: FUNC
90  */
HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1030, TestSize.Level1)91 HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1030, TestSize.Level1)
92 {
93     printf("---- %s ------\n", g_mp4Uri6.data());
94     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri6.data()));
95     ASSERT_EQ(source_, nullptr);
96 }
97 
98 /**
99  * @tc.name: AVSource_CreateSourceWithURI_1040
100  * @tc.desc: create source with uri, but file is error
101  * @tc.type: FUNC
102  */
HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1040, TestSize.Level1)103 HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1040, TestSize.Level1)
104 {
105     printf("---- %s ------\n", g_mp4Uri7.data());
106     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri7.data()));
107     ASSERT_EQ(source_, nullptr);
108 }
109 
110 /**
111  * @tc.name: AVSource_CreateSourceWithURI_1050
112  * @tc.desc: create source with uri, but track is zero
113  * @tc.type: FUNC
114  */
HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1050, TestSize.Level1)115 HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1050, TestSize.Level1)
116 {
117     printf("---- %s ------\n", g_mp4Uri8.data());
118     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri8.data()));
119     ASSERT_NE(source_, nullptr);
120 }
121 
122 /**
123  * @tc.name: AVSource_CreateSourceWithURI_1060
124  * @tc.desc: create source with invalid uri
125  * @tc.type: FUNC
126  */
HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1060, TestSize.Level1)127 HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1060, TestSize.Level1)
128 {
129     string uri = "http://127.0.0.1:46666/asdffafafaf";
130     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(uri.data()));
131     ASSERT_EQ(source_, nullptr);
132 }
133 
134 /**
135  * @tc.name: AVSource_CreateSourceWithURI_1070
136  * @tc.desc: Create source repeatedly
137  * @tc.type: FUNC
138  */
HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1070, TestSize.Level1)139 HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1070, TestSize.Level1)
140 {
141     printf("---- %s ------\n", g_mp4Uri.data());
142     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri.data()));
143     ASSERT_NE(source_, nullptr);
144     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri.data()));
145     ASSERT_NE(source_, nullptr);
146 }
147 
148 /**
149  * @tc.name: AVSource_CreateSourceWithURI_1080
150  * @tc.desc: destroy source
151  * @tc.type: FUNC
152  */
HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1080, TestSize.Level1)153 HWTEST_F(AVSourceUnitTest, AVSource_CreateSourceWithURI_1080, TestSize.Level1)
154 {
155     printf("---- %s ------\n", g_mp4Uri.data());
156     printf("---- %s ------\n", g_mp3Uri.data());
157     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri.data()));
158     ASSERT_NE(source_, nullptr);
159     shared_ptr<AVSourceMock> source2 = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp3Uri.data()));
160     ASSERT_NE(source2, nullptr);
161     ASSERT_EQ(source_->Destroy(), AV_ERR_OK);
162     ASSERT_EQ(source2->Destroy(), AV_ERR_OK);
163     source2 = nullptr;
164 }
165 
166 /**
167  * @tc.name: AVSource_GetFormat_2000
168  * @tc.desc: get source format when the file is mp4
169  * @tc.type: FUNC
170  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2000, TestSize.Level1)171 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2000, TestSize.Level1)
172 {
173     printf("---- %s ------\n", g_mp4Uri.data());
174     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri.data()));
175     ASSERT_NE(source_, nullptr);
176     format_ = source_->GetSourceFormat();
177     ASSERT_NE(format_, nullptr);
178     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
179     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_TITLE, formatVal_.title));
180     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ARTIST, formatVal_.artist));
181     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ALBUM, formatVal_.album));
182     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ALBUM_ARTIST, formatVal_.albumArtist));
183     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_DATE, formatVal_.date));
184     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COMMENT, formatVal_.comment));
185     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_GENRE, formatVal_.genre));
186     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COPYRIGHT, formatVal_.copyright));
187     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_DESCRIPTION, formatVal_.description));
188     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_LYRICS, formatVal_.lyrics));
189     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
190     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
191     ASSERT_EQ(formatVal_.title, "title");
192     ASSERT_EQ(formatVal_.artist, "artist");
193     ASSERT_EQ(formatVal_.album, "album");
194     ASSERT_EQ(formatVal_.albumArtist, "album artist");
195     ASSERT_EQ(formatVal_.date, "2023");
196     ASSERT_EQ(formatVal_.comment, "comment");
197     ASSERT_EQ(formatVal_.genre, "genre");
198     ASSERT_EQ(formatVal_.copyright, "Copyright");
199     ASSERT_EQ(formatVal_.lyrics, "lyrics");
200     ASSERT_EQ(formatVal_.description, "description");
201     ASSERT_EQ(formatVal_.duration, 4120000);
202     ASSERT_EQ(formatVal_.trackCount, 3);
203 #ifdef AVSOURCE_INNER_UNIT_TEST
204     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
205     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
206     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
207     ASSERT_EQ(formatVal_.hasVideo, 1);
208     ASSERT_EQ(formatVal_.hasAudio, 1);
209     ASSERT_EQ(formatVal_.fileType, 101);
210 #endif
211 }
212 
213 /**
214  * @tc.name: AVSource_GetFormat_2010
215  * @tc.desc: get track format when the file is mp4
216  * @tc.type: FUNC
217  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2010, TestSize.Level1)218 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2010, TestSize.Level1)
219 {
220     printf("---- %s ------\n", g_mp4Uri.data());
221     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri.data()));
222     ASSERT_NE(source_, nullptr);
223     trackIndex_ = 0;
224     format_ = source_->GetTrackFormat(trackIndex_);
225     ASSERT_NE(format_, nullptr);
226     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
227     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
228     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
229     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
230     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
231     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
232     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
233     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
234     ASSERT_EQ(formatVal_.codecMime, "video/avc");
235     ASSERT_EQ(formatVal_.width, 1920);
236     ASSERT_EQ(formatVal_.height, 1080);
237     ASSERT_EQ(formatVal_.bitRate, 7782407);
238     ASSERT_DOUBLE_EQ(formatVal_.frameRate, 25.000000);
239     trackIndex_ = 1;
240     format_ = source_->GetTrackFormat(trackIndex_);
241     ASSERT_NE(format_, nullptr);
242     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
243     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
244     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
245     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
246     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
247     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, formatVal_.aacIsAdts));
248     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
249     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
250     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
251     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
252     ASSERT_EQ(formatVal_.sampleRate, 44100);
253     ASSERT_EQ(formatVal_.channelCount, 2);
254     ASSERT_EQ(formatVal_.bitRate, 128563);
255     ASSERT_EQ(formatVal_.aacIsAdts, 1);
256     ASSERT_EQ(formatVal_.codecMime, "audio/mp4a-latm");
257     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
258     ASSERT_EQ(formatVal_.channelLayout, 3);
259 }
260 
261 /**
262  * @tc.name: AVSource_GetFormat_2011
263  * @tc.desc: get track format when the file is mp4
264  * @tc.type: FUNC
265  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2011, TestSize.Level1)266 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2011, TestSize.Level1)
267 {
268     printf("---- %s ------\n", g_mp4Uri.data());
269     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri.data()));
270     ASSERT_NE(source_, nullptr);
271     trackIndex_ = 2;
272     format_ = source_->GetTrackFormat(trackIndex_);
273     ASSERT_NE(format_, nullptr);
274 #ifdef AVSOURCE_INNER_UNIT_TEST
275     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
276     const char* outFile = "/data/test/test_264_B_Gop25_4sec_cover_uri.bin";
277     FILE* saveFile = fopen(outFile, "wb");
278     ASSERT_TRUE(format_->GetBuffer(MediaDescriptionKey::MD_KEY_COVER, &addr_, buffSize_));
279     fwrite(addr_, sizeof(uint8_t), buffSize_, saveFile);
280     fclose(saveFile);
281 #endif
282 }
283 
284 /**
285  * @tc.name: AVSource_GetFormat_2020
286  * @tc.desc: get source format when the file is ts
287  * @tc.type: FUNC
288  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2020, TestSize.Level1)289 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2020, TestSize.Level1)
290 {
291     printf("---- %s ------\n", g_tsUri.data());
292     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_tsUri.data()));
293     ASSERT_NE(source_, nullptr);
294     trackIndex_ = 0;
295     format_ = source_->GetTrackFormat(trackIndex_);
296     ASSERT_NE(format_, nullptr);
297     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
298     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
299     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
300     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
301     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
302     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
303     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
304     ASSERT_EQ(formatVal_.codecMime, "video/mpeg2");
305     ASSERT_EQ(formatVal_.width, 1920);
306     ASSERT_EQ(formatVal_.height, 1080);
307     ASSERT_DOUBLE_EQ(formatVal_.frameRate, 25.000000);
308     trackIndex_ = 1;
309     format_ = source_->GetTrackFormat(trackIndex_);
310     ASSERT_NE(format_, nullptr);
311     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
312     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
313     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
314     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
315     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
316     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
317     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
318     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
319     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
320     ASSERT_EQ(formatVal_.sampleRate, 44100);
321     ASSERT_EQ(formatVal_.channelCount, 2);
322     ASSERT_EQ(formatVal_.bitRate, 127103);
323     ASSERT_EQ(formatVal_.codecMime, "audio/mp4a-latm");
324     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
325     ASSERT_EQ(formatVal_.channelLayout, 3);
326 }
327 
328 /**
329  * @tc.name: AVSource_GetFormat_2030
330  * @tc.desc: get source format when the file is mp4
331  * @tc.type: FUNC
332  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2030, TestSize.Level1)333 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2030, TestSize.Level1)
334 {
335     printf("---- %s ------\n", g_mp4Uri3.data());
336     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri3.data()));
337     ASSERT_NE(source_, nullptr);
338     format_ = source_->GetSourceFormat();
339     ASSERT_NE(format_, nullptr);
340     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
341 #ifdef AVSOURCE_INNER_UNIT_TEST
342     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
343     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
344     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
345     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COMPOSER, formatVal_.composer));
346     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_AUTHOR, formatVal_.author));
347     ASSERT_EQ(formatVal_.hasVideo, 1);
348     ASSERT_EQ(formatVal_.hasAudio, 1);
349     ASSERT_EQ(formatVal_.fileType, 101);
350     ASSERT_EQ(formatVal_.composer, "composer");
351     ASSERT_EQ(formatVal_.author, "author");
352 #endif
353     trackIndex_ = 0;
354     format_ = source_->GetTrackFormat(trackIndex_);
355     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
356     ASSERT_NE(format_, nullptr);
357     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
358     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
359     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
360     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
361     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
362     ASSERT_EQ(formatVal_.codecMime, "video/mpeg2");
363     ASSERT_EQ(formatVal_.bitRate, 3889231);
364     ASSERT_DOUBLE_EQ(formatVal_.frameRate, 25.000000);
365     trackIndex_ = 1;
366     format_ = source_->GetTrackFormat(trackIndex_);
367     ASSERT_NE(format_, nullptr);
368     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
369     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
370     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
371     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
372     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
373     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
374     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
375     ASSERT_EQ(formatVal_.sampleRate, 44100);
376     ASSERT_EQ(formatVal_.channelCount, 2);
377     ASSERT_EQ(formatVal_.bitRate, 128563);
378     ASSERT_EQ(formatVal_.codecMime, "audio/mp4a-latm");
379     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
380     ASSERT_EQ(formatVal_.channelLayout, 3);
381 }
382 
383 /**
384  * @tc.name: AVSource_GetFormat_2050
385  * @tc.desc: get format when the file is mkv (video: h264, audio: opus)
386  * @tc.type: FUNC
387  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2050, TestSize.Level1)388 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2050, TestSize.Level1)
389 {
390     printf("---- %s ------\n", g_mkvUri2.data());
391     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mkvUri2.data()));
392     ASSERT_NE(source_, nullptr);
393     format_ = source_->GetSourceFormat();
394     ASSERT_NE(format_, nullptr);
395     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
396     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_TITLE, formatVal_.title));
397     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ARTIST, formatVal_.artist));
398     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ALBUM_ARTIST, formatVal_.albumArtist));
399     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_DATE, formatVal_.date));
400     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COMMENT, formatVal_.comment));
401     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_GENRE, formatVal_.genre));
402     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COPYRIGHT, formatVal_.copyright));
403     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_DESCRIPTION, formatVal_.description));
404     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_LYRICS, formatVal_.lyrics));
405     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
406     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
407     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_LANGUAGE, formatVal_.language));
408     ASSERT_EQ(formatVal_.title, "title");
409     ASSERT_EQ(formatVal_.artist, "artist");
410     ASSERT_EQ(formatVal_.albumArtist, "album_artist");
411     ASSERT_EQ(formatVal_.date, "2023");
412     ASSERT_EQ(formatVal_.comment, "comment");
413     ASSERT_EQ(formatVal_.genre, "genre");
414     ASSERT_EQ(formatVal_.copyright, "copyRight");
415     ASSERT_EQ(formatVal_.lyrics, "lyrics");
416     ASSERT_EQ(formatVal_.description, "description");
417     ASSERT_EQ(formatVal_.duration, 4001000);
418     ASSERT_EQ(formatVal_.trackCount, 2);
419     ASSERT_EQ(formatVal_.language, "language");
420 #ifdef AVSOURCE_INNER_UNIT_TEST
421     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COMPOSER, formatVal_.composer));
422     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_AUTHOR, formatVal_.author));
423     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
424     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
425     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
426     ASSERT_EQ(formatVal_.composer, "composer");
427     ASSERT_EQ(formatVal_.hasVideo, 1);
428     ASSERT_EQ(formatVal_.hasAudio, 1);
429     ASSERT_EQ(formatVal_.fileType, 103);
430     ASSERT_EQ(formatVal_.author, "author");
431 #endif
432 }
433 
434 /**
435  * @tc.name: AVSource_GetFormat_2060
436  * @tc.desc: get format when the file is mkv (video: h264, audio: opus)
437  * @tc.type: FUNC
438  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2060, TestSize.Level1)439 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2060, TestSize.Level1)
440 {
441     printf("---- %s ------\n", g_mkvUri2.data());
442     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mkvUri2.data()));
443     ASSERT_NE(source_, nullptr);
444     trackIndex_ = 0;
445     format_ = source_->GetTrackFormat(trackIndex_);
446     ASSERT_NE(format_, nullptr);
447     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
448     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
449     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
450     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
451     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
452     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
453     ASSERT_EQ(formatVal_.codecMime, "video/avc");
454     ASSERT_EQ(formatVal_.width, 1920);
455     ASSERT_EQ(formatVal_.height, 1080);
456     ASSERT_EQ(formatVal_.frameRate, 60.000000);
457     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
458     trackIndex_ = 1;
459     format_ = source_->GetTrackFormat(trackIndex_);
460     ASSERT_NE(format_, nullptr);
461     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
462     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
463     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
464     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
465     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
466     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
467     ASSERT_EQ(formatVal_.channelLayout, 4);
468     ASSERT_EQ(formatVal_.sampleRate, 48000);
469     ASSERT_EQ(formatVal_.codecMime, "audio/opus");
470     ASSERT_EQ(formatVal_.channelCount, 1);
471     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
472 }
473 
474 /**
475  * @tc.name: AVSource_GetFormat_2100
476  * @tc.desc: get format when the file is aac
477  * @tc.type: FUNC
478  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2100, TestSize.Level1)479 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2100, TestSize.Level1)
480 {
481     printf("---- %s ------\n", g_aacUri.data());
482     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_aacUri.data()));
483     ASSERT_NE(source_, nullptr);
484     format_ = source_->GetSourceFormat();
485     ASSERT_NE(format_, nullptr);
486     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
487     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
488     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
489     ASSERT_EQ(formatVal_.duration, 30023469);
490     ASSERT_EQ(formatVal_.trackCount, 1);
491 #ifdef AVSOURCE_INNER_UNIT_TEST
492     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
493     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
494     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
495     ASSERT_EQ(formatVal_.fileType, 202);
496     ASSERT_EQ(formatVal_.hasAudio, 1);
497     ASSERT_EQ(formatVal_.hasVideo, 0);
498 #endif
499     trackIndex_ = 0;
500     format_ = source_->GetTrackFormat(trackIndex_);
501     ASSERT_NE(format_, nullptr);
502     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
503     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
504     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
505     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
506     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
507     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, formatVal_.aacIsAdts));
508     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
509     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
510     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
511     ASSERT_EQ(formatVal_.channelLayout, 3);
512     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
513     ASSERT_EQ(formatVal_.sampleRate, 44100);
514     ASSERT_EQ(formatVal_.channelCount, 2);
515     ASSERT_EQ(formatVal_.bitRate, 126800);
516     ASSERT_EQ(formatVal_.aacIsAdts, 1);
517     ASSERT_EQ(formatVal_.codecMime, "audio/mp4a-latm");
518     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
519 }
520 
521 
522 /**
523  * @tc.name: AVSource_GetFormat_2110
524  * @tc.desc: get format when the file is flac
525  * @tc.type: FUNC
526  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2110, TestSize.Level1)527 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2110, TestSize.Level1)
528 {
529     printf("---- %s ------\n", g_flacUri.data());
530     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_flacUri.data()));
531     ASSERT_NE(source_, nullptr);
532     format_ = source_->GetSourceFormat();
533     ASSERT_NE(format_, nullptr);
534     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
535     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_TITLE, formatVal_.title));
536     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ARTIST, formatVal_.artist));
537     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ALBUM, formatVal_.album));
538     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ALBUM_ARTIST, formatVal_.albumArtist));
539     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_DATE, formatVal_.date));
540     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COMMENT, formatVal_.comment));
541     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_GENRE, formatVal_.genre));
542     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COPYRIGHT, formatVal_.copyright));
543     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_LYRICS, formatVal_.lyrics));
544     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_LANGUAGE, formatVal_.language));
545     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
546     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
547     ASSERT_EQ(formatVal_.title, "title");
548     ASSERT_EQ(formatVal_.artist, "artist");
549     ASSERT_EQ(formatVal_.album, "album");
550     ASSERT_EQ(formatVal_.albumArtist, "album artist");
551     ASSERT_EQ(formatVal_.date, "2023");
552     ASSERT_EQ(formatVal_.comment, "comment");
553     ASSERT_EQ(formatVal_.genre, "genre");
554     ASSERT_EQ(formatVal_.copyright, "Copyright");
555     ASSERT_EQ(formatVal_.lyrics, "lyrics");
556     ASSERT_EQ(formatVal_.duration, 30000000);
557     ASSERT_EQ(formatVal_.trackCount, 2);
558 #ifdef AVSOURCE_INNER_UNIT_TEST
559     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COMPOSER, formatVal_.composer));
560     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_AUTHOR, formatVal_.author));
561     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
562     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
563     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
564     ASSERT_EQ(formatVal_.composer, "composer");
565     ASSERT_EQ(formatVal_.author, "author");
566     ASSERT_EQ(formatVal_.fileType, 204);
567     ASSERT_EQ(formatVal_.hasAudio, 1);
568     ASSERT_EQ(formatVal_.hasVideo, 0);
569 #endif
570 }
571 
572 /**
573  * @tc.name: AVSource_GetFormat_2111
574  * @tc.desc: get format when the file is flac
575  * @tc.type: FUNC
576  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2111, TestSize.Level1)577 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2111, TestSize.Level1)
578 {
579     printf("---- %s ------\n", g_flacUri.data());
580     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_flacUri.data()));
581     ASSERT_NE(source_, nullptr);
582     trackIndex_ = 0;
583     format_ = source_->GetTrackFormat(trackIndex_);
584     ASSERT_NE(format_, nullptr);
585     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
586     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
587     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
588     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
589     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
590     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
591     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
592     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
593     ASSERT_EQ(formatVal_.channelLayout, 4);
594     ASSERT_EQ(formatVal_.sampleRate, 48000);
595     ASSERT_EQ(formatVal_.channelCount, 1);
596     ASSERT_EQ(formatVal_.codecMime, "audio/flac");
597     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_S32LE);
598 #ifdef AVSOURCE_INNER_UNIT_TEST
599     trackIndex_ = 1;
600     format_ = source_->GetTrackFormat(trackIndex_);
601     ASSERT_NE(format_, nullptr);
602     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
603     const char* outFile = "/data/test/flac_48000_1_uri.bin";
604     FILE* saveFile = fopen(outFile, "wb");
605     ASSERT_TRUE(format_->GetBuffer(MediaDescriptionKey::MD_KEY_COVER, &addr_, buffSize_));
606     fwrite(addr_, sizeof(uint8_t), buffSize_, saveFile);
607     fclose(saveFile);
608 #endif
609 }
610 
611 /**
612  * @tc.name: AVSource_GetFormat_2120
613  * @tc.desc: get format when the file is m4a
614  * @tc.type: FUNC
615  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2120, TestSize.Level1)616 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2120, TestSize.Level1)
617 {
618     printf("---- %s ------\n", g_m4aUri.data());
619     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_m4aUri.data()));
620     ASSERT_NE(source_, nullptr);
621     format_ = source_->GetSourceFormat();
622     ASSERT_NE(format_, nullptr);
623     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
624     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_TITLE, formatVal_.title));
625     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ARTIST, formatVal_.artist));
626     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ALBUM, formatVal_.album));
627     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ALBUM_ARTIST, formatVal_.albumArtist));
628     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_DATE, formatVal_.date));
629     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COMMENT, formatVal_.comment));
630     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_GENRE, formatVal_.genre));
631     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COPYRIGHT, formatVal_.copyright));
632     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_LYRICS, formatVal_.lyrics));
633     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_DESCRIPTION, formatVal_.description));
634     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
635     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
636     ASSERT_EQ(formatVal_.title, "title");
637     ASSERT_EQ(formatVal_.artist, "artist");
638     ASSERT_EQ(formatVal_.album, "album");
639     ASSERT_EQ(formatVal_.albumArtist, "album artist");
640     ASSERT_EQ(formatVal_.date, "2023");
641     ASSERT_EQ(formatVal_.comment, "comment");
642     ASSERT_EQ(formatVal_.genre, "genre");
643     ASSERT_EQ(formatVal_.copyright, "Copyright");
644     ASSERT_EQ(formatVal_.lyrics, "lyrics");
645     ASSERT_EQ(formatVal_.description, "description");
646     ASSERT_EQ(formatVal_.duration, 30016000);
647     ASSERT_EQ(formatVal_.trackCount, 1);
648 #ifdef AVSOURCE_INNER_UNIT_TEST
649     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COMPOSER, formatVal_.composer));
650     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
651     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
652     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
653     ASSERT_EQ(formatVal_.composer, "composer");
654     ASSERT_EQ(formatVal_.fileType, 206);
655     ASSERT_EQ(formatVal_.hasAudio, 1);
656     ASSERT_EQ(formatVal_.hasVideo, 0);
657 #endif
658 }
659 
660 /**
661  * @tc.name: AVSource_GetFormat_2121
662  * @tc.desc: get format when the file is m4a
663  * @tc.type: FUNC
664  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2121, TestSize.Level1)665 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2121, TestSize.Level1)
666 {
667     printf("---- %s ------\n", g_m4aUri.data());
668     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_m4aUri.data()));
669     ASSERT_NE(source_, nullptr);
670     format_ = source_->GetTrackFormat(trackIndex_);
671     ASSERT_NE(format_, nullptr);
672     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
673     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
674     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
675     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
676     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
677     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
678     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
679     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
680     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
681     ASSERT_EQ(formatVal_.channelLayout, 4);
682     ASSERT_EQ(formatVal_.sampleRate, 48000);
683     ASSERT_EQ(formatVal_.channelCount, 1);
684     ASSERT_EQ(formatVal_.codecMime, "audio/mp4a-latm");
685     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
686     ASSERT_EQ(formatVal_.bitRate, 69594);
687 }
688 
689 /**
690  * @tc.name: AVSource_GetFormat_2130
691  * @tc.desc: get format when the file is mp3
692  * @tc.type: FUNC
693  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2130, TestSize.Level1)694 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2130, TestSize.Level1)
695 {
696     printf("---- %s ------\n", g_mp3Uri.data());
697     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp3Uri.data()));
698     ASSERT_NE(source_, nullptr);
699     format_ = source_->GetSourceFormat();
700     ASSERT_NE(format_, nullptr);
701     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
702     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_TITLE, formatVal_.title));
703     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ARTIST, formatVal_.artist));
704     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ALBUM, formatVal_.album));
705     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ALBUM_ARTIST, formatVal_.albumArtist));
706     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_DATE, formatVal_.date));
707     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COMMENT, formatVal_.comment));
708     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_GENRE, formatVal_.genre));
709     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COPYRIGHT, formatVal_.copyright));
710     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_LYRICS, formatVal_.lyrics));
711     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_LANGUAGE, formatVal_.language));
712     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_DESCRIPTION, formatVal_.description));
713     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
714     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
715     ASSERT_EQ(formatVal_.title, "title");
716     ASSERT_EQ(formatVal_.artist, "artist");
717     ASSERT_EQ(formatVal_.album, "album");
718     ASSERT_EQ(formatVal_.albumArtist, "album artist");
719     ASSERT_EQ(formatVal_.date, "2023");
720     ASSERT_EQ(formatVal_.comment, "comment");
721     ASSERT_EQ(formatVal_.genre, "genre");
722     ASSERT_EQ(formatVal_.copyright, "Copyright");
723     ASSERT_EQ(formatVal_.lyrics, "SLT");
724     ASSERT_EQ(formatVal_.description, "description");
725     ASSERT_EQ(formatVal_.language, "language");
726     ASSERT_EQ(formatVal_.duration, 30024000);
727     ASSERT_EQ(formatVal_.trackCount, 2);
728 #ifdef AVSOURCE_INNER_UNIT_TEST
729     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
730     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
731     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
732     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COMPOSER, formatVal_.composer));
733     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_AUTHOR, formatVal_.author));
734     ASSERT_EQ(formatVal_.author, "author");
735     ASSERT_EQ(formatVal_.composer, "composer");
736     ASSERT_EQ(formatVal_.fileType, 203);
737     ASSERT_EQ(formatVal_.hasAudio, 1);
738     ASSERT_EQ(formatVal_.hasVideo, 0);
739 #endif
740 }
741 
742 /**
743  * @tc.name: AVSource_GetFormat_2131
744  * @tc.desc: get format when the file is mp3
745  * @tc.type: FUNC
746  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2131, TestSize.Level1)747 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2131, TestSize.Level1)
748 {
749     printf("---- %s ------\n", g_mp3Uri.data());
750     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp3Uri.data()));
751     ASSERT_NE(source_, nullptr);
752     trackIndex_ = 0;
753     format_ = source_->GetTrackFormat(trackIndex_);
754     ASSERT_NE(format_, nullptr);
755     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
756     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
757     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
758     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
759     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
760     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
761     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
762     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
763     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
764     ASSERT_EQ(formatVal_.channelLayout, 4);
765     ASSERT_EQ(formatVal_.sampleRate, 48000);
766     ASSERT_EQ(formatVal_.channelCount, 1);
767     ASSERT_EQ(formatVal_.codecMime, "audio/mpeg");
768     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
769     ASSERT_EQ(formatVal_.bitRate, 64000);
770 #ifdef AVSOURCE_INNER_UNIT_TEST
771     trackIndex_ = 1;
772     format_ = source_->GetTrackFormat(trackIndex_);
773     ASSERT_NE(format_, nullptr);
774     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
775     const char* outFile = "/data/test/mp3_48000_1_cover_uri.bin";
776     FILE* saveFile = fopen(outFile, "wb");
777     ASSERT_TRUE(format_->GetBuffer(MediaDescriptionKey::MD_KEY_COVER, &addr_, buffSize_));
778     fwrite(addr_, sizeof(uint8_t), buffSize_, saveFile);
779     fclose(saveFile);
780 #endif
781 }
782 
783 /**
784  * @tc.name: AVSource_GetFormat_2140
785  * @tc.desc: get format when the file is ogg
786  * @tc.type: FUNC
787  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2140, TestSize.Level1)788 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2140, TestSize.Level1)
789 {
790     printf("---- %s ------\n", g_oggUri.data());
791     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_oggUri.data()));
792     ASSERT_NE(source_, nullptr);
793     format_ = source_->GetSourceFormat();
794     ASSERT_NE(format_, nullptr);
795     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
796     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
797     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
798     ASSERT_EQ(formatVal_.duration, 30000000);
799     ASSERT_EQ(formatVal_.trackCount, 1);
800     format_ = source_->GetTrackFormat(trackIndex_);
801     ASSERT_NE(format_, nullptr);
802     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
803     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
804     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
805     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
806     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
807     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
808     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
809     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
810     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
811     ASSERT_EQ(formatVal_.channelLayout, 4);
812     ASSERT_EQ(formatVal_.sampleRate, 48000);
813     ASSERT_EQ(formatVal_.channelCount, 1);
814     ASSERT_EQ(formatVal_.codecMime, "audio/vorbis");
815     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
816     ASSERT_EQ(formatVal_.bitRate, 80000);
817 }
818 
819 /**
820  * @tc.name: AVSource_GetFormat_2150
821  * @tc.desc: get format when the file is wav
822  * @tc.type: FUNC
823  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2150, TestSize.Level1)824 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2150, TestSize.Level1)
825 {
826     printf("---- %s ------\n", g_wavUri.data());
827     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_wavUri.data()));
828     ASSERT_NE(source_, nullptr);
829     format_ = source_->GetSourceFormat();
830     ASSERT_NE(format_, nullptr);
831     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
832     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_TITLE, formatVal_.title));
833     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ARTIST, formatVal_.artist));
834     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_ALBUM, formatVal_.album));
835     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_DATE, formatVal_.date));
836     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COMMENT, formatVal_.comment));
837     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_GENRE, formatVal_.genre));
838     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_COPYRIGHT, formatVal_.copyright));
839     ASSERT_TRUE(format_->GetStringValue(AVSourceFormat::SOURCE_LANGUAGE, formatVal_.language));
840     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
841     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
842     ASSERT_EQ(formatVal_.title, "title");
843     ASSERT_EQ(formatVal_.artist, "artist");
844     ASSERT_EQ(formatVal_.album, "album");
845     ASSERT_EQ(formatVal_.date, "2023");
846     ASSERT_EQ(formatVal_.comment, "comment");
847     ASSERT_EQ(formatVal_.genre, "genre");
848     ASSERT_EQ(formatVal_.copyright, "Copyright");
849     ASSERT_EQ(formatVal_.language, "language");
850     ASSERT_EQ(formatVal_.duration, 30037333);
851     ASSERT_EQ(formatVal_.trackCount, 1);
852 #ifdef AVSOURCE_INNER_UNIT_TEST
853     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
854     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
855     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
856     ASSERT_EQ(formatVal_.fileType, 207);
857     ASSERT_EQ(formatVal_.hasAudio, 1);
858     ASSERT_EQ(formatVal_.hasVideo, 0);
859 #endif
860 }
861 
862 /**
863  * @tc.name: AVSource_GetFormat_2151
864  * @tc.desc: get format when the file is wav
865  * @tc.type: FUNC
866  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2151, TestSize.Level1)867 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2151, TestSize.Level1)
868 {
869     printf("---- %s ------\n", g_wavUri.data());
870     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_wavUri.data()));
871     ASSERT_NE(source_, nullptr);
872     format_ = source_->GetTrackFormat(trackIndex_);
873     ASSERT_NE(format_, nullptr);
874     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
875     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
876     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
877     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
878     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
879     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
880     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
881     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
882     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
883     ASSERT_EQ(formatVal_.channelLayout, 4);
884     ASSERT_EQ(formatVal_.sampleRate, 48000);
885     ASSERT_EQ(formatVal_.channelCount, 1);
886     ASSERT_EQ(formatVal_.codecMime, "audio/raw");
887     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_S16LE);
888     ASSERT_EQ(formatVal_.bitRate, 768000);
889 }
890 
891 /**
892  * @tc.name: AVSource_GetFormat_2160
893  * @tc.desc: get format when the file is amr
894  * @tc.type: FUNC
895  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2160, TestSize.Level1)896 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2160, TestSize.Level1)
897 {
898     printf("---- %s ------\n", g_amrUri.data());
899     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_amrUri.data()));
900     ASSERT_NE(source_, nullptr);
901     format_ = source_->GetSourceFormat();
902     ASSERT_NE(format_, nullptr);
903     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
904     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
905     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
906     ASSERT_EQ(formatVal_.duration, 30988375);
907     ASSERT_EQ(formatVal_.trackCount, 1);
908 #ifdef AVSOURCE_INNER_UNIT_TEST
909     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
910     ASSERT_EQ(formatVal_.fileType, 201);
911 #endif
912     format_ = source_->GetTrackFormat(trackIndex_);
913     ASSERT_NE(format_, nullptr);
914     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
915     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
916     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
917     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
918     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
919     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
920     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
921     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
922     ASSERT_EQ(formatVal_.channelLayout, 4);
923     ASSERT_EQ(formatVal_.sampleRate, 8000);
924     ASSERT_EQ(formatVal_.channelCount, 1);
925     ASSERT_EQ(formatVal_.codecMime, "audio/3gpp");
926     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
927 }
928 
929 /**
930  * @tc.name: AVSource_GetFormat_2170
931  * @tc.desc: get format when the file is amr
932  * @tc.type: FUNC
933  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2170, TestSize.Level1)934 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2170, TestSize.Level1)
935 {
936     printf("---- %s ------\n", g_amrUri2.data());
937     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_amrUri2.data()));
938     ASSERT_NE(source_, nullptr);
939     format_ = source_->GetSourceFormat();
940     ASSERT_NE(format_, nullptr);
941     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
942     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
943     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
944     ASSERT_EQ(formatVal_.duration, 30937500);
945     ASSERT_EQ(formatVal_.trackCount, 1);
946 #ifdef AVSOURCE_INNER_UNIT_TEST
947     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
948     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
949     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
950     ASSERT_EQ(formatVal_.fileType, 201);
951     ASSERT_EQ(formatVal_.hasAudio, 1);
952     ASSERT_EQ(formatVal_.hasVideo, 0);
953 #endif
954     format_ = source_->GetTrackFormat(trackIndex_);
955     ASSERT_NE(format_, nullptr);
956     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
957     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
958     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
959     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
960     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
961     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
962     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
963     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
964     ASSERT_EQ(formatVal_.channelLayout, 4);
965     ASSERT_EQ(formatVal_.sampleRate, 16000);
966     ASSERT_EQ(formatVal_.channelCount, 1);
967     ASSERT_EQ(formatVal_.codecMime, "audio/amr-wb");
968     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
969 }
970 
971 /**
972  * @tc.name: AVSource_GetFormat_2180
973  * @tc.desc: get format when the file is audio vivid (m4a)
974  * @tc.type: FUNC
975  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2180, TestSize.Level1)976 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2180, TestSize.Level1)
977 {
978     printf("---- %s ------\n", g_audioVividUri.data());
979     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_audioVividUri.data()));
980     ASSERT_NE(source_, nullptr);
981     format_ = source_->GetSourceFormat();
982     ASSERT_NE(format_, nullptr);
983     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
984     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
985     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
986     ASSERT_EQ(formatVal_.duration, 32044000);
987     ASSERT_EQ(formatVal_.trackCount, 1);
988 #ifdef AVSOURCE_INNER_UNIT_TEST
989     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
990     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
991     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
992     ASSERT_EQ(formatVal_.fileType, 206);
993     ASSERT_EQ(formatVal_.hasVideo, 0);
994     ASSERT_EQ(formatVal_.hasAudio, 1);
995 #endif
996     format_ = source_->GetTrackFormat(trackIndex_);
997     ASSERT_NE(format_, nullptr);
998     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
999     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
1000     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
1001     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
1002     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
1003     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
1004     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
1005     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
1006     ASSERT_EQ(formatVal_.channelLayout, 3);
1007     ASSERT_EQ(formatVal_.sampleRate, 44100);
1008     ASSERT_EQ(formatVal_.channelCount, 2);
1009     ASSERT_EQ(formatVal_.codecMime, CodecMimeType::AUDIO_AVS3DA);
1010     ASSERT_EQ(formatVal_.bitRate, 64082);
1011 }
1012 
1013 /**
1014  * @tc.name: AVSource_GetFormat_1317
1015  * @tc.desc: get fmp4 264 mp4 format, uri
1016  * @tc.type: FUNC
1017  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1317, TestSize.Level1)1018 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1317, TestSize.Level1)
1019 {
1020     printf("---- %s ------\n", g_fmp4AvcUri.data());
1021     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_fmp4AvcUri.data()));
1022     ASSERT_NE(source_, nullptr);
1023     format_ = source_->GetSourceFormat();
1024     ASSERT_NE(format_, nullptr);
1025     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
1026     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
1027     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
1028     ASSERT_EQ(formatVal_.duration, 10066666);
1029     ASSERT_EQ(formatVal_.trackCount, 2);
1030 #ifdef AVSOURCE_INNER_UNIT_TEST
1031     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
1032     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
1033     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
1034     ASSERT_EQ(formatVal_.hasVideo, 1);
1035     ASSERT_EQ(formatVal_.hasAudio, 1);
1036     ASSERT_EQ(formatVal_.fileType, 101);
1037 #endif
1038     format_ = source_->GetTrackFormat(trackIndex_);
1039     ASSERT_NE(format_, nullptr);
1040     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
1041     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
1042     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
1043     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
1044     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
1045     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
1046     ASSERT_EQ(formatVal_.codecMime, "video/avc");
1047     ASSERT_EQ(formatVal_.width, 720);
1048     ASSERT_EQ(formatVal_.height, 480);
1049     ASSERT_EQ(formatVal_.frameRate, 60.000000);
1050     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
1051     trackIndex_ = 1;
1052     format_ = source_->GetTrackFormat(trackIndex_);
1053     ASSERT_NE(format_, nullptr);
1054     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
1055     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
1056     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
1057     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
1058     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
1059     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
1060     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
1061     ASSERT_EQ(formatVal_.channelLayout, 3);
1062     ASSERT_EQ(formatVal_.sampleRate, 44100);
1063     ASSERT_EQ(formatVal_.codecMime, "audio/mp4a-latm");
1064     ASSERT_EQ(formatVal_.channelCount, 2);
1065     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
1066     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
1067 }
1068 
1069 /**
1070  * @tc.name: AVSource_GetFormat_1320
1071  * @tc.desc: get fmp4 m4v format, uri
1072  * @tc.type: FUNC
1073  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1320, TestSize.Level1)1074 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1320, TestSize.Level1)
1075 {
1076     printf("---- %s ------\n", g_fmp4m4vUri.data());
1077     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_fmp4m4vUri.data()));
1078     ASSERT_NE(source_, nullptr);
1079     format_ = source_->GetSourceFormat();
1080     ASSERT_NE(format_, nullptr);
1081     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
1082     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
1083     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
1084     ASSERT_EQ(formatVal_.duration, 10033333);
1085     ASSERT_EQ(formatVal_.trackCount, 1);
1086 #ifdef AVSOURCE_INNER_UNIT_TEST
1087     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
1088     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
1089     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
1090     ASSERT_EQ(formatVal_.hasVideo, 1);
1091     ASSERT_EQ(formatVal_.hasAudio, 0);
1092     ASSERT_EQ(formatVal_.fileType, 206);
1093 #endif
1094     format_ = source_->GetTrackFormat(trackIndex_);
1095     ASSERT_NE(format_, nullptr);
1096     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
1097     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
1098     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
1099     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
1100     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
1101     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
1102     ASSERT_EQ(formatVal_.codecMime, "video/avc");
1103     ASSERT_EQ(formatVal_.width, 720);
1104     ASSERT_EQ(formatVal_.height, 480);
1105     ASSERT_EQ(formatVal_.frameRate, 60.000000);
1106     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
1107 }
1108 
1109 /**
1110  * @tc.name: AVSource_GetFormat_1321
1111  * @tc.desc: get fmp4 m4a format, uri
1112  * @tc.type: FUNC
1113  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1321, TestSize.Level1)1114 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1321, TestSize.Level1)
1115 {
1116     printf("---- %s ------\n", g_fmp4m4aUri.data());
1117     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_fmp4m4aUri.data()));
1118     ASSERT_NE(source_, nullptr);
1119     format_ = source_->GetSourceFormat();
1120     ASSERT_NE(format_, nullptr);
1121     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
1122     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
1123     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
1124     ASSERT_EQ(formatVal_.duration, 10064354);
1125     ASSERT_EQ(formatVal_.trackCount, 1);
1126 #ifdef AVSOURCE_INNER_UNIT_TEST
1127     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
1128     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
1129     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
1130     ASSERT_EQ(formatVal_.hasVideo, 0);
1131     ASSERT_EQ(formatVal_.hasAudio, 1);
1132     ASSERT_EQ(formatVal_.fileType, 206);
1133 #endif
1134     format_ = source_->GetTrackFormat(trackIndex_);
1135     ASSERT_NE(format_, nullptr);
1136     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
1137     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
1138     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
1139     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
1140     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
1141     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
1142     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
1143     ASSERT_EQ(formatVal_.channelLayout, 3);
1144     ASSERT_EQ(formatVal_.sampleRate, 44100);
1145     ASSERT_EQ(formatVal_.codecMime, "audio/mp4a-latm");
1146     ASSERT_EQ(formatVal_.channelCount, 2);
1147     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
1148     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
1149 }
1150 
1151 /**
1152  * @tc.name: AVSource_GetFormat_3001
1153  * @tc.desc: get format when the file is srt
1154  * @tc.type: FUNC
1155  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_3001, TestSize.Level1)1156 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_3001, TestSize.Level1)
1157 {
1158     printf("---- %s ------\n", g_srt.data());
1159     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_srt.data()));
1160     ASSERT_NE(source_, nullptr);
1161     format_ = source_->GetSourceFormat();
1162     ASSERT_NE(format_, nullptr);
1163     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
1164     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
1165     ASSERT_EQ(formatVal_.trackCount, 1);
1166 #ifdef AVSOURCE_INNER_UNIT_TEST
1167     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
1168     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
1169     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
1170     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_SUBTITLE, formatVal_.hasSubtitle));
1171     ASSERT_EQ(formatVal_.fileType, 301);
1172     ASSERT_EQ(formatVal_.hasVideo, 0);
1173     ASSERT_EQ(formatVal_.hasAudio, 0);
1174     ASSERT_EQ(formatVal_.hasSubtitle, 1);
1175 #endif
1176 
1177     printf("---- %s ----\n", g_srt.c_str());
1178     trackIndex_ = 0;
1179     format_ = source_->GetTrackFormat(trackIndex_);
1180     ASSERT_NE(format_, nullptr);
1181     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
1182     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
1183     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
1184     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_SUBTITLE);
1185     ASSERT_EQ(formatVal_.codecMime, "application/x-subrip");
1186 }
1187 
1188 /**
1189  * @tc.name: AVSource_GetFormat_1611
1190  * @tc.desc: get mp4 vvc format, uri
1191  * @tc.type: FUNC
1192  */
HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1611, TestSize.Level1)1193 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1611, TestSize.Level1)
1194 {
1195     if (access(g_mp4VvcPath.c_str(), F_OK) != 0) {
1196         return;
1197     }
1198     printf("---- %s ------\n", g_mp4VvcUri.data());
1199     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4VvcUri.data()));
1200     ASSERT_NE(source_, nullptr);
1201     format_ = source_->GetSourceFormat();
1202     ASSERT_NE(format_, nullptr);
1203     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
1204     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
1205     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
1206     ASSERT_EQ(formatVal_.duration, 10000000);
1207     ASSERT_EQ(formatVal_.trackCount, 1);
1208 #ifdef AVSOURCE_INNER_UNIT_TEST
1209     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
1210     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
1211     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
1212     ASSERT_EQ(formatVal_.hasVideo, 1);
1213     ASSERT_EQ(formatVal_.hasAudio, 0);
1214     ASSERT_EQ(formatVal_.fileType, 101);
1215 #endif
1216     trackIndex_ = 0;
1217     format_ = source_->GetTrackFormat(trackIndex_);
1218     ASSERT_NE(format_, nullptr);
1219     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
1220     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
1221     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
1222     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
1223     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
1224     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
1225     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
1226     ASSERT_EQ(formatVal_.bitRate, 506976);
1227     ASSERT_EQ(formatVal_.codecMime, "video/vvc");
1228     ASSERT_DOUBLE_EQ(formatVal_.frameRate, 60.000000);
1229     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
1230     ASSERT_EQ(formatVal_.width, 640);
1231     ASSERT_EQ(formatVal_.height, 360);
1232 }
1233 } // namespace