HWC2.cpp revision 0e7a791d51e92aafefd416044a2d38b6eec22a00 
1/*
2 * Copyright 2015 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// #define LOG_NDEBUG 0
18
19#undef LOG_TAG
20#define LOG_TAG "HWC2"
21#define ATRACE_TAG ATRACE_TAG_GRAPHICS
22
23#include "HWC2.h"
24#include "ComposerHal.h"
25
26#include <ui/Fence.h>
27#include <ui/FloatRect.h>
28#include <ui/GraphicBuffer.h>
29#include <ui/Region.h>
30
31#include <android/configuration.h>
32
33#include <algorithm>
34#include <inttypes.h>
35
36using android::Fence;
37using android::FloatRect;
38using android::GraphicBuffer;
39using android::HdrCapabilities;
40using android::HdrMetadata;
41using android::Rect;
42using android::Region;
43using android::sp;
44using android::hardware::Return;
45using android::hardware::Void;
46
47namespace HWC2 {
48
49namespace Hwc2 = android::Hwc2;
50using android::ui::ColorMode;
51using android::ui::Dataspace;
52using android::ui::PixelFormat;
53using android::ui::RenderIntent;
54
55namespace {
56
57class ComposerCallbackBridge : public Hwc2::IComposerCallback {
58public:
59    ComposerCallbackBridge(ComposerCallback* callback, int32_t sequenceId)
60            : mCallback(callback), mSequenceId(sequenceId) {}
61
62    Return<void> onHotplug(Hwc2::Display display,
63                           IComposerCallback::Connection conn) override
64    {
65        HWC2::Connection connection = static_cast<HWC2::Connection>(conn);
66        mCallback->onHotplugReceived(mSequenceId, display, connection);
67        return Void();
68    }
69
70    Return<void> onRefresh(Hwc2::Display display) override
71    {
72        mCallback->onRefreshReceived(mSequenceId, display);
73        return Void();
74    }
75
76    Return<void> onVsync(Hwc2::Display display, int64_t timestamp) override
77    {
78        mCallback->onVsyncReceived(mSequenceId, display, timestamp);
79        return Void();
80    }
81
82private:
83    ComposerCallback* mCallback;
84    int32_t mSequenceId;
85};
86
87} // namespace anonymous
88
89
90// Device methods
91
92Device::Device(std::unique_ptr<android::Hwc2::Composer> composer) : mComposer(std::move(composer)) {
93    loadCapabilities();
94}
95
96void Device::registerCallback(ComposerCallback* callback, int32_t sequenceId) {
97    if (mRegisteredCallback) {
98        ALOGW("Callback already registered. Ignored extra registration "
99                "attempt.");
100        return;
101    }
102    mRegisteredCallback = true;
103    sp<ComposerCallbackBridge> callbackBridge(
104            new ComposerCallbackBridge(callback, sequenceId));
105    mComposer->registerCallback(callbackBridge);
106}
107
108// Required by HWC2 device
109
110std::string Device::dump() const
111{
112    return mComposer->dumpDebugInfo();
113}
114
115uint32_t Device::getMaxVirtualDisplayCount() const
116{
117    return mComposer->getMaxVirtualDisplayCount();
118}
119
120Error Device::createVirtualDisplay(uint32_t width, uint32_t height,
121        PixelFormat* format, Display** outDisplay)
122{
123    ALOGI("Creating virtual display");
124
125    hwc2_display_t displayId = 0;
126    auto intError = mComposer->createVirtualDisplay(width, height,
127            format, &displayId);
128    auto error = static_cast<Error>(intError);
129    if (error != Error::None) {
130        return error;
131    }
132
133    auto display = std::make_unique<Display>(
134            *mComposer.get(), mCapabilities, displayId, DisplayType::Virtual);
135    display->setConnected(true);
136    *outDisplay = display.get();
137    mDisplays.emplace(displayId, std::move(display));
138    ALOGI("Created virtual display");
139    return Error::None;
140}
141
142void Device::destroyDisplay(hwc2_display_t displayId)
143{
144    ALOGI("Destroying display %" PRIu64, displayId);
145    mDisplays.erase(displayId);
146}
147
148void Device::onHotplug(hwc2_display_t displayId, Connection connection) {
149    if (connection == Connection::Connected) {
150        // If we get a hotplug connected event for a display we already have,
151        // destroy the display and recreate it. This will force us to requery
152        // the display params and recreate all layers on that display.
153        auto oldDisplay = getDisplayById(displayId);
154        if (oldDisplay != nullptr && oldDisplay->isConnected()) {
155            ALOGI("Hotplug connecting an already connected display."
156                    " Clearing old display state.");
157        }
158        mDisplays.erase(displayId);
159
160        DisplayType displayType;
161        auto intError = mComposer->getDisplayType(displayId,
162                reinterpret_cast<Hwc2::IComposerClient::DisplayType *>(
163                        &displayType));
164        auto error = static_cast<Error>(intError);
165        if (error != Error::None) {
166            ALOGE("getDisplayType(%" PRIu64 ") failed: %s (%d). "
167                    "Aborting hotplug attempt.",
168                    displayId, to_string(error).c_str(), intError);
169            return;
170        }
171
172        auto newDisplay = std::make_unique<Display>(
173                *mComposer.get(), mCapabilities, displayId, displayType);
174        newDisplay->setConnected(true);
175        mDisplays.emplace(displayId, std::move(newDisplay));
176    } else if (connection == Connection::Disconnected) {
177        // The display will later be destroyed by a call to
178        // destroyDisplay(). For now we just mark it disconnected.
179        auto display = getDisplayById(displayId);
180        if (display) {
181            display->setConnected(false);
182        } else {
183            ALOGW("Attempted to disconnect unknown display %" PRIu64,
184                  displayId);
185        }
186    }
187}
188
189// Other Device methods
190
191Display* Device::getDisplayById(hwc2_display_t id) {
192    auto iter = mDisplays.find(id);
193    return iter == mDisplays.end() ? nullptr : iter->second.get();
194}
195
196// Device initialization methods
197
198void Device::loadCapabilities()
199{
200    static_assert(sizeof(Capability) == sizeof(int32_t),
201            "Capability size has changed");
202    auto capabilities = mComposer->getCapabilities();
203    for (auto capability : capabilities) {
204        mCapabilities.emplace(static_cast<Capability>(capability));
205    }
206}
207
208Error Device::flushCommands()
209{
210    return static_cast<Error>(mComposer->executeCommands());
211}
212
213// Display methods
214
215Display::Display(android::Hwc2::Composer& composer,
216                 const std::unordered_set<Capability>& capabilities, hwc2_display_t id,
217                 DisplayType type)
218      : mComposer(composer),
219        mCapabilities(capabilities),
220        mId(id),
221        mIsConnected(false),
222        mType(type) {
223    ALOGV("Created display %" PRIu64, id);
224}
225
226Display::~Display() {
227    mLayers.clear();
228
229    if (mType == DisplayType::Virtual) {
230        ALOGV("Destroying virtual display");
231        auto intError = mComposer.destroyVirtualDisplay(mId);
232        auto error = static_cast<Error>(intError);
233        ALOGE_IF(error != Error::None, "destroyVirtualDisplay(%" PRIu64
234                ") failed: %s (%d)", mId, to_string(error).c_str(), intError);
235    } else if (mType == DisplayType::Physical) {
236        auto error = setVsyncEnabled(HWC2::Vsync::Disable);
237        if (error != Error::None) {
238            ALOGE("~Display: Failed to disable vsync for display %" PRIu64
239                    ": %s (%d)", mId, to_string(error).c_str(),
240                    static_cast<int32_t>(error));
241        }
242    }
243}
244
245Display::Config::Config(Display& display, hwc2_config_t id)
246  : mDisplay(display),
247    mId(id),
248    mWidth(-1),
249    mHeight(-1),
250    mVsyncPeriod(-1),
251    mDpiX(-1),
252    mDpiY(-1) {}
253
254Display::Config::Builder::Builder(Display& display, hwc2_config_t id)
255  : mConfig(new Config(display, id)) {}
256
257float Display::Config::Builder::getDefaultDensity() {
258    // Default density is based on TVs: 1080p displays get XHIGH density, lower-
259    // resolution displays get TV density. Maybe eventually we'll need to update
260    // it for 4k displays, though hopefully those will just report accurate DPI
261    // information to begin with. This is also used for virtual displays and
262    // older HWC implementations, so be careful about orientation.
263
264    auto longDimension = std::max(mConfig->mWidth, mConfig->mHeight);
265    if (longDimension >= 1080) {
266        return ACONFIGURATION_DENSITY_XHIGH;
267    } else {
268        return ACONFIGURATION_DENSITY_TV;
269    }
270}
271
272// Required by HWC2 display
273
274Error Display::acceptChanges()
275{
276    auto intError = mComposer.acceptDisplayChanges(mId);
277    return static_cast<Error>(intError);
278}
279
280Error Display::createLayer(Layer** outLayer)
281{
282    if (!outLayer) {
283        return Error::BadParameter;
284    }
285    hwc2_layer_t layerId = 0;
286    auto intError = mComposer.createLayer(mId, &layerId);
287    auto error = static_cast<Error>(intError);
288    if (error != Error::None) {
289        return error;
290    }
291
292    auto layer = std::make_unique<Layer>(
293            mComposer, mCapabilities, mId, layerId);
294    *outLayer = layer.get();
295    mLayers.emplace(layerId, std::move(layer));
296    return Error::None;
297}
298
299Error Display::destroyLayer(Layer* layer)
300{
301    if (!layer) {
302        return Error::BadParameter;
303    }
304    mLayers.erase(layer->getId());
305    return Error::None;
306}
307
308Error Display::getActiveConfig(
309        std::shared_ptr<const Display::Config>* outConfig) const
310{
311    ALOGV("[%" PRIu64 "] getActiveConfig", mId);
312    hwc2_config_t configId = 0;
313    auto intError = mComposer.getActiveConfig(mId, &configId);
314    auto error = static_cast<Error>(intError);
315
316    if (error != Error::None) {
317        ALOGE("Unable to get active config for mId:[%" PRIu64 "]", mId);
318        *outConfig = nullptr;
319        return error;
320    }
321
322    if (mConfigs.count(configId) != 0) {
323        *outConfig = mConfigs.at(configId);
324    } else {
325        ALOGE("[%" PRIu64 "] getActiveConfig returned unknown config %u", mId,
326                configId);
327        // Return no error, but the caller needs to check for a null pointer to
328        // detect this case
329        *outConfig = nullptr;
330    }
331
332    return Error::None;
333}
334
335Error Display::getChangedCompositionTypes(
336        std::unordered_map<Layer*, Composition>* outTypes)
337{
338    std::vector<Hwc2::Layer> layerIds;
339    std::vector<Hwc2::IComposerClient::Composition> types;
340    auto intError = mComposer.getChangedCompositionTypes(
341            mId, &layerIds, &types);
342    uint32_t numElements = layerIds.size();
343    auto error = static_cast<Error>(intError);
344    error = static_cast<Error>(intError);
345    if (error != Error::None) {
346        return error;
347    }
348
349    outTypes->clear();
350    outTypes->reserve(numElements);
351    for (uint32_t element = 0; element < numElements; ++element) {
352        auto layer = getLayerById(layerIds[element]);
353        if (layer) {
354            auto type = static_cast<Composition>(types[element]);
355            ALOGV("getChangedCompositionTypes: adding %" PRIu64 " %s",
356                    layer->getId(), to_string(type).c_str());
357            outTypes->emplace(layer, type);
358        } else {
359            ALOGE("getChangedCompositionTypes: invalid layer %" PRIu64 " found"
360                    " on display %" PRIu64, layerIds[element], mId);
361        }
362    }
363
364    return Error::None;
365}
366
367Error Display::getColorModes(std::vector<ColorMode>* outModes) const
368{
369    auto intError = mComposer.getColorModes(mId, outModes);
370    return static_cast<Error>(intError);
371}
372
373Error Display::getRenderIntents(ColorMode colorMode,
374        std::vector<RenderIntent>* outRenderIntents) const
375{
376    auto intError = mComposer.getRenderIntents(mId, colorMode, outRenderIntents);
377    return static_cast<Error>(intError);
378}
379
380Error Display::getDataspaceSaturationMatrix(Dataspace dataspace, android::mat4* outMatrix)
381{
382    auto intError = mComposer.getDataspaceSaturationMatrix(dataspace, outMatrix);
383    return static_cast<Error>(intError);
384}
385
386std::vector<std::shared_ptr<const Display::Config>> Display::getConfigs() const
387{
388    std::vector<std::shared_ptr<const Config>> configs;
389    for (const auto& element : mConfigs) {
390        configs.emplace_back(element.second);
391    }
392    return configs;
393}
394
395Error Display::getName(std::string* outName) const
396{
397    auto intError = mComposer.getDisplayName(mId, outName);
398    return static_cast<Error>(intError);
399}
400
401Error Display::getRequests(HWC2::DisplayRequest* outDisplayRequests,
402        std::unordered_map<Layer*, LayerRequest>* outLayerRequests)
403{
404    uint32_t intDisplayRequests;
405    std::vector<Hwc2::Layer> layerIds;
406    std::vector<uint32_t> layerRequests;
407    auto intError = mComposer.getDisplayRequests(
408            mId, &intDisplayRequests, &layerIds, &layerRequests);
409    uint32_t numElements = layerIds.size();
410    auto error = static_cast<Error>(intError);
411    if (error != Error::None) {
412        return error;
413    }
414
415    *outDisplayRequests = static_cast<DisplayRequest>(intDisplayRequests);
416    outLayerRequests->clear();
417    outLayerRequests->reserve(numElements);
418    for (uint32_t element = 0; element < numElements; ++element) {
419        auto layer = getLayerById(layerIds[element]);
420        if (layer) {
421            auto layerRequest =
422                    static_cast<LayerRequest>(layerRequests[element]);
423            outLayerRequests->emplace(layer, layerRequest);
424        } else {
425            ALOGE("getRequests: invalid layer %" PRIu64 " found on display %"
426                    PRIu64, layerIds[element], mId);
427        }
428    }
429
430    return Error::None;
431}
432
433Error Display::getType(DisplayType* outType) const
434{
435    *outType = mType;
436    return Error::None;
437}
438
439Error Display::supportsDoze(bool* outSupport) const
440{
441    bool intSupport = false;
442    auto intError = mComposer.getDozeSupport(mId, &intSupport);
443    auto error = static_cast<Error>(intError);
444    if (error != Error::None) {
445        return error;
446    }
447    *outSupport = static_cast<bool>(intSupport);
448    return Error::None;
449}
450
451Error Display::getHdrCapabilities(
452        std::unique_ptr<HdrCapabilities>* outCapabilities) const
453{
454    float maxLuminance = -1.0f;
455    float maxAverageLuminance = -1.0f;
456    float minLuminance = -1.0f;
457    std::vector<Hwc2::Hdr> intTypes;
458    auto intError = mComposer.getHdrCapabilities(mId, &intTypes,
459            &maxLuminance, &maxAverageLuminance, &minLuminance);
460    auto error = static_cast<HWC2::Error>(intError);
461
462    std::vector<int32_t> types;
463    for (auto type : intTypes) {
464        types.push_back(static_cast<int32_t>(type));
465    }
466    if (error != Error::None) {
467        return error;
468    }
469
470    *outCapabilities = std::make_unique<HdrCapabilities>(std::move(types),
471            maxLuminance, maxAverageLuminance, minLuminance);
472    return Error::None;
473}
474
475Error Display::getReleaseFences(
476        std::unordered_map<Layer*, sp<Fence>>* outFences) const
477{
478    std::vector<Hwc2::Layer> layerIds;
479    std::vector<int> fenceFds;
480    auto intError = mComposer.getReleaseFences(mId, &layerIds, &fenceFds);
481    auto error = static_cast<Error>(intError);
482    uint32_t numElements = layerIds.size();
483    if (error != Error::None) {
484        return error;
485    }
486
487    std::unordered_map<Layer*, sp<Fence>> releaseFences;
488    releaseFences.reserve(numElements);
489    for (uint32_t element = 0; element < numElements; ++element) {
490        auto layer = getLayerById(layerIds[element]);
491        if (layer) {
492            sp<Fence> fence(new Fence(fenceFds[element]));
493            releaseFences.emplace(layer, fence);
494        } else {
495            ALOGE("getReleaseFences: invalid layer %" PRIu64
496                    " found on display %" PRIu64, layerIds[element], mId);
497            for (; element < numElements; ++element) {
498                close(fenceFds[element]);
499            }
500            return Error::BadLayer;
501        }
502    }
503
504    *outFences = std::move(releaseFences);
505    return Error::None;
506}
507
508Error Display::present(sp<Fence>* outPresentFence)
509{
510    int32_t presentFenceFd = -1;
511    auto intError = mComposer.presentDisplay(mId, &presentFenceFd);
512    auto error = static_cast<Error>(intError);
513    if (error != Error::None) {
514        return error;
515    }
516
517    *outPresentFence = new Fence(presentFenceFd);
518    return Error::None;
519}
520
521Error Display::setActiveConfig(const std::shared_ptr<const Config>& config)
522{
523    if (config->getDisplayId() != mId) {
524        ALOGE("setActiveConfig received config %u for the wrong display %"
525                PRIu64 " (expected %" PRIu64 ")", config->getId(),
526                config->getDisplayId(), mId);
527        return Error::BadConfig;
528    }
529    auto intError = mComposer.setActiveConfig(mId, config->getId());
530    return static_cast<Error>(intError);
531}
532
533Error Display::setClientTarget(uint32_t slot, const sp<GraphicBuffer>& target,
534        const sp<Fence>& acquireFence, Dataspace dataspace)
535{
536    // TODO: Properly encode client target surface damage
537    int32_t fenceFd = acquireFence->dup();
538    auto intError = mComposer.setClientTarget(mId, slot, target,
539            fenceFd, dataspace, std::vector<Hwc2::IComposerClient::Rect>());
540    return static_cast<Error>(intError);
541}
542
543Error Display::setColorMode(ColorMode mode, RenderIntent renderIntent)
544{
545    auto intError = mComposer.setColorMode(mId, mode, renderIntent);
546    return static_cast<Error>(intError);
547}
548
549Error Display::setColorTransform(const android::mat4& matrix,
550        android_color_transform_t hint)
551{
552    auto intError = mComposer.setColorTransform(mId,
553            matrix.asArray(), static_cast<Hwc2::ColorTransform>(hint));
554    return static_cast<Error>(intError);
555}
556
557Error Display::setOutputBuffer(const sp<GraphicBuffer>& buffer,
558        const sp<Fence>& releaseFence)
559{
560    int32_t fenceFd = releaseFence->dup();
561    auto handle = buffer->getNativeBuffer()->handle;
562    auto intError = mComposer.setOutputBuffer(mId, handle, fenceFd);
563    close(fenceFd);
564    return static_cast<Error>(intError);
565}
566
567Error Display::setPowerMode(PowerMode mode)
568{
569    auto intMode = static_cast<Hwc2::IComposerClient::PowerMode>(mode);
570    auto intError = mComposer.setPowerMode(mId, intMode);
571    return static_cast<Error>(intError);
572}
573
574Error Display::setVsyncEnabled(Vsync enabled)
575{
576    auto intEnabled = static_cast<Hwc2::IComposerClient::Vsync>(enabled);
577    auto intError = mComposer.setVsyncEnabled(mId, intEnabled);
578    return static_cast<Error>(intError);
579}
580
581Error Display::validate(uint32_t* outNumTypes, uint32_t* outNumRequests)
582{
583    uint32_t numTypes = 0;
584    uint32_t numRequests = 0;
585    auto intError = mComposer.validateDisplay(mId, &numTypes, &numRequests);
586    auto error = static_cast<Error>(intError);
587    if (error != Error::None && error != Error::HasChanges) {
588        return error;
589    }
590
591    *outNumTypes = numTypes;
592    *outNumRequests = numRequests;
593    return error;
594}
595
596Error Display::presentOrValidate(uint32_t* outNumTypes, uint32_t* outNumRequests,
597                                 sp<android::Fence>* outPresentFence, uint32_t* state) {
598
599    uint32_t numTypes = 0;
600    uint32_t numRequests = 0;
601    int32_t presentFenceFd = -1;
602    auto intError = mComposer.presentOrValidateDisplay(
603            mId, &numTypes, &numRequests, &presentFenceFd, state);
604    auto error = static_cast<Error>(intError);
605    if (error != Error::None && error != Error::HasChanges) {
606        return error;
607    }
608
609    if (*state == 1) {
610        *outPresentFence = new Fence(presentFenceFd);
611    }
612
613    if (*state == 0) {
614        *outNumTypes = numTypes;
615        *outNumRequests = numRequests;
616    }
617    return error;
618}
619
620// For use by Device
621
622void Display::setConnected(bool connected) {
623    if (!mIsConnected && connected) {
624        mComposer.setClientTargetSlotCount(mId);
625        if (mType == DisplayType::Physical) {
626            loadConfigs();
627        }
628    }
629    mIsConnected = connected;
630}
631
632int32_t Display::getAttribute(hwc2_config_t configId, Attribute attribute)
633{
634    int32_t value = 0;
635    auto intError = mComposer.getDisplayAttribute(mId, configId,
636            static_cast<Hwc2::IComposerClient::Attribute>(attribute),
637            &value);
638    auto error = static_cast<Error>(intError);
639    if (error != Error::None) {
640        ALOGE("getDisplayAttribute(%" PRIu64 ", %u, %s) failed: %s (%d)", mId,
641                configId, to_string(attribute).c_str(),
642                to_string(error).c_str(), intError);
643        return -1;
644    }
645    return value;
646}
647
648void Display::loadConfig(hwc2_config_t configId)
649{
650    ALOGV("[%" PRIu64 "] loadConfig(%u)", mId, configId);
651
652    auto config = Config::Builder(*this, configId)
653            .setWidth(getAttribute(configId, Attribute::Width))
654            .setHeight(getAttribute(configId, Attribute::Height))
655            .setVsyncPeriod(getAttribute(configId, Attribute::VsyncPeriod))
656            .setDpiX(getAttribute(configId, Attribute::DpiX))
657            .setDpiY(getAttribute(configId, Attribute::DpiY))
658            .build();
659    mConfigs.emplace(configId, std::move(config));
660}
661
662void Display::loadConfigs()
663{
664    ALOGV("[%" PRIu64 "] loadConfigs", mId);
665
666    std::vector<Hwc2::Config> configIds;
667    auto intError = mComposer.getDisplayConfigs(mId, &configIds);
668    auto error = static_cast<Error>(intError);
669    if (error != Error::None) {
670        ALOGE("[%" PRIu64 "] getDisplayConfigs [2] failed: %s (%d)", mId,
671                to_string(error).c_str(), intError);
672        return;
673    }
674
675    for (auto configId : configIds) {
676        loadConfig(configId);
677    }
678}
679
680// Other Display methods
681
682Layer* Display::getLayerById(hwc2_layer_t id) const
683{
684    if (mLayers.count(id) == 0) {
685        return nullptr;
686    }
687
688    return mLayers.at(id).get();
689}
690
691// Layer methods
692
693Layer::Layer(android::Hwc2::Composer& composer, const std::unordered_set<Capability>& capabilities,
694             hwc2_display_t displayId, hwc2_layer_t layerId)
695  : mComposer(composer),
696    mCapabilities(capabilities),
697    mDisplayId(displayId),
698    mId(layerId)
699{
700    ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, displayId);
701}
702
703Layer::~Layer()
704{
705    auto intError = mComposer.destroyLayer(mDisplayId, mId);
706    auto error = static_cast<Error>(intError);
707    ALOGE_IF(error != Error::None, "destroyLayer(%" PRIu64 ", %" PRIu64 ")"
708            " failed: %s (%d)", mDisplayId, mId, to_string(error).c_str(),
709            intError);
710    if (mLayerDestroyedListener) {
711        mLayerDestroyedListener(this);
712    }
713}
714
715void Layer::setLayerDestroyedListener(std::function<void(Layer*)> listener) {
716    LOG_ALWAYS_FATAL_IF(mLayerDestroyedListener && listener,
717            "Attempt to set layer destroyed listener multiple times");
718    mLayerDestroyedListener = listener;
719}
720
721Error Layer::setCursorPosition(int32_t x, int32_t y)
722{
723    auto intError = mComposer.setCursorPosition(mDisplayId, mId, x, y);
724    return static_cast<Error>(intError);
725}
726
727Error Layer::setBuffer(uint32_t slot, const sp<GraphicBuffer>& buffer,
728        const sp<Fence>& acquireFence)
729{
730    int32_t fenceFd = acquireFence->dup();
731    auto intError = mComposer.setLayerBuffer(mDisplayId, mId, slot, buffer,
732                                             fenceFd);
733    return static_cast<Error>(intError);
734}
735
736Error Layer::setSurfaceDamage(const Region& damage)
737{
738    // We encode default full-screen damage as INVALID_RECT upstream, but as 0
739    // rects for HWC
740    Hwc2::Error intError = Hwc2::Error::NONE;
741    if (damage.isRect() && damage.getBounds() == Rect::INVALID_RECT) {
742        intError = mComposer.setLayerSurfaceDamage(mDisplayId,
743                mId, std::vector<Hwc2::IComposerClient::Rect>());
744    } else {
745        size_t rectCount = 0;
746        auto rectArray = damage.getArray(&rectCount);
747
748        std::vector<Hwc2::IComposerClient::Rect> hwcRects;
749        for (size_t rect = 0; rect < rectCount; ++rect) {
750            hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
751                    rectArray[rect].right, rectArray[rect].bottom});
752        }
753
754        intError = mComposer.setLayerSurfaceDamage(mDisplayId, mId, hwcRects);
755    }
756
757    return static_cast<Error>(intError);
758}
759
760Error Layer::setBlendMode(BlendMode mode)
761{
762    auto intMode = static_cast<Hwc2::IComposerClient::BlendMode>(mode);
763    auto intError = mComposer.setLayerBlendMode(mDisplayId, mId, intMode);
764    return static_cast<Error>(intError);
765}
766
767Error Layer::setColor(hwc_color_t color)
768{
769    Hwc2::IComposerClient::Color hwcColor{color.r, color.g, color.b, color.a};
770    auto intError = mComposer.setLayerColor(mDisplayId, mId, hwcColor);
771    return static_cast<Error>(intError);
772}
773
774Error Layer::setCompositionType(Composition type)
775{
776    auto intType = static_cast<Hwc2::IComposerClient::Composition>(type);
777    auto intError = mComposer.setLayerCompositionType(
778            mDisplayId, mId, intType);
779    return static_cast<Error>(intError);
780}
781
782Error Layer::setDataspace(Dataspace dataspace)
783{
784    if (dataspace == mDataSpace) {
785        return Error::None;
786    }
787    mDataSpace = dataspace;
788    auto intError = mComposer.setLayerDataspace(mDisplayId, mId, mDataSpace);
789    return static_cast<Error>(intError);
790}
791
792Error Layer::setHdrMetadata(const android::HdrMetadata& metadata) {
793    if (metadata == mHdrMetadata) {
794        return Error::None;
795    }
796
797    mHdrMetadata = metadata;
798    auto intError = mComposer.setLayerHdrMetadata(mDisplayId, mId, metadata);
799    return static_cast<Error>(intError);
800}
801
802Error Layer::setDisplayFrame(const Rect& frame)
803{
804    Hwc2::IComposerClient::Rect hwcRect{frame.left, frame.top,
805        frame.right, frame.bottom};
806    auto intError = mComposer.setLayerDisplayFrame(mDisplayId, mId, hwcRect);
807    return static_cast<Error>(intError);
808}
809
810Error Layer::setPlaneAlpha(float alpha)
811{
812    auto intError = mComposer.setLayerPlaneAlpha(mDisplayId, mId, alpha);
813    return static_cast<Error>(intError);
814}
815
816Error Layer::setSidebandStream(const native_handle_t* stream)
817{
818    if (mCapabilities.count(Capability::SidebandStream) == 0) {
819        ALOGE("Attempted to call setSidebandStream without checking that the "
820                "device supports sideband streams");
821        return Error::Unsupported;
822    }
823    auto intError = mComposer.setLayerSidebandStream(mDisplayId, mId, stream);
824    return static_cast<Error>(intError);
825}
826
827Error Layer::setSourceCrop(const FloatRect& crop)
828{
829    Hwc2::IComposerClient::FRect hwcRect{
830        crop.left, crop.top, crop.right, crop.bottom};
831    auto intError = mComposer.setLayerSourceCrop(mDisplayId, mId, hwcRect);
832    return static_cast<Error>(intError);
833}
834
835Error Layer::setTransform(Transform transform)
836{
837    auto intTransform = static_cast<Hwc2::Transform>(transform);
838    auto intError = mComposer.setLayerTransform(mDisplayId, mId, intTransform);
839    return static_cast<Error>(intError);
840}
841
842Error Layer::setVisibleRegion(const Region& region)
843{
844    size_t rectCount = 0;
845    auto rectArray = region.getArray(&rectCount);
846
847    std::vector<Hwc2::IComposerClient::Rect> hwcRects;
848    for (size_t rect = 0; rect < rectCount; ++rect) {
849        hwcRects.push_back({rectArray[rect].left, rectArray[rect].top,
850                rectArray[rect].right, rectArray[rect].bottom});
851    }
852
853    auto intError = mComposer.setLayerVisibleRegion(mDisplayId, mId, hwcRects);
854    return static_cast<Error>(intError);
855}
856
857Error Layer::setZOrder(uint32_t z)
858{
859    auto intError = mComposer.setLayerZOrder(mDisplayId, mId, z);
860    return static_cast<Error>(intError);
861}
862
863Error Layer::setInfo(uint32_t type, uint32_t appId)
864{
865  auto intError = mComposer.setLayerInfo(mDisplayId, mId, type, appId);
866  return static_cast<Error>(intError);
867}
868
869} // namespace HWC2
870