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