--- /dev/null
+/*
+ * 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 <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/FramebufferNativeWindow.h>
+#include <ui/GraphicBuffer.h>
+#include <ui/EGLUtils.h>
+
+#define LOG_TAG "hwcCommitTest"
+#include <utils/Log.h>
+#include <testUtil.h>
+
+#include <hardware/hwcomposer.h>
+
+#include <glTestLib.h>
+#include <hwc/hwcTestLib.h>
+
+using namespace std;
+using namespace android;
+
+// Defaults
+const HwcTestDim defaultStartDim = HwcTestDim(100, 100);
+const bool defaultVerbose = false;
+
+const uint32_t defaultFormat = HAL_PIXEL_FORMAT_RGBA_8888;
+const int32_t defaultTransform = 0;
+const uint32_t defaultBlend = HWC_BLENDING_NONE;
+const ColorFract defaultColor(0.5, 0.5, 0.5);
+const float defaultAlpha = 1.0; // Opaque
+const HwcTestDim defaultSourceDim(1, 1);
+const struct hwc_rect defaultSourceCrop = {0, 0, 1, 1};
+const struct hwc_rect defaultDisplayFrame = {0, 0, 100, 100};
+
+// Global Constants
+const struct searchLimits {
+ uint32_t numOverlays;
+ HwcTestDim sourceCrop;
+} searchLimits = {
+ 10,
+ HwcTestDim(3000, 2000),
+};
+const struct transformType {
+ const char *desc;
+ uint32_t id;
+} transformType[] = {
+ {"fliph", HWC_TRANSFORM_FLIP_H},
+ {"flipv", HWC_TRANSFORM_FLIP_V},
+ {"rot90", HWC_TRANSFORM_ROT_90},
+ {"rot180", HWC_TRANSFORM_ROT_180},
+ {"rot270", HWC_TRANSFORM_ROT_270},
+};
+const struct blendType {
+ const char *desc;
+ uint32_t id;
+} blendType[] = {
+ {"none", HWC_BLENDING_NONE},
+ {"premult", HWC_BLENDING_PREMULT},
+ {"coverage", HWC_BLENDING_COVERAGE},
+};
+
+// Defines
+#define MAXCMD 200
+#define CMD_STOP_FRAMEWORK "stop 2>&1"
+#define CMD_START_FRAMEWORK "start 2>&1"
+
+// Macros
+#define NUMA(a) (sizeof(a) / sizeof(a [0])) // Num elements in an array
+
+// Local types
+class Rectangle {
+public:
+ Rectangle(uint32_t graphicFormat = defaultFormat,
+ HwcTestDim dfDim = HwcTestDim(1, 1),
+ HwcTestDim sDim = HwcTestDim(1, 1));
+ void setSourceDim(HwcTestDim dim);
+
+ uint32_t format;
+ uint32_t transform;
+ int32_t blend;
+ ColorFract color;
+ float alpha;
+ HwcTestDim sourceDim;
+ struct hwc_rect sourceCrop;
+ struct hwc_rect displayFrame;
+};
+
+class Range {
+public:
+ Range(void) : _l(0), _u(0) {}
+ Range(uint32_t lower, uint32_t upper) : _l(lower), _u(upper) {}
+ uint32_t lower(void) { return _l; }
+ uint32_t upper(void) { return _u; }
+
+ operator string();
+
+private:
+ uint32_t _l; // lower
+ uint32_t _u; // upper
+};
+
+Range::operator string()
+{
+ ostringstream out;
+
+ out << '[' << _l << ", " << _u << ']';
+
+ return out.str();
+}
+
+class Rational {
+public:
+ Rational(void) : _n(0), _d(1) {}
+ Rational(uint32_t n, uint32_t d) : _n(n), _d(d) {}
+ uint32_t numerator(void) { return _n; }
+ uint32_t denominator(void) { return _d; }
+ void setNumerator(uint32_t numerator) { _n = numerator; }
+
+ bool operator==(const Rational& other) const;
+ bool operator!=(const Rational& other) const { return !(*this == other); }
+ bool operator<(const Rational& other) const;
+ bool operator>(const Rational& other) const {
+ return (!(*this == other) && !(*this < other));
+ }
+ static void double2Rational(double f, Range nRange, Range dRange,
+ Rational& lower, Rational& upper);
+
+ operator string() const;
+ operator double() const { return (double) _n / (double) _d; }
+
+
+private:
+ uint32_t _n;
+ uint32_t _d;
+};
+
+// Globals
+static const int texUsage = GraphicBuffer::USAGE_HW_TEXTURE |
+ GraphicBuffer::USAGE_SW_WRITE_RARELY;
+static hwc_composer_device_t *hwcDevice;
+static EGLDisplay dpy;
+static EGLSurface surface;
+static EGLint width, height;
+
+// Measurements
+struct meas {
+ uint32_t format;
+ uint32_t startDimOverlays;
+ uint32_t maxNonOverlapping;
+ uint32_t maxOverlapping;
+ list<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<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);
+string transformList2str(const list<uint32_t>& transformList);
+string blendList2str(const list<uint32_t>& blendList);
+void init(void);
+void printSyntax(const char *cmd);
+
+// Command-line option settings
+static bool verbose = defaultVerbose;
+static HwcTestDim startDim = defaultStartDim;
+
+/*
+ * Main
+ *
+ * Performs the following high-level sequence of operations:
+ *
+ * 1. Command-line parsing
+ *
+ * 2. Form a list of command-line specified graphic formats. If
+ * no formats are specified, then form a list of all known formats.
+ *
+ * 3. Stop framework
+ * Only one user at a time is allowed to use the HWC. Surface
+ * Flinger uses the HWC and is part of the framework. Need to
+ * stop the framework so that Surface Flinger will stop using
+ * the HWC.
+ *
+ * 4. Initialization
+ *
+ * 5. For each graphic format in the previously formed list perform
+ * measurements on that format and report the results.
+ *
+ * 6. Start framework
+ */
+int
+main(int argc, char *argv[])
+{
+ int rv, opt;
+ char *chptr;
+ bool error;
+ string str;
+ char cmd[MAXCMD];
+ list<string> formats;
+ 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]);
+ }
+ }
+
+ // Stop framework
+ rv = snprintf(cmd, sizeof(cmd), "%s", CMD_STOP_FRAMEWORK);
+ if (rv >= (signed) sizeof(cmd) - 1) {
+ testPrintE("Command too long for: %s", CMD_STOP_FRAMEWORK);
+ exit(14);
+ }
+ testExecCmd(cmd);
+ testDelay(1.0); // TODO - needs means to query whether asynchronous stop
+ // framework operation has completed. For now, just wait
+ // a long time.
+
+ testPrintI("startDim: %s", ((string) startDim).c_str());
+
+ init();
+
+ // For each of the graphic formats
+ for (list<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());
+
+ }
+
+ // 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;
+}
+
+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_layer_list_t *hwcList;
+ list<sp<GraphicBuffer> > buffers;
+
+ hwcList = hwcTestCreateLayerList(rectList.size());
+ if (hwcList == NULL) {
+ testPrintE("numOverlays create hwcList failed");
+ exit(30);
+ }
+
+ hwc_layer_t *layer = &hwcList->hwLayers[0];
+ for (std::list<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, 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 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);
+ }
+}
OSDN Git Service
