1 /* 2 * Copyright (c) 2021-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 <cstdint> 17 #include <gtest/gtest.h> 18 #include <hilog/log.h> 19 #include <memory> 20 #include <unistd.h> 21 #include <iostream> 22 23 #include "transaction/rs_interfaces.h" 24 25 using namespace testing::ext; 26 27 namespace OHOS { 28 namespace Rosen { 29 class RSScreenSkipFrameTest : public testing::Test { 30 public: 31 static constexpr HiviewDFX::HiLogLabel LOG_LABEL = { LOG_CORE, 0, "RSScreenSkipFrameTest" }; 32 SetUpTestCase()33 static void SetUpTestCase() 34 { 35 rsInterfaces = &(RSInterfaces::GetInstance()); 36 } 37 TearDownTestCase()38 static void TearDownTestCase() 39 { 40 rsInterfaces = nullptr; 41 } 42 43 static inline RSInterfaces* rsInterfaces = nullptr; 44 ConvertScreenModeToRefreshRate(int32_t modeId)45 uint32_t ConvertScreenModeToRefreshRate(int32_t modeId) 46 { 47 uint32_t refreshRate = 0; 48 switch (modeId) { 49 case 0: // modeId 0 means 120hz 50 refreshRate = 120; // modeId 0 means 120hz 51 break; 52 case 1: // modeId 1 means 90hz 53 refreshRate = 90; // modeId 1 means 90hz 54 break; 55 case 2: // modeId 2 means 60hz 56 refreshRate = 60; // modeId 2 means 60hz 57 break; 58 case 3: // modeId 3 means 30hz 59 refreshRate = 30; // modeId 3 means 30hz 60 break; 61 default: 62 refreshRate = 0; 63 break; 64 } 65 return refreshRate; 66 } 67 68 private: 69 static constexpr uint32_t SET_REFRESHRATE_SLEEP_US = 50000; // wait for refreshrate change 70 uint32_t virtualScreenMirrorId = 1; 71 }; 72 73 /* 74 * Function: SetScreenSkipFrameInterval 75 * Type: Function 76 * Rank: Important(2) 77 * EnvConditions: N/A 78 * CaseDescription: 1. call SetScreenSkipFrameInterval with screenId 0 79 */ 80 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval001, Function | SmallTest | Level2) 81 { 82 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 83 EXPECT_NE(screenId, INVALID_SCREEN_ID); 84 uint32_t skipFrameInterval = 1; 85 std::cout << "Set screenId:" << 0 << ", skipFrameInterval:" << skipFrameInterval << std::endl; 86 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(0, skipFrameInterval); 87 if (screenId == 0) { 88 EXPECT_EQ(ret, StatusCode::SUCCESS); 89 } else { 90 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 91 } 92 } 93 94 /* 95 * Function: SetScreenSkipFrameInterval 96 * Type: Function 97 * Rank: Important(2) 98 * EnvConditions: N/A 99 * CaseDescription: 1. call SetScreenSkipFrameInterval with invalid screenId 100 */ 101 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval002, Function | SmallTest | Level2) 102 { 103 ScreenId screenId = INVALID_SCREEN_ID; 104 uint32_t skipFrameInterval = 1; 105 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 106 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 107 EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND); 108 } 109 110 /* 111 * Function: SetScreenSkipFrameInterval 112 * Type: Function 113 * Rank: Important(2) 114 * EnvConditions: N/A 115 * CaseDescription: 1. call Set primary screen with skipFrameInterval 0 116 */ 117 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval003, Function | SmallTest | Level2) 118 { 119 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 120 EXPECT_NE(screenId, INVALID_SCREEN_ID); 121 uint32_t skipFrameInterval = 0; 122 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 123 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 124 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 125 } 126 127 /* 128 * Function: SetScreenSkipFrameInterval 129 * Type: Function 130 * Rank: Important(2) 131 * EnvConditions: N/A 132 * CaseDescription: 1. call Set primary screen with skipFrameInterval 1 133 */ 134 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval004, Function | SmallTest | Level2) 135 { 136 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 137 EXPECT_NE(screenId, INVALID_SCREEN_ID); 138 uint32_t skipFrameInterval = 1; 139 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 140 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 141 EXPECT_EQ(ret, StatusCode::SUCCESS); 142 } 143 144 /* 145 * Function: SetScreenSkipFrameInterval 146 * Type: Function 147 * Rank: Important(1) 148 * EnvConditions: N/A 149 * CaseDescription: 1. Set primary screen with skipFrameInterval 2 150 */ 151 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval005, Function | SmallTest | Level1) 152 { 153 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 154 EXPECT_NE(screenId, INVALID_SCREEN_ID); 155 uint32_t skipFrameInterval = 2; 156 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 157 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 158 EXPECT_EQ(ret, StatusCode::SUCCESS); 159 160 // recover 161 ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, 1); 162 EXPECT_EQ(ret, StatusCode::SUCCESS); 163 } 164 165 /* 166 * Function: SetScreenSkipFrameInterval 167 * Type: Function 168 * Rank: Important(1) 169 * EnvConditions: N/A 170 * CaseDescription: 1. Set primary screen with the most screen refreshrate 171 */ 172 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval006, Function | SmallTest | Level1) 173 { 174 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 175 EXPECT_NE(screenId, INVALID_SCREEN_ID); 176 auto formerModeInfo = rsInterfaces->GetScreenActiveMode(screenId); 177 uint32_t skipFrameInterval = formerModeInfo.GetScreenRefreshRate(); 178 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 179 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 180 EXPECT_EQ(ret, StatusCode::SUCCESS); 181 182 // recover 183 ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, 1); 184 EXPECT_EQ(ret, StatusCode::SUCCESS); 185 } 186 187 /* 188 * Function: SetScreenSkipFrameInterval 189 * Type: Function 190 * Rank: Important(1) 191 * EnvConditions: N/A 192 * CaseDescription: 1. Set primary screen with the most screen refreshrate pluse 1 193 */ 194 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval007, Function | SmallTest | Level1) 195 { 196 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 197 EXPECT_NE(screenId, INVALID_SCREEN_ID); 198 auto formerModeInfo = rsInterfaces->GetScreenActiveMode(screenId); 199 uint32_t skipFrameInterval = formerModeInfo.GetScreenRefreshRate() + 1; 200 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 201 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 202 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 203 204 // recover 205 ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, 1); 206 EXPECT_EQ(ret, StatusCode::SUCCESS); 207 } 208 209 /* 210 * Function: SetScreenSkipFrameInterval 211 * Type: Function 212 * Rank: Important(1) 213 * EnvConditions: N/A 214 * CaseDescription: 1. Set virtual screen with skipFrameInterval 0 215 */ 216 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval008, Function | SmallTest | Level1) 217 { 218 auto csurface = IConsumerSurface::Create(); 219 EXPECT_NE(csurface, nullptr); 220 auto producer = csurface->GetProducer(); 221 auto psurface = Surface::CreateSurfaceAsProducer(producer); 222 uint32_t defaultWidth = 720; 223 uint32_t defaultHeight = 1280; 224 EXPECT_NE(psurface, nullptr); 225 226 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 227 "virtualScreen01", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 228 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 229 230 uint32_t skipFrameInterval = 0; 231 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 232 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 233 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 234 } 235 236 /* 237 * Function: SetScreenSkipFrameInterval 238 * Type: Function 239 * Rank: Important(1) 240 * EnvConditions: N/A 241 * CaseDescription: 1. Set virtual screen with skipFrameInterval 1 242 */ 243 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval009, Function | SmallTest | Level1) 244 { 245 auto csurface = IConsumerSurface::Create(); 246 EXPECT_NE(csurface, nullptr); 247 auto producer = csurface->GetProducer(); 248 auto psurface = Surface::CreateSurfaceAsProducer(producer); 249 uint32_t defaultWidth = 720; 250 uint32_t defaultHeight = 1280; 251 EXPECT_NE(psurface, nullptr); 252 253 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 254 "virtualScreen02", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 255 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 256 257 uint32_t skipFrameInterval = 1; 258 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 259 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 260 EXPECT_EQ(ret, StatusCode::SUCCESS); 261 } 262 263 /* 264 * Function: SetScreenSkipFrameInterval 265 * Type: Function 266 * Rank: Important(1) 267 * EnvConditions: N/A 268 * CaseDescription: 1. Set virtual screen with skipFrameInterval 2 269 */ 270 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval010, Function | SmallTest | Level1) 271 { 272 auto csurface = IConsumerSurface::Create(); 273 EXPECT_NE(csurface, nullptr); 274 auto producer = csurface->GetProducer(); 275 auto psurface = Surface::CreateSurfaceAsProducer(producer); 276 uint32_t defaultWidth = 720; 277 uint32_t defaultHeight = 1280; 278 EXPECT_NE(psurface, nullptr); 279 280 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 281 "virtualScreen03", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 282 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 283 284 uint32_t skipFrameInterval = 2; 285 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 286 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 287 EXPECT_EQ(ret, StatusCode::SUCCESS); 288 289 // recover 290 ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, 1); 291 EXPECT_EQ(ret, StatusCode::SUCCESS); 292 } 293 294 /* 295 * Function: SetScreenSkipFrameInterval 296 * Type: Function 297 * Rank: Important(1) 298 * EnvConditions: N/A 299 * CaseDescription: 1. Set virtual screen with the most screen refreshrate 300 */ 301 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval011, Function | SmallTest | Level1) 302 { 303 auto csurface = IConsumerSurface::Create(); 304 EXPECT_NE(csurface, nullptr); 305 auto producer = csurface->GetProducer(); 306 auto psurface = Surface::CreateSurfaceAsProducer(producer); 307 uint32_t defaultWidth = 720; 308 uint32_t defaultHeight = 1280; 309 EXPECT_NE(psurface, nullptr); 310 311 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 312 "virtualScreen04", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 313 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 314 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 315 EXPECT_NE(screenId, INVALID_SCREEN_ID); 316 auto formerModeInfo = rsInterfaces->GetScreenActiveMode(screenId); 317 318 uint32_t skipFrameInterval = formerModeInfo.GetScreenRefreshRate(); 319 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 320 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 321 EXPECT_EQ(ret, StatusCode::SUCCESS); 322 323 // recover 324 ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, 1); 325 EXPECT_EQ(ret, StatusCode::SUCCESS); 326 } 327 328 /* 329 * Function: SetScreenSkipFrameInterval 330 * Type: Function 331 * Rank: Important(1) 332 * EnvConditions: N/A 333 * CaseDescription: 1. Set virtual screen with the most screen refreshrate pluse 1 334 */ 335 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval012, Function | SmallTest | Level1) 336 { 337 auto csurface = IConsumerSurface::Create(); 338 EXPECT_NE(csurface, nullptr); 339 auto producer = csurface->GetProducer(); 340 auto psurface = Surface::CreateSurfaceAsProducer(producer); 341 uint32_t defaultWidth = 720; 342 uint32_t defaultHeight = 1280; 343 EXPECT_NE(psurface, nullptr); 344 345 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 346 "virtualScreen05", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 347 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 348 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 349 EXPECT_NE(screenId, INVALID_SCREEN_ID); 350 auto formerModeInfo = rsInterfaces->GetScreenActiveMode(screenId); 351 352 uint32_t skipFrameInterval = formerModeInfo.GetScreenRefreshRate() + 1; 353 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 354 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 355 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 356 357 // recover 358 ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, 1); 359 EXPECT_EQ(ret, StatusCode::SUCCESS); 360 } 361 362 /* 363 * Function: SetScreenSkipFrameInterval 364 * Type: Function 365 * Rank: Important(1) 366 * EnvConditions: N/A 367 * CaseDescription: 1. Set virtual screen with skipFrameInterval 99999 368 */ 369 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval013, Function | SmallTest | Level1) 370 { 371 auto csurface = IConsumerSurface::Create(); 372 EXPECT_NE(csurface, nullptr); 373 auto producer = csurface->GetProducer(); 374 auto psurface = Surface::CreateSurfaceAsProducer(producer); 375 uint32_t defaultWidth = 720; 376 uint32_t defaultHeight = 1280; 377 EXPECT_NE(psurface, nullptr); 378 379 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 380 "virtualScreen06", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 381 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 382 383 uint32_t skipFrameInterval = 99999; 384 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 385 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 386 EXPECT_EQ(ret, StatusCode::INVALID_ARGUMENTS); 387 388 // recover 389 ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, 1); 390 EXPECT_EQ(ret, StatusCode::SUCCESS); 391 } 392 393 /* 394 * Function: SetScreenSkipFrameInterval 395 * Type: Function 396 * Rank: Important(1) 397 * EnvConditions: N/A 398 * CaseDescription: 1. Set virtual screen with skipFrameInterval 2.1 399 */ 400 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval014, Function | SmallTest | Level1) 401 { 402 auto csurface = IConsumerSurface::Create(); 403 EXPECT_NE(csurface, nullptr); 404 auto producer = csurface->GetProducer(); 405 auto psurface = Surface::CreateSurfaceAsProducer(producer); 406 uint32_t defaultWidth = 720; 407 uint32_t defaultHeight = 1280; 408 EXPECT_NE(psurface, nullptr); 409 410 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 411 "virtualScreen07", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 412 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 413 414 float skipFrameInterval = 2.1; 415 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 416 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 417 EXPECT_EQ(ret, StatusCode::SUCCESS); 418 419 // recover 420 ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, 1); 421 EXPECT_EQ(ret, StatusCode::SUCCESS); 422 } 423 424 /* 425 * Function: SetScreenSkipFrameInterval 426 * Type: Function 427 * Rank: Important(1) 428 * EnvConditions: N/A 429 * CaseDescription: 1. Set virtual screen and primary screen with skipFrameInterval 2 430 */ 431 HWTEST_F(RSScreenSkipFrameTest, SetScreenSkipFrameInterval015, Function | SmallTest | Level1) 432 { 433 auto csurface = IConsumerSurface::Create(); 434 EXPECT_NE(csurface, nullptr); 435 auto producer = csurface->GetProducer(); 436 auto psurface = Surface::CreateSurfaceAsProducer(producer); 437 uint32_t defaultWidth = 720; 438 uint32_t defaultHeight = 1280; 439 EXPECT_NE(psurface, nullptr); 440 441 ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen( 442 "virtualScreen08", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1); 443 EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID); 444 ScreenId screenId = rsInterfaces->GetDefaultScreenId(); 445 EXPECT_NE(screenId, INVALID_SCREEN_ID); 446 447 uint32_t skipFrameInterval = 2; 448 std::cout << "Set virtualScreenId:" << virtualScreenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 449 int32_t ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, skipFrameInterval); 450 EXPECT_EQ(ret, StatusCode::SUCCESS); 451 std::cout << "Set screenId:" << screenId << ", skipFrameInterval:" << skipFrameInterval << std::endl; 452 ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, skipFrameInterval); 453 EXPECT_EQ(ret, StatusCode::SUCCESS); 454 455 // recover 456 ret = rsInterfaces->SetScreenSkipFrameInterval(virtualScreenId, 1); 457 EXPECT_EQ(ret, StatusCode::SUCCESS); 458 ret = rsInterfaces->SetScreenSkipFrameInterval(screenId, 1); 459 EXPECT_EQ(ret, StatusCode::SUCCESS); 460 } 461 } // namespace Rosen 462 } // namespace OHOS 463