ADHOC/replicant-frameworks_native
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ca69e8f2d0
replicant-frameworks_native/opengl/tests/hwc/hwcCommit.cpp
Andy McFadden 6ef57d7b36 Restore old OpenGL tests 
These tests call android_createDisplaySurface() to get a
FramebufferNativeWindow that is passed to EGL.  This relies on the
existence of the framebuffer HAL, which is not supported on many
recent devices.

This change adds a new "window surface" object that the tests
can use to get a window from SurfaceFlinger instead.  All tests
except for the HWC tests now appear to do things.

The HWC tests don't do anything useful, but they no longer depend
on the android_createDisplaySurface() function.

Bug 13323813

Change-Id: I2cbfbacb3452fb658c29e945b0c7ae7c94c1a4ba
2014-03-06 16:46:59 -08:00

1561 lines
53 KiB
C++
Raw Blame History

/*
* 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 <algorithm>
#include <assert.h>
#include <cerrno>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iomanip>
#include <istream>
#include <libgen.h>
#include <list>
#include <sched.h>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <vector>
#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/GraphicBuffer.h>
#define LOG_TAG "hwcCommitTest"
#include <utils/Log.h>
#include <testUtil.h>
#include <hardware/hwcomposer.h>
#include <glTestLib.h>
#include "hwcTestLib.h"
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 uint32_t printFieldWidth = 2;
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_1_t *hwcDevice;
static EGLDisplay dpy;
static EGLSurface surface;
static EGLint width, height;
static size_t maxHeadingLen;
static vector<string> formats;
// Measurements
struct meas {
uint32_t format;
uint32_t startDimOverlays;
uint32_t maxNonOverlapping;
uint32_t maxOverlapping;
list<uint32_t> transforms;
list<uint32_t> 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<uint32_t> overlapBlendNone;
vector<uint32_t> overlapBlendPremult;
vector<uint32_t> overlapBlendCoverage;
};
vector<meas> measurements;
// Function prototypes
uint32_t numOverlays(list<Rectangle>& rectList);
uint32_t maxOverlays(uint32_t format, bool allowOverlap);
list<uint32_t> supportedTransforms(uint32_t format);
list<uint32_t> 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);
uint32_t numOverlapping(uint32_t backgroundFormat, uint32_t foregroundFormat,
uint32_t backgroundBlend, uint32_t foregroundBlend);
string transformList2str(const list<uint32_t>& transformList);
string blendList2str(const list<uint32_t>& blendList);
void init(void);
void printFormatHeadings(size_t indent);
void printOverlapLine(size_t indent, const string formatStr,
const vector<uint32_t>& results);
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<Rectangle> 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]);
}
}
// Determine length of longest specified graphic format.
// This value is used for output formating
for (vector<string>::iterator it = formats.begin();
it != formats.end(); ++it) {
maxHeadingLen = max(maxHeadingLen, it->length());
}
// 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 (vector<string>::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());
// Overlap two graphic formats and different blends
// Results displayed after all overlap measurments with
// current format in the foreground
// TODO: make measurments with background blend other than
// none. All of these measurements are done with a
// background blend of HWC_BLENDING_NONE, with the
// blend type of the foregound being varied.
uint32_t foregroundFormat = format->format;
for (vector<string>::iterator it = formats.begin();
it != formats.end(); ++it) {
uint32_t num;
const struct hwcTestGraphicFormat *backgroundFormatPtr
= hwcTestGraphicFormatLookup((*it).c_str());
uint32_t backgroundFormat = backgroundFormatPtr->format;
num = numOverlapping(backgroundFormat, foregroundFormat,
HWC_BLENDING_NONE, HWC_BLENDING_NONE);
measPtr->overlapBlendNone.push_back(num);
num = numOverlapping(backgroundFormat, foregroundFormat,
HWC_BLENDING_NONE, HWC_BLENDING_PREMULT);
measPtr->overlapBlendPremult.push_back(num);
num = numOverlapping(backgroundFormat, foregroundFormat,
HWC_BLENDING_NONE, HWC_BLENDING_COVERAGE);
measPtr->overlapBlendCoverage.push_back(num);
}
}
// Display overlap results
size_t indent = 2;
testPrintI("overlapping blend: none");
printFormatHeadings(indent);
for (vector<string>::iterator it = formats.begin();
it != formats.end(); ++it) {
printOverlapLine(indent, *it, measurements[it
- formats.begin()].overlapBlendNone);
}
testPrintI("");
testPrintI("overlapping blend: premult");
printFormatHeadings(indent);
for (vector<string>::iterator it = formats.begin();
it != formats.end(); ++it) {
printOverlapLine(indent, *it, measurements[it
- formats.begin()].overlapBlendPremult);
}
testPrintI("");
testPrintI("overlapping blend: coverage");
printFormatHeadings(indent);
for (vector<string>::iterator it = formats.begin();
it != formats.end(); ++it) {
printOverlapLine(indent, *it, measurements[it
- formats.begin()].overlapBlendCoverage);
}
testPrintI("");
// 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<Rectangle> 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<uint32_t> supportedTransforms(uint32_t format)
{
list<uint32_t> rv;
list<Rectangle> 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<uint32_t> supportedBlends(uint32_t format)
{
list<uint32_t> rv;
list<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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<Rectangle> 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;
}
uint32_t numOverlapping(uint32_t backgroundFormat, uint32_t foregroundFormat,
uint32_t backgroundBlend, uint32_t foregroundBlend)
{
list<Rectangle> rectList;
Rectangle background(backgroundFormat, startDim, startDim);
background.blend = backgroundBlend;
rectList.push_back(background);
// TODO: Handle cases where startDim is so small that adding 5
// causes frames not to overlap.
// TODO: Handle cases where startDim is so large that adding 5
// cause a portion or all of the foreground displayFrame
// to be off the display.
Rectangle foreground(foregroundFormat, startDim, startDim);
foreground.displayFrame.left += 5;
foreground.displayFrame.top += 5;
foreground.displayFrame.right += 5;
foreground.displayFrame.bottom += 5;
background.blend = foregroundBlend;
rectList.push_back(foreground);
uint32_t num = numOverlays(rectList);
return num;
}
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<Rectangle>& rectList)
{
hwc_display_contents_1_t *hwcList;
list<sp<GraphicBuffer> > buffers;
hwcList = hwcTestCreateLayerList(rectList.size());
if (hwcList == NULL) {
testPrintE("numOverlays create hwcList failed");
exit(30);
}
hwc_layer_1_t *layer = &hwcList->hwLayers[0];
for (std::list<Rectangle>::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<GraphicBuffer> 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, 1, &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<uint32_t>& transformList)
{
ostringstream out;
for (list<uint32_t>::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<uint32_t>& blendList)
{
ostringstream out;
for (list<uint32_t>::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 printFormatHeadings(size_t indent)
{
for (size_t row = 0; row <= maxHeadingLen; row++) {
ostringstream line;
for(vector<string>::iterator it = formats.begin();
it != formats.end(); ++it) {
if ((maxHeadingLen - row) <= it->length()) {
if (row != maxHeadingLen) {
char ch = (*it)[it->length() - (maxHeadingLen - row)];
line << ' ' << setw(printFieldWidth) << ch;
} else {
line << ' ' << string(printFieldWidth, '-');
}
} else {
line << ' ' << setw(printFieldWidth) << "";
}
}
testPrintI("%*s%s", indent + maxHeadingLen, "",
line.str().c_str());
}
}
void printOverlapLine(size_t indent, const string formatStr,
const vector<uint32_t>& results)
{
ostringstream line;
line << setw(indent + maxHeadingLen - formatStr.length()) << "";
line << formatStr;
for (vector<uint32_t>::const_iterator it = results.begin();
it != results.end(); ++it) {
line << ' ' << setw(printFieldWidth) << *it;
}
testPrintI("%s", line.str().c_str());
}
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);
}
}
Reference in New Issue View Git Blame Copy Permalink