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