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 <map>
21 #include "gtest/gtest.h"
22 #include "avcodec_errors.h"
23 #include "avcodec_audio_common.h"
24 #include "avcodec_info.h"
25 #include "avcodec_audio_channel_layout.h"
26 #include "avcodec_mime_type.h"
27 #include "media_description.h"
28 #include "file_server_demo.h"
29 #include "avsource_unit_test.h"
30 
31 #define LOCAL true
32 #define URI false
33 
34 using namespace OHOS;
35 using namespace OHOS::MediaAVCodec;
36 using namespace testing::ext;
37 using namespace std;
38 
39 namespace {
40 unique_ptr<FileServerDemo> server = nullptr;
41 static const string TEST_FILE_PATH = "/data/test/media/";
42 static const string TEST_URI_PATH = "http://127.0.0.1:46666/";
43 const std::string HEVC_LIB_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_hevc_parser.z.so";
44 const int64_t SOURCE_OFFSET = 0;
45 string g_hdrVividPath = TEST_FILE_PATH + string("hdrvivid_720p_2s.mp4");
46 string g_hdrVividUri = TEST_URI_PATH + string("hdrvivid_720p_2s.mp4");
47 string g_mp4HevcPath = TEST_FILE_PATH + string("camera_h265_aac_rotate270.mp4");
48 string g_mp4HevcdUri = TEST_URI_PATH + string("camera_h265_aac_rotate270.mp4");
49 string g_mkvHevcAccPath = TEST_FILE_PATH + string("h265_aac_4sec.mkv");
50 string g_mkvHevcAccUri = TEST_URI_PATH + string("h265_aac_4sec.mkv");
51 string g_mkvAvcOpusPath = TEST_FILE_PATH + string("h264_opus_4sec.mkv");
52 string g_mkvAvcOpusUri = TEST_URI_PATH + string("h264_opus_4sec.mkv");
53 string g_mkvAvcMp3Path = TEST_FILE_PATH + string("h264_mp3_4sec.mkv");
54 string g_mkvAvcMp3Uri = TEST_URI_PATH + string("h264_mp3_4sec.mkv");
55 string g_tsHevcAacPath = TEST_FILE_PATH + string("hevc_aac_1920x1080_g30_30fps.ts");
56 string g_tsHevcAacUri = TEST_URI_PATH + string("hevc_aac_1920x1080_g30_30fps.ts");
57 string g_flvPath = TEST_FILE_PATH + string("h265_enhanced.flv");
58 string g_fmp4HevcPath = TEST_FILE_PATH + string("h265_fmp4.mp4");
59 string g_fmp4HevcUri = TEST_URI_PATH + string("h265_fmp4.mp4");
60 string g_doubleVividPath = TEST_FILE_PATH + string("audiovivid_hdrvivid_2s.mp4");
61 string g_doubleVividUri = TEST_URI_PATH + string("audiovivid_hdrvivid_2s.mp4");
62 string g_mp4265InfoParsePath = TEST_FILE_PATH + string("test_265_B_Gop25_4sec.mp4");
63 string g_265pcmPath = TEST_FILE_PATH + string("265_pcm_s16le.mov");
64 string g_265pcmUri = TEST_URI_PATH + string("265_pcm_s16le.mov");
65 
66 std::map<std::string, std::map<std::string, int32_t>> infoMap = {
67     {"hdrVivid", {
68         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN_10)},
69         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_4)},
70         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_BT2020_NCL)},
71         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_HLG)},
72         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_BT2020)},
73         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
74     }},
75     {"mp4Hevc", {
76         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN)},
77         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_31)},
78         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_BT709)},
79         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_BT709)},
80         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_BT709)},
81         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
82     }},
83     {"mkvHevcAcc", {
84         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN)},
85         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_41)},
86         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_UNSPECIFIED)},
87         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_UNSPECIFIED)},
88         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_UNSPECIFIED)},
89         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
90     }},
91     {"tsHevcAac", {
92         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN)},
93         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_4)},
94         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_UNSPECIFIED)},
95         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_UNSPECIFIED)},
96         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_UNSPECIFIED)},
97         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
98     }},
99     {"HevcFlv", {
100         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN_10)},
101         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_31)},
102         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_BT2020_NCL)},
103         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_HLG)},
104         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_BT2020)},
105         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
106     }},
107     {"Hevcfmp4", {
108         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN)},
109         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_31)},
110         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_UNSPECIFIED)},
111         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_UNSPECIFIED)},
112         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_UNSPECIFIED)},
113         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
114     }},
115     {"Hevcmov", {
116         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN)},
117         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_31)},
118         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_UNSPECIFIED)},
119         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_UNSPECIFIED)},
120         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_UNSPECIFIED)},
121         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
122     }},
123     {"doubleVivid", {
124         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN_10)},
125         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_4)},
126         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_BT2020_NCL)},
127         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_HLG)},
128         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_BT2020)},
129         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
130     }}
131 };
132 } // namespace
133 
InitResource(const std::string & path,bool local)134 void AVSourceUnitTest::InitResource(const std::string &path, bool local)
135 {
136     printf("---- %s ------\n", path.c_str());
137     if (local) {
138         fd_ = OpenFile(path);
139         int64_t size = GetFileSize(path);
140         source_ = AVSourceMockFactory::CreateSourceWithFD(fd_, SOURCE_OFFSET, size);
141         ASSERT_NE(source_, nullptr);
142     } else {
143         source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(path.data()));
144         ASSERT_NE(source_, nullptr);
145     }
146     format_ = source_->GetSourceFormat();
147     ASSERT_NE(format_, nullptr);
148     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, streamsCount_));
149     for (int i = 0; i < streamsCount_; i++) {
150         format_ = source_->GetTrackFormat(i);
151         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
152         if (formatVal_.trackType == MediaType::MEDIA_TYPE_VID) {
153             vTrackIdx_ = i;
154         } else if (formatVal_.trackType == MediaType::MEDIA_TYPE_AUD) {
155             aTrackIdx_ = i;
156         }
157     }
158     initStatus_ = true;
159 }
160 
CheckHevcInfo(const std::string resName)161 void AVSourceUnitTest::CheckHevcInfo(const std::string resName)
162 {
163     for (int i = 0; i < streamsCount_; i++) {
164         format_ = source_->GetTrackFormat(i);
165         string codecMime;
166         format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, codecMime);
167         if (codecMime == AVCodecMimeType::MEDIA_MIMETYPE_VIDEO_HEVC) {
168             printf("[trackFormat %d]: %s\n", i, format_->DumpInfo());
169             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_PROFILE, formatVal_.profile));
170             ASSERT_EQ(formatVal_.profile, infoMap[resName]["profile"]);
171             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_COLOR_PRIMARIES, formatVal_.colorPri));
172             ASSERT_EQ(formatVal_.colorPri, infoMap[resName]["colorPrim"]);
173             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRANSFER_CHARACTERISTICS,
174                 formatVal_.colorTrans));
175             ASSERT_EQ(formatVal_.colorTrans, infoMap[resName]["colorTrans"]);
176             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_MATRIX_COEFFICIENTS, formatVal_.colorMatrix));
177             ASSERT_EQ(formatVal_.colorMatrix, infoMap[resName]["colorMatrix"]);
178             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_RANGE_FLAG, formatVal_.colorRange));
179             ASSERT_EQ(formatVal_.colorRange, infoMap[resName]["colorRange"]);
180 #ifdef AVSOURCE_INNER_UNIT_TEST
181             printf("-------input inner--------\n");
182             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHROMA_LOCATION, formatVal_.chromaLoc));
183             ASSERT_EQ(formatVal_.chromaLoc, infoMap[resName]["chromaLoc"]);
184             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_LEVEL, formatVal_.level));
185             ASSERT_EQ(formatVal_.level, infoMap[resName]["level"]);
186 #endif
187             if (resName == "hdrVivid" || resName == "doubleVivid") {
188                 ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_VIDEO_IS_HDR_VIVID,
189                     formatVal_.isHdrVivid));
190                 printf("isHdrVivid = %d\n", formatVal_.isHdrVivid);
191                 ASSERT_EQ(formatVal_.isHdrVivid, 1);
192             } else {
193                 ASSERT_FALSE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_VIDEO_IS_HDR_VIVID,
194                     formatVal_.isHdrVivid));
195             }
196         }
197     }
198 }
199 
200 namespace {
201 /**
202  * @tc.name: AVSource_GetFormat_1190
203  * @tc.desc: get HDRVivid format, local
204  * @tc.type: FUNC
205  */
206 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1190, TestSize.Level1)
207 {
208     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
209         return;
210     }
211     InitResource(g_hdrVividPath, LOCAL);
212     ASSERT_TRUE(initStatus_);
213     CheckHevcInfo("hdrVivid");
214 }
215 
216 /**
217  * @tc.name: AVSource_GetFormat_1120
218  * @tc.desc: get HDRVivid format, uri
219  * @tc.type: FUNC
220  */
221 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1120, TestSize.Level1)
222 {
223     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
224         return;
225     }
226     InitResource(g_hdrVividUri, URI);
227     ASSERT_TRUE(initStatus_);
228     CheckHevcInfo("hdrVivid");
229 }
230 
231 /**
232  * @tc.name: AVSource_GetFormat_1200
233  * @tc.desc: get mp4 265 format, local
234  * @tc.type: FUNC
235  */
236 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1200, TestSize.Level1)
237 {
238     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
239         return;
240     }
241     InitResource(g_mp4HevcPath, LOCAL);
242     ASSERT_TRUE(initStatus_);
243     CheckHevcInfo("mp4Hevc");
244 }
245 
246 /**
247  * @tc.name: AVSource_GetFormat_1201
248  * @tc.desc: get mp4 265 format, uri
249  * @tc.type: FUNC
250  */
251 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1201, TestSize.Level1)
252 {
253     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
254         return;
255     }
256     InitResource(g_mp4HevcdUri, URI);
257     ASSERT_TRUE(initStatus_);
258     CheckHevcInfo("mp4Hevc");
259 }
260 
261 /**
262  * @tc.name: AVSource_GetFormat_1300
263  * @tc.desc: get mkv 265 aac format, local
264  * @tc.type: FUNC
265  */
266 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1300, TestSize.Level1)
267 {
268     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
269         return;
270     }
271     InitResource(g_mkvHevcAccPath, LOCAL);
272     ASSERT_TRUE(initStatus_);
273     CheckHevcInfo("mkvHevcAcc");
274 }
275 
276 /**
277  * @tc.name: AVSource_GetFormat_1303
278  * @tc.desc: get mkv 265 aac format, uri
279  * @tc.type: FUNC
280  */
281 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1303, TestSize.Level1)
282 {
283     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
284         return;
285     }
286     InitResource(g_mkvHevcAccUri, URI);
287     ASSERT_TRUE(initStatus_);
288     CheckHevcInfo("mkvHevcAcc");
289 }
290 
291 /**
292  * @tc.name: AVSource_GetFormat_1301
293  * @tc.desc: get mkv 264 opus format, local
294  * @tc.type: FUNC
295  */
296 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1301, TestSize.Level1)
297 {
298     InitResource(g_mkvAvcOpusPath, LOCAL);
299     ASSERT_TRUE(initStatus_);
300     trackIndex_ = vTrackIdx_;
301     format_ = source_->GetTrackFormat(trackIndex_);
302     ASSERT_NE(format_, nullptr);
303     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
304     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
305     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
306     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
307     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
308     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
309     ASSERT_EQ(formatVal_.codecMime, "video/avc");
310     ASSERT_EQ(formatVal_.width, 1920);
311     ASSERT_EQ(formatVal_.height, 1080);
312     ASSERT_EQ(formatVal_.frameRate, 60.000000);
313     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
314     trackIndex_ = aTrackIdx_;
315     format_ = source_->GetTrackFormat(trackIndex_);
316     ASSERT_NE(format_, nullptr);
317     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
318     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
319     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
320     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
321     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
322     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
323     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
324     ASSERT_EQ(formatVal_.channelLayout, static_cast<int64_t>(AudioChannelLayout::MONO));
325     ASSERT_EQ(formatVal_.sampleRate, 48000);
326     ASSERT_EQ(formatVal_.codecMime, "audio/opus");
327     ASSERT_EQ(formatVal_.channelCount, 1);
328     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
329     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
330 }
331 
332 /**
333  * @tc.name: AVSource_GetFormat_1302
334  * @tc.desc: get mkv 264 mp3 format, local
335  * @tc.type: FUNC
336  */
337 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1302, TestSize.Level1)
338 {
339     InitResource(g_mkvAvcMp3Path, LOCAL);
340     ASSERT_TRUE(initStatus_);
341     trackIndex_ = vTrackIdx_;
342     format_ = source_->GetTrackFormat(trackIndex_);
343     ASSERT_NE(format_, nullptr);
344     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
345     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
346     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
347     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
348     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
349     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
350     ASSERT_EQ(formatVal_.codecMime, "video/avc");
351     ASSERT_EQ(formatVal_.width, 1920);
352     ASSERT_EQ(formatVal_.height, 1080);
353     ASSERT_EQ(formatVal_.frameRate, 60.000000);
354     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
355     trackIndex_ = aTrackIdx_;
356     format_ = source_->GetTrackFormat(trackIndex_);
357     ASSERT_NE(format_, nullptr);
358     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
359     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
360     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
361     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
362     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
363     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
364     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
365     ASSERT_EQ(formatVal_.channelLayout, static_cast<int64_t>(AudioChannelLayout::STEREO));
366     ASSERT_EQ(formatVal_.sampleRate, 44100);
367     ASSERT_EQ(formatVal_.codecMime, "audio/mpeg");
368     ASSERT_EQ(formatVal_.channelCount, 2);
369     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
370     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
371 }
372 
373 /**
374  * @tc.name: AVSource_GetFormat_2310
375  * @tc.desc: get pcm hevc track format, local
376  * @tc.type: FUNC
377  */
378 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2310, TestSize.Level1)
379 {
380     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
381         return;
382     }
383     InitResource(g_265pcmPath, LOCAL);
384     ASSERT_TRUE(initStatus_);
385     trackIndex_ = 0;
386     format_ = source_->GetTrackFormat(trackIndex_);
387     ASSERT_NE(format_, nullptr);
388     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
389     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
390     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
391     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
392     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
393     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
394     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
395     ASSERT_EQ(formatVal_.codecMime, "video/hevc");
396     ASSERT_EQ(formatVal_.width, 720);
397     ASSERT_EQ(formatVal_.height, 480);
398     ASSERT_DOUBLE_EQ(formatVal_.frameRate, 60.000000);
399     trackIndex_ = 1;
400     format_->Destroy();
401     format_ = source_->GetTrackFormat(trackIndex_);
402     ASSERT_NE(format_, nullptr);
403     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
404     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
405     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
406     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
407     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
408     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
409     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
410     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
411     ASSERT_EQ(formatVal_.sampleRate, 44100);
412     ASSERT_EQ(formatVal_.channelCount, 2);
413     ASSERT_EQ(formatVal_.codecMime, "audio/raw");
414     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_S16LE);
415     ASSERT_EQ(formatVal_.channelLayout, 3);
416     CheckHevcInfo("Hevcmov");
417 }
418 
419 /**
420  * @tc.name: AVSource_GetFormat_2311
421  * @tc.desc: get pcm hevc track format, uri
422  * @tc.type: FUNC
423  */
424 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2311, TestSize.Level1)
425 {
426     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
427         return;
428     }
429     InitResource(g_265pcmUri, URI);
430     ASSERT_TRUE(initStatus_);
431     trackIndex_ = 0;
432     format_ = source_->GetTrackFormat(trackIndex_);
433     ASSERT_NE(format_, nullptr);
434     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
435     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
436     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
437     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
438     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
439     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
440     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
441     ASSERT_EQ(formatVal_.codecMime, "video/hevc");
442     ASSERT_EQ(formatVal_.width, 720);
443     ASSERT_EQ(formatVal_.height, 480);
444     ASSERT_DOUBLE_EQ(formatVal_.frameRate, 60.000000);
445     trackIndex_ = 1;
446     format_->Destroy();
447     format_ = source_->GetTrackFormat(trackIndex_);
448     ASSERT_NE(format_, nullptr);
449     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
450     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
451     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
452     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
453     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
454     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
455     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
456     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
457     ASSERT_EQ(formatVal_.sampleRate, 44100);
458     ASSERT_EQ(formatVal_.channelCount, 2);
459     ASSERT_EQ(formatVal_.codecMime, "audio/raw");
460     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_S16LE);
461     ASSERT_EQ(formatVal_.channelLayout, 3);
462     CheckHevcInfo("Hevcmov");
463 }
464 
465 /**
466  * @tc.name: AVSource_GetFormat_1304
467  * @tc.desc: get mkv 264 opus format, uri
468  * @tc.type: FUNC
469  */
470 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1304, TestSize.Level1)
471 {
472     InitResource(g_mkvAvcOpusUri, URI);
473     ASSERT_TRUE(initStatus_);
474     trackIndex_ = vTrackIdx_;
475     format_ = source_->GetTrackFormat(trackIndex_);
476     ASSERT_NE(format_, nullptr);
477     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
478     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
479     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
480     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
481     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
482     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
483     ASSERT_EQ(formatVal_.codecMime, "video/avc");
484     ASSERT_EQ(formatVal_.width, 1920);
485     ASSERT_EQ(formatVal_.height, 1080);
486     ASSERT_EQ(formatVal_.frameRate, 60.000000);
487     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
488     trackIndex_ = aTrackIdx_;
489     format_ = source_->GetTrackFormat(trackIndex_);
490     ASSERT_NE(format_, nullptr);
491     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
492     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
493     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
494     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
495     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
496     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
497     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
498     ASSERT_EQ(formatVal_.channelLayout, static_cast<int64_t>(AudioChannelLayout::MONO));
499     ASSERT_EQ(formatVal_.sampleRate, 48000);
500     ASSERT_EQ(formatVal_.codecMime, "audio/opus");
501     ASSERT_EQ(formatVal_.channelCount, 1);
502     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
503     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
504 }
505 
506 /**
507  * @tc.name: AVSource_GetFormat_1305
508  * @tc.desc: get mkv 264 mp3 format, uri
509  * @tc.type: FUNC
510  */
511 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1305, TestSize.Level1)
512 {
513     InitResource(g_mkvAvcMp3Uri, URI);
514     ASSERT_TRUE(initStatus_);
515     trackIndex_ = vTrackIdx_;
516     format_ = source_->GetTrackFormat(trackIndex_);
517     ASSERT_NE(format_, nullptr);
518     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
519     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
520     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
521     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
522     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
523     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
524     ASSERT_EQ(formatVal_.codecMime, "video/avc");
525     ASSERT_EQ(formatVal_.width, 1920);
526     ASSERT_EQ(formatVal_.height, 1080);
527     ASSERT_EQ(formatVal_.frameRate, 60.000000);
528     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
529     trackIndex_ = aTrackIdx_;
530     format_ = source_->GetTrackFormat(trackIndex_);
531     ASSERT_NE(format_, nullptr);
532     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
533     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
534     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
535     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
536     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
537     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
538     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
539     ASSERT_EQ(formatVal_.channelLayout, static_cast<int64_t>(AudioChannelLayout::STEREO));
540     ASSERT_EQ(formatVal_.sampleRate, 44100);
541     ASSERT_EQ(formatVal_.codecMime, "audio/mpeg");
542     ASSERT_EQ(formatVal_.channelCount, 2);
543     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
544     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
545 }
546 
547 /**
548  * @tc.name: AVSource_GetFormat_1306
549  * @tc.desc: get hevc format, local (ts)
550  * @tc.type: FUNC
551  */
552 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1306, TestSize.Level1)
553 {
554     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
555         return;
556     }
557     InitResource(g_tsHevcAacPath, LOCAL);
558     ASSERT_TRUE(initStatus_);
559     format_ = source_->GetSourceFormat(); // source
560     ASSERT_NE(format_, nullptr);
561     format_->DumpInfo();
562     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
563     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
564     ASSERT_EQ(formatVal_.duration, 10123222);
565     ASSERT_EQ(formatVal_.trackCount, 2);
566     CheckHevcInfo("tsHevcAac");
567 }
568 
569 /**
570  * @tc.name: AVSource_GetFormat_1307
571  * @tc.desc: get hevc format, local (ts)
572  * @tc.type: FUNC
573  */
574 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1307, TestSize.Level1)
575 {
576     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
577         return;
578     }
579     InitResource(g_tsHevcAacUri, URI);
580     ASSERT_TRUE(initStatus_);
581     format_ = source_->GetSourceFormat(); // source
582     ASSERT_NE(format_, nullptr);
583     format_->DumpInfo();
584     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
585     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
586     ASSERT_EQ(formatVal_.duration, 10123222);
587     ASSERT_EQ(formatVal_.trackCount, 2);
588     CheckHevcInfo("tsHevcAac");
589 }
590 
591 /**
592  * @tc.name: AVSource_GetFormat_1312
593  * @tc.desc: get fmp4 hevc mp4 format, local
594  * @tc.type: FUNC
595  */
596 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1312, TestSize.Level1)
597 {
598     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
599         return;
600     }
601     InitResource(g_fmp4HevcPath, LOCAL);
602     ASSERT_TRUE(initStatus_);
603     format_ = source_->GetSourceFormat(); // source
604     ASSERT_NE(format_, nullptr);
605     format_->DumpInfo();
606     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
607     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
608     ASSERT_EQ(formatVal_.duration, 10100000);
609     ASSERT_EQ(formatVal_.trackCount, 2);
610 #ifdef AVSOURCE_INNER_UNIT_TEST
611     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
612     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
613     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
614     ASSERT_EQ(formatVal_.hasVideo, 1);
615     ASSERT_EQ(formatVal_.hasAudio, 1);
616     ASSERT_EQ(formatVal_.fileType, 101);
617 #endif
618     format_ = source_->GetTrackFormat(trackIndex_);
619     ASSERT_NE(format_, nullptr);
620     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
621     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
622     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
623     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
624     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
625     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
626     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
627     ASSERT_EQ(formatVal_.codecMime, "video/hevc");
628     ASSERT_EQ(formatVal_.width, 720);
629     ASSERT_EQ(formatVal_.height, 480);
630     ASSERT_DOUBLE_EQ(formatVal_.frameRate, 60.000000);
631     trackIndex_ = 1;
632     format_ = source_->GetTrackFormat(trackIndex_);
633     ASSERT_NE(format_, nullptr);
634     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
635     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
636     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
637     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
638     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
639     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
640     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
641     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
642     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
643     ASSERT_EQ(formatVal_.sampleRate, 44100);
644     ASSERT_EQ(formatVal_.channelCount, 2);
645     ASSERT_EQ(formatVal_.bitRate, 127407);
646     ASSERT_EQ(formatVal_.codecMime, "audio/mp4a-latm");
647     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
648     ASSERT_EQ(formatVal_.channelLayout, 3);
649     CheckHevcInfo("Hevcfmp4");
650 }
651 
652 /**
653  * @tc.name: AVSource_GetFormat_1313
654  * @tc.desc: get fmp4 hevc mp4 format, uri
655  * @tc.type: FUNC
656  */
657 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1313, TestSize.Level1)
658 {
659     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
660         return;
661     }
662     InitResource(g_fmp4HevcUri, URI);
663     ASSERT_TRUE(initStatus_);
664     format_ = source_->GetSourceFormat(); // source
665     ASSERT_NE(format_, nullptr);
666     format_->DumpInfo();
667     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
668     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
669     ASSERT_EQ(formatVal_.duration, 10100000);
670     ASSERT_EQ(formatVal_.trackCount, 2);
671 #ifdef AVSOURCE_INNER_UNIT_TEST
672     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
673     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
674     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
675     ASSERT_EQ(formatVal_.hasVideo, 1);
676     ASSERT_EQ(formatVal_.hasAudio, 1);
677     ASSERT_EQ(formatVal_.fileType, 101);
678 #endif
679     format_ = source_->GetTrackFormat(trackIndex_);
680     ASSERT_NE(format_, nullptr);
681     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
682     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
683     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
684     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
685     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
686     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
687     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
688     ASSERT_EQ(formatVal_.codecMime, "video/hevc");
689     ASSERT_EQ(formatVal_.width, 720);
690     ASSERT_EQ(formatVal_.height, 480);
691     ASSERT_DOUBLE_EQ(formatVal_.frameRate, 60.000000);
692     trackIndex_ = 1;
693     format_ = source_->GetTrackFormat(trackIndex_);
694     ASSERT_NE(format_, nullptr);
695     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
696     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
697     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
698     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
699     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
700     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
701     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
702     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
703     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
704     ASSERT_EQ(formatVal_.sampleRate, 44100);
705     ASSERT_EQ(formatVal_.channelCount, 2);
706     ASSERT_EQ(formatVal_.bitRate, 127407);
707     ASSERT_EQ(formatVal_.codecMime, "audio/mp4a-latm");
708     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
709     ASSERT_EQ(formatVal_.channelLayout, 3);
710     CheckHevcInfo("Hevcfmp4");
711 }
712 
713 /**
714  * @tc.name: AVSource_GetFormat_1314
715  * @tc.desc: get audiovivid hdrvivid fmp4 format, local
716  * @tc.type: FUNC
717  */
718 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1314, TestSize.Level1)
719 {
720     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
721         return;
722     }
723     InitResource(g_doubleVividPath, LOCAL);
724     ASSERT_TRUE(initStatus_);
725     format_ = source_->GetSourceFormat(); // source
726     ASSERT_NE(format_, nullptr);
727     format_->DumpInfo();
728     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
729     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
730     ASSERT_EQ(formatVal_.duration, 2699349);
731     ASSERT_EQ(formatVal_.trackCount, 2);
732 #ifdef AVSOURCE_INNER_UNIT_TEST
733     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
734     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
735     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
736     ASSERT_EQ(formatVal_.hasVideo, 1);
737     ASSERT_EQ(formatVal_.hasAudio, 1);
738     ASSERT_EQ(formatVal_.fileType, 101);
739 #endif
740     format_ = source_->GetTrackFormat(trackIndex_);
741     ASSERT_NE(format_, nullptr);
742     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
743     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
744     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
745     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
746     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
747     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
748     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
749     ASSERT_EQ(formatVal_.codecMime, "video/hevc");
750     ASSERT_EQ(formatVal_.width, 1280);
751     ASSERT_EQ(formatVal_.height, 720);
752     ASSERT_DOUBLE_EQ(formatVal_.frameRate, 28.154937050793496);
753     trackIndex_ = 1;
754     format_ = source_->GetTrackFormat(trackIndex_);
755     ASSERT_NE(format_, nullptr);
756     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
757     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
758     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
759     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
760     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
761     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
762     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
763     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
764     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
765     ASSERT_EQ(formatVal_.sampleRate, 44100);
766     ASSERT_EQ(formatVal_.channelCount, 2);
767     ASSERT_EQ(formatVal_.bitRate, 64083);
768     ASSERT_EQ(formatVal_.codecMime, "audio/av3a");
769     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::INVALID_WIDTH);
770     ASSERT_EQ(formatVal_.channelLayout, 0);
771     CheckHevcInfo("doubleVivid");
772 }
773 
774 /**
775  * @tc.name: AVSource_GetFormat_1315
776  * @tc.desc: get audiovivid hdrvivid fmp4 format, uri
777  * @tc.type: FUNC
778  */
779 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1315, TestSize.Level1)
780 {
781     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
782         return;
783     }
784     InitResource(g_doubleVividUri, URI);
785     ASSERT_TRUE(initStatus_);
786     format_ = source_->GetSourceFormat(); // source
787     ASSERT_NE(format_, nullptr);
788     format_->DumpInfo();
789     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
790     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
791     ASSERT_EQ(formatVal_.duration, 2699349);
792     ASSERT_EQ(formatVal_.trackCount, 2);
793 #ifdef AVSOURCE_INNER_UNIT_TEST
794     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
795     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
796     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
797     ASSERT_EQ(formatVal_.hasVideo, 1);
798     ASSERT_EQ(formatVal_.hasAudio, 1);
799     ASSERT_EQ(formatVal_.fileType, 101);
800 #endif
801     format_ = source_->GetTrackFormat(trackIndex_);
802     ASSERT_NE(format_, nullptr);
803     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
804     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
805     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
806     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
807     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
808     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
809     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
810     ASSERT_EQ(formatVal_.codecMime, "video/hevc");
811     ASSERT_EQ(formatVal_.width, 1280);
812     ASSERT_EQ(formatVal_.height, 720);
813     ASSERT_DOUBLE_EQ(formatVal_.frameRate, 28.154937050793496);
814     trackIndex_ = 1;
815     format_ = source_->GetTrackFormat(trackIndex_);
816     ASSERT_NE(format_, nullptr);
817     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
818     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
819     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
820     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
821     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
822     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
823     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
824     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
825     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
826     ASSERT_EQ(formatVal_.sampleRate, 44100);
827     ASSERT_EQ(formatVal_.channelCount, 2);
828     ASSERT_EQ(formatVal_.bitRate, 64083);
829     ASSERT_EQ(formatVal_.codecMime, "audio/av3a");
830     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::INVALID_WIDTH);
831     ASSERT_EQ(formatVal_.channelLayout, 0);
832     CheckHevcInfo("doubleVivid");
833 }
834 
835 /**
836  * @tc.name: AVSource_GetFormat_1402
837  * @tc.desc: get source format(flv)
838  * @tc.type: FUNC
839  */
840 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1402, TestSize.Level1)
841 {
842     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
843         return;
844     }
845     fd_ = OpenFile(g_flvPath);
846     size_ = GetFileSize(g_flvPath);
847     printf("---- %s ----\n", g_flvPath.c_str());
848     source_ = AVSourceMockFactory::CreateSourceWithFD(fd_, SOURCE_OFFSET, size_);
849     ASSERT_NE(source_, nullptr);
850     format_ = source_->GetSourceFormat();
851     ASSERT_NE(format_, nullptr);
852     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
853     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, streamsCount_));
854     ASSERT_EQ(streamsCount_, 2);
855 #ifdef AVSOURCE_INNER_UNIT_TEST
856     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
857     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
858     ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
859     ASSERT_EQ(formatVal_.hasVideo, 1);
860     ASSERT_EQ(formatVal_.hasAudio, 1);
861     ASSERT_EQ(formatVal_.fileType, 104);
862 #endif
863     CheckHevcInfo("HevcFlv");
864 }
865 
866 /**
867  * @tc.name: AVSource_GetFormat_1403
868  * @tc.desc: get format when the file is flv
869  * @tc.type: FUNC
870  */
871 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1403, TestSize.Level1)
872 {
873     if (access(HEVC_LIB_PATH.c_str(), F_OK) != 0) {
874         return;
875     }
876     fd_ = OpenFile(g_flvPath);
877     size_ = GetFileSize(g_flvPath);
878     printf("---- %s ------\n", g_flvPath.c_str());
879     source_ = AVSourceMockFactory::CreateSourceWithFD(fd_, SOURCE_OFFSET, size_);
880     ASSERT_NE(source_, nullptr);
881     trackIndex_ = 0;
882     format_ = source_->GetTrackFormat(trackIndex_);
883     ASSERT_NE(format_, nullptr);
884     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
885     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
886     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
887     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
888     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
889     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
890     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
891     ASSERT_EQ(formatVal_.codecMime, "video/hevc");
892     ASSERT_EQ(formatVal_.width, 720);
893     ASSERT_EQ(formatVal_.height, 1280);
894     ASSERT_DOUBLE_EQ(formatVal_.frameRate, 30.000000);
895     trackIndex_ = 1;
896     format_ = source_->GetTrackFormat(trackIndex_);
897     ASSERT_NE(format_, nullptr);
898     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
899     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
900     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
901     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
902     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
903     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
904     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
905     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
906     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
907     ASSERT_EQ(formatVal_.sampleRate, 48000);
908     ASSERT_EQ(formatVal_.channelCount, 2);
909     ASSERT_EQ(formatVal_.bitRate, 128000);
910     ASSERT_EQ(formatVal_.codecMime, "audio/mpeg");
911     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
912     ASSERT_EQ(formatVal_.channelLayout, 3);
913 }
914 
915 /**
916  * @tc.name: AVSource_GetFormat_1700
917  * @tc.desc: get mp4 265 format, local
918  * @tc.type: FUNC
919  */
920 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1700, TestSize.Level1)
921 {
922     if (access(g_mp4265InfoParsePath.c_str(), F_OK) != 0) {
923         return;
924     }
925     printf("---- %s ------\n", g_mp4265InfoParsePath.data());
926     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4265InfoParsePath.data()));
927     ASSERT_NE(source_, nullptr);
928     format_ = source_->GetSourceFormat();
929     ASSERT_NE(format_, nullptr);
930     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
931     int64_t startTime;
932     format_->GetLongValue(Media::Tag::MEDIA_CONTAINER_START_TIME, startTime);
933 
934     trackIndex_ = 0;
935     format_ = source_->GetTrackFormat(trackIndex_);
936     ASSERT_NE(format_, nullptr);
937     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
938     double sar;
939     format_->GetDoubleValue(Media::Tag::VIDEO_SAR, sar);
940 
941     trackIndex_ = 1;
942     format_ = source_->GetTrackFormat(trackIndex_);
943     ASSERT_NE(format_, nullptr);
944     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
945     int64_t sampleFormat;
946     format_->GetLongValue(Media::Tag::AUDIO_SAMPLE_FORMAT, sampleFormat);
947     int64_t bitsPerCodecSample;
948     format_->GetLongValue(Media::Tag::AUDIO_BITS_PER_CODED_SAMPLE, bitsPerCodecSample);
949 }
950 } // namespace
951