diff --git a/opengl/tests/hwc/Android.mk b/opengl/tests/hwc/Android.mk index 93a554597..631297010 100644 --- a/opengl/tests/hwc/Android.mk +++ b/opengl/tests/hwc/Android.mk @@ -124,3 +124,33 @@ LOCAL_MODULE_TAGS := tests LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES include $(BUILD_NATIVE_TEST) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES:= hwcCommit.cpp + +LOCAL_SHARED_LIBRARIES := \ + libcutils \ + libEGL \ + libGLESv2 \ + libui \ + libhardware \ + +LOCAL_STATIC_LIBRARIES := \ + libtestUtil \ + libglTest \ + libhwcTest \ + +LOCAL_C_INCLUDES += \ + system/extras/tests/include \ + hardware/libhardware/include \ + frameworks/base/opengl/tests \ + frameworks/base/opengl/tests/include \ + +LOCAL_MODULE:= hwcCommit +LOCAL_MODULE_PATH := $(TARGET_OUT_DATA)/nativebenchmark + +LOCAL_MODULE_TAGS := tests + +LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES + +include $(BUILD_NATIVE_TEST) diff --git a/opengl/tests/hwc/hwcColorEquiv.cpp b/opengl/tests/hwc/hwcColorEquiv.cpp index 4a87a05b2..1d039481c 100644 --- a/opengl/tests/hwc/hwcColorEquiv.cpp +++ b/opengl/tests/hwc/hwcColorEquiv.cpp @@ -176,6 +176,8 @@ main(int argc, char *argv[]) assert(refFormat != NULL); + testSetLogCatTag(LOG_TAG); + // Parse command line arguments while ((opt = getopt(argc, argv, "vs:e:r:D:?h")) != -1) { switch (opt) { diff --git a/opengl/tests/hwc/hwcCommit.cpp b/opengl/tests/hwc/hwcCommit.cpp new file mode 100644 index 000000000..ed74cbe72 --- /dev/null +++ b/opengl/tests/hwc/hwcCommit.cpp @@ -0,0 +1,1420 @@ +/* + * 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 Commit Points + * + * Synopsis + * hwcCommit [options] graphicFormat ... + * options: + * -s [width, height] - Starting dimension + * -v - Verbose + * + * graphic formats: + * RGBA8888 (reference frame default) + * RGBX8888 + * RGB888 + * RGB565 + * BGRA8888 + * RGBA5551 + * RGBA4444 + * YV12 + * + * Description + * The Hardware Composer (HWC) Commit test is a benchmark that + * discovers the points at which the HWC will commit to rendering an + * overlay(s). Before rendering a set of overlays, the HWC is shown + * the list through a prepare call. During the prepare call the HWC + * is able to examine the list and specify which overlays it is able + * to handle. The overlays that it can't handle are typically composited + * by a higher level (e.g. Surface Flinger) and then the original list + * plus a composit of what HWC passed on are provided back to the HWC + * for rendering. + * + * Once an implementation of the HWC has been shipped, a regression would + * likely occur if a latter implementation started passing on conditions + * that it used to commit to. The primary purpose of this benchmark + * is the automated discovery of the commit points, where an implementation + * is on the edge between committing and not committing. These are commonly + * referred to as commit points. Between implementations changes to the + * commit points are allowed, as long as they improve what the HWC commits + * to. Once an implementation of the HWC is shipped, the commit points are + * not allowed to regress in future implementations. + * + * This benchmark takes a sampling and then adjusts until it finds a + * commit point. It doesn't exhaustively check all possible conditions, + * which do to the number of combinations would be impossible. Instead + * it starts its search from a starting dimension, that can be changed + * via the -s option. The search is also bounded by a set of search + * limits, that are hard-coded into a structure of constants named + * searchLimits. Results that happen to reach a searchLimit are prefixed + * with >=, so that it is known that the value could possibly be larger. + * + * Measurements are made for each of the graphic formats specified as + * positional parameters on the command-line. If no graphic formats + * are specified on the command line, then by default measurements are + * made and reported for each of the known graphic format. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include + +#define LOG_TAG "hwcCommitTest" +#include +#include + +#include + +#include +#include + +using namespace std; +using namespace android; + +// Defaults +const HwcTestDim defaultStartDim = HwcTestDim(100, 100); +const bool defaultVerbose = false; + +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}; + +// Global Constants +const struct searchLimits { + uint32_t numOverlays; + HwcTestDim sourceCrop; +} searchLimits = { + 10, + HwcTestDim(3000, 2000), +}; +const struct transformType { + const char *desc; + uint32_t id; +} transformType[] = { + {"fliph", HWC_TRANSFORM_FLIP_H}, + {"flipv", HWC_TRANSFORM_FLIP_V}, + {"rot90", HWC_TRANSFORM_ROT_90}, + {"rot180", HWC_TRANSFORM_ROT_180}, + {"rot270", HWC_TRANSFORM_ROT_270}, +}; +const struct blendType { + const char *desc; + uint32_t id; +} blendType[] = { + {"none", HWC_BLENDING_NONE}, + {"premult", HWC_BLENDING_PREMULT}, + {"coverage", HWC_BLENDING_COVERAGE}, +}; + +// 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(uint32_t graphicFormat = defaultFormat, + HwcTestDim dfDim = HwcTestDim(1, 1), + HwcTestDim sDim = HwcTestDim(1, 1)); + void setSourceDim(HwcTestDim dim); + + uint32_t format; + uint32_t transform; + int32_t blend; + ColorFract color; + float alpha; + HwcTestDim sourceDim; + struct hwc_rect sourceCrop; + struct hwc_rect displayFrame; +}; + +class Range { +public: + Range(void) : _l(0), _u(0) {} + Range(uint32_t lower, uint32_t upper) : _l(lower), _u(upper) {} + uint32_t lower(void) { return _l; } + uint32_t upper(void) { return _u; } + + operator string(); + +private: + uint32_t _l; // lower + uint32_t _u; // upper +}; + +Range::operator string() +{ + ostringstream out; + + out << '[' << _l << ", " << _u << ']'; + + return out.str(); +} + +class Rational { +public: + Rational(void) : _n(0), _d(1) {} + Rational(uint32_t n, uint32_t d) : _n(n), _d(d) {} + uint32_t numerator(void) { return _n; } + uint32_t denominator(void) { return _d; } + void setNumerator(uint32_t numerator) { _n = numerator; } + + bool operator==(const Rational& other) const; + bool operator!=(const Rational& other) const { return !(*this == other); } + bool operator<(const Rational& other) const; + bool operator>(const Rational& other) const { + return (!(*this == other) && !(*this < other)); + } + static void double2Rational(double f, Range nRange, Range dRange, + Rational& lower, Rational& upper); + + operator string() const; + operator double() const { return (double) _n / (double) _d; } + + +private: + uint32_t _n; + uint32_t _d; +}; + +// Globals +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; + +// Measurements +struct meas { + uint32_t format; + uint32_t startDimOverlays; + uint32_t maxNonOverlapping; + uint32_t maxOverlapping; + list transforms; + list blends; + struct displayFrame { + uint32_t minWidth; + uint32_t minHeight; + HwcTestDim minDim; + uint32_t maxWidth; + uint32_t maxHeight; + HwcTestDim maxDim; + } df; + struct sourceCrop { + uint32_t minWidth; + uint32_t minHeight; + HwcTestDim minDim; + uint32_t maxWidth; + uint32_t maxHeight; + HwcTestDim maxDim; + Rational hScale; + HwcTestDim hScaleBestDf; + HwcTestDim hScaleBestSc; + Rational vScale; + HwcTestDim vScaleBestDf; + HwcTestDim vScaleBestSc; + } sc; +}; +vector measurements; + +// Function prototypes +uint32_t numOverlays(list& rectList); +uint32_t maxOverlays(uint32_t format, bool allowOverlap); +list supportedTransforms(uint32_t format); +list supportedBlends(uint32_t format); +uint32_t dfMinWidth(uint32_t format); +uint32_t dfMinHeight(uint32_t format); +uint32_t dfMaxWidth(uint32_t format); +uint32_t dfMaxHeight(uint32_t format); +HwcTestDim dfMinDim(uint32_t format); +HwcTestDim dfMaxDim(uint32_t format); +uint32_t scMinWidth(uint32_t format, const HwcTestDim& dfDim); +uint32_t scMinHeight(uint32_t format, const HwcTestDim& dfDim); +uint32_t scMaxWidth(uint32_t format, const HwcTestDim& dfDim); +uint32_t scMaxHeight(uint32_t format, const HwcTestDim& dfDim); +HwcTestDim scMinDim(uint32_t format, const HwcTestDim& dfDim); +HwcTestDim scMaxDim(uint32_t format, const HwcTestDim& dfDim); +Rational scHScale(uint32_t format, + const HwcTestDim& dfMin, const HwcTestDim& dfMax, + const HwcTestDim& scMin, const HwcTestDim& scMax, + HwcTestDim& outBestDf, HwcTestDim& outBestSc); +Rational scVScale(uint32_t format, + const HwcTestDim& dfMin, const HwcTestDim& dfMax, + const HwcTestDim& scMin, const HwcTestDim& scMax, + HwcTestDim& outBestDf, HwcTestDim& outBestSc); +string transformList2str(const list& transformList); +string blendList2str(const list& blendList); +void init(void); +void printSyntax(const char *cmd); + +// Command-line option settings +static bool verbose = defaultVerbose; +static HwcTestDim startDim = defaultStartDim; + +/* + * Main + * + * Performs the following high-level sequence of operations: + * + * 1. Command-line parsing + * + * 2. Form a list of command-line specified graphic formats. If + * no formats are specified, then form a list of all known formats. + * + * 3. Stop framework + * Only one user at a time is allowed to use the HWC. Surface + * Flinger uses the HWC and is part of the framework. Need to + * stop the framework so that Surface Flinger will stop using + * the HWC. + * + * 4. Initialization + * + * 5. For each graphic format in the previously formed list perform + * measurements on that format and report the results. + * + * 6. Start framework + */ +int +main(int argc, char *argv[]) +{ + int rv, opt; + char *chptr; + bool error; + string str; + char cmd[MAXCMD]; + list formats; + list rectList; + + testSetLogCatTag(LOG_TAG); + + // Parse command line arguments + while ((opt = getopt(argc, argv, "s:v?h")) != -1) { + switch (opt) { + + case 's': // Start Dimension + // Use arguments until next starts with a dash + // or current ends with a > or ] + str = optarg; + while (optind < argc) { + if (*argv[optind] == '-') { break; } + char endChar = (str.length() > 1) ? str[str.length() - 1] : 0; + if ((endChar == '>') || (endChar == ']')) { break; } + str += " " + string(argv[optind++]); + } + { + istringstream in(str); + startDim = hwcTestParseDim(in, error); + // Any parse error or characters not used by parser + if (error + || (((unsigned int) in.tellg() != in.str().length()) + && (in.tellg() != (streampos) -1))) { + testPrintE("Invalid command-line specified start " + "dimension of: %s", str.c_str()); + exit(8); + } + } + break; + + case 'v': // Verbose + verbose = true; + break; + + case 'h': // Help + case '?': + default: + printSyntax(basename(argv[0])); + exit(((optopt == 0) || (optopt == '?')) ? 0 : 11); + } + } + + // Positional parameters + // Positional parameters provide the names of graphic formats that + // measurements are to be made on. Measurements are made on all + // known graphic formats when no positional parameters are provided. + if (optind == argc) { + // No command-line specified graphic formats + // Add all graphic formats to the list of formats to be measured + for (unsigned int n1 = 0; n1 < NUMA(hwcTestGraphicFormat); n1++) { + formats.push_back(hwcTestGraphicFormat[n1].desc); + } + } else { + // Add names of command-line specified graphic formats to the + // list of formats to be tested + for (; argv[optind] != NULL; optind++) { + formats.push_back(argv[optind]); + } + } + + // 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(14); + } + testExecCmd(cmd); + testDelay(1.0); // TODO - needs means to query whether asynchronous stop + // framework operation has completed. For now, just wait + // a long time. + + testPrintI("startDim: %s", ((string) startDim).c_str()); + + init(); + + // For each of the graphic formats + for (list::iterator itFormat = formats.begin(); + itFormat != formats.end(); ++itFormat) { + + // Locate hwcTestLib structure that describes this format + const struct hwcTestGraphicFormat *format; + format = hwcTestGraphicFormatLookup((*itFormat).c_str()); + if (format == NULL) { + testPrintE("Unknown graphic format of: %s", (*itFormat).c_str()); + exit(1); + } + + // Display format header + testPrintI("format: %s", format->desc); + + // Create area to hold the measurements + struct meas meas; + struct meas *measPtr; + meas.format = format->format; + measurements.push_back(meas); + measPtr = &measurements[measurements.size() - 1]; + + // Start dimension num overlays + Rectangle rect(format->format, startDim); + rectList.clear(); + rectList.push_back(rect); + measPtr->startDimOverlays = numOverlays(rectList); + testPrintI(" startDimOverlays: %u", measPtr->startDimOverlays); + + // Skip the rest of the measurements, when the start dimension + // doesn't produce an overlay + if (measPtr->startDimOverlays == 0) { continue; } + + // Max Overlays + measPtr->maxNonOverlapping = maxOverlays(format->format, false); + testPrintI(" max nonOverlapping overlays: %s%u", + (measPtr->maxNonOverlapping == searchLimits.numOverlays) + ? ">= " : "", + measPtr->maxNonOverlapping); + measPtr->maxOverlapping = maxOverlays(format->format, true); + testPrintI(" max Overlapping overlays: %s%u", + (measPtr->maxOverlapping == searchLimits.numOverlays) + ? ">= " : "", + measPtr->maxOverlapping); + + // Transforms and blends + measPtr->transforms = supportedTransforms(format->format); + testPrintI(" transforms: %s", + transformList2str(measPtr->transforms).c_str()); + measPtr->blends = supportedBlends(format->format); + testPrintI(" blends: %s", + blendList2str(measPtr->blends).c_str()); + + // Display frame measurements + measPtr->df.minWidth = dfMinWidth(format->format); + testPrintI(" dfMinWidth: %u", measPtr->df.minWidth); + + measPtr->df.minHeight = dfMinHeight(format->format); + testPrintI(" dfMinHeight: %u", measPtr->df.minHeight); + + measPtr->df.maxWidth = dfMaxWidth(format->format); + testPrintI(" dfMaxWidth: %u", measPtr->df.maxWidth); + + measPtr->df.maxHeight = dfMaxHeight(format->format); + testPrintI(" dfMaxHeight: %u", measPtr->df.maxHeight); + + measPtr->df.minDim = dfMinDim(format->format); + testPrintI(" dfMinDim: %s", ((string) measPtr->df.minDim).c_str()); + + measPtr->df.maxDim = dfMaxDim(format->format); + testPrintI(" dfMaxDim: %s", ((string) measPtr->df.maxDim).c_str()); + + // Source crop measurements + measPtr->sc.minWidth = scMinWidth(format->format, measPtr->df.minDim); + testPrintI(" scMinWidth: %u", measPtr->sc.minWidth); + + measPtr->sc.minHeight = scMinHeight(format->format, measPtr->df.minDim); + testPrintI(" scMinHeight: %u", measPtr->sc.minHeight); + + measPtr->sc.maxWidth = scMaxWidth(format->format, measPtr->df.maxDim); + testPrintI(" scMaxWidth: %s%u", (measPtr->sc.maxWidth + == searchLimits.sourceCrop.width()) ? ">= " : "", + measPtr->sc.maxWidth); + + measPtr->sc.maxHeight = scMaxHeight(format->format, measPtr->df.maxDim); + testPrintI(" scMaxHeight: %s%u", (measPtr->sc.maxHeight + == searchLimits.sourceCrop.height()) ? ">= " : "", + measPtr->sc.maxHeight); + + measPtr->sc.minDim = scMinDim(format->format, measPtr->df.minDim); + testPrintI(" scMinDim: %s", ((string) measPtr->sc.minDim).c_str()); + + measPtr->sc.maxDim = scMaxDim(format->format, measPtr->df.maxDim); + testPrintI(" scMaxDim: %s%s", ((measPtr->sc.maxDim.width() + >= searchLimits.sourceCrop.width()) + || (measPtr->sc.maxDim.width() >= + searchLimits.sourceCrop.height())) ? ">= " : "", + ((string) measPtr->sc.maxDim).c_str()); + + measPtr->sc.hScale = scHScale(format->format, + measPtr->df.minDim, measPtr->df.maxDim, + measPtr->sc.minDim, measPtr->sc.maxDim, + measPtr->sc.hScaleBestDf, + measPtr->sc.hScaleBestSc); + testPrintI(" scHScale: %s%f", + (measPtr->sc.hScale + >= Rational(searchLimits.sourceCrop.width(), + measPtr->df.minDim.width())) ? ">= " : "", + (double) measPtr->sc.hScale); + testPrintI(" HScale Best Display Frame: %s", + ((string) measPtr->sc.hScaleBestDf).c_str()); + testPrintI(" HScale Best Source Crop: %s", + ((string) measPtr->sc.hScaleBestSc).c_str()); + + measPtr->sc.vScale = scVScale(format->format, + measPtr->df.minDim, measPtr->df.maxDim, + measPtr->sc.minDim, measPtr->sc.maxDim, + measPtr->sc.vScaleBestDf, + measPtr->sc.vScaleBestSc); + testPrintI(" scVScale: %s%f", + (measPtr->sc.vScale + >= Rational(searchLimits.sourceCrop.height(), + measPtr->df.minDim.height())) ? ">= " : "", + (double) measPtr->sc.vScale); + testPrintI(" VScale Best Display Frame: %s", + ((string) measPtr->sc.vScaleBestDf).c_str()); + testPrintI(" VScale Best Source Crop: %s", + ((string) measPtr->sc.vScaleBestSc).c_str()); + + } + + // 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(21); + } + testExecCmd(cmd); + + return 0; +} + +// Determine the maximum number of overlays that are all of the same format +// that the HWC will commit to. If allowOverlap is true, then the rectangles +// are laid out on a diagonal starting from the upper left corner. With +// each rectangle adjust one pixel to the right and one pixel down. +// When allowOverlap is false, the rectangles are tiled in column major +// order. Note, column major ordering is used so that the initial rectangles +// are all on different horizontal scan rows. It is common that hardware +// has limits on the number of objects it can handle on any single row. +uint32_t maxOverlays(uint32_t format, bool allowOverlap) +{ + unsigned int max = 0; + + for (unsigned int numRects = 1; numRects <= searchLimits.numOverlays; + numRects++) { + list rectList; + + for (unsigned int x = 0; + (x + startDim.width()) < (unsigned int) width; + x += (allowOverlap) ? 1 : startDim.width()) { + for (unsigned int y = 0; + (y + startDim.height()) < (unsigned int) height; + y += (allowOverlap) ? 1 : startDim.height()) { + Rectangle rect(format, startDim, startDim); + rect.displayFrame.left = x; + rect.displayFrame.top = y; + rect.displayFrame.right = x + startDim.width(); + rect.displayFrame.bottom = y + startDim.height(); + + rectList.push_back(rect); + + if (rectList.size() >= numRects) { break; } + } + if (rectList.size() >= numRects) { break; } + } + + uint32_t num = numOverlays(rectList); + if (num > max) { max = num; } + } + + return max; +} + +// Measures what transforms (i.e. flip horizontal, rotate 180) are +// supported by the specified format +list supportedTransforms(uint32_t format) +{ + list rv; + list rectList; + Rectangle rect(format, startDim); + + // For each of the transform types + for (unsigned int idx = 0; idx < NUMA(transformType); idx++) { + unsigned int id = transformType[idx].id; + + rect.transform = id; + rectList.clear(); + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + + if (num == 1) { + rv.push_back(id); + } + } + + return rv; +} + +// Determines which types of blends (i.e. none, premult, coverage) are +// supported by the specified format +list supportedBlends(uint32_t format) +{ + list rv; + list rectList; + Rectangle rect(format, startDim); + + // For each of the blend types + for (unsigned int idx = 0; idx < NUMA(blendType); idx++) { + unsigned int id = blendType[idx].id; + + rect.blend = id; + rectList.clear(); + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + + if (num == 1) { + rv.push_back(id); + } + } + + return rv; +} + +// Determines the minimum width of any display frame of the given format +// that the HWC will commit to. +uint32_t dfMinWidth(uint32_t format) +{ + uint32_t w; + list rectList; + + for (w = 1; w <= startDim.width(); w++) { + HwcTestDim dim(w, startDim.height()); + Rectangle rect(format, dim); + rectList.clear(); + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num > 0) { + return w; + } + } + if (w > startDim.width()) { + testPrintE("Failed to locate display frame min width"); + exit(33); + } + + return w; +} + +// Display frame minimum height +uint32_t dfMinHeight(uint32_t format) +{ + uint32_t h; + list rectList; + + for (h = 1; h <= startDim.height(); h++) { + HwcTestDim dim(startDim.width(), h); + Rectangle rect(format, dim); + rectList.clear(); + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num > 0) { + return h; + } + } + if (h > startDim.height()) { + testPrintE("Failed to locate display frame min height"); + exit(34); + } + + return h; +} + +// Display frame maximum width +uint32_t dfMaxWidth(uint32_t format) +{ + uint32_t w; + list rectList; + + for (w = width; w >= startDim.width(); w--) { + HwcTestDim dim(w, startDim.height()); + Rectangle rect(format, dim); + rectList.clear(); + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num > 0) { + return w; + } + } + if (w < startDim.width()) { + testPrintE("Failed to locate display frame max width"); + exit(35); + } + + return w; +} + +// Display frame maximum height +uint32_t dfMaxHeight(uint32_t format) +{ + uint32_t h; + + for (h = height; h >= startDim.height(); h--) { + HwcTestDim dim(startDim.width(), h); + Rectangle rect(format, dim); + list rectList; + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num > 0) { + return h; + } + } + if (h < startDim.height()) { + testPrintE("Failed to locate display frame max height"); + exit(36); + } + + return h; +} + +// Determine the minimum number of pixels that the HWC will ever commit to. +// Note, this might be different that dfMinWidth * dfMinHeight, in that this +// function adjusts both the width and height from the starting dimension. +HwcTestDim dfMinDim(uint32_t format) +{ + uint64_t bestMinPixels = 0; + HwcTestDim bestDim; + bool bestSet = false; // True when value has been assigned to + // bestMinPixels and bestDim + + bool origVerbose = verbose; // Temporarily turn off verbose + verbose = false; + for (uint32_t w = 1; w <= startDim.width(); w++) { + for (uint32_t h = 1; h <= startDim.height(); h++) { + if (bestSet && ((w > bestMinPixels) || (h > bestMinPixels))) { + break; + } + + HwcTestDim dim(w, h); + Rectangle rect(format, dim); + list rectList; + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num > 0) { + uint64_t pixels = dim.width() * dim.height(); + if (!bestSet || (pixels < bestMinPixels)) { + bestMinPixels = pixels; + bestDim = dim; + bestSet = true; + } + } + } + } + verbose = origVerbose; + + if (!bestSet) { + testPrintE("Unable to locate display frame min dimension"); + exit(20); + } + + return bestDim; +} + +// Display frame maximum dimension +HwcTestDim dfMaxDim(uint32_t format) +{ + uint64_t bestMaxPixels = 0; + HwcTestDim bestDim; + bool bestSet = false; // True when value has been assigned to + // bestMaxPixels and bestDim; + + // Potentially increase benchmark performance by first checking + // for the common case of supporting a full display frame. + HwcTestDim dim(width, height); + Rectangle rect(format, dim); + list rectList; + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num == 1) { return dim; } + + // TODO: Use a binary search + bool origVerbose = verbose; // Temporarily turn off verbose + verbose = false; + for (uint32_t w = startDim.width(); w <= (uint32_t) width; w++) { + for (uint32_t h = startDim.height(); h <= (uint32_t) height; h++) { + if (bestSet && ((w * h) <= bestMaxPixels)) { continue; } + + HwcTestDim dim(w, h); + Rectangle rect(format, dim); + list rectList; + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num > 0) { + uint64_t pixels = dim.width() * dim.height(); + if (!bestSet || (pixels > bestMaxPixels)) { + bestMaxPixels = pixels; + bestDim = dim; + bestSet = true; + } + } + } + } + verbose = origVerbose; + + if (!bestSet) { + testPrintE("Unable to locate display frame max dimension"); + exit(21); + } + + return bestDim; +} + +// Source crop minimum width +uint32_t scMinWidth(uint32_t format, const HwcTestDim& dfDim) +{ + uint32_t w; + list rectList; + + // Source crop frame min width + for (w = 1; w <= dfDim.width(); w++) { + Rectangle rect(format, dfDim, HwcTestDim(w, dfDim.height())); + rectList.clear(); + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num > 0) { + return w; + } + } + testPrintE("Failed to locate source crop min width"); + exit(35); +} + +// Source crop minimum height +uint32_t scMinHeight(uint32_t format, const HwcTestDim& dfDim) +{ + uint32_t h; + list rectList; + + for (h = 1; h <= dfDim.height(); h++) { + Rectangle rect(format, dfDim, HwcTestDim(dfDim.width(), h)); + rectList.clear(); + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num > 0) { + return h; + } + } + testPrintE("Failed to locate source crop min height"); + exit(36); +} + +// Source crop maximum width +uint32_t scMaxWidth(uint32_t format, const HwcTestDim& dfDim) +{ + uint32_t w; + list rectList; + + for (w = searchLimits.sourceCrop.width(); w >= dfDim.width(); w--) { + Rectangle rect(format, dfDim, HwcTestDim(w, dfDim.height())); + rectList.clear(); + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num > 0) { + return w; + } + } + testPrintE("Failed to locate source crop max width"); + exit(35); +} + +// Source crop maximum height +uint32_t scMaxHeight(uint32_t format, const HwcTestDim& dfDim) +{ + uint32_t h; + list rectList; + + for (h = searchLimits.sourceCrop.height(); h >= dfDim.height(); h--) { + Rectangle rect(format, dfDim, HwcTestDim(dfDim.width(), h)); + rectList.clear(); + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num > 0) { + return h; + } + } + testPrintE("Failed to locate source crop max height"); + exit(36); +} + +// Source crop minimum dimension +// Discovers the source crop with the least number of pixels that the +// HWC will commit to. Note, this may be different from scMinWidth +// * scMinHeight, in that this function searches for a combination of +// width and height. While the other routines always keep one of the +// dimensions equal to the corresponding start dimension. +HwcTestDim scMinDim(uint32_t format, const HwcTestDim& dfDim) +{ + uint64_t bestMinPixels = 0; + HwcTestDim bestDim; + bool bestSet = false; // True when value has been assigned to + // bestMinPixels and bestDim + + bool origVerbose = verbose; // Temporarily turn off verbose + verbose = false; + for (uint32_t w = 1; w <= dfDim.width(); w++) { + for (uint32_t h = 1; h <= dfDim.height(); h++) { + if (bestSet && ((w > bestMinPixels) || (h > bestMinPixels))) { + break; + } + + HwcTestDim dim(w, h); + Rectangle rect(format, dfDim, HwcTestDim(w, h)); + list rectList; + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num > 0) { + uint64_t pixels = dim.width() * dim.height(); + if (!bestSet || (pixels < bestMinPixels)) { + bestMinPixels = pixels; + bestDim = dim; + bestSet = true; + } + } + } + } + verbose = origVerbose; + + if (!bestSet) { + testPrintE("Unable to locate source crop min dimension"); + exit(20); + } + + return bestDim; +} + +// Source crop maximum dimension +HwcTestDim scMaxDim(uint32_t format, const HwcTestDim& dfDim) +{ + uint64_t bestMaxPixels = 0; + HwcTestDim bestDim; + bool bestSet = false; // True when value has been assigned to + // bestMaxPixels and bestDim; + + // Potentially increase benchmark performance by first checking + // for the common case of supporting the maximum checked source size + HwcTestDim dim = searchLimits.sourceCrop; + Rectangle rect(format, dfDim, searchLimits.sourceCrop); + list rectList; + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num == 1) { return dim; } + + // TODO: Use a binary search + bool origVerbose = verbose; // Temporarily turn off verbose + verbose = false; + for (uint32_t w = dfDim.width(); + w <= searchLimits.sourceCrop.width(); w++) { + for (uint32_t h = dfDim.height(); + h <= searchLimits.sourceCrop.height(); h++) { + if (bestSet && ((w * h) <= bestMaxPixels)) { continue; } + + HwcTestDim dim(w, h); + Rectangle rect(format, dfDim, dim); + list rectList; + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + if (num > 0) { + uint64_t pixels = dim.width() * dim.height(); + if (!bestSet || (pixels > bestMaxPixels)) { + bestMaxPixels = pixels; + bestDim = dim; + bestSet = true; + } + } + } + } + verbose = origVerbose; + + if (!bestSet) { + testPrintE("Unable to locate source crop max dimension"); + exit(21); + } + + return bestDim; +} + +// Source crop horizontal scale +// Determines the maximum factor by which the source crop can be larger +// that the display frame. The commit point is discovered through a +// binary search of rational numbers. The numerator in each of the +// rational numbers contains the dimension for the source crop, while +// the denominator specifies the dimension for the display frame. On +// each pass of the binary search the mid-point between the greatest +// point committed to (best) and the smallest point in which a commit +// has failed is calculated. This mid-point is then passed to a function +// named double2Rational, which determines the closest rational numbers +// just below and above the mid-point. By default the lower rational +// number is used for the scale factor on the next pass of the binary +// search. The upper value is only used when best is already equal +// to the lower value. This only occurs when the lower value has already +// been tried. +Rational scHScale(uint32_t format, + const HwcTestDim& dfMin, const HwcTestDim& dfMax, + const HwcTestDim& scMin, const HwcTestDim& scMax, + HwcTestDim& outBestDf, HwcTestDim& outBestSc) +{ + HwcTestDim scDim, dfDim; // Source crop and display frame dimension + Rational best(0, 1), minBad; // Current bounds for a binary search + // MinGood is set below the lowest + // possible scale. The value of minBad, + // will be set by the first pass + // of the binary search. + + // Perform the passes of the binary search + bool firstPass = true; + do { + // On first pass try the maximum scale within the search limits + if (firstPass) { + // Try the maximum possible scale, within the search limits + scDim = HwcTestDim(searchLimits.sourceCrop.width(), scMin.height()); + dfDim = dfMin; + } else { + // Subsequent pass + // Halve the difference between best and minBad. + Rational lower, upper, selected; + + // Try the closest ratio halfway between minBood and minBad; + // TODO: Avoid rounding issue by using Rational type for + // midpoint. For now will use double, which should + // have more than sufficient resolution. + double mid = (double) best + + ((double) minBad - (double) best) / 2.0; + Rational::double2Rational(mid, + Range(scMin.width(), scMax.width()), + Range(dfMin.width(), dfMax.width()), + lower, upper); + if (((lower == best) && (upper == minBad))) { + return best; + } + + // Use lower value unless its already been tried + selected = (lower != best) ? lower : upper; + + // Assign the size of the source crop and display frame + // from the selected ratio of source crop to display frame. + scDim = HwcTestDim(selected.numerator(), scMin.height()); + dfDim = HwcTestDim(selected.denominator(), dfMin.height()); + } + + // See if the HWC will commit to this combination + Rectangle rect(format, dfDim, scDim); + list rectList; + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + + if (verbose) { + testPrintI(" scHscale num: %u scale: %f dfDim: %s scDim: %s", + num, (float) Rational(scDim.width(), dfDim.width()), + ((string) dfDim).c_str(), ((string) scDim).c_str()); + } + if (num == 1) { + // HWC committed to the combination + // This is the best scale factor seen so far. Report the + // dimensions to the caller, in case nothing better is seen. + outBestDf = dfDim; + outBestSc = scDim; + + // Success on the first pass means the largest possible scale + // is supported, in which case no need to search any further. + if (firstPass) { return Rational(scDim.width(), dfDim.width()); } + + // Update the lower bound of the binary search + best = Rational(scDim.width(), dfDim.width()); + } else { + // HWC didn't commit to this combination, so update the + // upper bound of the binary search. + minBad = Rational(scDim.width(), dfDim.width()); + } + + firstPass = false; + } while (best != minBad); + + return best; +} + +// Source crop vertical scale +// Determines the maximum factor by which the source crop can be larger +// that the display frame. The commit point is discovered through a +// binary search of rational numbers. The numerator in each of the +// rational numbers contains the dimension for the source crop, while +// the denominator specifies the dimension for the display frame. On +// each pass of the binary search the mid-point between the greatest +// point committed to (best) and the smallest point in which a commit +// has failed is calculated. This mid-point is then passed to a function +// named double2Rational, which determines the closest rational numbers +// just below and above the mid-point. By default the lower rational +// number is used for the scale factor on the next pass of the binary +// search. The upper value is only used when best is already equal +// to the lower value. This only occurs when the lower value has already +// been tried. +Rational scVScale(uint32_t format, + const HwcTestDim& dfMin, const HwcTestDim& dfMax, + const HwcTestDim& scMin, const HwcTestDim& scMax, + HwcTestDim& outBestDf, HwcTestDim& outBestSc) +{ + HwcTestDim scDim, dfDim; // Source crop and display frame dimension + Rational best(0, 1), minBad; // Current bounds for a binary search + // MinGood is set below the lowest + // possible scale. The value of minBad, + // will be set by the first pass + // of the binary search. + + // Perform the passes of the binary search + bool firstPass = true; + do { + // On first pass try the maximum scale within the search limits + if (firstPass) { + // Try the maximum possible scale, within the search limits + scDim = HwcTestDim(scMin.width(), searchLimits.sourceCrop.height()); + dfDim = dfMin; + } else { + // Subsequent pass + // Halve the difference between best and minBad. + Rational lower, upper, selected; + + // Try the closest ratio halfway between minBood and minBad; + // TODO: Avoid rounding issue by using Rational type for + // midpoint. For now will use double, which should + // have more than sufficient resolution. + double mid = (double) best + + ((double) minBad - (double) best) / 2.0; + Rational::double2Rational(mid, + Range(scMin.height(), scMax.height()), + Range(dfMin.height(), dfMax.height()), + lower, upper); + if (((lower == best) && (upper == minBad))) { + return best; + } + + // Use lower value unless its already been tried + selected = (lower != best) ? lower : upper; + + // Assign the size of the source crop and display frame + // from the selected ratio of source crop to display frame. + scDim = HwcTestDim(scMin.width(), selected.numerator()); + dfDim = HwcTestDim(dfMin.width(), selected.denominator()); + } + + // See if the HWC will commit to this combination + Rectangle rect(format, dfDim, scDim); + list rectList; + rectList.push_back(rect); + uint32_t num = numOverlays(rectList); + + if (verbose) { + testPrintI(" scHscale num: %u scale: %f dfDim: %s scDim: %s", + num, (float) Rational(scDim.height(), dfDim.height()), + ((string) dfDim).c_str(), ((string) scDim).c_str()); + } + if (num == 1) { + // HWC committed to the combination + // This is the best scale factor seen so far. Report the + // dimensions to the caller, in case nothing better is seen. + outBestDf = dfDim; + outBestSc = scDim; + + // Success on the first pass means the largest possible scale + // is supported, in which case no need to search any further. + if (firstPass) { return Rational(scDim.height(), dfDim.height()); } + + // Update the lower bound of the binary search + best = Rational(scDim.height(), dfDim.height()); + } else { + // HWC didn't commit to this combination, so update the + // upper bound of the binary search. + minBad = Rational(scDim.height(), dfDim.height()); + } + + firstPass = false; + } while (best != minBad); + + return best; +} + +Rectangle::Rectangle(uint32_t graphicFormat, HwcTestDim dfDim, + HwcTestDim sDim) : + format(graphicFormat), transform(defaultTransform), + blend(defaultBlend), color(defaultColor), alpha(defaultAlpha), + sourceCrop(sDim), displayFrame(dfDim) +{ + // Set source dimension + // Can't use a base initializer, because the setting of format + // must be done before setting the sourceDimension. + setSourceDim(sDim); +} + +void Rectangle::setSourceDim(HwcTestDim dim) +{ + this->sourceDim = dim; + + const struct hwcTestGraphicFormat *attrib; + attrib = hwcTestGraphicFormatLookup(this->format); + if (attrib != NULL) { + if (sourceDim.width() % attrib->wMod) { + sourceDim.setWidth(sourceDim.width() + attrib->wMod + - (sourceDim.width() % attrib->wMod)); + } + if (sourceDim.height() % attrib->hMod) { + sourceDim.setHeight(sourceDim.height() + attrib->hMod + - (sourceDim.height() % attrib->hMod)); + } + } +} + +// Rational member functions +bool Rational::operator==(const Rational& other) const +{ + if (((uint64_t) _n * other._d) + == ((uint64_t) _d * other._n)) { return true; } + + return false; +} + +bool Rational::operator<(const Rational& other) const +{ + if (((uint64_t) _n * other._d) + < ((uint64_t) _d * other._n)) { return true; } + + return false; +} + +Rational::operator string() const +{ + ostringstream out; + + out << _n << '/' << _d; + + return out.str(); +} + +void Rational::double2Rational(double f, Range nRange, Range dRange, + Rational& lower, Rational& upper) +{ + Rational bestLower(nRange.lower(), dRange.upper()); + Rational bestUpper(nRange.upper(), dRange.lower()); + + // Search for a better solution + for (uint32_t d = dRange.lower(); d <= dRange.upper(); d++) { + Rational val(d * f, d); // Lower, because double to int cast truncates + + if ((val.numerator() < nRange.lower()) + || (val.numerator() > nRange.upper())) { continue; } + + if (((double) val > (double) bestLower) && ((double) val <= f)) { + bestLower = val; + } + + val.setNumerator(val.numerator() + 1); + if (val.numerator() > nRange.upper()) { continue; } + + if (((double) val < (double) bestUpper) && ((double) val >= f)) { + bestUpper = val; + } + } + + lower = bestLower; + upper = bestUpper; +} + +// Local functions + +// Num Overlays +// Given a list of rectangles, determine how many HWC will commit to render +uint32_t numOverlays(list& rectList) +{ + hwc_layer_list_t *hwcList; + list > buffers; + + hwcList = hwcTestCreateLayerList(rectList.size()); + if (hwcList == NULL) { + testPrintE("numOverlays create hwcList failed"); + exit(30); + } + + hwc_layer_t *layer = &hwcList->hwLayers[0]; + for (std::list::iterator it = rectList.begin(); + it != rectList.end(); ++it, ++layer) { + // Allocate the texture for the source frame + // and push it onto the buffers list, so that it + // stays in scope until a return from this function. + sp texture; + texture = new GraphicBuffer(it->sourceDim.width(), + it->sourceDim.height(), + it->format, texUsage); + buffers.push_back(texture); + + layer->handle = 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(hwcList); } + hwcDevice->prepare(hwcDevice, hwcList); + if (verbose) { + testPrintI("Post Prepare:"); + hwcTestDisplayListPrepareModifiable(hwcList); + } + + // Count the number of overlays + uint32_t total = 0; + for (unsigned int n1 = 0; n1 < hwcList->numHwLayers; n1++) { + if (hwcList->hwLayers[n1].compositionType == HWC_OVERLAY) { + total++; + } + } + + // Free the layer list and graphic buffers + hwcTestFreeLayerList(hwcList); + + return total; +} + +string transformList2str(const list& transformList) +{ + ostringstream out; + + for (list::const_iterator it = transformList.begin(); + it != transformList.end(); ++it) { + uint32_t id = *it; + + if (it != transformList.begin()) { + out << ", "; + } + out << id; + + for (unsigned int idx = 0; idx < NUMA(transformType); idx++) { + if (id == transformType[idx].id) { + out << " (" << transformType[idx].desc << ')'; + break; + } + } + } + + return out.str(); +} + +string blendList2str(const list& blendList) +{ + ostringstream out; + + for (list::const_iterator it = blendList.begin(); + it != blendList.end(); ++it) { + uint32_t id = *it; + + if (it != blendList.begin()) { + out << ", "; + } + out << id; + + for (unsigned int idx = 0; idx < NUMA(blendType); idx++) { + if (id == blendType[idx].id) { + out << " (" << blendType[idx].desc << ')'; + break; + } + } + } + + return out.str(); +} + +void init(void) +{ + srand48(0); + + hwcTestInitDisplay(verbose, &dpy, &surface, &width, &height); + + hwcTestOpenHwc(&hwcDevice); +} + +void printSyntax(const char *cmd) +{ + testPrintE(" %s [options] [graphicFormat] ...", + cmd); + testPrintE(" options:"); + testPrintE(" -s [width, height] - start dimension"); + testPrintE(" -v - Verbose"); + testPrintE(""); + testPrintE(" graphic formats:"); + for (unsigned int n1 = 0; n1 < NUMA(hwcTestGraphicFormat); n1++) { + testPrintE(" %s", hwcTestGraphicFormat[n1].desc); + } +} diff --git a/opengl/tests/hwc/hwcRects.cpp b/opengl/tests/hwc/hwcRects.cpp index c93124e5e..523e3dea7 100644 --- a/opengl/tests/hwc/hwcRects.cpp +++ b/opengl/tests/hwc/hwcRects.cpp @@ -21,7 +21,7 @@ * hwcRects [options] (graphicFormat displayFrame [attributes],)... * options: * -D #.## - End of test delay - * -v Verbose"); + * -v - Verbose * * graphic formats: * RGBA8888 (reference frame default) @@ -108,7 +108,7 @@ #include #include -#define LOG_TAG "hwcColorEquivTest" +#define LOG_TAG "hwcRectsTest" #include #include @@ -210,6 +210,8 @@ main(int argc, char *argv[]) string str; char cmd[MAXCMD]; + testSetLogCatTag(LOG_TAG); + // Parse command line arguments while ((opt = getopt(argc, argv, "D:v?h")) != -1) { switch (opt) { diff --git a/opengl/tests/hwc/hwcTestLib.cpp b/opengl/tests/hwc/hwcTestLib.cpp index 575af8993..b790c513d 100644 --- a/opengl/tests/hwc/hwcTestLib.cpp +++ b/opengl/tests/hwc/hwcTestLib.cpp @@ -174,6 +174,19 @@ HwcTestDim::operator string() return out.str(); } +// Dimension class to hwc_rect conversion +HwcTestDim::operator hwc_rect() const +{ + hwc_rect rect; + + rect.left = rect.top = 0; + + rect.right = this->_w; + rect.bottom = this->_h; + + return rect; +} + // Hardware Composer rectangle to string conversion string hwcTestRect2str(const struct hwc_rect& rect) { @@ -349,6 +362,21 @@ const struct hwcTestGraphicFormat *hwcTestGraphicFormatLookup(const char *desc) return NULL; } +// Look up and return pointer to structure with the characteristics +// of the graphic format specified by the id parameter. Search failure +// indicated by the return of NULL. +const struct hwcTestGraphicFormat *hwcTestGraphicFormatLookup(uint32_t id) +{ + for (unsigned int n1 = 0; n1 < NUMA(hwcTestGraphicFormat); n1++) { + if (id == hwcTestGraphicFormat[n1].format) { + return &hwcTestGraphicFormat[n1]; + } + } + + return NULL; +} + + // Given the integer ID of a graphic format, return a pointer to // a string that describes the format. const char *hwcTestGraphicFormat2str(uint32_t format) diff --git a/opengl/tests/hwc/hwcTestLib.h b/opengl/tests/hwc/hwcTestLib.h index e19e16301..99ee60867 100644 --- a/opengl/tests/hwc/hwcTestLib.h +++ b/opengl/tests/hwc/hwcTestLib.h @@ -98,6 +98,7 @@ class HwcTestDim { void setHeight(uint32_t h) { _h = h; } operator std::string(); + operator hwc_rect() const; private: uint32_t _w; @@ -109,6 +110,7 @@ void hwcTestInitDisplay(bool verbose, EGLDisplay *dpy, EGLSurface *surface, EGLint *width, EGLint *height); void hwcTestOpenHwc(hwc_composer_device_t **hwcDevicePtr); const struct hwcTestGraphicFormat *hwcTestGraphicFormatLookup(const char *desc); +const struct hwcTestGraphicFormat *hwcTestGraphicFormatLookup(uint32_t id); const char *hwcTestGraphicFormat2str(uint32_t format); std::string hwcTestRect2str(const struct hwc_rect& rect);