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