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