1/*
2 * Copyright (C) 2016 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#include <sstream>
18#include <cutils/log.h>
19#include <ui/Rect.h>
20
21#define HWC2_INCLUDE_STRINGIFICATION
22#define HWC2_USE_CPP11
23#include <hardware/hwcomposer2.h>
24#undef HWC2_INCLUDE_STRINGIFICATION
25#undef HWC2_USE_CPP11
26
27#include "Hwc2TestBuffer.h"
28#include "Hwc2TestProperties.h"
29
30Hwc2TestBufferArea::Hwc2TestBufferArea(Hwc2TestCoverage coverage,
31        const Area& displayArea)
32    : Hwc2TestProperty(mBufferAreas, mCompositionSupport),
33      mScalars((coverage == Hwc2TestCoverage::Complete)? mCompleteScalars:
34            (coverage == Hwc2TestCoverage::Basic)? mBasicScalars:
35            mDefaultScalars),
36      mDisplayArea(displayArea)
37{
38    update();
39}
40
41std::string Hwc2TestBufferArea::dump() const
42{
43    std::stringstream dmp;
44    const Area& curr = get();
45    dmp << "\tbuffer area: width " << curr.width << ", height " << curr.height
46            << "\n";
47    return dmp.str();
48}
49
50void Hwc2TestBufferArea::setDependent(Hwc2TestBuffer* buffer)
51{
52    mBuffer = buffer;
53    if (buffer) {
54        buffer->updateBufferArea(get());
55    }
56}
57
58void Hwc2TestBufferArea::setDependent(Hwc2TestSourceCrop* sourceCrop)
59{
60    mSourceCrop = sourceCrop;
61    if (mSourceCrop) {
62        mSourceCrop->updateBufferArea(get());
63    }
64}
65
66void Hwc2TestBufferArea::setDependent(Hwc2TestSurfaceDamage* surfaceDamage)
67{
68    mSurfaceDamage = surfaceDamage;
69    if (mSurfaceDamage) {
70        mSurfaceDamage->updateBufferArea(get());
71    }
72}
73
74void Hwc2TestBufferArea::update()
75{
76    mBufferAreas.clear();
77
78    if (mDisplayArea.width == 0 && mDisplayArea.height == 0) {
79        mBufferAreas.push_back({0, 0});
80        return;
81    }
82
83    for (auto scalar : mScalars) {
84        mBufferAreas.push_back({static_cast<int32_t>(scalar * mDisplayArea.width),
85                static_cast<int32_t>(scalar * mDisplayArea.height)});
86    }
87
88    updateDependents();
89}
90
91void Hwc2TestBufferArea::updateDependents()
92{
93    const Area& curr = get();
94
95    if (mBuffer)
96        mBuffer->updateBufferArea(curr);
97    if (mSourceCrop)
98        mSourceCrop->updateBufferArea(curr);
99    if (mSurfaceDamage)
100        mSurfaceDamage->updateBufferArea(curr);
101}
102
103const std::vector<float> Hwc2TestBufferArea::mDefaultScalars = {
104    1.0f,
105};
106
107const std::vector<float> Hwc2TestBufferArea::mBasicScalars = {
108    1.0f, 0.5f,
109};
110
111const std::vector<float> Hwc2TestBufferArea::mCompleteScalars = {
112    1.0f, 0.75f, 0.5f
113};
114
115
116Hwc2TestBlendMode::Hwc2TestBlendMode(Hwc2TestCoverage coverage)
117    : Hwc2TestProperty(coverage, mCompleteBlendModes, mBasicBlendModes,
118            mDefaultBlendModes, mCompositionSupport) { }
119
120std::string Hwc2TestBlendMode::dump() const
121{
122    std::stringstream dmp;
123    dmp << "\tblend mode: " << getBlendModeName(get()) << "\n";
124    return dmp.str();
125}
126
127void Hwc2TestBlendMode::setDependent(Hwc2TestColor* color)
128{
129    mColor = color;
130    updateDependents();
131}
132
133void Hwc2TestBlendMode::updateDependents()
134{
135    if (mColor)
136        mColor->updateBlendMode(get());
137}
138
139const std::vector<hwc2_blend_mode_t> Hwc2TestBlendMode::mDefaultBlendModes = {
140    HWC2_BLEND_MODE_NONE,
141};
142
143const std::vector<hwc2_blend_mode_t> Hwc2TestBlendMode::mBasicBlendModes = {
144    HWC2_BLEND_MODE_NONE,
145    HWC2_BLEND_MODE_PREMULTIPLIED,
146};
147
148const std::vector<hwc2_blend_mode_t> Hwc2TestBlendMode::mCompleteBlendModes = {
149    HWC2_BLEND_MODE_NONE,
150    HWC2_BLEND_MODE_PREMULTIPLIED,
151    HWC2_BLEND_MODE_COVERAGE,
152};
153
154
155Hwc2TestColor::Hwc2TestColor(Hwc2TestCoverage coverage,
156        hwc2_blend_mode_t blendMode)
157    : Hwc2TestProperty(mColors, mCompositionSupport),
158      mBaseColors((coverage == Hwc2TestCoverage::Complete)? mCompleteBaseColors:
159            (coverage == Hwc2TestCoverage::Basic)? mBasicBaseColors:
160            mDefaultBaseColors),
161      mBlendMode(blendMode)
162{
163    update();
164}
165
166std::string Hwc2TestColor::dump() const
167{
168    std::stringstream dmp;
169    const hwc_color_t& color = get();
170    dmp << "\tcolor: r " << std::to_string(color.r) << ", g "
171            << std::to_string(color.g) << ", b " << std::to_string(color.b)
172            << ", a " << std::to_string(color.a) << "\n";
173    return dmp.str();
174}
175
176void Hwc2TestColor::updateBlendMode(hwc2_blend_mode_t blendMode)
177{
178    mBlendMode = blendMode;
179    update();
180}
181
182void Hwc2TestColor::update()
183{
184    if (mBlendMode != HWC2_BLEND_MODE_PREMULTIPLIED) {
185        mColors = mBaseColors;
186        return;
187    }
188
189    mColors.clear();
190
191    for (const hwc_color_t& baseColor : mBaseColors) {
192        if (baseColor.a >= baseColor.r && baseColor.a >= baseColor.g
193                && baseColor.a >= baseColor.b) {
194            mColors.push_back(baseColor);
195        }
196    }
197
198}
199
200const std::vector<hwc_color_t> Hwc2TestColor::mDefaultBaseColors = {
201    {UINT8_MAX, UINT8_MAX, UINT8_MAX, UINT8_MAX},
202};
203
204const std::vector<hwc_color_t> Hwc2TestColor::mBasicBaseColors = {
205    {UINT8_MAX, UINT8_MAX, UINT8_MAX, UINT8_MAX},
206    {        0,         0,         0,         0},
207};
208
209const std::vector<hwc_color_t> Hwc2TestColor::mCompleteBaseColors = {
210    {UINT8_MAX, UINT8_MAX, UINT8_MAX, UINT8_MAX},
211    {UINT8_MAX, UINT8_MAX, UINT8_MAX,         0},
212    {UINT8_MAX, UINT8_MAX,         0, UINT8_MAX},
213    {UINT8_MAX, UINT8_MAX,         0,         0},
214    {UINT8_MAX,         0, UINT8_MAX, UINT8_MAX},
215    {UINT8_MAX,         0, UINT8_MAX,         0},
216    {UINT8_MAX,         0,         0, UINT8_MAX},
217    {UINT8_MAX,         0,         0,         0},
218    {        0, UINT8_MAX, UINT8_MAX, UINT8_MAX},
219    {        0, UINT8_MAX, UINT8_MAX,         0},
220    {        0, UINT8_MAX,         0, UINT8_MAX},
221    {        0, UINT8_MAX,         0,         0},
222    {        0,         0, UINT8_MAX, UINT8_MAX},
223    {        0,         0, UINT8_MAX,         0},
224    {        0,         0,         0, UINT8_MAX},
225    {        0,         0,         0,         0},
226};
227
228
229Hwc2TestComposition::Hwc2TestComposition(Hwc2TestCoverage coverage)
230    : Hwc2TestProperty(coverage, mCompleteCompositions, mBasicCompositions,
231            mDefaultCompositions, mCompositionSupport) { }
232
233std::string Hwc2TestComposition::dump() const
234{
235    std::stringstream dmp;
236    dmp << "\tcomposition: " << getCompositionName(get()) << "\n";
237    return dmp.str();
238}
239
240const std::vector<hwc2_composition_t> Hwc2TestComposition::mDefaultCompositions = {
241    HWC2_COMPOSITION_DEVICE,
242};
243
244const std::vector<hwc2_composition_t> Hwc2TestComposition::mBasicCompositions = {
245    HWC2_COMPOSITION_CLIENT,
246    HWC2_COMPOSITION_DEVICE,
247};
248
249const std::vector<hwc2_composition_t> Hwc2TestComposition::mCompleteCompositions = {
250    HWC2_COMPOSITION_CLIENT,
251    HWC2_COMPOSITION_DEVICE,
252    HWC2_COMPOSITION_SOLID_COLOR,
253    HWC2_COMPOSITION_CURSOR,
254    HWC2_COMPOSITION_SIDEBAND,
255};
256
257
258Hwc2TestDataspace::Hwc2TestDataspace(Hwc2TestCoverage coverage)
259    : Hwc2TestProperty(coverage, completeDataspaces, basicDataspaces,
260            defaultDataspaces, mCompositionSupport) { }
261
262std::string Hwc2TestDataspace::dump() const
263{
264    std::stringstream dmp;
265    dmp << "\tdataspace: " << get() << "\n";
266    return dmp.str();
267}
268
269const std::vector<android_dataspace_t> Hwc2TestDataspace::defaultDataspaces = {
270    HAL_DATASPACE_UNKNOWN,
271};
272
273const std::vector<android_dataspace_t> Hwc2TestDataspace::basicDataspaces = {
274    HAL_DATASPACE_UNKNOWN,
275    HAL_DATASPACE_V0_SRGB,
276};
277
278const std::vector<android_dataspace_t> Hwc2TestDataspace::completeDataspaces = {
279    HAL_DATASPACE_UNKNOWN,
280    HAL_DATASPACE_ARBITRARY,
281    HAL_DATASPACE_STANDARD_SHIFT,
282    HAL_DATASPACE_STANDARD_MASK,
283    HAL_DATASPACE_STANDARD_UNSPECIFIED,
284    HAL_DATASPACE_STANDARD_BT709,
285    HAL_DATASPACE_STANDARD_BT601_625,
286    HAL_DATASPACE_STANDARD_BT601_625_UNADJUSTED,
287    HAL_DATASPACE_STANDARD_BT601_525,
288    HAL_DATASPACE_STANDARD_BT601_525_UNADJUSTED,
289    HAL_DATASPACE_STANDARD_BT2020,
290    HAL_DATASPACE_STANDARD_BT2020_CONSTANT_LUMINANCE,
291    HAL_DATASPACE_STANDARD_BT470M,
292    HAL_DATASPACE_STANDARD_FILM,
293    HAL_DATASPACE_TRANSFER_SHIFT,
294    HAL_DATASPACE_TRANSFER_MASK,
295    HAL_DATASPACE_TRANSFER_UNSPECIFIED,
296    HAL_DATASPACE_TRANSFER_LINEAR,
297    HAL_DATASPACE_TRANSFER_SRGB,
298    HAL_DATASPACE_TRANSFER_SMPTE_170M,
299    HAL_DATASPACE_TRANSFER_GAMMA2_2,
300    HAL_DATASPACE_TRANSFER_GAMMA2_8,
301    HAL_DATASPACE_TRANSFER_ST2084,
302    HAL_DATASPACE_TRANSFER_HLG,
303    HAL_DATASPACE_RANGE_SHIFT,
304    HAL_DATASPACE_RANGE_MASK,
305    HAL_DATASPACE_RANGE_UNSPECIFIED,
306    HAL_DATASPACE_RANGE_FULL,
307    HAL_DATASPACE_RANGE_LIMITED,
308    HAL_DATASPACE_SRGB_LINEAR,
309    HAL_DATASPACE_V0_SRGB_LINEAR,
310    HAL_DATASPACE_SRGB,
311    HAL_DATASPACE_V0_SRGB,
312    HAL_DATASPACE_JFIF,
313    HAL_DATASPACE_V0_JFIF,
314    HAL_DATASPACE_BT601_625,
315    HAL_DATASPACE_V0_BT601_625,
316    HAL_DATASPACE_BT601_525,
317    HAL_DATASPACE_V0_BT601_525,
318    HAL_DATASPACE_BT709,
319    HAL_DATASPACE_V0_BT709,
320    HAL_DATASPACE_DEPTH,
321};
322
323
324Hwc2TestDisplayDimension::Hwc2TestDisplayDimension(Hwc2TestCoverage coverage)
325    : Hwc2TestProperty(
326            (coverage == Hwc2TestCoverage::Complete)? mCompleteDisplayDimensions:
327            (coverage == Hwc2TestCoverage::Basic)? mBasicDisplayDimensions:
328            mDefaultDisplayDimensions, mCompositionSupport) { }
329
330std::string Hwc2TestDisplayDimension::dump() const
331{
332    std::stringstream dmp;
333    const UnsignedArea& curr = get();
334    dmp << "\tdisplay dimension: " << curr.width<< " x " << curr.height<< "\n";
335    return dmp.str();
336}
337
338void Hwc2TestDisplayDimension::setDependent(Hwc2TestBuffer* buffer)
339{
340    mBuffer = buffer;
341    updateDependents();
342}
343
344void Hwc2TestDisplayDimension::updateDependents()
345{
346    const UnsignedArea& curr = get();
347
348    if (mBuffer)
349        mBuffer->updateBufferArea({static_cast<int32_t>(curr.width),
350                static_cast<int32_t>(curr.height)});
351}
352
353const std::vector<UnsignedArea>
354        Hwc2TestDisplayDimension::mDefaultDisplayDimensions = {
355    {1920, 1080},
356};
357
358const std::vector<UnsignedArea>
359        Hwc2TestDisplayDimension::mBasicDisplayDimensions = {
360    {640, 480},
361    {1280, 720},
362    {1920, 1080},
363    {1920, 1200},
364};
365
366const std::vector<UnsignedArea>
367        Hwc2TestDisplayDimension::mCompleteDisplayDimensions = {
368    {320, 240},
369    {480, 320},
370    {640, 480},
371    {1280, 720},
372    {1920, 1080},
373    {1920, 1200},
374    {2560, 1440},
375    {2560, 1600},
376    {3840, 2160},
377    {4096, 2160},
378};
379
380
381Hwc2TestDisplayFrame::Hwc2TestDisplayFrame(Hwc2TestCoverage coverage,
382        const Area& displayArea)
383    : Hwc2TestProperty(mDisplayFrames, mCompositionSupport),
384      mFrectScalars((coverage == Hwc2TestCoverage::Complete)? mCompleteFrectScalars:
385            (coverage == Hwc2TestCoverage::Basic)? mBasicFrectScalars:
386            mDefaultFrectScalars),
387      mDisplayArea(displayArea)
388{
389    update();
390}
391
392std::string Hwc2TestDisplayFrame::dump() const
393{
394    std::stringstream dmp;
395    const hwc_rect_t& displayFrame = get();
396    dmp << "\tdisplay frame: left " << displayFrame.left << ", top "
397            << displayFrame.top << ", right " << displayFrame.right
398            << ", bottom " << displayFrame.bottom << "\n";
399    return dmp.str();
400}
401
402void Hwc2TestDisplayFrame::update()
403{
404    mDisplayFrames.clear();
405
406    if (mDisplayArea.width == 0 && mDisplayArea.height == 0) {
407        mDisplayFrames.push_back({0, 0, 0, 0});
408        return;
409    }
410
411    for (const auto& frectScalar : mFrectScalars) {
412        mDisplayFrames.push_back({
413                static_cast<int>(frectScalar.left * mDisplayArea.width),
414                static_cast<int>(frectScalar.top * mDisplayArea.height),
415                static_cast<int>(frectScalar.right * mDisplayArea.width),
416                static_cast<int>(frectScalar.bottom * mDisplayArea.height)});
417    }
418}
419
420const std::vector<hwc_frect_t> Hwc2TestDisplayFrame::mDefaultFrectScalars = {
421    {0.0, 0.0, 1.0, 1.0},
422};
423
424const std::vector<hwc_frect_t> Hwc2TestDisplayFrame::mBasicFrectScalars = {
425    {0.0, 0.0, 1.0, 1.0},
426    {0.0, 0.0, 1.0, 0.05},
427    {0.0, 0.95, 1.0, 1.0},
428};
429
430const std::vector<hwc_frect_t> Hwc2TestDisplayFrame::mCompleteFrectScalars = {
431    {0.0, 0.0, 1.0, 1.0},
432    {0.0, 0.05, 1.0, 0.95},
433    {0.0, 0.05, 1.0, 1.0},
434    {0.0, 0.0, 1.0, 0.05},
435    {0.0, 0.95, 1.0, 1.0},
436    {0.25, 0.0, 0.75, 0.35},
437    {0.25, 0.25, 0.75, 0.75},
438};
439
440
441Hwc2TestPlaneAlpha::Hwc2TestPlaneAlpha(Hwc2TestCoverage coverage)
442    : Hwc2TestProperty(coverage, mCompletePlaneAlphas, mBasicPlaneAlphas,
443            mDefaultPlaneAlphas, mCompositionSupport) { }
444
445std::string Hwc2TestPlaneAlpha::dump() const
446{
447    std::stringstream dmp;
448    dmp << "\tplane alpha: " << get() << "\n";
449    return dmp.str();
450}
451
452const std::vector<float> Hwc2TestPlaneAlpha::mDefaultPlaneAlphas = {
453    1.0f,
454};
455
456const std::vector<float> Hwc2TestPlaneAlpha::mBasicPlaneAlphas = {
457    1.0f, 0.0f,
458};
459
460const std::vector<float> Hwc2TestPlaneAlpha::mCompletePlaneAlphas = {
461    1.0f, 0.75f, 0.5f, 0.25f, 0.0f,
462};
463
464
465Hwc2TestSourceCrop::Hwc2TestSourceCrop(Hwc2TestCoverage coverage,
466        const Area& bufferArea)
467    : Hwc2TestProperty(mSourceCrops, mCompositionSupport),
468      mFrectScalars((coverage == Hwc2TestCoverage::Complete)? mCompleteFrectScalars:
469            (coverage == Hwc2TestCoverage::Basic)? mBasicFrectScalars:
470            mDefaultFrectScalars),
471      mBufferArea(bufferArea)
472{
473    update();
474}
475
476std::string Hwc2TestSourceCrop::dump() const
477{
478    std::stringstream dmp;
479    const hwc_frect_t& sourceCrop = get();
480    dmp << "\tsource crop: left " << sourceCrop.left << ", top "
481            << sourceCrop.top << ", right " << sourceCrop.right << ", bottom "
482            << sourceCrop.bottom << "\n";
483    return dmp.str();
484}
485
486void Hwc2TestSourceCrop::updateBufferArea(const Area& bufferArea)
487{
488    mBufferArea = bufferArea;
489    update();
490}
491
492void Hwc2TestSourceCrop::update()
493{
494    mSourceCrops.clear();
495
496    if (mBufferArea.width == 0 && mBufferArea.height == 0) {
497        mSourceCrops.push_back({0, 0, 0, 0});
498        return;
499    }
500
501    for (const auto& frectScalar : mFrectScalars) {
502        mSourceCrops.push_back({
503                frectScalar.left * mBufferArea.width,
504                frectScalar.top * mBufferArea.height,
505                frectScalar.right * mBufferArea.width,
506                frectScalar.bottom * mBufferArea.height});
507    }
508}
509
510const std::vector<hwc_frect_t> Hwc2TestSourceCrop::mDefaultFrectScalars = {
511    {0.0, 0.0, 1.0, 1.0},
512};
513
514const std::vector<hwc_frect_t> Hwc2TestSourceCrop::mBasicFrectScalars = {
515    {0.0, 0.0, 1.0, 1.0},
516    {0.0, 0.0, 0.5, 0.5},
517    {0.5, 0.5, 1.0, 1.0},
518};
519
520const std::vector<hwc_frect_t> Hwc2TestSourceCrop::mCompleteFrectScalars = {
521    {0.0, 0.0, 1.0, 1.0},
522    {0.0, 0.0, 0.5, 0.5},
523    {0.5, 0.5, 1.0, 1.0},
524    {0.0, 0.0, 0.25, 0.25},
525    {0.25, 0.25, 0.75, 0.75},
526};
527
528
529Hwc2TestSurfaceDamage::Hwc2TestSurfaceDamage(Hwc2TestCoverage coverage)
530    : Hwc2TestProperty(mSurfaceDamages, mCompositionSupport),
531      mRegionScalars((coverage == Hwc2TestCoverage::Complete)? mCompleteRegionScalars:
532            (coverage == Hwc2TestCoverage::Basic)? mBasicRegionScalars:
533            mDefaultRegionScalars)
534{
535    update();
536}
537
538Hwc2TestSurfaceDamage::~Hwc2TestSurfaceDamage()
539{
540    freeSurfaceDamages();
541}
542
543std::string Hwc2TestSurfaceDamage::dump() const
544{
545    std::stringstream dmp;
546
547    const hwc_region_t& curr = get();
548    dmp << "\tsurface damage: region count " << curr.numRects << "\n";
549    for (size_t i = 0; i < curr.numRects; i++) {
550        const hwc_rect_t& rect = curr.rects[i];
551        dmp << "\t\trect: left " << rect.left << ", top " << rect.top
552                << ", right " << rect.right << ", bottom " << rect.bottom << "\n";
553    }
554
555    return dmp.str();
556}
557
558void Hwc2TestSurfaceDamage::updateBufferArea(const Area& bufferArea)
559{
560    mBufferArea = bufferArea;
561    update();
562}
563
564void Hwc2TestSurfaceDamage::update()
565{
566    freeSurfaceDamages();
567
568    if (mBufferArea.width == 0 && mBufferArea.height == 0) {
569        mSurfaceDamages.push_back({0, nullptr});
570        return;
571    }
572
573    hwc_region_t damage;
574
575    for (const auto& regionScalar : mRegionScalars) {
576        damage.numRects = regionScalar.size();
577
578        if (damage.numRects > 0) {
579            hwc_rect_t* rects = new hwc_rect_t[damage.numRects];
580            if (!rects) {
581                ALOGW("failed to allocate new hwc_rect_t array");
582                continue;
583            }
584
585            for (size_t i = 0; i < damage.numRects; i++) {
586                rects[i].left = regionScalar[i].left * mBufferArea.width;
587                rects[i].top = regionScalar[i].top * mBufferArea.height;
588                rects[i].right = regionScalar[i].right * mBufferArea.width;
589                rects[i].bottom = regionScalar[i].bottom * mBufferArea.height;
590            }
591
592            damage.rects = static_cast<hwc_rect_t const*>(rects);
593        } else {
594            damage.rects = nullptr;
595        }
596
597        mSurfaceDamages.push_back(damage);
598    }
599}
600
601void Hwc2TestSurfaceDamage::freeSurfaceDamages()
602{
603    for (const auto& surfaceDamage : mSurfaceDamages) {
604        if (surfaceDamage.numRects > 0 && surfaceDamage.rects)
605            delete[] surfaceDamage.rects;
606    }
607    mSurfaceDamages.clear();
608}
609
610const std::vector<std::vector<hwc_frect_t>> Hwc2TestSurfaceDamage::mDefaultRegionScalars = {
611    {{}},
612};
613
614const std::vector<std::vector<hwc_frect_t>> Hwc2TestSurfaceDamage::mBasicRegionScalars = {
615    {{}},
616    {{0.0, 0.0, 1.0, 1.0}},
617};
618
619const std::vector<std::vector<hwc_frect_t>> Hwc2TestSurfaceDamage::mCompleteRegionScalars = {
620    {{}},
621    {{0.0, 0.0, 1.0, 1.0}},
622    {{0.0, 0.0, 0.5, 0.5}, {0.5, 0.5, 1.0, 1.0}},
623};
624
625
626Hwc2TestTransform::Hwc2TestTransform(Hwc2TestCoverage coverage)
627    : Hwc2TestProperty(coverage, mCompleteTransforms, mBasicTransforms,
628            mDefaultTransforms, mCompositionSupport) { }
629
630std::string Hwc2TestTransform::dump() const
631{
632    std::stringstream dmp;
633    dmp << "\ttransform: " << getTransformName(get()) << "\n";
634    return dmp.str();
635}
636
637const std::vector<hwc_transform_t> Hwc2TestTransform::mDefaultTransforms = {
638    static_cast<hwc_transform_t>(0),
639};
640
641const std::vector<hwc_transform_t> Hwc2TestTransform::mBasicTransforms = {
642    static_cast<hwc_transform_t>(0),
643    HWC_TRANSFORM_FLIP_H,
644    HWC_TRANSFORM_FLIP_V,
645    HWC_TRANSFORM_ROT_90,
646};
647
648const std::vector<hwc_transform_t> Hwc2TestTransform::mCompleteTransforms = {
649    static_cast<hwc_transform_t>(0),
650    HWC_TRANSFORM_FLIP_H,
651    HWC_TRANSFORM_FLIP_V,
652    HWC_TRANSFORM_ROT_90,
653    HWC_TRANSFORM_ROT_180,
654    HWC_TRANSFORM_ROT_270,
655    HWC_TRANSFORM_FLIP_H_ROT_90,
656    HWC_TRANSFORM_FLIP_V_ROT_90,
657};
658
659
660Hwc2TestVisibleRegion::~Hwc2TestVisibleRegion()
661{
662    release();
663}
664
665std::string Hwc2TestVisibleRegion::dump() const
666{
667    std::stringstream dmp;
668
669    const hwc_region_t& curr = get();
670    dmp << "\tvisible region: region count " << curr.numRects << "\n";
671    for (size_t i = 0; i < curr.numRects; i++) {
672        const hwc_rect_t& rect = curr.rects[i];
673        dmp << "\t\trect: left " << rect.left << ", top " << rect.top
674                << ", right " << rect.right << ", bottom " << rect.bottom << "\n";
675    }
676
677    return dmp.str();
678}
679
680void Hwc2TestVisibleRegion::set(const android::Region& visibleRegion)
681{
682    release();
683
684    size_t size = 0;
685    const android::Rect* rects = visibleRegion.getArray(&size);
686
687    mVisibleRegion.numRects = size;
688    mVisibleRegion.rects = nullptr;
689
690    if (size > 0) {
691        hwc_rect_t* hwcRects = new hwc_rect_t[size];
692        for (size_t i = 0; i < size; i++) {
693            hwcRects[i].left = rects[i].left;
694            hwcRects[i].top = rects[i].top;
695            hwcRects[i].right = rects[i].right;
696            hwcRects[i].bottom = rects[i].bottom;
697        }
698        mVisibleRegion.rects = hwcRects;
699    }
700}
701
702hwc_region_t Hwc2TestVisibleRegion::get() const
703{
704    return mVisibleRegion;
705}
706
707void Hwc2TestVisibleRegion::release()
708{
709    if (mVisibleRegion.numRects > 0 && mVisibleRegion.rects)
710        delete[] mVisibleRegion.rects;
711    mVisibleRegion.rects = nullptr;
712    mVisibleRegion.numRects = 0;
713}
714
715/* Identifies which layer properties are supported by each composition type.
716 * hwc2_composition_t values range from:
717 *  HWC2_COMPOSITION_INVALID = 0,
718 *  HWC2_COMPOSITION_CLIENT = 1,
719 *  HWC2_COMPOSITION_DEVICE = 2,
720 *  HWC2_COMPOSITION_SOLID_COLOR = 3,
721 *  HWC2_COMPOSITION_CURSOR = 4,
722 *  HWC2_COMPOSITION_SIDEBAND = 5,
723 *
724 * Each property array can be indexed by a hwc2_composition_t value.
725 * By using an array instead of a more complex data structure, runtimes for
726 * some test cases showed a noticeable improvement.
727 */
728
729/*  INVALID  CLIENT   DEVICE   COLOR    CURSOR   SIDEBAND */
730const std::array<bool, 6> Hwc2TestBufferArea::mCompositionSupport = {{
731    false,   true,    true,    false,   true,    true,
732}};
733
734/*  INVALID  CLIENT   DEVICE   COLOR    CURSOR   SIDEBAND */
735const std::array<bool, 6> Hwc2TestBlendMode::mCompositionSupport = {{
736    false,   true,    true,    false,   true,    true,
737}};
738
739/*  INVALID  CLIENT   DEVICE   COLOR    CURSOR   SIDEBAND */
740const std::array<bool, 6> Hwc2TestColor::mCompositionSupport = {{
741    false,   false,   false,   true,    false,   false,
742}};
743
744/*  INVALID  CLIENT   DEVICE   COLOR    CURSOR   SIDEBAND */
745const std::array<bool, 6> Hwc2TestComposition::mCompositionSupport = {{
746    false,   true,    true,    true,    true,    true,
747}};
748
749/*  INVALID  CLIENT   DEVICE   COLOR    CURSOR   SIDEBAND */
750const std::array<bool, 6> Hwc2TestDataspace::mCompositionSupport = {{
751    false,   true,    true,    true,    true,    false,
752}};
753
754/*  INVALID  CLIENT   DEVICE   COLOR    CURSOR   SIDEBAND */
755const std::array<bool, 6> Hwc2TestDisplayDimension::mCompositionSupport = {{
756    false,   true,    true,    true,    true,    true,
757}};
758
759/*  INVALID  CLIENT   DEVICE   COLOR    CURSOR   SIDEBAND */
760const std::array<bool, 6> Hwc2TestDisplayFrame::mCompositionSupport = {{
761    false,   true,    true,    true,    false,   true,
762}};
763
764/*  INVALID  CLIENT   DEVICE   COLOR    CURSOR   SIDEBAND */
765const std::array<bool, 6> Hwc2TestPlaneAlpha::mCompositionSupport = {{
766    false,   true,    true,    true,    true,    true,
767}};
768
769/*  INVALID  CLIENT   DEVICE   COLOR    CURSOR   SIDEBAND */
770const std::array<bool, 6> Hwc2TestSourceCrop::mCompositionSupport = {{
771    false,   true,    true,    false,   true,    false,
772}};
773
774/*  INVALID  CLIENT   DEVICE   COLOR    CURSOR   SIDEBAND */
775const std::array<bool, 6> Hwc2TestSurfaceDamage::mCompositionSupport = {{
776    false,   false,   true,    false,   true,    false,
777}};
778
779/*  INVALID  CLIENT   DEVICE   COLOR    CURSOR   SIDEBAND */
780const std::array<bool, 6> Hwc2TestTransform::mCompositionSupport = {{
781    false,   true,    true,    false,   true,    true,
782}};
783