path: root/opengl/tests/hwc/hwcRects.cpp

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * Hardware Composer Rectangles
 *
 * Synopsis
 *   hwcRects [options] (graphicFormat displayFrame [attributes],)...
 *     options:
 *       -D #.## - End of test delay
 *       -v - Verbose
 *
 *      graphic formats:
 *        RGBA8888 (reference frame default)
 *        RGBX8888
 *        RGB888
 *        RGB565
 *        BGRA8888
 *        RGBA5551
 *        RGBA4444
 *        YV12
 *
 *      displayFrame
 *        [left, top, right, bottom]
 *
 *      attributes:
 *        transform: none | fliph | flipv | rot90 | rot180 | rot270
 *        blend: none | premult | coverage
 *        color: [0.##, 0.##, 0.##]
 *        alpha: 0.##
 *        sourceDim: [width, height]
 *        sourceCrop: [left, top, right, bottom]
 *
 *      Example:
 *        # White YV12 rectangle, with overlapping turquoise
 *        #  RGBA8888 rectangle at 30%% (alpha: 0.7) transparency
 *        hwcRects -v -D 30.0 \
 *          YV12 [50, 80, 200, 300] transform: none \
 *            color: [1.0, 0.5, 0.5], \
 *          RGBA8888 [100, 150, 300, 400] blend: coverage \
 *            color: [0.251, 0.878, 0.816] alpha: 0.7 \
 *            sourceDim: [50, 60] sourceCrop: [5, 8, 12, 15]
 *
 * Description
 *   Constructs a Hardware Composer (HWC) list of frames from
 *   command-line specified parameters.  Then sends it to the HWC
 *   be rendered.  The intended purpose of this tool is as a means to
 *   reproduce and succinctly specify an observed HWC operation, with
 *   no need to modify/compile a program.
 *
 *   The command-line syntax consists of a few standard command-line
 *   options and then a description of one or more frames.  The frame
 *   descriptions are separated from one another via a comma.  The
 *   beginning of a frame description requires the specification
 *   of the graphic format and then the display frame rectangle where
 *   the frame will be displayed.  The display frame rectangle is
 *   specified as follows, with the right and bottom coordinates being
 *   exclusive values:
 *
 *     [left, top, right, bottom]
 *    
 *   After these two required parameters each frame description can
 *   specify 1 or more optional attributes.  The name of each optional
 *   attribute is preceded by a colon.  The current implementation
 *   then requires white space after the colon and then the value of
 *   the attribute is specified.  See the synopsis section above for
 *   a list of attributes and the format of their expected value.
 */

#include <algorithm>
#include <assert.h>
#include <cerrno>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <istream>
#include <libgen.h>
#include <list>
#include <sched.h>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <unistd.h>

#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>

#include <ui/FramebufferNativeWindow.h>
#include <ui/GraphicBuffer.h>
#include <ui/EGLUtils.h>

#define LOG_TAG "hwcRectsTest"
#include <utils/Log.h>
#include <testUtil.h>

#include <hardware/hwcomposer.h>

#include <glTestLib.h>
#include <hwc/hwcTestLib.h>

using namespace std;
using namespace android;

// Defaults
const bool defaultVerbose = false;
const float defaultEndDelay = 2.0; // Default delay after rendering graphics

const uint32_t   defaultFormat = HAL_PIXEL_FORMAT_RGBA_8888;
const int32_t    defaultTransform = 0;
const uint32_t   defaultBlend = HWC_BLENDING_NONE;
const ColorFract defaultColor(0.5, 0.5, 0.5);
const float      defaultAlpha = 1.0; // Opaque
const HwcTestDim defaultSourceDim(1, 1);
const struct hwc_rect defaultSourceCrop = {0, 0, 1, 1};
const struct hwc_rect defaultDisplayFrame = {0, 0, 100, 100};

// Defines
#define MAXCMD               200
#define CMD_STOP_FRAMEWORK   "stop 2>&1"
#define CMD_START_FRAMEWORK  "start 2>&1"

// Macros
#define NUMA(a) (sizeof(a) / sizeof(a [0])) // Num elements in an array

// Local types
class Rectangle {
public:
    Rectangle() : format(defaultFormat), transform(defaultTransform),
                  blend(defaultBlend), color(defaultColor),
                  alpha(defaultAlpha), sourceDim(defaultSourceDim),
                  sourceCrop(defaultSourceCrop),
                  displayFrame(defaultDisplayFrame) {};

    uint32_t     format;
    uint32_t     transform;
    int32_t      blend;
    ColorFract   color;
    float        alpha;
    HwcTestDim   sourceDim;
    struct hwc_rect   sourceCrop;
    struct hwc_rect   displayFrame;

    sp<GraphicBuffer> texture;
};

// Globals
list<Rectangle> rectangle;
static const int texUsage = GraphicBuffer::USAGE_HW_TEXTURE |
        GraphicBuffer::USAGE_SW_WRITE_RARELY;
static hwc_composer_device_t *hwcDevice;
static EGLDisplay dpy;
static EGLSurface surface;
static EGLint width, height;

// Function prototypes
static Rectangle parseRect(string rectStr);
void init(void);
void printSyntax(const char *cmd);

// Command-line option settings
static bool verbose = defaultVerbose;
static float endDelay = defaultEndDelay;

/*
 * Main
 *
 * Performs the following high-level sequence of operations:
 *
 *   1. Parse command-line options
 *
 *   2. Stop framework
 *
 *   3. Initialization
 *
 *   4. Parse frame descriptions
 *
 *   5. Create HWC list from frame descriptions
 *
 *   6. Have HWC render the list description of the frames
 *
 *   7. Delay for amount of time given by endDelay
 *
 *   8. Start framework
 */
int
main(int argc, char *argv[])
{
    int     rv, opt;
    char   *chptr;
    bool    error;
    string  str;
    char cmd[MAXCMD];

    testSetLogCatTag(LOG_TAG);

    // Parse command line arguments
    while ((opt = getopt(argc, argv, "D:v?h")) != -1) {
        switch (opt) {
          case 'D': // End of test delay
            endDelay = strtod(optarg, &chptr);
            if ((*chptr != '\0') || (endDelay < 0.0)) {
                testPrintE("Invalid command-line specified end of test delay "
                           "of: %s", optarg);
                exit(1);
            }
            break;

          case 'v': // Verbose
            verbose = true;
            break;

          case 'h': // Help
          case '?':
          default:
            printSyntax(basename(argv[0]));
            exit(((optopt == 0) || (optopt == '?')) ? 0 : 2);
        }
    }

    // Stop framework
    rv = snprintf(cmd, sizeof(cmd), "%s", CMD_STOP_FRAMEWORK);
    if (rv >= (signed) sizeof(cmd) - 1) {
        testPrintE("Command too long for: %s", CMD_STOP_FRAMEWORK);
        exit(3);
    }
    testExecCmd(cmd);
    testDelay(1.0); // TODO - needs means to query whether asyncronous stop
                    // framework operation has completed.  For now, just wait
                    // a long time.

    init();

    // Parse rectangle descriptions
    int numOpen = 0; // Current number of unmatched <[
    string rectDesc(""); // String description of a single rectangle
    while (optind < argc) {
        string argNext = string(argv[optind++]);

        if (rectDesc.length()) { rectDesc += ' '; }
        rectDesc += argNext;

        // Count number of opening <[ and matching >]
        // At this point not worried about an opening character being
        // matched by it's corresponding closing character.  For example,
        // "<1.0, 2.0]" is incorrect because the opening < should be matched
        // with a closing >, instead of the closing ].  Such errors are
        // detected when the actual value is parsed.
        for (unsigned int n1 = 0; n1 < argNext.length(); n1++) {
            switch(argNext[n1]) {
              case '[':
              case '<':
                numOpen++;
                break;

              case ']':
              case '>':
                numOpen--;
                break;
            }

            // Error anytime there is more closing then opening characters
            if (numOpen < 0) {
                testPrintI("Mismatched number of opening <[ with "
                           "closing >] in: %s", rectDesc.c_str());
                exit(4);
            }
        }

        // Description of a rectangle is complete when all opening
        // <[ are closed with >] and the string ends with a comma or
        // there are no more args.
        if ((numOpen == 0) && rectDesc.length()
            && ((rectDesc[rectDesc.length() - 1] == ',')
                || (optind == argc))) {
            // Remove trailing comma if it is present
            if (rectDesc[rectDesc.length() - 1] == ',') {
                rectDesc.erase(rectDesc.length() - 1);
            }

            // Parse string description of rectangle
            Rectangle rect = parseRect(rectDesc);

            // Add to the list of rectangles
            rectangle.push_back(rect);

            // Prepare for description of another rectangle
            rectDesc = string("");
        }
    }

    // Create list of frames
    hwc_layer_list_t *list;
    list = hwcTestCreateLayerList(rectangle.size());
    if (list == NULL) {
        testPrintE("hwcTestCreateLayerList failed");
        exit(5);
    }

    hwc_layer_t *layer = &list->hwLayers[0];
    for (std::list<Rectangle>::iterator it = rectangle.begin();
         it != rectangle.end(); ++it, ++layer) {
        layer->handle = it->texture->handle;
        layer->blending = it->blend;
        layer->transform = it->transform;
        layer->sourceCrop = it->sourceCrop;
        layer->displayFrame = it->displayFrame;

        layer->visibleRegionScreen.numRects = 1;
        layer->visibleRegionScreen.rects = &layer->displayFrame;
    }

    // Perform prepare operation
    if (verbose) { testPrintI("Prepare:"); hwcTestDisplayList(list); }
    hwcDevice->prepare(hwcDevice, list);
    if (verbose) {
        testPrintI("Post Prepare:");
        hwcTestDisplayListPrepareModifiable(list);
    }

    // Turn off the geometry changed flag
    list->flags &= ~HWC_GEOMETRY_CHANGED;

    // Perform the set operation(s)
    if (verbose) {testPrintI("Set:"); }
    if (verbose) { hwcTestDisplayListHandles(list); }
    hwcDevice->set(hwcDevice, dpy, surface, list);

    testDelay(endDelay);

    // Start framework
    rv = snprintf(cmd, sizeof(cmd), "%s", CMD_START_FRAMEWORK);
    if (rv >= (signed) sizeof(cmd) - 1) {
        testPrintE("Command too long for: %s", CMD_START_FRAMEWORK);
        exit(6);
    }
    testExecCmd(cmd);

    return 0;
}

// Parse string description of rectangle and add it to list of rectangles
// to be rendered.
static Rectangle parseRect(string rectStr)
{
    int rv;
    string str;
    bool   error;
    istringstream in(rectStr);
    const struct hwcTestGraphicFormat *format;
    Rectangle rect;
    struct hwc_rect hwcRect;

    // Graphic Format
    in >> str;
    if (!in) {
        testPrintE("Error parsing format from: %s", rectStr.c_str());
        exit(20);
    }
    format = hwcTestGraphicFormatLookup(str.c_str());
    if (format == NULL) {
        testPrintE("Unknown graphic format in: %s", rectStr.c_str());
        exit(21);
    }
    rect.format = format->format;

    // Display Frame
    rect.displayFrame = hwcTestParseHwcRect(in, error);
    if (error) {
        testPrintE("Invalid display frame in: %s", rectStr.c_str());
        exit(22);
    }

    // Set default sourceDim and sourceCrop based on size of display frame.
    // Default is source size equal to the size of the display frame, with
    // the source crop being the entire size of the source frame.
    rect.sourceDim = HwcTestDim(rect.displayFrame.right
                                     - rect.displayFrame.left,
                                 rect.displayFrame.bottom
                                     - rect.displayFrame.top);
    rect.sourceCrop.left = 0;
    rect.sourceCrop.top = 0;
    rect.sourceCrop.right = rect.sourceDim.width();
    rect.sourceCrop.bottom = rect.sourceDim.height();

    // Optional settings
    while ((in.tellg() < (streampos) in.str().length())
           && (in.tellg() != (streampos) -1)) {
        string attrName;

        in >> attrName;
        if (in.eof()) { break; }
        if (!in) {
            testPrintE("Error reading attribute name in: %s",
                       rectStr.c_str());
            exit(23);
        }

        // Transform
        if (attrName == "transform:") { // Transform
            string str;

            in >> str;
            if (str == "none") {
                rect.transform = 0;
            } else if (str == "fliph") {
                rect.transform = HWC_TRANSFORM_FLIP_H;
            } else if (str == "flipv") {
                rect.transform = HWC_TRANSFORM_FLIP_V;
            } else if (str == "rot90") {
                rect.transform = HWC_TRANSFORM_ROT_90;
            } else if (str == "rot180") {
                rect.transform = HWC_TRANSFORM_ROT_180;
            } else if (str == "rot270") {
                rect.transform = HWC_TRANSFORM_ROT_270;
            } else {
                testPrintE("Unknown transform of \"%s\" in: %s", str.c_str(),
                           rectStr.c_str());
                exit(24);
            }
        } else if (attrName == "blend:") { // Blend
            string str;

            in >> str;
            if (str == string("none")) {
                rect.blend = HWC_BLENDING_NONE;
            } else if (str == "premult") {
                rect.blend = HWC_BLENDING_PREMULT;
            } else if (str == "coverage") {
                rect.blend = HWC_BLENDING_COVERAGE;
            } else {
                testPrintE("Unknown blend of \"%s\" in: %s", str.c_str(),
                           rectStr.c_str());
                exit(25);
            }
        } else if (attrName == "color:") { // Color
            rect.color = hwcTestParseColor(in, error);
            if (error) {
                testPrintE("Error parsing color in: %s", rectStr.c_str());
                exit(26);
            }
        } else if (attrName == "alpha:") { // Alpha
            in >> rect.alpha;
            if (!in) {
                testPrintE("Error parsing value for alpha attribute in: %s",
                           rectStr.c_str());
                exit(27);
            }
        } else if (attrName == "sourceDim:") { // Source Dimension
           rect.sourceDim = hwcTestParseDim(in, error);
            if (error) {
                testPrintE("Error parsing source dimenision in: %s",
                           rectStr.c_str());
                exit(28);
            }
        } else if (attrName == "sourceCrop:") { // Source Crop
            rect.sourceCrop = hwcTestParseHwcRect(in, error);
            if (error) {
                testPrintE("Error parsing source crop in: %s",
                           rectStr.c_str());
                exit(29);
            }
        } else { // Unknown attribute
            testPrintE("Unknown attribute of \"%s\" in: %s", attrName.c_str(),
                       rectStr.c_str());
            exit(30);
        }
    }

    // Validate
    if (((uint32_t) rect.sourceCrop.left >= rect.sourceDim.width())
        || ((uint32_t) rect.sourceCrop.right > rect.sourceDim.width())
        || ((uint32_t) rect.sourceCrop.top >= rect.sourceDim.height())
        || ((uint32_t) rect.sourceCrop.bottom > rect.sourceDim.height())) {
        testPrintE("Invalid source crop in: %s", rectStr.c_str());
        exit(31);
    }
    if ((rect.displayFrame.left >= width)
        || (rect.displayFrame.right > width)
        || (rect.displayFrame.top >= height)
        || (rect.displayFrame.bottom > height)) {
        testPrintE("Invalid display frame in: %s", rectStr.c_str());
        exit(32);
    }
    if ((rect.alpha < 0.0) || (rect.alpha > 1.0)) {
        testPrintE("Invalid alpha in: %s", rectStr.c_str());
        exit(33);
    }

    // Create source texture
    rect.texture = new GraphicBuffer(rect.sourceDim.width(),
                                     rect.sourceDim.height(),
                                     rect.format, texUsage);
    if ((rv = rect.texture->initCheck()) != NO_ERROR) {
        testPrintE("source texture initCheck failed, rv: %i", rv);
        testPrintE("  %s", rectStr.c_str());

    }

    // Fill with uniform color
    hwcTestFillColor(rect.texture.get(), rect.color, rect.alpha);
    if (verbose) {
        testPrintI("    buf: %p handle: %p format: %s width: %u height: %u "
                   "color: %s alpha: %f",
                   rect.texture.get(), rect.texture->handle, format->desc,
                   rect.sourceDim.width(), rect.sourceDim.height(),
                   string(rect.color).c_str(), rect.alpha);
    }

    return rect;
}

void init(void)
{
    // Seed pseudo random number generator
    // Needed so that the pad areas of frames are filled with a deterministic
    // pseudo random value.
    srand48(0);

    hwcTestInitDisplay(verbose, &dpy, &surface, &width, &height);

    hwcTestOpenHwc(&hwcDevice);
}

void printSyntax(const char *cmd)
{
    testPrintE("  %s [options] (graphicFormat displayFrame [attributes],)...",
               cmd);
    testPrintE("    options:");
    testPrintE("      -D End of test delay");
    testPrintE("      -v Verbose");
    testPrintE("");
    testPrintE("    graphic formats:");
    for (unsigned int n1 = 0; n1 < NUMA(hwcTestGraphicFormat); n1++) {
        testPrintE("      %s", hwcTestGraphicFormat[n1].desc);
    }
    testPrintE("");
    testPrintE("    displayFrame");
    testPrintE("      [left, top, right, bottom]");
    testPrintE("");
    testPrintE("    attributes:");
    testPrintE("      transform: none | fliph | flipv | rot90 | rot180 "
               " | rot270");
    testPrintE("      blend: none | premult | coverage");
    testPrintE("      color: [0.##, 0.##, 0.##]");
    testPrintE("      alpha: 0.##");
    testPrintE("      sourceDim: [width, height]");
    testPrintE("      sourceCrop: [left, top, right, bottom]");
    testPrintE("");
    testPrintE("    Example:");
    testPrintE("      # White YV12 rectangle, with overlapping turquoise ");
    testPrintE("      #  RGBA8888 rectangle at 30%% (alpha: 0.7) transparency");
    testPrintE("      %s -v -D 30.0 \\", cmd);
    testPrintE("        YV12 [50, 80, 200, 300] transform: none \\");
    testPrintE("          color: [1.0, 0.5, 0.5], \\");
    testPrintE("        RGBA8888 [100, 150, 300, 400] blend: coverage \\");
    testPrintE("          color: [0.251, 0.878, 0.816] alpha: 0.7 \\");
    testPrintE("          sourceDim: [50, 60] sourceCrop: [5, 8, 12, 15]");
}