• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2023-2025 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <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 string g_mp4AuxlPath = TEST_FILE_PATH + string("muxer_auxl_265.mp4");
66 string g_mp4AuxlUri = TEST_URI_PATH + string("muxer_auxl_265.mp4");
67 
68 std::map<std::string, std::map<std::string, int32_t>> infoMap = {
69     {"hdrVivid", {
70         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN_10)},
71         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_4)},
72         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_BT2020_NCL)},
73         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_HLG)},
74         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_BT2020)},
75         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
76     }},
77     {"mp4Hevc", {
78         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN)},
79         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_31)},
80         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_BT709)},
81         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_BT709)},
82         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_BT709)},
83         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
84     }},
85     {"mkvHevcAcc", {
86         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN)},
87         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_41)},
88         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_UNSPECIFIED)},
89         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_UNSPECIFIED)},
90         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_UNSPECIFIED)},
91         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
92     }},
93     {"tsHevcAac", {
94         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN)},
95         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_4)},
96         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_UNSPECIFIED)},
97         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_UNSPECIFIED)},
98         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_UNSPECIFIED)},
99         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
100     }},
101     {"HevcFlv", {
102         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN_10)},
103         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_31)},
104         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_BT2020_NCL)},
105         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_HLG)},
106         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_BT2020)},
107         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
108     }},
109     {"Hevcfmp4", {
110         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN)},
111         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_31)},
112         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_UNSPECIFIED)},
113         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_UNSPECIFIED)},
114         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_UNSPECIFIED)},
115         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
116     }},
117     {"Hevcmov", {
118         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN)},
119         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_31)},
120         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_UNSPECIFIED)},
121         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_UNSPECIFIED)},
122         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_UNSPECIFIED)},
123         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
124     }},
125     {"doubleVivid", {
126         {"profile", static_cast<int32_t>(OH_HEVCProfile::HEVC_PROFILE_MAIN_10)},
127         {"level", static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_4)},
128         {"colorRange", 0}, {"colorMatrix", static_cast<int32_t>(OH_MatrixCoefficient::MATRIX_COEFFICIENT_BT2020_NCL)},
129         {"colorTrans", static_cast<int32_t>(OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_HLG)},
130         {"colorPrim", static_cast<int32_t>(OH_ColorPrimary::COLOR_PRIMARY_BT2020)},
131         {"chromaLoc", static_cast<int32_t>(ChromaLocation::CHROMA_LOC_LEFT)},
132     }}
133 };
134 } // namespace
135 
InitResource(const std::string & path,bool local)136 void AVSourceUnitTest::InitResource(const std::string &path, bool local)
137 {
138     printf("---- %s ------\n", path.c_str());
139     if (local) {
140         fd_ = OpenFile(path);
141         int64_t size = GetFileSize(path);
142         source_ = AVSourceMockFactory::CreateSourceWithFD(fd_, SOURCE_OFFSET, size);
143         ASSERT_NE(source_, nullptr);
144     } else {
145         source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(path.data()));
146         ASSERT_NE(source_, nullptr);
147     }
148     format_ = source_->GetSourceFormat();
149     ASSERT_NE(format_, nullptr);
150     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, streamsCount_));
151     for (int i = 0; i < streamsCount_; i++) {
152         format_ = source_->GetTrackFormat(i);
153         ASSERT_NE(format_, nullptr);
154         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
155         if (formatVal_.trackType == MediaType::MEDIA_TYPE_VID) {
156             vTrackIdx_ = i;
157         } else if (formatVal_.trackType == MediaType::MEDIA_TYPE_AUD) {
158             aTrackIdx_ = i;
159         }
160     }
161     initStatus_ = true;
162 }
163 
CheckHevcInfo(const std::string resName)164 void AVSourceUnitTest::CheckHevcInfo(const std::string resName)
165 {
166     for (int i = 0; i < streamsCount_; i++) {
167         format_ = source_->GetTrackFormat(i);
168         string codecMime;
169         format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, codecMime);
170         if (codecMime == AVCodecMimeType::MEDIA_MIMETYPE_VIDEO_HEVC) {
171             printf("[trackFormat %d]: %s\n", i, format_->DumpInfo());
172             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_PROFILE, formatVal_.profile));
173             ASSERT_EQ(formatVal_.profile, infoMap[resName]["profile"]);
174             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_COLOR_PRIMARIES, formatVal_.colorPri));
175             ASSERT_EQ(formatVal_.colorPri, infoMap[resName]["colorPrim"]);
176             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRANSFER_CHARACTERISTICS,
177                 formatVal_.colorTrans));
178             ASSERT_EQ(formatVal_.colorTrans, infoMap[resName]["colorTrans"]);
179             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_MATRIX_COEFFICIENTS, formatVal_.colorMatrix));
180             ASSERT_EQ(formatVal_.colorMatrix, infoMap[resName]["colorMatrix"]);
181             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_RANGE_FLAG, formatVal_.colorRange));
182             ASSERT_EQ(formatVal_.colorRange, infoMap[resName]["colorRange"]);
183 #ifdef AVSOURCE_INNER_UNIT_TEST
184             printf("-------input inner--------\n");
185             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHROMA_LOCATION, formatVal_.chromaLoc));
186             ASSERT_EQ(formatVal_.chromaLoc, infoMap[resName]["chromaLoc"]);
187             ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_LEVEL, formatVal_.level));
188             ASSERT_EQ(formatVal_.level, infoMap[resName]["level"]);
189 #endif
190             if (resName == "hdrVivid" || resName == "doubleVivid") {
191                 ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_VIDEO_IS_HDR_VIVID,
192                     formatVal_.isHdrVivid));
193                 printf("isHdrVivid = %d\n", formatVal_.isHdrVivid);
194                 ASSERT_EQ(formatVal_.isHdrVivid, 1);
195             } else {
196                 ASSERT_FALSE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_VIDEO_IS_HDR_VIVID,
197                     formatVal_.isHdrVivid));
198             }
199         }
200     }
201 }
202 
CheckAuxlHevc()203 void AVSourceUnitTest::CheckAuxlHevc()
204 {
205     checkPass_ = false;
206     format_ = source_->GetSourceFormat();
207     ASSERT_NE(format_, nullptr);
208     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
209 #ifdef AVSOURCE_INNER_UNIT_TEST
210     ASSERT_TRUE(format_->GetIntValue(Media::Tag::MEDIA_HAS_VIDEO, formatVal_.hasVideo));
211     ASSERT_TRUE(format_->GetIntValue(Media::Tag::MEDIA_HAS_AUDIO, formatVal_.hasAudio));
212     ASSERT_TRUE(format_->GetIntValue(Media::Tag::MEDIA_HAS_AUXILIARY, formatVal_.hasAuxl));
213     ASSERT_TRUE(format_->GetIntValue(Media::Tag::MEDIA_FILE_TYPE, formatVal_.fileType));
214     ASSERT_EQ(formatVal_.fileType, 101);
215     ASSERT_EQ(formatVal_.hasAudio, 0);
216     ASSERT_EQ(formatVal_.hasVideo, 1);
217     ASSERT_EQ(formatVal_.hasAuxl, 1);
218 #endif
219     ASSERT_TRUE(format_->GetLongValue(OH_MD_KEY_DURATION, formatVal_.duration));
220     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_TRACK_COUNT, formatVal_.trackCount));
221     ASSERT_EQ(formatVal_.duration, 501000);
222     ASSERT_EQ(formatVal_.trackCount, 3);
223     format_->Destroy();
224 
225     trackIndex_ = 0;
226     format_ = source_->GetTrackFormat(trackIndex_);
227     ASSERT_NE(format_, nullptr);
228     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
229     uint8_t *codecConfig = nullptr;
230     size_t codecConfigSize;
231     int32_t *trackIds = nullptr;
232     size_t trackIdsSize;
233     string trackDesc;
234     string referenceType;
235     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_TRACK_TYPE, formatVal_.trackType));
236     ASSERT_TRUE(format_->GetStringValue(OH_MD_KEY_CODEC_MIME, formatVal_.codecMime));
237     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_WIDTH, formatVal_.width));
238     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_HEIGHT, formatVal_.height));
239     ASSERT_TRUE(format_->GetDoubleValue(OH_MD_KEY_FRAME_RATE, formatVal_.frameRate));
240     ASSERT_TRUE(format_->GetBuffer(OH_MD_KEY_CODEC_CONFIG, &codecConfig, codecConfigSize));
241     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_PROFILE, formatVal_.profile));
242     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_COLOR_PRIMARIES, formatVal_.colorPri));
243     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_TRANSFER_CHARACTERISTICS, formatVal_.colorTrans));
244     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_MATRIX_COEFFICIENTS, formatVal_.colorMatrix));
245     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_RANGE_FLAG, formatVal_.colorRange));
246     ASSERT_TRUE(format_->GetIntBuffer(OH_MD_KEY_REFERENCE_TRACK_IDS, &trackIds, trackIdsSize));
247     ASSERT_EQ(formatVal_.trackType, OH_MediaType::MEDIA_TYPE_VID);
248     ASSERT_EQ(formatVal_.codecMime, OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
249     ASSERT_EQ(formatVal_.width, 720);
250     ASSERT_EQ(formatVal_.height, 480);
251     ASSERT_EQ(static_cast<int32_t>(formatVal_.frameRate), 31);
252     ASSERT_EQ(codecConfigSize, 113);
253     ASSERT_EQ(formatVal_.profile, 1);
254     ASSERT_EQ(formatVal_.colorPri, 9);
255     ASSERT_EQ(formatVal_.colorTrans, 2);
256     ASSERT_EQ(formatVal_.colorMatrix, 9);
257     ASSERT_EQ(formatVal_.colorRange, 0);
258     ASSERT_EQ(trackIds[0], 1);
259     ASSERT_EQ(trackIds[1], 2);
260     ASSERT_EQ(trackIdsSize, 2);
261     format_->Destroy();
262 
263     trackIndex_ = 1;
264     format_ = source_->GetTrackFormat(trackIndex_);
265     ASSERT_NE(format_, nullptr);
266     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
267     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_TRACK_TYPE, formatVal_.trackType));
268     ASSERT_TRUE(format_->GetStringValue(OH_MD_KEY_CODEC_MIME, formatVal_.codecMime));
269     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_WIDTH, formatVal_.width));
270     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_HEIGHT, formatVal_.height));
271     ASSERT_TRUE(format_->GetDoubleValue(OH_MD_KEY_FRAME_RATE, formatVal_.frameRate));
272     ASSERT_TRUE(format_->GetBuffer(OH_MD_KEY_CODEC_CONFIG, &codecConfig, codecConfigSize));
273     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_PROFILE, formatVal_.profile));
274     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_COLOR_PRIMARIES, formatVal_.colorPri));
275     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_TRANSFER_CHARACTERISTICS, formatVal_.colorTrans));
276     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_MATRIX_COEFFICIENTS, formatVal_.colorMatrix));
277     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_RANGE_FLAG, formatVal_.colorRange));
278     ASSERT_TRUE(format_->GetIntBuffer(OH_MD_KEY_REFERENCE_TRACK_IDS, &trackIds, trackIdsSize));
279     ASSERT_TRUE(format_->GetStringValue(OH_MD_KEY_TRACK_REFERENCE_TYPE, referenceType));
280     ASSERT_TRUE(format_->GetStringValue(OH_MD_KEY_TRACK_DESCRIPTION, trackDesc));
281     ASSERT_EQ(formatVal_.trackType, OH_MediaType::MEDIA_TYPE_AUXILIARY);
282     ASSERT_EQ(formatVal_.codecMime, OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
283     ASSERT_EQ(formatVal_.width, 720);
284     ASSERT_EQ(formatVal_.height, 480);
285     ASSERT_EQ(static_cast<int32_t>(formatVal_.frameRate), 31);
286     ASSERT_EQ(codecConfigSize, 113);
287     ASSERT_EQ(formatVal_.profile, 1);
288     ASSERT_EQ(formatVal_.colorPri, 9);
289     ASSERT_EQ(formatVal_.colorTrans, 2);
290     ASSERT_EQ(formatVal_.colorMatrix, 9);
291     ASSERT_EQ(formatVal_.colorRange, 0);
292     ASSERT_EQ(trackIds[0], 0);
293     ASSERT_EQ(trackIds[1], 2);
294     ASSERT_EQ(trackIdsSize, 2);
295     ASSERT_EQ(referenceType, "vdep");
296     ASSERT_EQ(trackDesc, "com.openharmony.moviemode.depth");
297     format_->Destroy();
298 
299     trackIndex_ = 2;
300     format_ = source_->GetTrackFormat(trackIndex_);
301     ASSERT_NE(format_, nullptr);
302     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
303     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_TRACK_TYPE, formatVal_.trackType));
304     ASSERT_TRUE(format_->GetStringValue(OH_MD_KEY_CODEC_MIME, formatVal_.codecMime));
305     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_WIDTH, formatVal_.width));
306     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_HEIGHT, formatVal_.height));
307     ASSERT_TRUE(format_->GetDoubleValue(OH_MD_KEY_FRAME_RATE, formatVal_.frameRate));
308     ASSERT_TRUE(format_->GetBuffer(OH_MD_KEY_CODEC_CONFIG, &codecConfig, codecConfigSize));
309     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_PROFILE, formatVal_.profile));
310     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_COLOR_PRIMARIES, formatVal_.colorPri));
311     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_TRANSFER_CHARACTERISTICS, formatVal_.colorTrans));
312     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_MATRIX_COEFFICIENTS, formatVal_.colorMatrix));
313     ASSERT_TRUE(format_->GetIntValue(OH_MD_KEY_RANGE_FLAG, formatVal_.colorRange));
314     ASSERT_TRUE(format_->GetIntBuffer(OH_MD_KEY_REFERENCE_TRACK_IDS, &trackIds, trackIdsSize));
315     ASSERT_TRUE(format_->GetStringValue(OH_MD_KEY_TRACK_REFERENCE_TYPE, referenceType));
316     ASSERT_TRUE(format_->GetStringValue(OH_MD_KEY_TRACK_DESCRIPTION, trackDesc));
317     ASSERT_EQ(formatVal_.trackType, OH_MediaType::MEDIA_TYPE_AUXILIARY);
318     ASSERT_EQ(formatVal_.codecMime, OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
319     ASSERT_EQ(formatVal_.width, 720);
320     ASSERT_EQ(formatVal_.height, 480);
321     ASSERT_EQ(static_cast<int32_t>(formatVal_.frameRate), 31);
322     ASSERT_EQ(codecConfigSize, 113);
323     ASSERT_EQ(formatVal_.profile, 1);
324     ASSERT_EQ(formatVal_.colorPri, 9);
325     ASSERT_EQ(formatVal_.colorTrans, 2);
326     ASSERT_EQ(formatVal_.colorMatrix, 9);
327     ASSERT_EQ(formatVal_.colorRange, 0);
328     ASSERT_EQ(trackIds[0], 0);
329     ASSERT_EQ(trackIds[1], 1);
330     ASSERT_EQ(trackIdsSize, 2);
331     ASSERT_EQ(referenceType, "auxl");
332     ASSERT_EQ(trackDesc, "com.openharmony.moviemode.prey");
333     format_->Destroy();
334     checkPass_ = true;
335 }
336 
337 namespace {
338 /**
339  * @tc.name: AVSource_GetFormat_1190
340  * @tc.desc: get HDRVivid format, local
341  * @tc.type: FUNC
342  */
343 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1190, TestSize.Level1)
344 {
345     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
346         InitResource(g_hdrVividPath, LOCAL);
347         ASSERT_TRUE(initStatus_);
348         CheckHevcInfo("hdrVivid");
349     }
350 }
351 
352 /**
353  * @tc.name: AVSource_GetFormat_1120
354  * @tc.desc: get HDRVivid format, uri
355  * @tc.type: FUNC
356  */
357 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1120, TestSize.Level1)
358 {
359     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
360         InitResource(g_hdrVividUri, URI);
361         ASSERT_TRUE(initStatus_);
362         CheckHevcInfo("hdrVivid");
363     }
364 }
365 
366 /**
367  * @tc.name: AVSource_GetFormat_1200
368  * @tc.desc: get mp4 265 format, local
369  * @tc.type: FUNC
370  */
371 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1200, TestSize.Level1)
372 {
373     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
374         InitResource(g_mp4HevcPath, LOCAL);
375         ASSERT_TRUE(initStatus_);
376         CheckHevcInfo("mp4Hevc");
377     }
378 }
379 
380 /**
381  * @tc.name: AVSource_GetFormat_1201
382  * @tc.desc: get mp4 265 format, uri
383  * @tc.type: FUNC
384  */
385 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1201, TestSize.Level1)
386 {
387     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
388         InitResource(g_mp4HevcdUri, URI);
389         ASSERT_TRUE(initStatus_);
390         CheckHevcInfo("mp4Hevc");
391     }
392 }
393 
394 /**
395  * @tc.name: AVSource_GetFormat_1300
396  * @tc.desc: get mkv 265 aac format, local
397  * @tc.type: FUNC
398  */
399 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1300, TestSize.Level1)
400 {
401     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
402         InitResource(g_mkvHevcAccPath, LOCAL);
403         ASSERT_TRUE(initStatus_);
404         CheckHevcInfo("mkvHevcAcc");
405     }
406 }
407 
408 /**
409  * @tc.name: AVSource_GetFormat_1303
410  * @tc.desc: get mkv 265 aac format, uri
411  * @tc.type: FUNC
412  */
413 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1303, TestSize.Level1)
414 {
415     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
416         InitResource(g_mkvHevcAccUri, URI);
417         ASSERT_TRUE(initStatus_);
418         CheckHevcInfo("mkvHevcAcc");
419     }
420 }
421 
422 /**
423  * @tc.name: AVSource_GetFormat_1301
424  * @tc.desc: get mkv 264 opus format, local
425  * @tc.type: FUNC
426  */
427 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1301, TestSize.Level1)
428 {
429     InitResource(g_mkvAvcOpusPath, LOCAL);
430     ASSERT_TRUE(initStatus_);
431     trackIndex_ = vTrackIdx_;
432     format_ = source_->GetTrackFormat(trackIndex_);
433     ASSERT_NE(format_, nullptr);
434     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
435     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
436     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
437     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
438     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
439     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
440     ASSERT_EQ(formatVal_.codecMime, "video/avc");
441     ASSERT_EQ(formatVal_.width, 1920);
442     ASSERT_EQ(formatVal_.height, 1080);
443     ASSERT_EQ(formatVal_.frameRate, 60.000000);
444     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
445     trackIndex_ = aTrackIdx_;
446     format_ = source_->GetTrackFormat(trackIndex_);
447     ASSERT_NE(format_, nullptr);
448     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
449     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
450     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
451     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
452     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
453     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
454     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
455     ASSERT_EQ(formatVal_.channelLayout, static_cast<int64_t>(AudioChannelLayout::MONO));
456     ASSERT_EQ(formatVal_.sampleRate, 48000);
457     ASSERT_EQ(formatVal_.codecMime, "audio/opus");
458     ASSERT_EQ(formatVal_.channelCount, 1);
459     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
460     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
461 }
462 
463 /**
464  * @tc.name: AVSource_GetFormat_1302
465  * @tc.desc: get mkv 264 mp3 format, local
466  * @tc.type: FUNC
467  */
468 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1302, TestSize.Level1)
469 {
470     InitResource(g_mkvAvcMp3Path, LOCAL);
471     ASSERT_TRUE(initStatus_);
472     trackIndex_ = vTrackIdx_;
473     format_ = source_->GetTrackFormat(trackIndex_);
474     ASSERT_NE(format_, nullptr);
475     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
476     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
477     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
478     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
479     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
480     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
481     ASSERT_EQ(formatVal_.codecMime, "video/avc");
482     ASSERT_EQ(formatVal_.width, 1920);
483     ASSERT_EQ(formatVal_.height, 1080);
484     ASSERT_EQ(formatVal_.frameRate, 60.000000);
485     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
486     trackIndex_ = aTrackIdx_;
487     format_ = source_->GetTrackFormat(trackIndex_);
488     ASSERT_NE(format_, nullptr);
489     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
490     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
491     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
492     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
493     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
494     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
495     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
496     ASSERT_EQ(formatVal_.channelLayout, static_cast<int64_t>(AudioChannelLayout::STEREO));
497     ASSERT_EQ(formatVal_.sampleRate, 44100);
498     ASSERT_EQ(formatVal_.codecMime, "audio/mpeg");
499     ASSERT_EQ(formatVal_.channelCount, 2);
500     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
501     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
502 }
503 
504 /**
505  * @tc.name: AVSource_GetFormat_2310
506  * @tc.desc: get pcm hevc track format, local
507  * @tc.type: FUNC
508  */
509 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2310, TestSize.Level1)
510 {
511     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
512         InitResource(g_265pcmPath, LOCAL);
513         ASSERT_TRUE(initStatus_);
514         trackIndex_ = 0;
515         format_ = source_->GetTrackFormat(trackIndex_);
516         ASSERT_NE(format_, nullptr);
517         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
518         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
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_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
524         ASSERT_EQ(formatVal_.codecMime, "video/hevc");
525         ASSERT_EQ(formatVal_.width, 720);
526         ASSERT_EQ(formatVal_.height, 480);
527         ASSERT_DOUBLE_EQ(formatVal_.frameRate, 60.000000);
528         trackIndex_ = 1;
529         format_->Destroy();
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_TRACK_TYPE, formatVal_.trackType));
534         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
535         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
536         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
537         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT,
538             formatVal_.audioSampleFormat));
539         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
540         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
541         ASSERT_EQ(formatVal_.sampleRate, 44100);
542         ASSERT_EQ(formatVal_.channelCount, 2);
543         ASSERT_EQ(formatVal_.codecMime, "audio/raw");
544         ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_S16LE);
545         ASSERT_EQ(formatVal_.channelLayout, 3);
546         CheckHevcInfo("Hevcmov");
547     }
548 }
549 
550 /**
551  * @tc.name: AVSource_GetFormat_2311
552  * @tc.desc: get pcm hevc track format, uri
553  * @tc.type: FUNC
554  */
555 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_2311, TestSize.Level1)
556 {
557     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
558         InitResource(g_265pcmUri, URI);
559         ASSERT_TRUE(initStatus_);
560         trackIndex_ = 0;
561         format_ = source_->GetTrackFormat(trackIndex_);
562         ASSERT_NE(format_, nullptr);
563         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
564         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
565         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
566         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
567         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
568         ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
569         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
570         ASSERT_EQ(formatVal_.codecMime, "video/hevc");
571         ASSERT_EQ(formatVal_.width, 720);
572         ASSERT_EQ(formatVal_.height, 480);
573         ASSERT_DOUBLE_EQ(formatVal_.frameRate, 60.000000);
574         trackIndex_ = 1;
575         format_->Destroy();
576         format_ = source_->GetTrackFormat(trackIndex_);
577         ASSERT_NE(format_, nullptr);
578         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
579         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
580         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
581         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
582         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
583         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT,
584             formatVal_.audioSampleFormat));
585         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
586         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
587         ASSERT_EQ(formatVal_.sampleRate, 44100);
588         ASSERT_EQ(formatVal_.channelCount, 2);
589         ASSERT_EQ(formatVal_.codecMime, "audio/raw");
590         ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_S16LE);
591         ASSERT_EQ(formatVal_.channelLayout, 3);
592         CheckHevcInfo("Hevcmov");
593     }
594 }
595 
596 /**
597  * @tc.name: AVSource_GetFormat_1304
598  * @tc.desc: get mkv 264 opus format, uri
599  * @tc.type: FUNC
600  */
601 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1304, TestSize.Level1)
602 {
603     InitResource(g_mkvAvcOpusUri, URI);
604     ASSERT_TRUE(initStatus_);
605     trackIndex_ = vTrackIdx_;
606     format_ = source_->GetTrackFormat(trackIndex_);
607     ASSERT_NE(format_, nullptr);
608     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
609     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
610     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
611     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
612     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
613     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
614     ASSERT_EQ(formatVal_.codecMime, "video/avc");
615     ASSERT_EQ(formatVal_.width, 1920);
616     ASSERT_EQ(formatVal_.height, 1080);
617     ASSERT_EQ(formatVal_.frameRate, 60.000000);
618     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
619     trackIndex_ = aTrackIdx_;
620     format_ = source_->GetTrackFormat(trackIndex_);
621     ASSERT_NE(format_, nullptr);
622     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
623     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
624     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
625     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
626     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
627     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
628     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
629     ASSERT_EQ(formatVal_.channelLayout, static_cast<int64_t>(AudioChannelLayout::MONO));
630     ASSERT_EQ(formatVal_.sampleRate, 48000);
631     ASSERT_EQ(formatVal_.codecMime, "audio/opus");
632     ASSERT_EQ(formatVal_.channelCount, 1);
633     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
634     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
635 }
636 
637 /**
638  * @tc.name: AVSource_GetFormat_1305
639  * @tc.desc: get mkv 264 mp3 format, uri
640  * @tc.type: FUNC
641  */
642 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1305, TestSize.Level1)
643 {
644     InitResource(g_mkvAvcMp3Uri, URI);
645     ASSERT_TRUE(initStatus_);
646     trackIndex_ = vTrackIdx_;
647     format_ = source_->GetTrackFormat(trackIndex_);
648     ASSERT_NE(format_, nullptr);
649     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
650     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
651     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
652     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
653     ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
654     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
655     ASSERT_EQ(formatVal_.codecMime, "video/avc");
656     ASSERT_EQ(formatVal_.width, 1920);
657     ASSERT_EQ(formatVal_.height, 1080);
658     ASSERT_EQ(formatVal_.frameRate, 60.000000);
659     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
660     trackIndex_ = aTrackIdx_;
661     format_ = source_->GetTrackFormat(trackIndex_);
662     ASSERT_NE(format_, nullptr);
663     printf("[trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
664     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT, formatVal_.audioSampleFormat));
665     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
666     ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
667     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
668     ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
669     ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
670     ASSERT_EQ(formatVal_.channelLayout, static_cast<int64_t>(AudioChannelLayout::STEREO));
671     ASSERT_EQ(formatVal_.sampleRate, 44100);
672     ASSERT_EQ(formatVal_.codecMime, "audio/mpeg");
673     ASSERT_EQ(formatVal_.channelCount, 2);
674     ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
675     ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
676 }
677 
678 /**
679  * @tc.name: AVSource_GetFormat_1306
680  * @tc.desc: get hevc format, local (ts)
681  * @tc.type: FUNC
682  */
683 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1306, TestSize.Level1)
684 {
685     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
686         InitResource(g_tsHevcAacPath, LOCAL);
687         ASSERT_TRUE(initStatus_);
688         format_ = source_->GetSourceFormat(); // source
689         ASSERT_NE(format_, nullptr);
690         format_->DumpInfo();
691         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
692         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
693         ASSERT_EQ(formatVal_.duration, 10123222);
694         ASSERT_EQ(formatVal_.trackCount, 2);
695         CheckHevcInfo("tsHevcAac");
696     }
697 }
698 
699 /**
700  * @tc.name: AVSource_GetFormat_1307
701  * @tc.desc: get hevc format, local (ts)
702  * @tc.type: FUNC
703  */
704 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1307, TestSize.Level1)
705 {
706     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
707         InitResource(g_tsHevcAacUri, URI);
708         ASSERT_TRUE(initStatus_);
709         format_ = source_->GetSourceFormat(); // source
710         ASSERT_NE(format_, nullptr);
711         format_->DumpInfo();
712         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
713         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
714         ASSERT_EQ(formatVal_.duration, 10123222);
715         ASSERT_EQ(formatVal_.trackCount, 2);
716         CheckHevcInfo("tsHevcAac");
717     }
718 }
719 
720 /**
721  * @tc.name: AVSource_GetFormat_1312
722  * @tc.desc: get fmp4 hevc mp4 format, local
723  * @tc.type: FUNC
724  */
725 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1312, TestSize.Level1)
726 {
727     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
728         InitResource(g_fmp4HevcPath, LOCAL);
729         ASSERT_TRUE(initStatus_);
730         format_ = source_->GetSourceFormat(); // source
731         ASSERT_NE(format_, nullptr);
732         format_->DumpInfo();
733         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
734         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
735         ASSERT_EQ(formatVal_.duration, 10100000);
736         ASSERT_EQ(formatVal_.trackCount, 2);
737 #ifdef AVSOURCE_INNER_UNIT_TEST
738         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
739         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
740         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
741         ASSERT_EQ(formatVal_.hasVideo, 1);
742         ASSERT_EQ(formatVal_.hasAudio, 1);
743         ASSERT_EQ(formatVal_.fileType, 101);
744 #endif
745         format_ = source_->GetTrackFormat(trackIndex_);
746         ASSERT_NE(format_, nullptr);
747         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
748         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
749         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
750         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
751         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
752         ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
753         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
754         ASSERT_EQ(formatVal_.codecMime, "video/hevc");
755         ASSERT_EQ(formatVal_.width, 720);
756         ASSERT_EQ(formatVal_.height, 480);
757         ASSERT_DOUBLE_EQ(formatVal_.frameRate, 60.000000);
758         trackIndex_ = 1;
759         format_ = source_->GetTrackFormat(trackIndex_);
760         ASSERT_NE(format_, nullptr);
761         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
762         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
763         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
764         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
765         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
766         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
767         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT,
768             formatVal_.audioSampleFormat));
769         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
770         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
771         ASSERT_EQ(formatVal_.sampleRate, 44100);
772         ASSERT_EQ(formatVal_.channelCount, 2);
773         ASSERT_EQ(formatVal_.bitRate, 127407);
774         ASSERT_EQ(formatVal_.codecMime, "audio/mp4a-latm");
775         ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
776         ASSERT_EQ(formatVal_.channelLayout, 3);
777         CheckHevcInfo("Hevcfmp4");
778     }
779 }
780 
781 /**
782  * @tc.name: AVSource_GetFormat_1313
783  * @tc.desc: get fmp4 hevc mp4 format, uri
784  * @tc.type: FUNC
785  */
786 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1313, TestSize.Level1)
787 {
788     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
789         InitResource(g_fmp4HevcUri, URI);
790         ASSERT_TRUE(initStatus_);
791         format_ = source_->GetSourceFormat(); // source
792         ASSERT_NE(format_, nullptr);
793         format_->DumpInfo();
794         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
795         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
796         ASSERT_EQ(formatVal_.duration, 10100000);
797         ASSERT_EQ(formatVal_.trackCount, 2);
798 #ifdef AVSOURCE_INNER_UNIT_TEST
799         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
800         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
801         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
802         ASSERT_EQ(formatVal_.hasVideo, 1);
803         ASSERT_EQ(formatVal_.hasAudio, 1);
804         ASSERT_EQ(formatVal_.fileType, 101);
805 #endif
806         format_ = source_->GetTrackFormat(trackIndex_);
807         ASSERT_NE(format_, nullptr);
808         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
809         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
810         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
811         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
812         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
813         ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
814         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
815         ASSERT_EQ(formatVal_.codecMime, "video/hevc");
816         ASSERT_EQ(formatVal_.width, 720);
817         ASSERT_EQ(formatVal_.height, 480);
818         ASSERT_DOUBLE_EQ(formatVal_.frameRate, 60.000000);
819         trackIndex_ = 1;
820         format_ = source_->GetTrackFormat(trackIndex_);
821         ASSERT_NE(format_, nullptr);
822         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
823         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
824         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
825         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
826         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
827         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
828         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT,
829             formatVal_.audioSampleFormat));
830         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
831         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
832         ASSERT_EQ(formatVal_.sampleRate, 44100);
833         ASSERT_EQ(formatVal_.channelCount, 2);
834         ASSERT_EQ(formatVal_.bitRate, 127407);
835         ASSERT_EQ(formatVal_.codecMime, "audio/mp4a-latm");
836         ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
837         ASSERT_EQ(formatVal_.channelLayout, 3);
838         CheckHevcInfo("Hevcfmp4");
839     }
840 }
841 
842 /**
843  * @tc.name: AVSource_GetFormat_1314
844  * @tc.desc: get audiovivid hdrvivid fmp4 format, local
845  * @tc.type: FUNC
846  */
847 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1314, TestSize.Level1)
848 {
849     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
850         InitResource(g_doubleVividPath, LOCAL);
851         ASSERT_TRUE(initStatus_);
852         format_ = source_->GetSourceFormat(); // source
853         ASSERT_NE(format_, nullptr);
854         format_->DumpInfo();
855         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
856         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
857         ASSERT_EQ(formatVal_.duration, 2699349);
858         ASSERT_EQ(formatVal_.trackCount, 2);
859 #ifdef AVSOURCE_INNER_UNIT_TEST
860         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
861         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
862         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
863         ASSERT_EQ(formatVal_.hasVideo, 1);
864         ASSERT_EQ(formatVal_.hasAudio, 1);
865         ASSERT_EQ(formatVal_.fileType, 101);
866 #endif
867         format_ = source_->GetTrackFormat(trackIndex_);
868         ASSERT_NE(format_, nullptr);
869         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
870         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
871         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
872         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
873         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
874         ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
875         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
876         ASSERT_EQ(formatVal_.codecMime, "video/hevc");
877         ASSERT_EQ(formatVal_.width, 1280);
878         ASSERT_EQ(formatVal_.height, 720);
879         ASSERT_DOUBLE_EQ(formatVal_.frameRate, 28.154937050793496);
880         trackIndex_ = 1;
881         format_ = source_->GetTrackFormat(trackIndex_);
882         ASSERT_NE(format_, nullptr);
883         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
884         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
885         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
886         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
887         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
888         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
889         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT,
890             formatVal_.audioSampleFormat));
891         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
892         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
893         ASSERT_EQ(formatVal_.sampleRate, 44100);
894         ASSERT_EQ(formatVal_.channelCount, 2);
895         ASSERT_EQ(formatVal_.bitRate, 64083);
896         ASSERT_EQ(formatVal_.codecMime, "audio/av3a");
897         ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::INVALID_WIDTH);
898         ASSERT_EQ(formatVal_.channelLayout, 0);
899         CheckHevcInfo("doubleVivid");
900     }
901 }
902 
903 /**
904  * @tc.name: AVSource_GetFormat_1315
905  * @tc.desc: get audiovivid hdrvivid fmp4 format, uri
906  * @tc.type: FUNC
907  */
908 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1315, TestSize.Level1)
909 {
910     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
911         InitResource(g_doubleVividUri, URI);
912         ASSERT_TRUE(initStatus_);
913         format_ = source_->GetSourceFormat(); // source
914         ASSERT_NE(format_, nullptr);
915         format_->DumpInfo();
916         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_DURATION, formatVal_.duration));
917         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, formatVal_.trackCount));
918         ASSERT_EQ(formatVal_.duration, 2699349);
919         ASSERT_EQ(formatVal_.trackCount, 2);
920 #ifdef AVSOURCE_INNER_UNIT_TEST
921         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
922         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
923         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
924         ASSERT_EQ(formatVal_.hasVideo, 1);
925         ASSERT_EQ(formatVal_.hasAudio, 1);
926         ASSERT_EQ(formatVal_.fileType, 101);
927 #endif
928         format_ = source_->GetTrackFormat(trackIndex_);
929         ASSERT_NE(format_, nullptr);
930         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
931         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
932         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
933         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
934         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
935         ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
936         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
937         ASSERT_EQ(formatVal_.codecMime, "video/hevc");
938         ASSERT_EQ(formatVal_.width, 1280);
939         ASSERT_EQ(formatVal_.height, 720);
940         ASSERT_DOUBLE_EQ(formatVal_.frameRate, 28.154937050793496);
941         trackIndex_ = 1;
942         format_ = source_->GetTrackFormat(trackIndex_);
943         ASSERT_NE(format_, nullptr);
944         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
945         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
946         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
947         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
948         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
949         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
950         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT,
951             formatVal_.audioSampleFormat));
952         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
953         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
954         ASSERT_EQ(formatVal_.sampleRate, 44100);
955         ASSERT_EQ(formatVal_.channelCount, 2);
956         ASSERT_EQ(formatVal_.bitRate, 64083);
957         ASSERT_EQ(formatVal_.codecMime, "audio/av3a");
958         ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::INVALID_WIDTH);
959         ASSERT_EQ(formatVal_.channelLayout, 0);
960         CheckHevcInfo("doubleVivid");
961     }
962 }
963 
964 /**
965  * @tc.name: AVSource_GetFormat_1402
966  * @tc.desc: get source format(flv)
967  * @tc.type: FUNC
968  */
969 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1402, TestSize.Level1)
970 {
971     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
972         fd_ = OpenFile(g_flvPath);
973         size_ = GetFileSize(g_flvPath);
974         printf("---- %s ----\n", g_flvPath.c_str());
975         source_ = AVSourceMockFactory::CreateSourceWithFD(fd_, SOURCE_OFFSET, size_);
976         ASSERT_NE(source_, nullptr);
977         format_ = source_->GetSourceFormat();
978         ASSERT_NE(format_, nullptr);
979         printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
980         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_COUNT, streamsCount_));
981         ASSERT_EQ(streamsCount_, 2);
982 #ifdef AVSOURCE_INNER_UNIT_TEST
983         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_VIDEO, formatVal_.hasVideo));
984         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_HAS_AUDIO, formatVal_.hasAudio));
985         ASSERT_TRUE(format_->GetIntValue(AVSourceFormat::SOURCE_FILE_TYPE, formatVal_.fileType));
986         ASSERT_EQ(formatVal_.hasVideo, 1);
987         ASSERT_EQ(formatVal_.hasAudio, 1);
988         ASSERT_EQ(formatVal_.fileType, 104);
989 #endif
990         CheckHevcInfo("HevcFlv");
991     }
992 }
993 
994 /**
995  * @tc.name: AVSource_GetFormat_1403
996  * @tc.desc: get format when the file is flv
997  * @tc.type: FUNC
998  */
999 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1403, TestSize.Level1)
1000 {
1001     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
1002         fd_ = OpenFile(g_flvPath);
1003         size_ = GetFileSize(g_flvPath);
1004         printf("---- %s ------\n", g_flvPath.c_str());
1005         source_ = AVSourceMockFactory::CreateSourceWithFD(fd_, SOURCE_OFFSET, size_);
1006         ASSERT_NE(source_, nullptr);
1007         trackIndex_ = 0;
1008         format_ = source_->GetTrackFormat(trackIndex_);
1009         ASSERT_NE(format_, nullptr);
1010         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
1011         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
1012         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
1013         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, formatVal_.width));
1014         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, formatVal_.height));
1015         ASSERT_TRUE(format_->GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, formatVal_.frameRate));
1016         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_VID);
1017         ASSERT_EQ(formatVal_.codecMime, "video/hevc");
1018         ASSERT_EQ(formatVal_.width, 720);
1019         ASSERT_EQ(formatVal_.height, 1280);
1020         ASSERT_DOUBLE_EQ(formatVal_.frameRate, 30.000000);
1021         trackIndex_ = 1;
1022         format_ = source_->GetTrackFormat(trackIndex_);
1023         ASSERT_NE(format_, nullptr);
1024         printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
1025         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, formatVal_.trackType));
1026         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, formatVal_.sampleRate));
1027         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, formatVal_.channelCount));
1028         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, formatVal_.bitRate));
1029         ASSERT_TRUE(format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, formatVal_.codecMime));
1030         ASSERT_TRUE(format_->GetIntValue(MediaDescriptionKey::MD_KEY_AUDIO_SAMPLE_FORMAT,
1031             formatVal_.audioSampleFormat));
1032         ASSERT_TRUE(format_->GetLongValue(MediaDescriptionKey::MD_KEY_CHANNEL_LAYOUT, formatVal_.channelLayout));
1033         ASSERT_EQ(formatVal_.trackType, MediaType::MEDIA_TYPE_AUD);
1034         ASSERT_EQ(formatVal_.sampleRate, 48000);
1035         ASSERT_EQ(formatVal_.channelCount, 2);
1036         ASSERT_EQ(formatVal_.bitRate, 128000);
1037         ASSERT_EQ(formatVal_.codecMime, "audio/mpeg");
1038         ASSERT_EQ(formatVal_.audioSampleFormat, AudioSampleFormat::SAMPLE_F32P);
1039         ASSERT_EQ(formatVal_.channelLayout, 3);
1040     }
1041 }
1042 
1043 /**
1044  * @tc.name: AVSource_GetFormat_1700
1045  * @tc.desc: get mp4 265 format, local
1046  * @tc.type: FUNC
1047  */
1048 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_1700, TestSize.Level1)
1049 {
1050     ASSERT_EQ(access(g_mp4265InfoParsePath.c_str(), F_OK), 0);
1051     printf("---- %s ------\n", g_mp4265InfoParsePath.data());
1052     source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4265InfoParsePath.data()));
1053     ASSERT_NE(source_, nullptr);
1054     format_ = source_->GetSourceFormat();
1055     ASSERT_NE(format_, nullptr);
1056     printf("[ sourceFormat ]: %s\n", format_->DumpInfo());
1057     int64_t startTime;
1058     format_->GetLongValue(Media::Tag::MEDIA_CONTAINER_START_TIME, startTime);
1059 
1060     trackIndex_ = 0;
1061     format_ = source_->GetTrackFormat(trackIndex_);
1062     ASSERT_NE(format_, nullptr);
1063     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
1064     double sar;
1065     format_->GetDoubleValue(Media::Tag::VIDEO_SAR, sar);
1066 
1067     trackIndex_ = 1;
1068     format_ = source_->GetTrackFormat(trackIndex_);
1069     ASSERT_NE(format_, nullptr);
1070     printf("[ trackFormat %d]: %s\n", trackIndex_, format_->DumpInfo());
1071     int64_t sampleFormat;
1072     format_->GetLongValue(Media::Tag::AUDIO_SAMPLE_FORMAT, sampleFormat);
1073     int64_t bitsPerCodecSample;
1074     format_->GetLongValue(Media::Tag::AUDIO_BITS_PER_CODED_SAMPLE, bitsPerCodecSample);
1075 }
1076 
1077 /**
1078  * @tc.name: AVSource_GetFormat_Auxl_0001
1079  * @tc.desc: get format(auxl local)
1080  * @tc.type: FUNC
1081  */
1082 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_Auxl_0001, TestSize.Level1)
1083 {
1084     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
1085         InitResource(g_mp4AuxlPath, LOCAL);
1086         ASSERT_TRUE(initStatus_);
1087         CheckAuxlHevc();
1088         ASSERT_TRUE(checkPass_);
1089     }
1090 }
1091 
1092 /**
1093  * @tc.name: AVSource_GetFormat_Auxl_0002
1094  * @tc.desc: get format(auxl url)
1095  * @tc.type: FUNC
1096  */
1097 HWTEST_F(AVSourceUnitTest, AVSource_GetFormat_Auxl_0002, TestSize.Level1)
1098 {
1099     if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) {
1100         InitResource(g_mp4AuxlUri, URI);
1101         ASSERT_TRUE(initStatus_);
1102         CheckAuxlHevc();
1103         ASSERT_TRUE(checkPass_);
1104     }
1105 }
1106 } // namespace
1107