1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *
16 */
17
18/*
19 * Hardware Composer Commit Points
20 *
21 * Synopsis
22 *   hwcCommit [options] graphicFormat ...
23 *     options:
24 *       -s [width, height] - Starting dimension
25 *       -v - Verbose
26 *
27 *      graphic formats:
28 *        RGBA8888 (reference frame default)
29 *        RGBX8888
30 *        RGB888
31 *        RGB565
32 *        BGRA8888
33 *        RGBA5551
34 *        RGBA4444
35 *        YV12
36 *
37 * Description
38 *   The Hardware Composer (HWC) Commit test is a benchmark that
39 *   discovers the points at which the HWC will commit to rendering an
40 *   overlay(s).  Before rendering a set of overlays, the HWC is shown
41 *   the list through a prepare call.  During the prepare call the HWC
42 *   is able to examine the list and specify which overlays it is able
43 *   to handle.  The overlays that it can't handle are typically composited
44 *   by a higher level (e.g. Surface Flinger) and then the original list
45 *   plus a composit of what HWC passed on are provided back to the HWC
46 *   for rendering.
47 *
48 *   Once an implementation of the HWC has been shipped, a regression would
49 *   likely occur if a latter implementation started passing on conditions
50 *   that it used to commit to.  The primary purpose of this benchmark
51 *   is the automated discovery of the commit points, where an implementation
52 *   is on the edge between committing and not committing.  These are commonly
53 *   referred to as commit points.  Between implementations changes to the
54 *   commit points are allowed, as long as they improve what the HWC commits
55 *   to.  Once an implementation of the HWC is shipped, the commit points are
56 *   not allowed to regress in future implementations.
57 *
58 *   This benchmark takes a sampling and then adjusts until it finds a
59 *   commit point.  It doesn't exhaustively check all possible conditions,
60 *   which do to the number of combinations would be impossible.  Instead
61 *   it starts its search from a starting dimension, that can be changed
62 *   via the -s option.  The search is also bounded by a set of search
63 *   limits, that are hard-coded into a structure of constants named
64 *   searchLimits.  Results that happen to reach a searchLimit are prefixed
65 *   with >=, so that it is known that the value could possibly be larger.
66 *
67 *   Measurements are made for each of the graphic formats specified as
68 *   positional parameters on the command-line.  If no graphic formats
69 *   are specified on the command line, then by default measurements are
70 *   made and reported for each of the known graphic format.
71 */
72
73#define LOG_TAG "hwcCommitTest"
74
75#include <algorithm>
76#include <assert.h>
77#include <cerrno>
78#include <cmath>
79#include <cstdlib>
80#include <ctime>
81#include <iomanip>
82#include <istream>
83#include <libgen.h>
84#include <list>
85#include <sched.h>
86#include <sstream>
87#include <stdint.h>
88#include <string.h>
89#include <unistd.h>
90#include <vector>
91
92#include <sys/syscall.h>
93#include <sys/types.h>
94#include <sys/wait.h>
95
96#include <EGL/egl.h>
97#include <EGL/eglext.h>
98#include <GLES2/gl2.h>
99#include <GLES2/gl2ext.h>
100
101#include <ui/GraphicBuffer.h>
102
103#include <utils/Log.h>
104#include <testUtil.h>
105
106#include <hardware/hwcomposer.h>
107
108#include <glTestLib.h>
109#include "hwcTestLib.h"
110
111using namespace std;
112using namespace android;
113
114// Defaults
115const HwcTestDim defaultStartDim = HwcTestDim(100, 100);
116const bool defaultVerbose = false;
117
118const uint32_t   defaultFormat = HAL_PIXEL_FORMAT_RGBA_8888;
119const int32_t    defaultTransform = 0;
120const uint32_t   defaultBlend = HWC_BLENDING_NONE;
121const ColorFract defaultColor(0.5, 0.5, 0.5);
122const float      defaultAlpha = 1.0; // Opaque
123const HwcTestDim defaultSourceDim(1, 1);
124
125// Global Constants
126const uint32_t printFieldWidth = 2;
127const struct searchLimits {
128    uint32_t   numOverlays;
129    HwcTestDim sourceCrop;
130} searchLimits = {
131    10,
132    HwcTestDim(3000, 2000),
133};
134const struct transformType {
135    const char *desc;
136    uint32_t id;
137} transformType[] = {
138    {"fliph",  HWC_TRANSFORM_FLIP_H},
139    {"flipv",  HWC_TRANSFORM_FLIP_V},
140    {"rot90",  HWC_TRANSFORM_ROT_90},
141    {"rot180", HWC_TRANSFORM_ROT_180},
142    {"rot270", HWC_TRANSFORM_ROT_270},
143};
144const struct blendType {
145    const char *desc;
146    uint32_t id;
147} blendType[] = {
148    {"none", HWC_BLENDING_NONE},
149    {"premult", HWC_BLENDING_PREMULT},
150    {"coverage", HWC_BLENDING_COVERAGE},
151};
152
153// Defines
154#define MAXCMD               200
155#define CMD_STOP_FRAMEWORK   "stop 2>&1"
156#define CMD_START_FRAMEWORK  "start 2>&1"
157
158// Macros
159#define NUMA(a) (sizeof(a) / sizeof(a [0])) // Num elements in an array
160
161// Local types
162class Rectangle {
163public:
164    Rectangle(uint32_t graphicFormat = defaultFormat,
165              HwcTestDim dfDim = HwcTestDim(1, 1),
166              HwcTestDim sDim = HwcTestDim(1, 1));
167    void setSourceDim(HwcTestDim dim);
168
169    uint32_t     format;
170    uint32_t     transform;
171    int32_t      blend;
172    ColorFract   color;
173    float        alpha;
174    HwcTestDim   sourceDim;
175    struct hwc_rect   sourceCrop;
176    struct hwc_rect   displayFrame;
177};
178
179class Range {
180public:
181    Range(void) : _l(0), _u(0) {}
182    Range(uint32_t lower, uint32_t upper) : _l(lower), _u(upper) {}
183    uint32_t lower(void) { return _l; }
184    uint32_t upper(void) { return _u; }
185
186    operator string();
187
188private:
189    uint32_t _l; // lower
190    uint32_t _u; // upper
191};
192
193Range::operator string()
194{
195    ostringstream out;
196
197    out << '[' << _l << ", " << _u << ']';
198
199    return out.str();
200}
201
202class Rational {
203public:
204    Rational(void) : _n(0), _d(1) {}
205    Rational(uint32_t n, uint32_t d) : _n(n), _d(d) {}
206    uint32_t numerator(void) { return _n; }
207    uint32_t denominator(void) { return _d; }
208    void setNumerator(uint32_t numerator) { _n = numerator; }
209
210    bool operator==(const Rational& other) const;
211    bool operator!=(const Rational& other) const { return !(*this == other); }
212    bool operator<(const Rational& other) const;
213    bool operator>(const Rational& other) const {
214        return (!(*this == other) && !(*this < other));
215    }
216    static void double2Rational(double f, Range nRange, Range dRange,
217                               Rational& lower, Rational& upper);
218
219    operator string() const;
220    operator double() const { return (double) _n / (double) _d; }
221
222
223private:
224    uint32_t _n;
225    uint32_t _d;
226};
227
228// Globals
229static const int texUsage = GraphicBuffer::USAGE_HW_TEXTURE |
230        GraphicBuffer::USAGE_SW_WRITE_RARELY;
231static hwc_composer_device_1_t *hwcDevice;
232static EGLDisplay dpy;
233static EGLSurface surface;
234static EGLint width, height;
235static size_t maxHeadingLen;
236static vector<string> formats;
237
238// Measurements
239struct meas {
240    uint32_t format;
241    uint32_t startDimOverlays;
242    uint32_t maxNonOverlapping;
243    uint32_t maxOverlapping;
244    list<uint32_t> transforms;
245    list<uint32_t> blends;
246    struct displayFrame {
247        uint32_t minWidth;
248        uint32_t minHeight;
249        HwcTestDim minDim;
250        uint32_t maxWidth;
251        uint32_t maxHeight;
252        HwcTestDim maxDim;
253    } df;
254    struct sourceCrop {
255        uint32_t minWidth;
256        uint32_t minHeight;
257        HwcTestDim minDim;
258        uint32_t maxWidth;
259        uint32_t maxHeight;
260        HwcTestDim maxDim;
261        Rational hScale;
262        HwcTestDim hScaleBestDf;
263        HwcTestDim hScaleBestSc;
264        Rational vScale;
265        HwcTestDim vScaleBestDf;
266        HwcTestDim vScaleBestSc;
267    } sc;
268    vector<uint32_t> overlapBlendNone;
269    vector<uint32_t> overlapBlendPremult;
270    vector<uint32_t> overlapBlendCoverage;
271};
272vector<meas> measurements;
273
274// Function prototypes
275uint32_t numOverlays(list<Rectangle>& rectList);
276uint32_t maxOverlays(uint32_t format, bool allowOverlap);
277list<uint32_t> supportedTransforms(uint32_t format);
278list<uint32_t> supportedBlends(uint32_t format);
279uint32_t dfMinWidth(uint32_t format);
280uint32_t dfMinHeight(uint32_t format);
281uint32_t dfMaxWidth(uint32_t format);
282uint32_t dfMaxHeight(uint32_t format);
283HwcTestDim dfMinDim(uint32_t format);
284HwcTestDim dfMaxDim(uint32_t format);
285uint32_t scMinWidth(uint32_t format, const HwcTestDim& dfDim);
286uint32_t scMinHeight(uint32_t format, const HwcTestDim& dfDim);
287uint32_t scMaxWidth(uint32_t format, const HwcTestDim& dfDim);
288uint32_t scMaxHeight(uint32_t format, const HwcTestDim& dfDim);
289HwcTestDim scMinDim(uint32_t format, const HwcTestDim& dfDim);
290HwcTestDim scMaxDim(uint32_t format, const HwcTestDim& dfDim);
291Rational scHScale(uint32_t format,
292                  const HwcTestDim& dfMin, const HwcTestDim& dfMax,
293                  const HwcTestDim& scMin, const HwcTestDim& scMax,
294                  HwcTestDim& outBestDf, HwcTestDim& outBestSc);
295Rational scVScale(uint32_t format,
296                  const HwcTestDim& dfMin, const HwcTestDim& dfMax,
297                  const HwcTestDim& scMin, const HwcTestDim& scMax,
298                  HwcTestDim& outBestDf, HwcTestDim& outBestSc);
299uint32_t numOverlapping(uint32_t backgroundFormat, uint32_t foregroundFormat,
300                        uint32_t backgroundBlend, uint32_t foregroundBlend);
301string transformList2str(const list<uint32_t>& transformList);
302string blendList2str(const list<uint32_t>& blendList);
303void init(void);
304void printFormatHeadings(size_t indent);
305void printOverlapLine(size_t indent, const string formatStr,
306                      const vector<uint32_t>& results);
307void printSyntax(const char *cmd);
308
309// Command-line option settings
310static bool verbose = defaultVerbose;
311static HwcTestDim startDim = defaultStartDim;
312
313/*
314 * Main
315 *
316 * Performs the following high-level sequence of operations:
317 *
318 *   1. Command-line parsing
319 *
320 *   2. Form a list of command-line specified graphic formats.  If
321 *      no formats are specified, then form a list of all known formats.
322 *
323 *   3. Stop framework
324 *      Only one user at a time is allowed to use the HWC.  Surface
325 *      Flinger uses the HWC and is part of the framework.  Need to
326 *      stop the framework so that Surface Flinger will stop using
327 *      the HWC.
328 *
329 *   4. Initialization
330 *
331 *   5. For each graphic format in the previously formed list perform
332 *      measurements on that format and report the results.
333 *
334 *   6. Start framework
335 */
336int
337main(int argc, char *argv[])
338{
339    int     rv, opt;
340    bool    error;
341    string  str;
342    char cmd[MAXCMD];
343    list<Rectangle> rectList;
344
345    testSetLogCatTag(LOG_TAG);
346
347    // Parse command line arguments
348    while ((opt = getopt(argc, argv, "s:v?h")) != -1) {
349        switch (opt) {
350
351          case 's': // Start Dimension
352            // Use arguments until next starts with a dash
353            // or current ends with a > or ]
354            str = optarg;
355            while (optind < argc) {
356                if (*argv[optind] == '-') { break; }
357                char endChar = (str.length() > 1) ? str[str.length() - 1] : 0;
358                if ((endChar == '>') || (endChar == ']')) { break; }
359                str += " " + string(argv[optind++]);
360            }
361            {
362                istringstream in(str);
363                startDim = hwcTestParseDim(in, error);
364                // Any parse error or characters not used by parser
365                if (error
366                    || (((unsigned int) in.tellg() != in.str().length())
367                        && (in.tellg() != (streampos) -1))) {
368                    testPrintE("Invalid command-line specified start "
369                               "dimension of: %s", str.c_str());
370                    exit(8);
371                }
372            }
373            break;
374
375          case 'v': // Verbose
376            verbose = true;
377            break;
378
379          case 'h': // Help
380          case '?':
381          default:
382            printSyntax(basename(argv[0]));
383            exit(((optopt == 0) || (optopt == '?')) ? 0 : 11);
384        }
385    }
386
387    // Positional parameters
388    // Positional parameters provide the names of graphic formats that
389    // measurements are to be made on.  Measurements are made on all
390    // known graphic formats when no positional parameters are provided.
391    if (optind == argc) {
392        // No command-line specified graphic formats
393        // Add all graphic formats to the list of formats to be measured
394        for (unsigned int n1 = 0; n1 < NUMA(hwcTestGraphicFormat); n1++) {
395            formats.push_back(hwcTestGraphicFormat[n1].desc);
396        }
397    } else {
398        // Add names of command-line specified graphic formats to the
399        // list of formats to be tested
400        for (; argv[optind] != NULL; optind++) {
401            formats.push_back(argv[optind]);
402        }
403    }
404
405    // Determine length of longest specified graphic format.
406    // This value is used for output formating
407    for (vector<string>::iterator it = formats.begin();
408         it != formats.end(); ++it) {
409         maxHeadingLen = max(maxHeadingLen, it->length());
410    }
411
412    // Stop framework
413    rv = snprintf(cmd, sizeof(cmd), "%s", CMD_STOP_FRAMEWORK);
414    if (rv >= (signed) sizeof(cmd) - 1) {
415        testPrintE("Command too long for: %s", CMD_STOP_FRAMEWORK);
416        exit(14);
417    }
418    testExecCmd(cmd);
419    testDelay(1.0); // TODO - needs means to query whether asynchronous stop
420                    // framework operation has completed.  For now, just wait
421                    // a long time.
422
423    testPrintI("startDim: %s", ((string) startDim).c_str());
424
425    init();
426
427    // For each of the graphic formats
428    for (vector<string>::iterator itFormat = formats.begin();
429         itFormat != formats.end(); ++itFormat) {
430
431        // Locate hwcTestLib structure that describes this format
432        const struct hwcTestGraphicFormat *format;
433        format = hwcTestGraphicFormatLookup((*itFormat).c_str());
434        if (format == NULL) {
435            testPrintE("Unknown graphic format of: %s", (*itFormat).c_str());
436            exit(1);
437        }
438
439        // Display format header
440        testPrintI("format: %s", format->desc);
441
442        // Create area to hold the measurements
443        struct meas meas;
444        struct meas *measPtr;
445        meas.format = format->format;
446        measurements.push_back(meas);
447        measPtr = &measurements[measurements.size() - 1];
448
449        // Start dimension num overlays
450        Rectangle rect(format->format, startDim);
451        rectList.clear();
452        rectList.push_back(rect);
453        measPtr->startDimOverlays = numOverlays(rectList);
454        testPrintI("  startDimOverlays: %u", measPtr->startDimOverlays);
455
456        // Skip the rest of the measurements, when the start dimension
457        // doesn't produce an overlay
458        if (measPtr->startDimOverlays == 0) { continue; }
459
460        // Max Overlays
461        measPtr->maxNonOverlapping = maxOverlays(format->format, false);
462        testPrintI("  max nonOverlapping overlays: %s%u",
463                   (measPtr->maxNonOverlapping == searchLimits.numOverlays)
464                       ? ">= " : "",
465                   measPtr->maxNonOverlapping);
466        measPtr->maxOverlapping = maxOverlays(format->format, true);
467        testPrintI("  max Overlapping overlays: %s%u",
468                   (measPtr->maxOverlapping == searchLimits.numOverlays)
469                       ? ">= " : "",
470                   measPtr->maxOverlapping);
471
472        // Transforms and blends
473        measPtr->transforms = supportedTransforms(format->format);
474        testPrintI("  transforms: %s",
475                   transformList2str(measPtr->transforms).c_str());
476        measPtr->blends = supportedBlends(format->format);
477        testPrintI("  blends: %s",
478                   blendList2str(measPtr->blends).c_str());
479
480        // Display frame measurements
481        measPtr->df.minWidth = dfMinWidth(format->format);
482        testPrintI("  dfMinWidth: %u", measPtr->df.minWidth);
483
484        measPtr->df.minHeight = dfMinHeight(format->format);
485        testPrintI("  dfMinHeight: %u", measPtr->df.minHeight);
486
487        measPtr->df.maxWidth = dfMaxWidth(format->format);
488        testPrintI("  dfMaxWidth: %u", measPtr->df.maxWidth);
489
490        measPtr->df.maxHeight = dfMaxHeight(format->format);
491        testPrintI("  dfMaxHeight: %u", measPtr->df.maxHeight);
492
493        measPtr->df.minDim = dfMinDim(format->format);
494        testPrintI("  dfMinDim: %s", ((string) measPtr->df.minDim).c_str());
495
496        measPtr->df.maxDim = dfMaxDim(format->format);
497        testPrintI("  dfMaxDim: %s", ((string) measPtr->df.maxDim).c_str());
498
499        // Source crop measurements
500        measPtr->sc.minWidth = scMinWidth(format->format, measPtr->df.minDim);
501        testPrintI("  scMinWidth: %u", measPtr->sc.minWidth);
502
503        measPtr->sc.minHeight = scMinHeight(format->format, measPtr->df.minDim);
504        testPrintI("  scMinHeight: %u", measPtr->sc.minHeight);
505
506        measPtr->sc.maxWidth = scMaxWidth(format->format, measPtr->df.maxDim);
507        testPrintI("  scMaxWidth: %s%u", (measPtr->sc.maxWidth
508                   == searchLimits.sourceCrop.width()) ? ">= " : "",
509                   measPtr->sc.maxWidth);
510
511        measPtr->sc.maxHeight = scMaxHeight(format->format, measPtr->df.maxDim);
512        testPrintI("  scMaxHeight: %s%u", (measPtr->sc.maxHeight
513                   == searchLimits.sourceCrop.height()) ? ">= " : "",
514                   measPtr->sc.maxHeight);
515
516        measPtr->sc.minDim = scMinDim(format->format, measPtr->df.minDim);
517        testPrintI("  scMinDim: %s", ((string) measPtr->sc.minDim).c_str());
518
519        measPtr->sc.maxDim = scMaxDim(format->format, measPtr->df.maxDim);
520        testPrintI("  scMaxDim: %s%s", ((measPtr->sc.maxDim.width()
521                         >= searchLimits.sourceCrop.width())
522                         || (measPtr->sc.maxDim.width() >=
523                         searchLimits.sourceCrop.height())) ? ">= " : "",
524                   ((string) measPtr->sc.maxDim).c_str());
525
526        measPtr->sc.hScale = scHScale(format->format,
527                                      measPtr->df.minDim, measPtr->df.maxDim,
528                                      measPtr->sc.minDim, measPtr->sc.maxDim,
529                                      measPtr->sc.hScaleBestDf,
530                                      measPtr->sc.hScaleBestSc);
531        testPrintI("  scHScale: %s%f",
532                   (measPtr->sc.hScale
533                       >= Rational(searchLimits.sourceCrop.width(),
534                                   measPtr->df.minDim.width())) ? ">= " : "",
535                   (double) measPtr->sc.hScale);
536        testPrintI("    HScale Best Display Frame: %s",
537                   ((string) measPtr->sc.hScaleBestDf).c_str());
538        testPrintI("    HScale Best Source Crop: %s",
539                   ((string) measPtr->sc.hScaleBestSc).c_str());
540
541        measPtr->sc.vScale = scVScale(format->format,
542                                      measPtr->df.minDim, measPtr->df.maxDim,
543                                      measPtr->sc.minDim, measPtr->sc.maxDim,
544                                      measPtr->sc.vScaleBestDf,
545                                      measPtr->sc.vScaleBestSc);
546        testPrintI("  scVScale: %s%f",
547                   (measPtr->sc.vScale
548                       >= Rational(searchLimits.sourceCrop.height(),
549                                   measPtr->df.minDim.height())) ? ">= " : "",
550                   (double) measPtr->sc.vScale);
551        testPrintI("    VScale Best Display Frame: %s",
552                   ((string) measPtr->sc.vScaleBestDf).c_str());
553        testPrintI("    VScale Best Source Crop: %s",
554                   ((string) measPtr->sc.vScaleBestSc).c_str());
555
556        // Overlap two graphic formats and different blends
557        // Results displayed after all overlap measurments with
558        // current format in the foreground
559        // TODO: make measurments with background blend other than
560        //       none.  All of these measurements are done with a
561        //       background blend of HWC_BLENDING_NONE, with the
562        //       blend type of the foregound being varied.
563        uint32_t foregroundFormat = format->format;
564        for (vector<string>::iterator it = formats.begin();
565             it != formats.end(); ++it) {
566            uint32_t num;
567
568            const struct hwcTestGraphicFormat *backgroundFormatPtr
569                = hwcTestGraphicFormatLookup((*it).c_str());
570            uint32_t backgroundFormat = backgroundFormatPtr->format;
571
572            num = numOverlapping(backgroundFormat, foregroundFormat,
573                                 HWC_BLENDING_NONE, HWC_BLENDING_NONE);
574            measPtr->overlapBlendNone.push_back(num);
575
576            num = numOverlapping(backgroundFormat, foregroundFormat,
577                                 HWC_BLENDING_NONE, HWC_BLENDING_PREMULT);
578            measPtr->overlapBlendPremult.push_back(num);
579
580            num = numOverlapping(backgroundFormat, foregroundFormat,
581                                 HWC_BLENDING_NONE, HWC_BLENDING_COVERAGE);
582            measPtr->overlapBlendCoverage.push_back(num);
583        }
584
585    }
586
587    // Display overlap results
588    size_t indent = 2;
589    testPrintI("overlapping blend: none");
590    printFormatHeadings(indent);
591    for (vector<string>::iterator it = formats.begin();
592         it != formats.end(); ++it) {
593        printOverlapLine(indent, *it, measurements[it
594                         - formats.begin()].overlapBlendNone);
595    }
596    testPrintI("");
597
598    testPrintI("overlapping blend: premult");
599    printFormatHeadings(indent);
600    for (vector<string>::iterator it = formats.begin();
601         it != formats.end(); ++it) {
602        printOverlapLine(indent, *it, measurements[it
603                         - formats.begin()].overlapBlendPremult);
604    }
605    testPrintI("");
606
607    testPrintI("overlapping blend: coverage");
608    printFormatHeadings(indent);
609    for (vector<string>::iterator it = formats.begin();
610         it != formats.end(); ++it) {
611        printOverlapLine(indent, *it, measurements[it
612                         - formats.begin()].overlapBlendCoverage);
613    }
614    testPrintI("");
615
616    // Start framework
617    rv = snprintf(cmd, sizeof(cmd), "%s", CMD_START_FRAMEWORK);
618    if (rv >= (signed) sizeof(cmd) - 1) {
619        testPrintE("Command too long for: %s", CMD_START_FRAMEWORK);
620        exit(21);
621    }
622    testExecCmd(cmd);
623
624    return 0;
625}
626
627// Determine the maximum number of overlays that are all of the same format
628// that the HWC will commit to.  If allowOverlap is true, then the rectangles
629// are laid out on a diagonal starting from the upper left corner.  With
630// each rectangle adjust one pixel to the right and one pixel down.
631// When allowOverlap is false, the rectangles are tiled in column major
632// order.  Note, column major ordering is used so that the initial rectangles
633// are all on different horizontal scan rows.  It is common that hardware
634// has limits on the number of objects it can handle on any single row.
635uint32_t maxOverlays(uint32_t format, bool allowOverlap)
636{
637    unsigned int max = 0;
638
639    for (unsigned int numRects = 1; numRects <= searchLimits.numOverlays;
640         numRects++) {
641        list<Rectangle> rectList;
642
643        for (unsigned int x = 0;
644             (x + startDim.width()) < (unsigned int) width;
645             x += (allowOverlap) ? 1 : startDim.width()) {
646            for (unsigned int y = 0;
647                 (y + startDim.height()) < (unsigned int) height;
648                 y += (allowOverlap) ? 1 : startDim.height()) {
649                Rectangle rect(format, startDim, startDim);
650                rect.displayFrame.left = x;
651                rect.displayFrame.top = y;
652                rect.displayFrame.right = x + startDim.width();
653                rect.displayFrame.bottom = y + startDim.height();
654
655                rectList.push_back(rect);
656
657                if (rectList.size() >= numRects) { break; }
658            }
659            if (rectList.size() >= numRects) { break; }
660        }
661
662        uint32_t num = numOverlays(rectList);
663        if (num > max) { max = num; }
664    }
665
666    return max;
667}
668
669// Measures what transforms (i.e. flip horizontal, rotate 180) are
670// supported by the specified format
671list<uint32_t> supportedTransforms(uint32_t format)
672{
673    list<uint32_t> rv;
674    list<Rectangle> rectList;
675    Rectangle rect(format, startDim);
676
677    // For each of the transform types
678    for (unsigned int idx = 0; idx < NUMA(transformType); idx++) {
679        unsigned int id = transformType[idx].id;
680
681        rect.transform = id;
682        rectList.clear();
683        rectList.push_back(rect);
684        uint32_t num = numOverlays(rectList);
685
686        if (num == 1) {
687            rv.push_back(id);
688        }
689    }
690
691    return rv;
692}
693
694// Determines which types of blends (i.e. none, premult, coverage) are
695// supported by the specified format
696list<uint32_t> supportedBlends(uint32_t format)
697{
698    list<uint32_t> rv;
699    list<Rectangle> rectList;
700    Rectangle rect(format, startDim);
701
702    // For each of the blend types
703    for (unsigned int idx = 0; idx < NUMA(blendType); idx++) {
704        unsigned int id = blendType[idx].id;
705
706        rect.blend = id;
707        rectList.clear();
708        rectList.push_back(rect);
709        uint32_t num = numOverlays(rectList);
710
711        if (num == 1) {
712            rv.push_back(id);
713        }
714    }
715
716    return rv;
717}
718
719// Determines the minimum width of any display frame of the given format
720// that the HWC will commit to.
721uint32_t dfMinWidth(uint32_t format)
722{
723    uint32_t w;
724    list<Rectangle> rectList;
725
726    for (w = 1; w <= startDim.width(); w++) {
727        HwcTestDim dim(w, startDim.height());
728        Rectangle rect(format, dim);
729        rectList.clear();
730        rectList.push_back(rect);
731        uint32_t num = numOverlays(rectList);
732        if (num > 0) {
733            return w;
734        }
735    }
736    if (w > startDim.width()) {
737        testPrintE("Failed to locate display frame min width");
738        exit(33);
739    }
740
741    return w;
742}
743
744// Display frame minimum height
745uint32_t dfMinHeight(uint32_t format)
746{
747    uint32_t h;
748    list<Rectangle> rectList;
749
750    for (h = 1; h <= startDim.height(); h++) {
751        HwcTestDim dim(startDim.width(), h);
752        Rectangle rect(format, dim);
753        rectList.clear();
754        rectList.push_back(rect);
755        uint32_t num = numOverlays(rectList);
756        if (num > 0) {
757            return h;
758        }
759    }
760    if (h > startDim.height()) {
761        testPrintE("Failed to locate display frame min height");
762        exit(34);
763    }
764
765    return h;
766}
767
768// Display frame maximum width
769uint32_t dfMaxWidth(uint32_t format)
770{
771    uint32_t w;
772    list<Rectangle> rectList;
773
774    for (w = width; w >= startDim.width(); w--) {
775        HwcTestDim dim(w, startDim.height());
776        Rectangle rect(format, dim);
777        rectList.clear();
778        rectList.push_back(rect);
779        uint32_t num = numOverlays(rectList);
780        if (num > 0) {
781            return w;
782        }
783    }
784    if (w < startDim.width()) {
785        testPrintE("Failed to locate display frame max width");
786        exit(35);
787    }
788
789    return w;
790}
791
792// Display frame maximum height
793uint32_t dfMaxHeight(uint32_t format)
794{
795    uint32_t h;
796
797    for (h = height; h >= startDim.height(); h--) {
798        HwcTestDim dim(startDim.width(), h);
799        Rectangle rect(format, dim);
800        list<Rectangle> rectList;
801        rectList.push_back(rect);
802        uint32_t num = numOverlays(rectList);
803        if (num > 0) {
804            return h;
805        }
806    }
807    if (h < startDim.height()) {
808        testPrintE("Failed to locate display frame max height");
809        exit(36);
810    }
811
812    return h;
813}
814
815// Determine the minimum number of pixels that the HWC will ever commit to.
816// Note, this might be different that dfMinWidth * dfMinHeight, in that this
817// function adjusts both the width and height from the starting dimension.
818HwcTestDim dfMinDim(uint32_t format)
819{
820    uint64_t bestMinPixels = 0;
821    HwcTestDim bestDim;
822    bool bestSet = false; // True when value has been assigned to
823                          // bestMinPixels and bestDim
824
825    bool origVerbose = verbose;  // Temporarily turn off verbose
826    verbose = false;
827    for (uint32_t w = 1; w <= startDim.width(); w++) {
828        for (uint32_t h = 1; h <= startDim.height(); h++) {
829            if (bestSet && ((w > bestMinPixels) || (h > bestMinPixels))) {
830                break;
831            }
832
833            HwcTestDim dim(w, h);
834            Rectangle rect(format, dim);
835            list<Rectangle> rectList;
836            rectList.push_back(rect);
837            uint32_t num = numOverlays(rectList);
838            if (num > 0) {
839                uint64_t pixels = dim.width() * dim.height();
840                if (!bestSet || (pixels < bestMinPixels)) {
841                    bestMinPixels = pixels;
842                    bestDim = dim;
843                    bestSet = true;
844                }
845            }
846        }
847    }
848    verbose = origVerbose;
849
850    if (!bestSet) {
851        testPrintE("Unable to locate display frame min dimension");
852        exit(20);
853    }
854
855    return bestDim;
856}
857
858// Display frame maximum dimension
859HwcTestDim dfMaxDim(uint32_t format)
860{
861    uint64_t bestMaxPixels = 0;
862    HwcTestDim bestDim;
863    bool bestSet = false; // True when value has been assigned to
864                          // bestMaxPixels and bestDim;
865
866    // Potentially increase benchmark performance by first checking
867    // for the common case of supporting a full display frame.
868    HwcTestDim dim(width, height);
869    Rectangle rect(format, dim);
870    list<Rectangle> rectList;
871    rectList.push_back(rect);
872    uint32_t num = numOverlays(rectList);
873    if (num == 1) { return dim; }
874
875    // TODO: Use a binary search
876    bool origVerbose = verbose;  // Temporarily turn off verbose
877    verbose = false;
878    for (uint32_t w = startDim.width(); w <= (uint32_t) width; w++) {
879        for (uint32_t h = startDim.height(); h <= (uint32_t) height; h++) {
880            if (bestSet && ((w * h) <= bestMaxPixels)) { continue; }
881
882            HwcTestDim dim(w, h);
883            Rectangle rect(format, dim);
884            list<Rectangle> rectList;
885            rectList.push_back(rect);
886            uint32_t num = numOverlays(rectList);
887            if (num > 0) {
888                uint64_t pixels = dim.width() * dim.height();
889                if (!bestSet || (pixels > bestMaxPixels)) {
890                    bestMaxPixels = pixels;
891                    bestDim = dim;
892                    bestSet = true;
893                }
894            }
895        }
896    }
897    verbose = origVerbose;
898
899    if (!bestSet) {
900        testPrintE("Unable to locate display frame max dimension");
901        exit(21);
902    }
903
904    return bestDim;
905}
906
907// Source crop minimum width
908uint32_t scMinWidth(uint32_t format, const HwcTestDim& dfDim)
909{
910    uint32_t w;
911    list<Rectangle> rectList;
912
913    // Source crop frame min width
914    for (w = 1; w <= dfDim.width(); w++) {
915        Rectangle rect(format, dfDim, HwcTestDim(w, dfDim.height()));
916        rectList.clear();
917        rectList.push_back(rect);
918        uint32_t num = numOverlays(rectList);
919        if (num > 0) {
920            return w;
921        }
922    }
923    testPrintE("Failed to locate source crop min width");
924    exit(35);
925}
926
927// Source crop minimum height
928uint32_t scMinHeight(uint32_t format, const HwcTestDim& dfDim)
929{
930    uint32_t h;
931    list<Rectangle> rectList;
932
933    for (h = 1; h <= dfDim.height(); h++) {
934        Rectangle rect(format, dfDim, HwcTestDim(dfDim.width(), h));
935        rectList.clear();
936        rectList.push_back(rect);
937        uint32_t num = numOverlays(rectList);
938        if (num > 0) {
939            return h;
940        }
941    }
942    testPrintE("Failed to locate source crop min height");
943    exit(36);
944}
945
946// Source crop maximum width
947uint32_t scMaxWidth(uint32_t format, const HwcTestDim& dfDim)
948{
949    uint32_t w;
950    list<Rectangle> rectList;
951
952    for (w = searchLimits.sourceCrop.width(); w >= dfDim.width(); w--) {
953        Rectangle rect(format, dfDim, HwcTestDim(w, dfDim.height()));
954        rectList.clear();
955        rectList.push_back(rect);
956        uint32_t num = numOverlays(rectList);
957        if (num > 0) {
958            return w;
959        }
960    }
961    testPrintE("Failed to locate source crop max width");
962    exit(35);
963}
964
965// Source crop maximum height
966uint32_t scMaxHeight(uint32_t format, const HwcTestDim& dfDim)
967{
968    uint32_t h;
969    list<Rectangle> rectList;
970
971    for (h = searchLimits.sourceCrop.height(); h >= dfDim.height(); h--) {
972        Rectangle rect(format, dfDim, HwcTestDim(dfDim.width(), h));
973        rectList.clear();
974        rectList.push_back(rect);
975        uint32_t num = numOverlays(rectList);
976        if (num > 0) {
977            return h;
978        }
979    }
980    testPrintE("Failed to locate source crop max height");
981    exit(36);
982}
983
984// Source crop minimum dimension
985// Discovers the source crop with the least number of pixels that the
986// HWC will commit to.  Note, this may be different from scMinWidth
987// * scMinHeight, in that this function searches for a combination of
988// width and height.  While the other routines always keep one of the
989// dimensions equal to the corresponding start dimension.
990HwcTestDim scMinDim(uint32_t format, const HwcTestDim& dfDim)
991{
992    uint64_t bestMinPixels = 0;
993    HwcTestDim bestDim;
994    bool bestSet = false; // True when value has been assigned to
995                          // bestMinPixels and bestDim
996
997    bool origVerbose = verbose;  // Temporarily turn off verbose
998    verbose = false;
999    for (uint32_t w = 1; w <= dfDim.width(); w++) {
1000        for (uint32_t h = 1; h <= dfDim.height(); h++) {
1001            if (bestSet && ((w > bestMinPixels) || (h > bestMinPixels))) {
1002                break;
1003            }
1004
1005            HwcTestDim dim(w, h);
1006            Rectangle rect(format, dfDim, HwcTestDim(w, h));
1007            list<Rectangle> rectList;
1008            rectList.push_back(rect);
1009            uint32_t num = numOverlays(rectList);
1010            if (num > 0) {
1011                uint64_t pixels = dim.width() * dim.height();
1012                if (!bestSet || (pixels < bestMinPixels)) {
1013                    bestMinPixels = pixels;
1014                    bestDim = dim;
1015                    bestSet = true;
1016                }
1017            }
1018        }
1019    }
1020    verbose = origVerbose;
1021
1022    if (!bestSet) {
1023        testPrintE("Unable to locate source crop min dimension");
1024        exit(20);
1025    }
1026
1027    return bestDim;
1028}
1029
1030// Source crop maximum dimension
1031HwcTestDim scMaxDim(uint32_t format, const HwcTestDim& dfDim)
1032{
1033    uint64_t bestMaxPixels = 0;
1034    HwcTestDim bestDim;
1035    bool bestSet = false; // True when value has been assigned to
1036                          // bestMaxPixels and bestDim;
1037
1038    // Potentially increase benchmark performance by first checking
1039    // for the common case of supporting the maximum checked source size
1040    HwcTestDim dim = searchLimits.sourceCrop;
1041    Rectangle rect(format, dfDim, searchLimits.sourceCrop);
1042    list<Rectangle> rectList;
1043    rectList.push_back(rect);
1044    uint32_t num = numOverlays(rectList);
1045    if (num == 1) { return dim; }
1046
1047    // TODO: Use a binary search
1048    bool origVerbose = verbose;  // Temporarily turn off verbose
1049    verbose = false;
1050    for (uint32_t w = dfDim.width();
1051         w <= searchLimits.sourceCrop.width(); w++) {
1052        for (uint32_t h = dfDim.height();
1053             h <= searchLimits.sourceCrop.height(); h++) {
1054            if (bestSet && ((w * h) <= bestMaxPixels)) { continue; }
1055
1056            HwcTestDim dim(w, h);
1057            Rectangle rect(format, dfDim, dim);
1058            list<Rectangle> rectList;
1059            rectList.push_back(rect);
1060            uint32_t num = numOverlays(rectList);
1061            if (num > 0) {
1062                uint64_t pixels = dim.width() * dim.height();
1063                if (!bestSet || (pixels > bestMaxPixels)) {
1064                    bestMaxPixels = pixels;
1065                    bestDim = dim;
1066                    bestSet = true;
1067                }
1068            }
1069        }
1070    }
1071    verbose = origVerbose;
1072
1073    if (!bestSet) {
1074        testPrintE("Unable to locate source crop max dimension");
1075        exit(21);
1076    }
1077
1078    return bestDim;
1079}
1080
1081// Source crop horizontal scale
1082// Determines the maximum factor by which the source crop can be larger
1083// that the display frame.  The commit point is discovered through a
1084// binary search of rational numbers.  The numerator in each of the
1085// rational numbers contains the dimension for the source crop, while
1086// the denominator specifies the dimension for the display frame.  On
1087// each pass of the binary search the mid-point between the greatest
1088// point committed to (best) and the smallest point in which a commit
1089// has failed is calculated.  This mid-point is then passed to a function
1090// named double2Rational, which determines the closest rational numbers
1091// just below and above the mid-point.  By default the lower rational
1092// number is used for the scale factor on the next pass of the binary
1093// search.  The upper value is only used when best is already equal
1094// to the lower value.  This only occurs when the lower value has already
1095// been tried.
1096Rational scHScale(uint32_t format,
1097                      const HwcTestDim& dfMin, const HwcTestDim& dfMax,
1098                      const HwcTestDim& scMin, const HwcTestDim& scMax,
1099                      HwcTestDim& outBestDf, HwcTestDim& outBestSc)
1100{
1101    HwcTestDim scDim, dfDim; // Source crop and display frame dimension
1102    Rational best(0, 1), minBad;  // Current bounds for a binary search
1103                                  // MinGood is set below the lowest
1104                                  // possible scale.  The value of minBad,
1105                                  // will be set by the first pass
1106                                  // of the binary search.
1107
1108    // Perform the passes of the binary search
1109    bool firstPass = true;
1110    do {
1111        // On first pass try the maximum scale within the search limits
1112        if (firstPass) {
1113            // Try the maximum possible scale, within the search limits
1114            scDim = HwcTestDim(searchLimits.sourceCrop.width(), scMin.height());
1115            dfDim = dfMin;
1116        } else {
1117            // Subsequent pass
1118            // Halve the difference between best and minBad.
1119            Rational lower, upper, selected;
1120
1121            // Try the closest ratio halfway between minBood and minBad;
1122            // TODO: Avoid rounding issue by using Rational type for
1123            //       midpoint.  For now will use double, which should
1124            //       have more than sufficient resolution.
1125            double mid = (double) best
1126                         + ((double) minBad - (double) best) / 2.0;
1127            Rational::double2Rational(mid,
1128                            Range(scMin.width(), scMax.width()),
1129                            Range(dfMin.width(), dfMax.width()),
1130                            lower, upper);
1131            if (((lower == best) && (upper == minBad))) {
1132                return best;
1133            }
1134
1135            // Use lower value unless its already been tried
1136            selected = (lower != best) ? lower : upper;
1137
1138            // Assign the size of the source crop and display frame
1139            // from the selected ratio of source crop to display frame.
1140            scDim = HwcTestDim(selected.numerator(), scMin.height());
1141            dfDim = HwcTestDim(selected.denominator(), dfMin.height());
1142        }
1143
1144        // See if the HWC will commit to this combination
1145        Rectangle rect(format, dfDim, scDim);
1146        list<Rectangle> rectList;
1147        rectList.push_back(rect);
1148        uint32_t num = numOverlays(rectList);
1149
1150        if (verbose) {
1151            testPrintI("  scHscale num: %u scale: %f dfDim: %s scDim: %s",
1152                       num, (float) Rational(scDim.width(), dfDim.width()),
1153                       ((string) dfDim).c_str(), ((string) scDim).c_str());
1154        }
1155        if (num == 1) {
1156            // HWC committed to the combination
1157            // This is the best scale factor seen so far.  Report the
1158            // dimensions to the caller, in case nothing better is seen.
1159            outBestDf = dfDim;
1160            outBestSc = scDim;
1161
1162            // Success on the first pass means the largest possible scale
1163            // is supported, in which case no need to search any further.
1164            if (firstPass) { return Rational(scDim.width(), dfDim.width()); }
1165
1166            // Update the lower bound of the binary search
1167            best = Rational(scDim.width(), dfDim.width());
1168        } else {
1169            // HWC didn't commit to this combination, so update the
1170            // upper bound of the binary search.
1171            minBad = Rational(scDim.width(), dfDim.width());
1172        }
1173
1174        firstPass = false;
1175    } while (best != minBad);
1176
1177    return best;
1178}
1179
1180// Source crop vertical scale
1181// Determines the maximum factor by which the source crop can be larger
1182// that the display frame.  The commit point is discovered through a
1183// binary search of rational numbers.  The numerator in each of the
1184// rational numbers contains the dimension for the source crop, while
1185// the denominator specifies the dimension for the display frame.  On
1186// each pass of the binary search the mid-point between the greatest
1187// point committed to (best) and the smallest point in which a commit
1188// has failed is calculated.  This mid-point is then passed to a function
1189// named double2Rational, which determines the closest rational numbers
1190// just below and above the mid-point.  By default the lower rational
1191// number is used for the scale factor on the next pass of the binary
1192// search.  The upper value is only used when best is already equal
1193// to the lower value.  This only occurs when the lower value has already
1194// been tried.
1195Rational scVScale(uint32_t format,
1196                      const HwcTestDim& dfMin, const HwcTestDim& dfMax,
1197                      const HwcTestDim& scMin, const HwcTestDim& scMax,
1198                      HwcTestDim& outBestDf, HwcTestDim& outBestSc)
1199{
1200    HwcTestDim scDim, dfDim; // Source crop and display frame dimension
1201    Rational best(0, 1), minBad;  // Current bounds for a binary search
1202                                  // MinGood is set below the lowest
1203                                  // possible scale.  The value of minBad,
1204                                  // will be set by the first pass
1205                                  // of the binary search.
1206
1207    // Perform the passes of the binary search
1208    bool firstPass = true;
1209    do {
1210        // On first pass try the maximum scale within the search limits
1211        if (firstPass) {
1212            // Try the maximum possible scale, within the search limits
1213            scDim = HwcTestDim(scMin.width(), searchLimits.sourceCrop.height());
1214            dfDim = dfMin;
1215        } else {
1216            // Subsequent pass
1217            // Halve the difference between best and minBad.
1218            Rational lower, upper, selected;
1219
1220            // Try the closest ratio halfway between minBood and minBad;
1221            // TODO: Avoid rounding issue by using Rational type for
1222            //       midpoint.  For now will use double, which should
1223            //       have more than sufficient resolution.
1224            double mid = (double) best
1225                         + ((double) minBad - (double) best) / 2.0;
1226            Rational::double2Rational(mid,
1227                            Range(scMin.height(), scMax.height()),
1228                            Range(dfMin.height(), dfMax.height()),
1229                            lower, upper);
1230            if (((lower == best) && (upper == minBad))) {
1231                return best;
1232            }
1233
1234            // Use lower value unless its already been tried
1235            selected = (lower != best) ? lower : upper;
1236
1237            // Assign the size of the source crop and display frame
1238            // from the selected ratio of source crop to display frame.
1239            scDim = HwcTestDim(scMin.width(), selected.numerator());
1240            dfDim = HwcTestDim(dfMin.width(), selected.denominator());
1241        }
1242
1243        // See if the HWC will commit to this combination
1244        Rectangle rect(format, dfDim, scDim);
1245        list<Rectangle> rectList;
1246        rectList.push_back(rect);
1247        uint32_t num = numOverlays(rectList);
1248
1249        if (verbose) {
1250            testPrintI("  scHscale num: %u scale: %f dfDim: %s scDim: %s",
1251                       num, (float) Rational(scDim.height(), dfDim.height()),
1252                       ((string) dfDim).c_str(), ((string) scDim).c_str());
1253        }
1254        if (num == 1) {
1255            // HWC committed to the combination
1256            // This is the best scale factor seen so far.  Report the
1257            // dimensions to the caller, in case nothing better is seen.
1258            outBestDf = dfDim;
1259            outBestSc = scDim;
1260
1261            // Success on the first pass means the largest possible scale
1262            // is supported, in which case no need to search any further.
1263            if (firstPass) { return Rational(scDim.height(), dfDim.height()); }
1264
1265            // Update the lower bound of the binary search
1266            best = Rational(scDim.height(), dfDim.height());
1267        } else {
1268            // HWC didn't commit to this combination, so update the
1269            // upper bound of the binary search.
1270            minBad = Rational(scDim.height(), dfDim.height());
1271        }
1272
1273        firstPass = false;
1274    } while (best != minBad);
1275
1276    return best;
1277}
1278
1279uint32_t numOverlapping(uint32_t backgroundFormat, uint32_t foregroundFormat,
1280                        uint32_t backgroundBlend, uint32_t foregroundBlend)
1281{
1282    list<Rectangle> rectList;
1283
1284    Rectangle background(backgroundFormat, startDim, startDim);
1285    background.blend = backgroundBlend;
1286    rectList.push_back(background);
1287
1288    // TODO: Handle cases where startDim is so small that adding 5
1289    //       causes frames not to overlap.
1290    // TODO: Handle cases where startDim is so large that adding 5
1291    //       cause a portion or all of the foreground displayFrame
1292    //       to be off the display.
1293    Rectangle foreground(foregroundFormat, startDim, startDim);
1294    foreground.displayFrame.left += 5;
1295    foreground.displayFrame.top += 5;
1296    foreground.displayFrame.right += 5;
1297    foreground.displayFrame.bottom += 5;
1298    background.blend = foregroundBlend;
1299    rectList.push_back(foreground);
1300
1301    uint32_t num = numOverlays(rectList);
1302
1303    return num;
1304}
1305
1306Rectangle::Rectangle(uint32_t graphicFormat, HwcTestDim dfDim,
1307                     HwcTestDim sDim) :
1308    format(graphicFormat), transform(defaultTransform),
1309    blend(defaultBlend), color(defaultColor), alpha(defaultAlpha),
1310    sourceCrop(sDim), displayFrame(dfDim)
1311{
1312    // Set source dimension
1313    // Can't use a base initializer, because the setting of format
1314    // must be done before setting the sourceDimension.
1315    setSourceDim(sDim);
1316}
1317
1318void Rectangle::setSourceDim(HwcTestDim dim)
1319{
1320    this->sourceDim = dim;
1321
1322    const struct hwcTestGraphicFormat *attrib;
1323    attrib = hwcTestGraphicFormatLookup(this->format);
1324    if (attrib != NULL) {
1325        if (sourceDim.width() % attrib->wMod) {
1326            sourceDim.setWidth(sourceDim.width() + attrib->wMod
1327            - (sourceDim.width() % attrib->wMod));
1328        }
1329        if (sourceDim.height() % attrib->hMod) {
1330            sourceDim.setHeight(sourceDim.height() + attrib->hMod
1331            - (sourceDim.height() % attrib->hMod));
1332        }
1333    }
1334}
1335
1336// Rational member functions
1337bool Rational::operator==(const Rational& other) const
1338{
1339    if (((uint64_t) _n * other._d)
1340        == ((uint64_t) _d * other._n)) { return true; }
1341
1342    return false;
1343}
1344
1345bool Rational::operator<(const Rational& other) const
1346{
1347    if (((uint64_t) _n * other._d)
1348        < ((uint64_t) _d * other._n)) { return true; }
1349
1350    return false;
1351}
1352
1353Rational::operator string() const
1354{
1355    ostringstream out;
1356
1357    out << _n << '/' << _d;
1358
1359    return out.str();
1360}
1361
1362void Rational::double2Rational(double f, Range nRange, Range dRange,
1363                    Rational& lower, Rational& upper)
1364{
1365    Rational bestLower(nRange.lower(), dRange.upper());
1366    Rational bestUpper(nRange.upper(), dRange.lower());
1367
1368    // Search for a better solution
1369    for (uint32_t d = dRange.lower(); d <= dRange.upper(); d++) {
1370        Rational val(d * f, d);  // Lower, because double to int cast truncates
1371
1372        if ((val.numerator() < nRange.lower())
1373            || (val.numerator() > nRange.upper())) { continue; }
1374
1375        if (((double) val > (double) bestLower) && ((double) val <= f)) {
1376            bestLower = val;
1377        }
1378
1379        val.setNumerator(val.numerator() + 1);
1380        if (val.numerator() > nRange.upper()) { continue; }
1381
1382        if (((double) val < (double) bestUpper) && ((double) val >= f)) {
1383            bestUpper = val;
1384        }
1385    }
1386
1387    lower = bestLower;
1388    upper = bestUpper;
1389}
1390
1391// Local functions
1392
1393// Num Overlays
1394// Given a list of rectangles, determine how many HWC will commit to render
1395uint32_t numOverlays(list<Rectangle>& rectList)
1396{
1397    hwc_display_contents_1_t *hwcList;
1398    list<sp<GraphicBuffer> > buffers;
1399
1400    hwcList = hwcTestCreateLayerList(rectList.size());
1401    if (hwcList == NULL) {
1402        testPrintE("numOverlays create hwcList failed");
1403        exit(30);
1404    }
1405
1406    hwc_layer_1_t *layer = &hwcList->hwLayers[0];
1407    for (std::list<Rectangle>::iterator it = rectList.begin();
1408         it != rectList.end(); ++it, ++layer) {
1409        // Allocate the texture for the source frame
1410        // and push it onto the buffers list, so that it
1411        // stays in scope until a return from this function.
1412        sp<GraphicBuffer> texture;
1413        texture  = new GraphicBuffer(it->sourceDim.width(),
1414                                     it->sourceDim.height(),
1415                                     it->format, texUsage);
1416        buffers.push_back(texture);
1417
1418        layer->handle = texture->handle;
1419        layer->blending = it->blend;
1420        layer->transform = it->transform;
1421        layer->sourceCrop = it->sourceCrop;
1422        layer->displayFrame = it->displayFrame;
1423
1424        layer->visibleRegionScreen.numRects = 1;
1425        layer->visibleRegionScreen.rects = &layer->displayFrame;
1426    }
1427
1428    // Perform prepare operation
1429    if (verbose) { testPrintI("Prepare:"); hwcTestDisplayList(hwcList); }
1430    hwcDevice->prepare(hwcDevice, 1, &hwcList);
1431    if (verbose) {
1432        testPrintI("Post Prepare:");
1433        hwcTestDisplayListPrepareModifiable(hwcList);
1434    }
1435
1436    // Count the number of overlays
1437    uint32_t total = 0;
1438    for (unsigned int n1 = 0; n1 < hwcList->numHwLayers; n1++) {
1439        if (hwcList->hwLayers[n1].compositionType == HWC_OVERLAY) {
1440            total++;
1441        }
1442    }
1443
1444    // Free the layer list and graphic buffers
1445    hwcTestFreeLayerList(hwcList);
1446
1447    return total;
1448}
1449
1450string transformList2str(const list<uint32_t>& transformList)
1451{
1452    ostringstream out;
1453
1454    for (list<uint32_t>::const_iterator it = transformList.begin();
1455         it != transformList.end(); ++it) {
1456        uint32_t id = *it;
1457
1458        if (it != transformList.begin()) {
1459            out << ", ";
1460        }
1461        out << id;
1462
1463        for (unsigned int idx = 0; idx < NUMA(transformType); idx++) {
1464            if (id == transformType[idx].id) {
1465                out << " (" << transformType[idx].desc << ')';
1466                break;
1467            }
1468        }
1469    }
1470
1471    return out.str();
1472}
1473
1474string blendList2str(const list<uint32_t>& blendList)
1475{
1476    ostringstream out;
1477
1478    for (list<uint32_t>::const_iterator it = blendList.begin();
1479         it != blendList.end(); ++it) {
1480        uint32_t id = *it;
1481
1482        if (it != blendList.begin()) {
1483            out << ", ";
1484        }
1485        out << id;
1486
1487        for (unsigned int idx = 0; idx < NUMA(blendType); idx++) {
1488            if (id == blendType[idx].id) {
1489                out << " (" << blendType[idx].desc << ')';
1490                break;
1491            }
1492        }
1493    }
1494
1495    return out.str();
1496}
1497
1498void init(void)
1499{
1500    srand48(0);
1501
1502    hwcTestInitDisplay(verbose, &dpy, &surface, &width, &height);
1503
1504    hwcTestOpenHwc(&hwcDevice);
1505}
1506
1507void printFormatHeadings(size_t indent)
1508{
1509    for (size_t row = 0; row <= maxHeadingLen; row++) {
1510        ostringstream line;
1511        for(vector<string>::iterator it = formats.begin();
1512            it != formats.end(); ++it) {
1513            if ((maxHeadingLen - row) <= it->length()) {
1514                if (row != maxHeadingLen) {
1515                    char ch = (*it)[it->length() - (maxHeadingLen - row)];
1516                    line << ' ' << setw(printFieldWidth) << ch;
1517                } else {
1518                    line << ' ' << string(printFieldWidth, '-');
1519                }
1520            } else {
1521               line << ' ' << setw(printFieldWidth) << "";
1522            }
1523        }
1524        testPrintI("%*s%s", indent + maxHeadingLen, "",
1525                   line.str().c_str());
1526    }
1527}
1528
1529void printOverlapLine(size_t indent, const string formatStr,
1530                        const vector<uint32_t>& results)
1531{
1532    ostringstream line;
1533
1534    line << setw(indent + maxHeadingLen - formatStr.length()) << "";
1535
1536    line << formatStr;
1537
1538    for (vector<uint32_t>::const_iterator it = results.begin();
1539         it != results.end(); ++it) {
1540        line << ' ' << setw(printFieldWidth) << *it;
1541    }
1542
1543    testPrintI("%s", line.str().c_str());
1544}
1545
1546void printSyntax(const char *cmd)
1547{
1548    testPrintE("  %s [options] [graphicFormat] ...",
1549               cmd);
1550    testPrintE("    options:");
1551    testPrintE("      -s [width, height] - start dimension");
1552    testPrintE("      -v - Verbose");
1553    testPrintE("");
1554    testPrintE("    graphic formats:");
1555    for (unsigned int n1 = 0; n1 < NUMA(hwcTestGraphicFormat); n1++) {
1556        testPrintE("      %s", hwcTestGraphicFormat[n1].desc);
1557    }
1558}
1559