hwcRects.cpp revision 734d8d898c6b0b315e431b231cc6759514da361b
1/* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17/* 18 * Hardware Composer Rectangles 19 * 20 * Synopsis 21 * hwcRects [options] (graphicFormat displayFrame [attributes],)... 22 * options: 23 * -D #.## - End of test delay 24 * -v Verbose"); 25 * 26 * graphic formats: 27 * RGBA8888 (reference frame default) 28 * RGBX8888 29 * RGB888 30 * RGB565 31 * BGRA8888 32 * RGBA5551 33 * RGBA4444 34 * YV12 35 * 36 * displayFrame 37 * [left, top, right, bottom] 38 * 39 * attributes: 40 * transform: none | fliph | flipv | rot90 | rot180 | rot270 41 * blend: none | premult | coverage 42 * color: [0.##, 0.##, 0.##] 43 * alpha: 0.## 44 * sourceDim: [width, height] 45 * sourceCrop: [left, top, right, bottom] 46 * 47 * Example: 48 * # White YV12 rectangle, with overlapping turquoise 49 * # RGBA8888 rectangle at 30%% (alpha: 0.7) transparency 50 * hwcRects -v -D 30.0 \ 51 * YV12 [50, 80, 200, 300] transform: none \ 52 * color: [1.0, 0.5, 0.5], \ 53 * RGBA8888 [100, 150, 300, 400] blend: coverage \ 54 * color: [0.251, 0.878, 0.816] alpha: 0.7 \ 55 * sourceDim: [50, 60] sourceCrop: [5, 8, 12, 15] 56 * 57 * Description 58 * Constructs a Hardware Composer (HWC) list of frames from 59 * command-line specified parameters. Then sends it to the HWC 60 * be rendered. The intended purpose of this tool is as a means to 61 * reproduce and succinctly specify an observed HWC operation, with 62 * no need to modify/compile a program. 63 * 64 * The command-line syntax consists of a few standard command-line 65 * options and then a description of one or more frames. The frame 66 * descriptions are separated from one another via a comma. The 67 * beginning of a frame description requires the specification 68 * of the graphic format and then the display frame rectangle where 69 * the frame will be displayed. The display frame rectangle is 70 * specified as follows, with the right and bottom coordinates being 71 * exclusive values: 72 * 73 * [left, top, right, bottom] 74 * 75 * After these two required parameters each frame description can 76 * specify 1 or more optional attributes. The name of each optional 77 * attribute is preceded by a colon. The current implementation 78 * then requires white space after the colon and then the value of 79 * the attribute is specified. See the synopsis section above for 80 * a list of attributes and the format of their expected value. 81 */ 82 83#include <algorithm> 84#include <assert.h> 85#include <cerrno> 86#include <cmath> 87#include <cstdlib> 88#include <ctime> 89#include <istream> 90#include <libgen.h> 91#include <list> 92#include <sched.h> 93#include <sstream> 94#include <stdint.h> 95#include <string.h> 96#include <unistd.h> 97 98#include <sys/syscall.h> 99#include <sys/types.h> 100#include <sys/wait.h> 101 102#include <EGL/egl.h> 103#include <EGL/eglext.h> 104#include <GLES2/gl2.h> 105#include <GLES2/gl2ext.h> 106 107#include <ui/FramebufferNativeWindow.h> 108#include <ui/GraphicBuffer.h> 109#include <ui/EGLUtils.h> 110 111#define LOG_TAG "hwcColorEquivTest" 112#include <utils/Log.h> 113#include <testUtil.h> 114 115#include <hardware/hwcomposer.h> 116 117#include <glTestLib.h> 118#include <hwc/hwcTestLib.h> 119 120using namespace std; 121using namespace android; 122 123// Defaults 124const bool defaultVerbose = false; 125const float defaultEndDelay = 2.0; // Default delay after rendering graphics 126 127const uint32_t defaultFormat = HAL_PIXEL_FORMAT_RGBA_8888; 128const int32_t defaultTransform = 0; 129const uint32_t defaultBlend = HWC_BLENDING_NONE; 130const ColorFract defaultColor(0.5, 0.5, 0.5); 131const float defaultAlpha = 1.0; // Opaque 132const HwcTestDim defaultSourceDim(1, 1); 133const struct hwc_rect defaultSourceCrop = {0, 0, 1, 1}; 134const struct hwc_rect defaultDisplayFrame = {0, 0, 100, 100}; 135 136// Defines 137#define MAXCMD 200 138#define CMD_STOP_FRAMEWORK "stop 2>&1" 139#define CMD_START_FRAMEWORK "start 2>&1" 140 141// Macros 142#define NUMA(a) (sizeof(a) / sizeof(a [0])) // Num elements in an array 143 144// Local types 145class Rectangle { 146public: 147 Rectangle() : format(defaultFormat), transform(defaultTransform), 148 blend(defaultBlend), color(defaultColor), 149 alpha(defaultAlpha), sourceDim(defaultSourceDim), 150 sourceCrop(defaultSourceCrop), 151 displayFrame(defaultDisplayFrame) {}; 152 153 uint32_t format; 154 uint32_t transform; 155 int32_t blend; 156 ColorFract color; 157 float alpha; 158 HwcTestDim sourceDim; 159 struct hwc_rect sourceCrop; 160 struct hwc_rect displayFrame; 161 162 sp<GraphicBuffer> texture; 163}; 164 165// Globals 166list<Rectangle> rectangle; 167static const int texUsage = GraphicBuffer::USAGE_HW_TEXTURE | 168 GraphicBuffer::USAGE_SW_WRITE_RARELY; 169static hwc_composer_device_t *hwcDevice; 170static EGLDisplay dpy; 171static EGLSurface surface; 172static EGLint width, height; 173 174// Function prototypes 175static Rectangle parseRect(string rectStr); 176void init(void); 177void printSyntax(const char *cmd); 178 179// Command-line option settings 180static bool verbose = defaultVerbose; 181static float endDelay = defaultEndDelay; 182 183/* 184 * Main 185 * 186 * Performs the following high-level sequence of operations: 187 * 188 * 1. Parse command-line options 189 * 190 * 2. Stop framework 191 * 192 * 3. Initialization 193 * 194 * 4. Parse frame descriptions 195 * 196 * 5. Create HWC list from frame descriptions 197 * 198 * 6. Have HWC render the list description of the frames 199 * 200 * 7. Delay for amount of time given by endDelay 201 * 202 * 8. Start framework 203 */ 204int 205main(int argc, char *argv[]) 206{ 207 int rv, opt; 208 char *chptr; 209 bool error; 210 string str; 211 char cmd[MAXCMD]; 212 213 // Parse command line arguments 214 while ((opt = getopt(argc, argv, "D:v?h")) != -1) { 215 switch (opt) { 216 case 'D': // End of test delay 217 endDelay = strtod(optarg, &chptr); 218 if ((*chptr != '\0') || (endDelay < 0.0)) { 219 testPrintE("Invalid command-line specified end of test delay " 220 "of: %s", optarg); 221 exit(1); 222 } 223 break; 224 225 case 'v': // Verbose 226 verbose = true; 227 break; 228 229 case 'h': // Help 230 case '?': 231 default: 232 printSyntax(basename(argv[0])); 233 exit(((optopt == 0) || (optopt == '?')) ? 0 : 2); 234 } 235 } 236 237 // Stop framework 238 rv = snprintf(cmd, sizeof(cmd), "%s", CMD_STOP_FRAMEWORK); 239 if (rv >= (signed) sizeof(cmd) - 1) { 240 testPrintE("Command too long for: %s", CMD_STOP_FRAMEWORK); 241 exit(3); 242 } 243 testExecCmd(cmd); 244 testDelay(1.0); // TODO - needs means to query whether asyncronous stop 245 // framework operation has completed. For now, just wait 246 // a long time. 247 248 init(); 249 250 // Parse rectangle descriptions 251 int numOpen = 0; // Current number of unmatched <[ 252 string rectDesc(""); // String description of a single rectangle 253 while (optind < argc) { 254 string argNext = string(argv[optind++]); 255 256 if (rectDesc.length()) { rectDesc += ' '; } 257 rectDesc += argNext; 258 259 // Count number of opening <[ and matching >] 260 // At this point not worried about an opening character being 261 // matched by it's corresponding closing character. For example, 262 // "<1.0, 2.0]" is incorrect because the opening < should be matched 263 // with a closing >, instead of the closing ]. Such errors are 264 // detected when the actual value is parsed. 265 for (unsigned int n1 = 0; n1 < argNext.length(); n1++) { 266 switch(argNext[n1]) { 267 case '[': 268 case '<': 269 numOpen++; 270 break; 271 272 case ']': 273 case '>': 274 numOpen--; 275 break; 276 } 277 278 // Error anytime there is more closing then opening characters 279 if (numOpen < 0) { 280 testPrintI("Mismatched number of opening <[ with " 281 "closing >] in: %s", rectDesc.c_str()); 282 exit(4); 283 } 284 } 285 286 // Description of a rectangle is complete when all opening 287 // <[ are closed with >] and the string ends with a comma or 288 // there are no more args. 289 if ((numOpen == 0) && rectDesc.length() 290 && ((rectDesc[rectDesc.length() - 1] == ',') 291 || (optind == argc))) { 292 // Remove trailing comma if it is present 293 if (rectDesc[rectDesc.length() - 1] == ',') { 294 rectDesc.erase(rectDesc.length() - 1); 295 } 296 297 // Parse string description of rectangle 298 Rectangle rect = parseRect(rectDesc); 299 300 // Add to the list of rectangles 301 rectangle.push_back(rect); 302 303 // Prepare for description of another rectangle 304 rectDesc = string(""); 305 } 306 } 307 308 // Create list of frames 309 hwc_layer_list_t *list; 310 list = hwcTestCreateLayerList(rectangle.size()); 311 if (list == NULL) { 312 testPrintE("hwcTestCreateLayerList failed"); 313 exit(5); 314 } 315 316 hwc_layer_t *layer = &list->hwLayers[0]; 317 for (std::list<Rectangle>::iterator it = rectangle.begin(); 318 it != rectangle.end(); ++it, ++layer) { 319 layer->handle = it->texture->handle; 320 layer->blending = it->blend; 321 layer->transform = it->transform; 322 layer->sourceCrop = it->sourceCrop; 323 layer->displayFrame = it->displayFrame; 324 325 layer->visibleRegionScreen.numRects = 1; 326 layer->visibleRegionScreen.rects = &layer->displayFrame; 327 } 328 329 // Perform prepare operation 330 if (verbose) { testPrintI("Prepare:"); hwcTestDisplayList(list); } 331 hwcDevice->prepare(hwcDevice, list); 332 if (verbose) { 333 testPrintI("Post Prepare:"); 334 hwcTestDisplayListPrepareModifiable(list); 335 } 336 337 // Turn off the geometry changed flag 338 list->flags &= ~HWC_GEOMETRY_CHANGED; 339 340 // Perform the set operation(s) 341 if (verbose) {testPrintI("Set:"); } 342 if (verbose) { hwcTestDisplayListHandles(list); } 343 hwcDevice->set(hwcDevice, dpy, surface, list); 344 345 testDelay(endDelay); 346 347 // Start framework 348 rv = snprintf(cmd, sizeof(cmd), "%s", CMD_START_FRAMEWORK); 349 if (rv >= (signed) sizeof(cmd) - 1) { 350 testPrintE("Command too long for: %s", CMD_START_FRAMEWORK); 351 exit(6); 352 } 353 testExecCmd(cmd); 354 355 return 0; 356} 357 358// Parse string description of rectangle and add it to list of rectangles 359// to be rendered. 360static Rectangle parseRect(string rectStr) 361{ 362 int rv; 363 string str; 364 bool error; 365 istringstream in(rectStr); 366 const struct hwcTestGraphicFormat *format; 367 Rectangle rect; 368 struct hwc_rect hwcRect; 369 370 // Graphic Format 371 in >> str; 372 if (!in) { 373 testPrintE("Error parsing format from: %s", rectStr.c_str()); 374 exit(20); 375 } 376 format = hwcTestGraphicFormatLookup(str.c_str()); 377 if (format == NULL) { 378 testPrintE("Unknown graphic format in: %s", rectStr.c_str()); 379 exit(21); 380 } 381 rect.format = format->format; 382 383 // Display Frame 384 rect.displayFrame = hwcTestParseHwcRect(in, error); 385 if (error) { 386 testPrintE("Invalid display frame in: %s", rectStr.c_str()); 387 exit(22); 388 } 389 390 // Set default sourceDim and sourceCrop based on size of display frame. 391 // Default is source size equal to the size of the display frame, with 392 // the source crop being the entire size of the source frame. 393 rect.sourceDim = HwcTestDim(rect.displayFrame.right 394 - rect.displayFrame.left, 395 rect.displayFrame.bottom 396 - rect.displayFrame.top); 397 rect.sourceCrop.left = 0; 398 rect.sourceCrop.top = 0; 399 rect.sourceCrop.right = rect.sourceDim.width(); 400 rect.sourceCrop.bottom = rect.sourceDim.height(); 401 402 // Optional settings 403 while ((in.tellg() < (streampos) in.str().length()) 404 && (in.tellg() != (streampos) -1)) { 405 string attrName; 406 407 in >> attrName; 408 if (in.eof()) { break; } 409 if (!in) { 410 testPrintE("Error reading attribute name in: %s", 411 rectStr.c_str()); 412 exit(23); 413 } 414 415 // Transform 416 if (attrName == "transform:") { // Transform 417 string str; 418 419 in >> str; 420 if (str == "none") { 421 rect.transform = 0; 422 } else if (str == "fliph") { 423 rect.transform = HWC_TRANSFORM_FLIP_H; 424 } else if (str == "flipv") { 425 rect.transform = HWC_TRANSFORM_FLIP_V; 426 } else if (str == "rot90") { 427 rect.transform = HWC_TRANSFORM_ROT_90; 428 } else if (str == "rot180") { 429 rect.transform = HWC_TRANSFORM_ROT_180; 430 } else if (str == "rot270") { 431 rect.transform = HWC_TRANSFORM_ROT_270; 432 } else { 433 testPrintE("Unknown transform of \"%s\" in: %s", str.c_str(), 434 rectStr.c_str()); 435 exit(24); 436 } 437 } else if (attrName == "blend:") { // Blend 438 string str; 439 440 in >> str; 441 if (str == string("none")) { 442 rect.blend = HWC_BLENDING_NONE; 443 } else if (str == "premult") { 444 rect.blend = HWC_BLENDING_PREMULT; 445 } else if (str == "coverage") { 446 rect.blend = HWC_BLENDING_COVERAGE; 447 } else { 448 testPrintE("Unknown blend of \"%s\" in: %s", str.c_str(), 449 rectStr.c_str()); 450 exit(25); 451 } 452 } else if (attrName == "color:") { // Color 453 rect.color = hwcTestParseColor(in, error); 454 if (error) { 455 testPrintE("Error parsing color in: %s", rectStr.c_str()); 456 exit(26); 457 } 458 } else if (attrName == "alpha:") { // Alpha 459 in >> rect.alpha; 460 if (!in) { 461 testPrintE("Error parsing value for alpha attribute in: %s", 462 rectStr.c_str()); 463 exit(27); 464 } 465 } else if (attrName == "sourceDim:") { // Source Dimension 466 rect.sourceDim = hwcTestParseDim(in, error); 467 if (error) { 468 testPrintE("Error parsing source dimenision in: %s", 469 rectStr.c_str()); 470 exit(28); 471 } 472 } else if (attrName == "sourceCrop:") { // Source Crop 473 rect.sourceCrop = hwcTestParseHwcRect(in, error); 474 if (error) { 475 testPrintE("Error parsing source crop in: %s", 476 rectStr.c_str()); 477 exit(29); 478 } 479 } else { // Unknown attribute 480 testPrintE("Unknown attribute of \"%s\" in: %s", attrName.c_str(), 481 rectStr.c_str()); 482 exit(30); 483 } 484 } 485 486 // Validate 487 if (((uint32_t) rect.sourceCrop.left >= rect.sourceDim.width()) 488 || ((uint32_t) rect.sourceCrop.right > rect.sourceDim.width()) 489 || ((uint32_t) rect.sourceCrop.top >= rect.sourceDim.height()) 490 || ((uint32_t) rect.sourceCrop.bottom > rect.sourceDim.height())) { 491 testPrintE("Invalid source crop in: %s", rectStr.c_str()); 492 exit(31); 493 } 494 if ((rect.displayFrame.left >= width) 495 || (rect.displayFrame.right > width) 496 || (rect.displayFrame.top >= height) 497 || (rect.displayFrame.bottom > height)) { 498 testPrintE("Invalid display frame in: %s", rectStr.c_str()); 499 exit(32); 500 } 501 if ((rect.alpha < 0.0) || (rect.alpha > 1.0)) { 502 testPrintE("Invalid alpha in: %s", rectStr.c_str()); 503 exit(33); 504 } 505 506 // Create source texture 507 rect.texture = new GraphicBuffer(rect.sourceDim.width(), 508 rect.sourceDim.height(), 509 rect.format, texUsage); 510 if ((rv = rect.texture->initCheck()) != NO_ERROR) { 511 testPrintE("source texture initCheck failed, rv: %i", rv); 512 testPrintE(" %s", rectStr.c_str()); 513 514 } 515 516 // Fill with uniform color 517 hwcTestFillColor(rect.texture.get(), rect.color, rect.alpha); 518 if (verbose) { 519 testPrintI(" buf: %p handle: %p format: %s width: %u height: %u " 520 "color: %s alpha: %f", 521 rect.texture.get(), rect.texture->handle, format->desc, 522 rect.sourceDim.width(), rect.sourceDim.height(), 523 string(rect.color).c_str(), rect.alpha); 524 } 525 526 return rect; 527} 528 529void init(void) 530{ 531 // Seed pseudo random number generator 532 // Needed so that the pad areas of frames are filled with a deterministic 533 // pseudo random value. 534 srand48(0); 535 536 hwcTestInitDisplay(verbose, &dpy, &surface, &width, &height); 537 538 hwcTestOpenHwc(&hwcDevice); 539} 540 541void printSyntax(const char *cmd) 542{ 543 testPrintE(" %s [options] (graphicFormat displayFrame [attributes],)...", 544 cmd); 545 testPrintE(" options:"); 546 testPrintE(" -D End of test delay"); 547 testPrintE(" -v Verbose"); 548 testPrintE(""); 549 testPrintE(" graphic formats:"); 550 for (unsigned int n1 = 0; n1 < NUMA(hwcTestGraphicFormat); n1++) { 551 testPrintE(" %s", hwcTestGraphicFormat[n1].desc); 552 } 553 testPrintE(""); 554 testPrintE(" displayFrame"); 555 testPrintE(" [left, top, right, bottom]"); 556 testPrintE(""); 557 testPrintE(" attributes:"); 558 testPrintE(" transform: none | fliph | flipv | rot90 | rot180 " 559 " | rot270"); 560 testPrintE(" blend: none | premult | coverage"); 561 testPrintE(" color: [0.##, 0.##, 0.##]"); 562 testPrintE(" alpha: 0.##"); 563 testPrintE(" sourceDim: [width, height]"); 564 testPrintE(" sourceCrop: [left, top, right, bottom]"); 565 testPrintE(""); 566 testPrintE(" Example:"); 567 testPrintE(" # White YV12 rectangle, with overlapping turquoise "); 568 testPrintE(" # RGBA8888 rectangle at 30%% (alpha: 0.7) transparency"); 569 testPrintE(" %s -v -D 30.0 \\", cmd); 570 testPrintE(" YV12 [50, 80, 200, 300] transform: none \\"); 571 testPrintE(" color: [1.0, 0.5, 0.5], \\"); 572 testPrintE(" RGBA8888 [100, 150, 300, 400] blend: coverage \\"); 573 testPrintE(" color: [0.251, 0.878, 0.816] alpha: 0.7 \\"); 574 testPrintE(" sourceDim: [50, 60] sourceCrop: [5, 8, 12, 15]"); 575} 576