647 lines
24 KiB
C++
647 lines
24 KiB
C++
/*
|
|
* Copyright (C) 2010 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 stress test
|
|
*
|
|
* Performs a pseudo-random (prandom) sequence of operations to the
|
|
* Hardware Composer (HWC), for a specified number of passes or for
|
|
* a specified period of time. By default the period of time is FLT_MAX,
|
|
* so that the number of passes will take precedence.
|
|
*
|
|
* The passes are grouped together, where (pass / passesPerGroup) specifies
|
|
* which group a particular pass is in. This causes every passesPerGroup
|
|
* worth of sequential passes to be within the same group. Computationally
|
|
* intensive operations are performed just once at the beginning of a group
|
|
* of passes and then used by all the passes in that group. This is done
|
|
* so as to increase both the average and peak rate of graphic operations,
|
|
* by moving computationally intensive operations to the beginning of a group.
|
|
* In particular, at the start of each group of passes a set of
|
|
* graphic buffers are created, then used by the first and remaining
|
|
* passes of that group of passes.
|
|
*
|
|
* The per-group initialization of the graphic buffers is performed
|
|
* by a function called initFrames. This function creates an array
|
|
* of smart pointers to the graphic buffers, in the form of a vector
|
|
* of vectors. The array is accessed in row major order, so each
|
|
* row is a vector of smart pointers. All the pointers of a single
|
|
* row point to graphic buffers which use the same pixel format and
|
|
* have the same dimension, although it is likely that each one is
|
|
* filled with a different color. This is done so that after doing
|
|
* the first HWC prepare then set call, subsequent set calls can
|
|
* be made with each of the layer handles changed to a different
|
|
* graphic buffer within the same row. Since the graphic buffers
|
|
* in a particular row have the same pixel format and dimension,
|
|
* additional HWC set calls can be made, without having to perform
|
|
* an HWC prepare call.
|
|
*
|
|
* This test supports the following command-line options:
|
|
*
|
|
* -v Verbose
|
|
* -s num Starting pass
|
|
* -e num Ending pass
|
|
* -p num Execute the single pass specified by num
|
|
* -n num Number of set operations to perform after each prepare operation
|
|
* -t float Maximum time in seconds to execute the test
|
|
* -d float Delay in seconds performed after each set operation
|
|
* -D float Delay in seconds performed after the last pass is executed
|
|
*
|
|
* Typically the test is executed for a large range of passes. By default
|
|
* passes 0 through 99999 (100,000 passes) are executed. Although this test
|
|
* does not validate the generated image, at times it is useful to reexecute
|
|
* a particular pass and leave the displayed image on the screen for an
|
|
* extended period of time. This can be done either by setting the -s
|
|
* and -e options to the desired pass, along with a large value for -D.
|
|
* This can also be done via the -p option, again with a large value for
|
|
* the -D options.
|
|
*
|
|
* So far this test only contains code to create graphic buffers with
|
|
* a continuous solid color. Although this test is unable to validate the
|
|
* image produced, any image that contains other than rectangles of a solid
|
|
* color are incorrect. Note that the rectangles may use a transparent
|
|
* color and have a blending operation that causes the color in overlapping
|
|
* rectangles to be mixed. In such cases the overlapping portions may have
|
|
* a different color from the rest of the rectangle.
|
|
*/
|
|
|
|
#include <algorithm>
|
|
#include <assert.h>
|
|
#include <cerrno>
|
|
#include <cmath>
|
|
#include <cstdlib>
|
|
#include <ctime>
|
|
#include <libgen.h>
|
|
#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/FramebufferNativeWindow.h>
|
|
#include <ui/GraphicBuffer.h>
|
|
|
|
#define LOG_TAG "hwcStressTest"
|
|
#include <utils/Log.h>
|
|
#include <testUtil.h>
|
|
|
|
#include <hardware/hwcomposer.h>
|
|
|
|
#include <glTestLib.h>
|
|
#include "hwcTestLib.h"
|
|
|
|
using namespace std;
|
|
using namespace android;
|
|
|
|
const float maxSizeRatio = 1.3; // Graphic buffers can be upto this munch
|
|
// larger than the default screen size
|
|
const unsigned int passesPerGroup = 10; // A group of passes all use the same
|
|
// graphic buffers
|
|
|
|
// Ratios at which rare and frequent conditions should be produced
|
|
const float rareRatio = 0.1;
|
|
const float freqRatio = 0.9;
|
|
|
|
// Defaults for command-line options
|
|
const bool defaultVerbose = false;
|
|
const unsigned int defaultStartPass = 0;
|
|
const unsigned int defaultEndPass = 99999;
|
|
const unsigned int defaultPerPassNumSet = 10;
|
|
const float defaultPerSetDelay = 0.0; // Default delay after each set
|
|
// operation. Default delay of
|
|
// zero used so as to perform the
|
|
// the set operations as quickly
|
|
// as possible.
|
|
const float defaultEndDelay = 2.0; // Default delay between completion of
|
|
// final pass and restart of framework
|
|
const float defaultDuration = FLT_MAX; // A fairly long time, so that
|
|
// range of passes will have
|
|
// precedence
|
|
|
|
// Command-line option settings
|
|
static bool verbose = defaultVerbose;
|
|
static unsigned int startPass = defaultStartPass;
|
|
static unsigned int endPass = defaultEndPass;
|
|
static unsigned int numSet = defaultPerPassNumSet;
|
|
static float perSetDelay = defaultPerSetDelay;
|
|
static float endDelay = defaultEndDelay;
|
|
static float duration = defaultDuration;
|
|
|
|
// Command-line mutual exclusion detection flags.
|
|
// Corresponding flag set true once an option is used.
|
|
bool eFlag, sFlag, pFlag;
|
|
|
|
#define MAXSTR 100
|
|
#define MAXCMD 200
|
|
#define BITSPERBYTE 8 // TODO: Obtain from <values.h>, once
|
|
// it has been added
|
|
|
|
#define CMD_STOP_FRAMEWORK "stop 2>&1"
|
|
#define CMD_START_FRAMEWORK "start 2>&1"
|
|
|
|
#define NUMA(a) (sizeof(a) / sizeof(a [0]))
|
|
#define MEMCLR(addr, size) do { \
|
|
memset((addr), 0, (size)); \
|
|
} while (0)
|
|
|
|
// File scope constants
|
|
const unsigned int blendingOps[] = {
|
|
HWC_BLENDING_NONE,
|
|
HWC_BLENDING_PREMULT,
|
|
HWC_BLENDING_COVERAGE,
|
|
};
|
|
const unsigned int layerFlags[] = {
|
|
HWC_SKIP_LAYER,
|
|
};
|
|
const vector<unsigned int> vecLayerFlags(layerFlags,
|
|
layerFlags + NUMA(layerFlags));
|
|
|
|
const unsigned int transformFlags[] = {
|
|
HWC_TRANSFORM_FLIP_H,
|
|
HWC_TRANSFORM_FLIP_V,
|
|
HWC_TRANSFORM_ROT_90,
|
|
// ROT_180 & ROT_270 intentionally not listed, because they
|
|
// they are formed from combinations of the flags already listed.
|
|
};
|
|
const vector<unsigned int> vecTransformFlags(transformFlags,
|
|
transformFlags + NUMA(transformFlags));
|
|
|
|
// File scope 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 vector <vector <sp<GraphicBuffer> > > frames;
|
|
|
|
// File scope prototypes
|
|
void init(void);
|
|
void initFrames(unsigned int seed);
|
|
template <class T> vector<T> vectorRandSelect(const vector<T>& vec, size_t num);
|
|
template <class T> T vectorOr(const vector<T>& vec);
|
|
|
|
/*
|
|
* Main
|
|
*
|
|
* Performs the following high-level sequence of operations:
|
|
*
|
|
* 1. Command-line parsing
|
|
*
|
|
* 2. Initialization
|
|
*
|
|
* 3. For each pass:
|
|
*
|
|
* a. If pass is first pass or in a different group from the
|
|
* previous pass, initialize the array of graphic buffers.
|
|
*
|
|
* b. Create a HWC list with room to specify a prandomly
|
|
* selected number of layers.
|
|
*
|
|
* c. Select a subset of the rows from the graphic buffer array,
|
|
* such that there is a unique row to be used for each
|
|
* of the layers in the HWC list.
|
|
*
|
|
* d. Prandomly fill in the HWC list with handles
|
|
* selected from any of the columns of the selected row.
|
|
*
|
|
* e. Pass the populated list to the HWC prepare call.
|
|
*
|
|
* f. Pass the populated list to the HWC set call.
|
|
*
|
|
* g. If additional set calls are to be made, then for each
|
|
* additional set call, select a new set of handles and
|
|
* perform the set call.
|
|
*/
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
int rv, opt;
|
|
char *chptr;
|
|
unsigned int pass;
|
|
char cmd[MAXCMD];
|
|
struct timeval startTime, currentTime, delta;
|
|
|
|
testSetLogCatTag(LOG_TAG);
|
|
|
|
// Parse command line arguments
|
|
while ((opt = getopt(argc, argv, "vp:d:D:n:s:e:t:?h")) != -1) {
|
|
switch (opt) {
|
|
case 'd': // Delay after each set operation
|
|
perSetDelay = strtod(optarg, &chptr);
|
|
if ((*chptr != '\0') || (perSetDelay < 0.0)) {
|
|
testPrintE("Invalid command-line specified per pass delay of: "
|
|
"%s", optarg);
|
|
exit(1);
|
|
}
|
|
break;
|
|
|
|
case 'D': // End of test delay
|
|
// Delay between completion of final pass and restart
|
|
// of framework
|
|
endDelay = strtod(optarg, &chptr);
|
|
if ((*chptr != '\0') || (endDelay < 0.0)) {
|
|
testPrintE("Invalid command-line specified end of test delay "
|
|
"of: %s", optarg);
|
|
exit(2);
|
|
}
|
|
break;
|
|
|
|
case 't': // Duration
|
|
duration = strtod(optarg, &chptr);
|
|
if ((*chptr != '\0') || (duration < 0.0)) {
|
|
testPrintE("Invalid command-line specified duration of: %s",
|
|
optarg);
|
|
exit(3);
|
|
}
|
|
break;
|
|
|
|
case 'n': // Num set operations per pass
|
|
numSet = strtoul(optarg, &chptr, 10);
|
|
if (*chptr != '\0') {
|
|
testPrintE("Invalid command-line specified num set per pass "
|
|
"of: %s", optarg);
|
|
exit(4);
|
|
}
|
|
break;
|
|
|
|
case 's': // Starting Pass
|
|
sFlag = true;
|
|
if (pFlag) {
|
|
testPrintE("Invalid combination of command-line options.");
|
|
testPrintE(" The -p option is mutually exclusive from the");
|
|
testPrintE(" -s and -e options.");
|
|
exit(5);
|
|
}
|
|
startPass = strtoul(optarg, &chptr, 10);
|
|
if (*chptr != '\0') {
|
|
testPrintE("Invalid command-line specified starting pass "
|
|
"of: %s", optarg);
|
|
exit(6);
|
|
}
|
|
break;
|
|
|
|
case 'e': // Ending Pass
|
|
eFlag = true;
|
|
if (pFlag) {
|
|
testPrintE("Invalid combination of command-line options.");
|
|
testPrintE(" The -p option is mutually exclusive from the");
|
|
testPrintE(" -s and -e options.");
|
|
exit(7);
|
|
}
|
|
endPass = strtoul(optarg, &chptr, 10);
|
|
if (*chptr != '\0') {
|
|
testPrintE("Invalid command-line specified ending pass "
|
|
"of: %s", optarg);
|
|
exit(8);
|
|
}
|
|
break;
|
|
|
|
case 'p': // Run a single specified pass
|
|
pFlag = true;
|
|
if (sFlag || eFlag) {
|
|
testPrintE("Invalid combination of command-line options.");
|
|
testPrintE(" The -p option is mutually exclusive from the");
|
|
testPrintE(" -s and -e options.");
|
|
exit(9);
|
|
}
|
|
startPass = endPass = strtoul(optarg, &chptr, 10);
|
|
if (*chptr != '\0') {
|
|
testPrintE("Invalid command-line specified pass of: %s",
|
|
optarg);
|
|
exit(10);
|
|
}
|
|
break;
|
|
|
|
case 'v': // Verbose
|
|
verbose = true;
|
|
break;
|
|
|
|
case 'h': // Help
|
|
case '?':
|
|
default:
|
|
testPrintE(" %s [options]", basename(argv[0]));
|
|
testPrintE(" options:");
|
|
testPrintE(" -p Execute specified pass");
|
|
testPrintE(" -s Starting pass");
|
|
testPrintE(" -e Ending pass");
|
|
testPrintE(" -t Duration");
|
|
testPrintE(" -d Delay after each set operation");
|
|
testPrintE(" -D End of test delay");
|
|
testPrintE(" -n Num set operations per pass");
|
|
testPrintE(" -v Verbose");
|
|
exit(((optopt == 0) || (optopt == '?')) ? 0 : 11);
|
|
}
|
|
}
|
|
if (endPass < startPass) {
|
|
testPrintE("Unexpected ending pass before starting pass");
|
|
testPrintE(" startPass: %u endPass: %u", startPass, endPass);
|
|
exit(12);
|
|
}
|
|
if (argc != optind) {
|
|
testPrintE("Unexpected command-line postional argument");
|
|
testPrintE(" %s [-s start_pass] [-e end_pass] [-t duration]",
|
|
basename(argv[0]));
|
|
exit(13);
|
|
}
|
|
testPrintI("duration: %g", duration);
|
|
testPrintI("startPass: %u", startPass);
|
|
testPrintI("endPass: %u", endPass);
|
|
testPrintI("numSet: %u", numSet);
|
|
|
|
// 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 - need means to query whether asyncronous stop
|
|
// framework operation has completed. For now, just wait
|
|
// a long time.
|
|
|
|
init();
|
|
|
|
// For each pass
|
|
gettimeofday(&startTime, NULL);
|
|
for (pass = startPass; pass <= endPass; pass++) {
|
|
// Stop if duration of work has already been performed
|
|
gettimeofday(¤tTime, NULL);
|
|
delta = tvDelta(&startTime, ¤tTime);
|
|
if (tv2double(&delta) > duration) { break; }
|
|
|
|
// Regenerate a new set of test frames when this pass is
|
|
// either the first pass or is in a different group then
|
|
// the previous pass. A group of passes are passes that
|
|
// all have the same quotient when their pass number is
|
|
// divided by passesPerGroup.
|
|
if ((pass == startPass)
|
|
|| ((pass / passesPerGroup) != ((pass - 1) / passesPerGroup))) {
|
|
initFrames(pass / passesPerGroup);
|
|
}
|
|
|
|
testPrintI("==== Starting pass: %u", pass);
|
|
|
|
// Cause deterministic sequence of prandom numbers to be
|
|
// generated for this pass.
|
|
srand48(pass);
|
|
|
|
hwc_display_contents_1_t *list;
|
|
list = hwcTestCreateLayerList(testRandMod(frames.size()) + 1);
|
|
if (list == NULL) {
|
|
testPrintE("hwcTestCreateLayerList failed");
|
|
exit(20);
|
|
}
|
|
|
|
// Prandomly select a subset of frames to be used by this pass.
|
|
vector <vector <sp<GraphicBuffer> > > selectedFrames;
|
|
selectedFrames = vectorRandSelect(frames, list->numHwLayers);
|
|
|
|
// Any transform tends to create a layer that the hardware
|
|
// composer is unable to support and thus has to leave for
|
|
// SurfaceFlinger. Place heavy bias on specifying no transforms.
|
|
bool noTransform = testRandFract() > rareRatio;
|
|
|
|
for (unsigned int n1 = 0; n1 < list->numHwLayers; n1++) {
|
|
unsigned int idx = testRandMod(selectedFrames[n1].size());
|
|
sp<GraphicBuffer> gBuf = selectedFrames[n1][idx];
|
|
hwc_layer_1_t *layer = &list->hwLayers[n1];
|
|
layer->handle = gBuf->handle;
|
|
|
|
layer->blending = blendingOps[testRandMod(NUMA(blendingOps))];
|
|
layer->flags = (testRandFract() > rareRatio) ? 0
|
|
: vectorOr(vectorRandSelect(vecLayerFlags,
|
|
testRandMod(vecLayerFlags.size() + 1)));
|
|
layer->transform = (noTransform || testRandFract() > rareRatio) ? 0
|
|
: vectorOr(vectorRandSelect(vecTransformFlags,
|
|
testRandMod(vecTransformFlags.size() + 1)));
|
|
layer->sourceCrop.left = testRandMod(gBuf->getWidth());
|
|
layer->sourceCrop.top = testRandMod(gBuf->getHeight());
|
|
layer->sourceCrop.right = layer->sourceCrop.left
|
|
+ testRandMod(gBuf->getWidth() - layer->sourceCrop.left) + 1;
|
|
layer->sourceCrop.bottom = layer->sourceCrop.top
|
|
+ testRandMod(gBuf->getHeight() - layer->sourceCrop.top) + 1;
|
|
layer->displayFrame.left = testRandMod(width);
|
|
layer->displayFrame.top = testRandMod(height);
|
|
layer->displayFrame.right = layer->displayFrame.left
|
|
+ testRandMod(width - layer->displayFrame.left) + 1;
|
|
layer->displayFrame.bottom = layer->displayFrame.top
|
|
+ testRandMod(height - layer->displayFrame.top) + 1;
|
|
|
|
// Increase the frequency that a scale factor of 1.0 from
|
|
// the sourceCrop to displayFrame occurs. This is the
|
|
// most common scale factor used by applications and would
|
|
// be rarely produced by this stress test without this
|
|
// logic.
|
|
if (testRandFract() <= freqRatio) {
|
|
// Only change to scale factor to 1.0 if both the
|
|
// width and height will fit.
|
|
int sourceWidth = layer->sourceCrop.right
|
|
- layer->sourceCrop.left;
|
|
int sourceHeight = layer->sourceCrop.bottom
|
|
- layer->sourceCrop.top;
|
|
if (((layer->displayFrame.left + sourceWidth) <= width)
|
|
&& ((layer->displayFrame.top + sourceHeight) <= height)) {
|
|
layer->displayFrame.right = layer->displayFrame.left
|
|
+ sourceWidth;
|
|
layer->displayFrame.bottom = layer->displayFrame.top
|
|
+ sourceHeight;
|
|
}
|
|
}
|
|
|
|
layer->visibleRegionScreen.numRects = 1;
|
|
layer->visibleRegionScreen.rects = &layer->displayFrame;
|
|
}
|
|
|
|
// Perform prepare operation
|
|
if (verbose) { testPrintI("Prepare:"); hwcTestDisplayList(list); }
|
|
hwcDevice->prepare(hwcDevice, 1, &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:"); }
|
|
for (unsigned int n1 = 0; n1 < numSet; n1++) {
|
|
if (verbose) { hwcTestDisplayListHandles(list); }
|
|
list->dpy = dpy;
|
|
list->sur = surface;
|
|
hwcDevice->set(hwcDevice, 1, &list);
|
|
|
|
// Prandomly select a new set of handles
|
|
for (unsigned int n1 = 0; n1 < list->numHwLayers; n1++) {
|
|
unsigned int idx = testRandMod(selectedFrames[n1].size());
|
|
sp<GraphicBuffer> gBuf = selectedFrames[n1][idx];
|
|
hwc_layer_1_t *layer = &list->hwLayers[n1];
|
|
layer->handle = (native_handle_t *) gBuf->handle;
|
|
}
|
|
|
|
testDelay(perSetDelay);
|
|
}
|
|
|
|
hwcTestFreeLayerList(list);
|
|
testPrintI("==== Completed pass: %u", pass);
|
|
}
|
|
|
|
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(21);
|
|
}
|
|
testExecCmd(cmd);
|
|
|
|
testPrintI("Successfully completed %u passes", pass - startPass);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void init(void)
|
|
{
|
|
srand48(0); // Defensively set pseudo random number generator.
|
|
// Should not need to set this, because a stress test
|
|
// sets the seed on each pass. Defensively set it here
|
|
// so that future code that uses pseudo random numbers
|
|
// before the first pass will be deterministic.
|
|
|
|
hwcTestInitDisplay(verbose, &dpy, &surface, &width, &height);
|
|
|
|
hwcTestOpenHwc(&hwcDevice);
|
|
}
|
|
|
|
/*
|
|
* Initialize Frames
|
|
*
|
|
* Creates an array of graphic buffers, within the global variable
|
|
* named frames. The graphic buffers are contained within a vector of
|
|
* vectors. All the graphic buffers in a particular row are of the same
|
|
* format and dimension. Each graphic buffer is uniformly filled with a
|
|
* prandomly selected color. It is likely that each buffer, even
|
|
* in the same row, will be filled with a unique color.
|
|
*/
|
|
void initFrames(unsigned int seed)
|
|
{
|
|
int rv;
|
|
const size_t maxRows = 5;
|
|
const size_t minCols = 2; // Need at least double buffering
|
|
const size_t maxCols = 4; // One more than triple buffering
|
|
|
|
if (verbose) { testPrintI("initFrames seed: %u", seed); }
|
|
srand48(seed);
|
|
size_t rows = testRandMod(maxRows) + 1;
|
|
|
|
frames.clear();
|
|
frames.resize(rows);
|
|
|
|
for (unsigned int row = 0; row < rows; row++) {
|
|
// All frames within a row have to have the same format and
|
|
// dimensions. Width and height need to be >= 1.
|
|
unsigned int formatIdx = testRandMod(NUMA(hwcTestGraphicFormat));
|
|
const struct hwcTestGraphicFormat *formatPtr
|
|
= &hwcTestGraphicFormat[formatIdx];
|
|
int format = formatPtr->format;
|
|
|
|
// Pick width and height, which must be >= 1 and the size
|
|
// mod the wMod/hMod value must be equal to 0.
|
|
size_t w = (width * maxSizeRatio) * testRandFract();
|
|
size_t h = (height * maxSizeRatio) * testRandFract();
|
|
w = max(1u, w);
|
|
h = max(1u, h);
|
|
if ((w % formatPtr->wMod) != 0) {
|
|
w += formatPtr->wMod - (w % formatPtr->wMod);
|
|
}
|
|
if ((h % formatPtr->hMod) != 0) {
|
|
h += formatPtr->hMod - (h % formatPtr->hMod);
|
|
}
|
|
if (verbose) {
|
|
testPrintI(" frame %u width: %u height: %u format: %u %s",
|
|
row, w, h, format, hwcTestGraphicFormat2str(format));
|
|
}
|
|
|
|
size_t cols = testRandMod((maxCols + 1) - minCols) + minCols;
|
|
frames[row].resize(cols);
|
|
for (unsigned int col = 0; col < cols; col++) {
|
|
ColorFract color(testRandFract(), testRandFract(), testRandFract());
|
|
float alpha = testRandFract();
|
|
|
|
frames[row][col] = new GraphicBuffer(w, h, format, texUsage);
|
|
if ((rv = frames[row][col]->initCheck()) != NO_ERROR) {
|
|
testPrintE("GraphicBuffer initCheck failed, rv: %i", rv);
|
|
testPrintE(" frame %u width: %u height: %u format: %u %s",
|
|
row, w, h, format, hwcTestGraphicFormat2str(format));
|
|
exit(80);
|
|
}
|
|
|
|
hwcTestFillColor(frames[row][col].get(), color, alpha);
|
|
if (verbose) {
|
|
testPrintI(" buf: %p handle: %p color: %s alpha: %f",
|
|
frames[row][col].get(), frames[row][col]->handle,
|
|
string(color).c_str(), alpha);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Vector Random Select
|
|
*
|
|
* Prandomly selects and returns num elements from vec.
|
|
*/
|
|
template <class T>
|
|
vector<T> vectorRandSelect(const vector<T>& vec, size_t num)
|
|
{
|
|
vector<T> rv = vec;
|
|
|
|
while (rv.size() > num) {
|
|
rv.erase(rv.begin() + testRandMod(rv.size()));
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* Vector Or
|
|
*
|
|
* Or's togethen the values of each element of vec and returns the result.
|
|
*/
|
|
template <class T>
|
|
T vectorOr(const vector<T>& vec)
|
|
{
|
|
T rv = 0;
|
|
|
|
for (size_t n1 = 0; n1 < vec.size(); n1++) {
|
|
rv |= vec[n1];
|
|
}
|
|
|
|
return rv;
|
|
}
|