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