1/*
2 * Copyright 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#undef LOG_TAG
18#define LOG_TAG "HwcComposer"
19
20#include <inttypes.h>
21#include <log/log.h>
22#include <gui/BufferQueue.h>
23
24#include "ComposerHal.h"
25
26namespace android {
27
28using hardware::Return;
29using hardware::hidl_vec;
30using hardware::hidl_handle;
31
32namespace Hwc2 {
33
34namespace {
35
36class BufferHandle {
37public:
38    BufferHandle(const native_handle_t* buffer)
39    {
40        // nullptr is not a valid handle to HIDL
41        mHandle = (buffer) ? buffer : native_handle_init(mStorage, 0, 0);
42    }
43
44    operator const hidl_handle&() const
45    {
46        return mHandle;
47    }
48
49private:
50    NATIVE_HANDLE_DECLARE_STORAGE(mStorage, 0, 0);
51    hidl_handle mHandle;
52};
53
54class FenceHandle
55{
56public:
57    FenceHandle(int fd, bool owned)
58        : mOwned(owned)
59    {
60        native_handle_t* handle;
61        if (fd >= 0) {
62            handle = native_handle_init(mStorage, 1, 0);
63            handle->data[0] = fd;
64        } else {
65            // nullptr is not a valid handle to HIDL
66            handle = native_handle_init(mStorage, 0, 0);
67        }
68        mHandle = handle;
69    }
70
71    ~FenceHandle()
72    {
73        if (mOwned) {
74            native_handle_close(mHandle);
75        }
76    }
77
78    operator const hidl_handle&() const
79    {
80        return mHandle;
81    }
82
83private:
84    bool mOwned;
85    NATIVE_HANDLE_DECLARE_STORAGE(mStorage, 1, 0);
86    hidl_handle mHandle;
87};
88
89// assume NO_RESOURCES when Status::isOk returns false
90constexpr Error kDefaultError = Error::NO_RESOURCES;
91
92template<typename T, typename U>
93T unwrapRet(Return<T>& ret, const U& default_val)
94{
95    return (ret.isOk()) ? static_cast<T>(ret) :
96        static_cast<T>(default_val);
97}
98
99Error unwrapRet(Return<Error>& ret)
100{
101    return unwrapRet(ret, kDefaultError);
102}
103
104} // anonymous namespace
105
106Composer::CommandWriter::CommandWriter(uint32_t initialMaxSize)
107    : CommandWriterBase(initialMaxSize) {}
108
109Composer::CommandWriter::~CommandWriter()
110{
111}
112
113void Composer::CommandWriter::setLayerInfo(uint32_t type, uint32_t appId)
114{
115    constexpr uint16_t kSetLayerInfoLength = 2;
116    beginCommand(
117        static_cast<IComposerClient::Command>(
118            IVrComposerClient::VrCommand::SET_LAYER_INFO),
119        kSetLayerInfoLength);
120    write(type);
121    write(appId);
122    endCommand();
123}
124
125void Composer::CommandWriter::setClientTargetMetadata(
126        const IVrComposerClient::BufferMetadata& metadata)
127{
128    constexpr uint16_t kSetClientTargetMetadataLength = 7;
129    beginCommand(
130        static_cast<IComposerClient::Command>(
131            IVrComposerClient::VrCommand::SET_CLIENT_TARGET_METADATA),
132        kSetClientTargetMetadataLength);
133    writeBufferMetadata(metadata);
134    endCommand();
135}
136
137void Composer::CommandWriter::setLayerBufferMetadata(
138        const IVrComposerClient::BufferMetadata& metadata)
139{
140    constexpr uint16_t kSetLayerBufferMetadataLength = 7;
141    beginCommand(
142        static_cast<IComposerClient::Command>(
143            IVrComposerClient::VrCommand::SET_LAYER_BUFFER_METADATA),
144        kSetLayerBufferMetadataLength);
145    writeBufferMetadata(metadata);
146    endCommand();
147}
148
149void Composer::CommandWriter::writeBufferMetadata(
150        const IVrComposerClient::BufferMetadata& metadata)
151{
152    write(metadata.width);
153    write(metadata.height);
154    write(metadata.stride);
155    write(metadata.layerCount);
156    writeSigned(static_cast<int32_t>(metadata.format));
157    write64(metadata.usage);
158}
159
160Composer::Composer(bool useVrComposer)
161    : mWriter(kWriterInitialSize),
162      mIsUsingVrComposer(useVrComposer)
163{
164    if (mIsUsingVrComposer) {
165        mComposer = IComposer::getService("vr");
166    } else {
167        mComposer = IComposer::getService(); // use default name
168    }
169
170    if (mComposer == nullptr) {
171        LOG_ALWAYS_FATAL("failed to get hwcomposer service");
172    }
173
174    mComposer->createClient(
175            [&](const auto& tmpError, const auto& tmpClient)
176            {
177                if (tmpError == Error::NONE) {
178                    mClient = tmpClient;
179                }
180            });
181    if (mClient == nullptr) {
182        LOG_ALWAYS_FATAL("failed to create composer client");
183    }
184
185    if (mIsUsingVrComposer) {
186        sp<IVrComposerClient> vrClient = IVrComposerClient::castFrom(mClient);
187        if (vrClient == nullptr) {
188            LOG_ALWAYS_FATAL("failed to create vr composer client");
189        }
190    }
191}
192
193std::vector<IComposer::Capability> Composer::getCapabilities()
194{
195    std::vector<IComposer::Capability> capabilities;
196    mComposer->getCapabilities(
197            [&](const auto& tmpCapabilities) {
198                capabilities = tmpCapabilities;
199            });
200
201    return capabilities;
202}
203
204std::string Composer::dumpDebugInfo()
205{
206    std::string info;
207    mComposer->dumpDebugInfo([&](const auto& tmpInfo) {
208        info = tmpInfo.c_str();
209    });
210
211    return info;
212}
213
214void Composer::registerCallback(const sp<IComposerCallback>& callback)
215{
216    auto ret = mClient->registerCallback(callback);
217    if (!ret.isOk()) {
218        ALOGE("failed to register IComposerCallback");
219    }
220}
221
222bool Composer::isRemote() {
223    return mClient->isRemote();
224}
225
226void Composer::resetCommands() {
227    mWriter.reset();
228}
229
230uint32_t Composer::getMaxVirtualDisplayCount()
231{
232    auto ret = mClient->getMaxVirtualDisplayCount();
233    return unwrapRet(ret, 0);
234}
235
236Error Composer::createVirtualDisplay(uint32_t width, uint32_t height,
237            PixelFormat* format, Display* outDisplay)
238{
239    const uint32_t bufferSlotCount = 1;
240    Error error = kDefaultError;
241    mClient->createVirtualDisplay(width, height, *format, bufferSlotCount,
242            [&](const auto& tmpError, const auto& tmpDisplay,
243                const auto& tmpFormat) {
244                error = tmpError;
245                if (error != Error::NONE) {
246                    return;
247                }
248
249                *outDisplay = tmpDisplay;
250                *format = tmpFormat;
251            });
252
253    return error;
254}
255
256Error Composer::destroyVirtualDisplay(Display display)
257{
258    auto ret = mClient->destroyVirtualDisplay(display);
259    return unwrapRet(ret);
260}
261
262Error Composer::acceptDisplayChanges(Display display)
263{
264    mWriter.selectDisplay(display);
265    mWriter.acceptDisplayChanges();
266    return Error::NONE;
267}
268
269Error Composer::createLayer(Display display, Layer* outLayer)
270{
271    Error error = kDefaultError;
272    mClient->createLayer(display, BufferQueue::NUM_BUFFER_SLOTS,
273            [&](const auto& tmpError, const auto& tmpLayer) {
274                error = tmpError;
275                if (error != Error::NONE) {
276                    return;
277                }
278
279                *outLayer = tmpLayer;
280            });
281
282    return error;
283}
284
285Error Composer::destroyLayer(Display display, Layer layer)
286{
287    auto ret = mClient->destroyLayer(display, layer);
288    return unwrapRet(ret);
289}
290
291Error Composer::getActiveConfig(Display display, Config* outConfig)
292{
293    Error error = kDefaultError;
294    mClient->getActiveConfig(display,
295            [&](const auto& tmpError, const auto& tmpConfig) {
296                error = tmpError;
297                if (error != Error::NONE) {
298                    return;
299                }
300
301                *outConfig = tmpConfig;
302            });
303
304    return error;
305}
306
307Error Composer::getChangedCompositionTypes(Display display,
308        std::vector<Layer>* outLayers,
309        std::vector<IComposerClient::Composition>* outTypes)
310{
311    mReader.takeChangedCompositionTypes(display, outLayers, outTypes);
312    return Error::NONE;
313}
314
315Error Composer::getColorModes(Display display,
316        std::vector<ColorMode>* outModes)
317{
318    Error error = kDefaultError;
319    mClient->getColorModes(display,
320            [&](const auto& tmpError, const auto& tmpModes) {
321                error = tmpError;
322                if (error != Error::NONE) {
323                    return;
324                }
325
326                *outModes = tmpModes;
327            });
328
329    return error;
330}
331
332Error Composer::getDisplayAttribute(Display display, Config config,
333        IComposerClient::Attribute attribute, int32_t* outValue)
334{
335    Error error = kDefaultError;
336    mClient->getDisplayAttribute(display, config, attribute,
337            [&](const auto& tmpError, const auto& tmpValue) {
338                error = tmpError;
339                if (error != Error::NONE) {
340                    return;
341                }
342
343                *outValue = tmpValue;
344            });
345
346    return error;
347}
348
349Error Composer::getDisplayConfigs(Display display,
350        std::vector<Config>* outConfigs)
351{
352    Error error = kDefaultError;
353    mClient->getDisplayConfigs(display,
354            [&](const auto& tmpError, const auto& tmpConfigs) {
355                error = tmpError;
356                if (error != Error::NONE) {
357                    return;
358                }
359
360                *outConfigs = tmpConfigs;
361            });
362
363    return error;
364}
365
366Error Composer::getDisplayName(Display display, std::string* outName)
367{
368    Error error = kDefaultError;
369    mClient->getDisplayName(display,
370            [&](const auto& tmpError, const auto& tmpName) {
371                error = tmpError;
372                if (error != Error::NONE) {
373                    return;
374                }
375
376                *outName = tmpName.c_str();
377            });
378
379    return error;
380}
381
382Error Composer::getDisplayRequests(Display display,
383        uint32_t* outDisplayRequestMask, std::vector<Layer>* outLayers,
384        std::vector<uint32_t>* outLayerRequestMasks)
385{
386    mReader.takeDisplayRequests(display, outDisplayRequestMask,
387            outLayers, outLayerRequestMasks);
388    return Error::NONE;
389}
390
391Error Composer::getDisplayType(Display display,
392        IComposerClient::DisplayType* outType)
393{
394    Error error = kDefaultError;
395    mClient->getDisplayType(display,
396            [&](const auto& tmpError, const auto& tmpType) {
397                error = tmpError;
398                if (error != Error::NONE) {
399                    return;
400                }
401
402                *outType = tmpType;
403            });
404
405    return error;
406}
407
408Error Composer::getDozeSupport(Display display, bool* outSupport)
409{
410    Error error = kDefaultError;
411    mClient->getDozeSupport(display,
412            [&](const auto& tmpError, const auto& tmpSupport) {
413                error = tmpError;
414                if (error != Error::NONE) {
415                    return;
416                }
417
418                *outSupport = tmpSupport;
419            });
420
421    return error;
422}
423
424Error Composer::getHdrCapabilities(Display display,
425        std::vector<Hdr>* outTypes, float* outMaxLuminance,
426        float* outMaxAverageLuminance, float* outMinLuminance)
427{
428    Error error = kDefaultError;
429    mClient->getHdrCapabilities(display,
430            [&](const auto& tmpError, const auto& tmpTypes,
431                const auto& tmpMaxLuminance,
432                const auto& tmpMaxAverageLuminance,
433                const auto& tmpMinLuminance) {
434                error = tmpError;
435                if (error != Error::NONE) {
436                    return;
437                }
438
439                *outTypes = tmpTypes;
440                *outMaxLuminance = tmpMaxLuminance;
441                *outMaxAverageLuminance = tmpMaxAverageLuminance;
442                *outMinLuminance = tmpMinLuminance;
443            });
444
445    return error;
446}
447
448Error Composer::getReleaseFences(Display display,
449        std::vector<Layer>* outLayers, std::vector<int>* outReleaseFences)
450{
451    mReader.takeReleaseFences(display, outLayers, outReleaseFences);
452    return Error::NONE;
453}
454
455Error Composer::presentDisplay(Display display, int* outPresentFence)
456{
457    mWriter.selectDisplay(display);
458    mWriter.presentDisplay();
459
460    Error error = execute();
461    if (error != Error::NONE) {
462        return error;
463    }
464
465    mReader.takePresentFence(display, outPresentFence);
466
467    return Error::NONE;
468}
469
470Error Composer::setActiveConfig(Display display, Config config)
471{
472    auto ret = mClient->setActiveConfig(display, config);
473    return unwrapRet(ret);
474}
475
476Error Composer::setClientTarget(Display display, uint32_t slot,
477        const sp<GraphicBuffer>& target,
478        int acquireFence, Dataspace dataspace,
479        const std::vector<IComposerClient::Rect>& damage)
480{
481    mWriter.selectDisplay(display);
482    if (mIsUsingVrComposer && target.get()) {
483        IVrComposerClient::BufferMetadata metadata = {
484            .width = target->getWidth(),
485            .height = target->getHeight(),
486            .stride = target->getStride(),
487            .layerCount = target->getLayerCount(),
488            .format = static_cast<PixelFormat>(target->getPixelFormat()),
489            .usage = target->getUsage(),
490        };
491        mWriter.setClientTargetMetadata(metadata);
492    }
493
494    const native_handle_t* handle = nullptr;
495    if (target.get()) {
496        handle = target->getNativeBuffer()->handle;
497    }
498
499    mWriter.setClientTarget(slot, handle, acquireFence, dataspace, damage);
500    return Error::NONE;
501}
502
503Error Composer::setColorMode(Display display, ColorMode mode)
504{
505    auto ret = mClient->setColorMode(display, mode);
506    return unwrapRet(ret);
507}
508
509Error Composer::setColorTransform(Display display, const float* matrix,
510        ColorTransform hint)
511{
512    mWriter.selectDisplay(display);
513    mWriter.setColorTransform(matrix, hint);
514    return Error::NONE;
515}
516
517Error Composer::setOutputBuffer(Display display, const native_handle_t* buffer,
518        int releaseFence)
519{
520    mWriter.selectDisplay(display);
521    mWriter.setOutputBuffer(0, buffer, dup(releaseFence));
522    return Error::NONE;
523}
524
525Error Composer::setPowerMode(Display display, IComposerClient::PowerMode mode)
526{
527    auto ret = mClient->setPowerMode(display, mode);
528    return unwrapRet(ret);
529}
530
531Error Composer::setVsyncEnabled(Display display, IComposerClient::Vsync enabled)
532{
533    auto ret = mClient->setVsyncEnabled(display, enabled);
534    return unwrapRet(ret);
535}
536
537Error Composer::setClientTargetSlotCount(Display display)
538{
539    const uint32_t bufferSlotCount = BufferQueue::NUM_BUFFER_SLOTS;
540    auto ret = mClient->setClientTargetSlotCount(display, bufferSlotCount);
541    return unwrapRet(ret);
542}
543
544Error Composer::validateDisplay(Display display, uint32_t* outNumTypes,
545        uint32_t* outNumRequests)
546{
547    mWriter.selectDisplay(display);
548    mWriter.validateDisplay();
549
550    Error error = execute();
551    if (error != Error::NONE) {
552        return error;
553    }
554
555    mReader.hasChanges(display, outNumTypes, outNumRequests);
556
557    return Error::NONE;
558}
559
560Error Composer::presentOrValidateDisplay(Display display, uint32_t* outNumTypes,
561                               uint32_t* outNumRequests, int* outPresentFence, uint32_t* state) {
562   mWriter.selectDisplay(display);
563   mWriter.presentOrvalidateDisplay();
564
565   Error error = execute();
566   if (error != Error::NONE) {
567       return error;
568   }
569
570   mReader.takePresentOrValidateStage(display, state);
571
572   if (*state == 1) { // Present succeeded
573       mReader.takePresentFence(display, outPresentFence);
574   }
575
576   if (*state == 0) { // Validate succeeded.
577       mReader.hasChanges(display, outNumTypes, outNumRequests);
578   }
579
580   return Error::NONE;
581}
582
583Error Composer::setCursorPosition(Display display, Layer layer,
584        int32_t x, int32_t y)
585{
586    mWriter.selectDisplay(display);
587    mWriter.selectLayer(layer);
588    mWriter.setLayerCursorPosition(x, y);
589    return Error::NONE;
590}
591
592Error Composer::setLayerBuffer(Display display, Layer layer,
593        uint32_t slot, const sp<GraphicBuffer>& buffer, int acquireFence)
594{
595    mWriter.selectDisplay(display);
596    mWriter.selectLayer(layer);
597    if (mIsUsingVrComposer && buffer.get()) {
598        IVrComposerClient::BufferMetadata metadata = {
599            .width = buffer->getWidth(),
600            .height = buffer->getHeight(),
601            .stride = buffer->getStride(),
602            .layerCount = buffer->getLayerCount(),
603            .format = static_cast<PixelFormat>(buffer->getPixelFormat()),
604            .usage = buffer->getUsage(),
605        };
606        mWriter.setLayerBufferMetadata(metadata);
607    }
608
609    const native_handle_t* handle = nullptr;
610    if (buffer.get()) {
611        handle = buffer->getNativeBuffer()->handle;
612    }
613
614    mWriter.setLayerBuffer(slot, handle, acquireFence);
615    return Error::NONE;
616}
617
618Error Composer::setLayerSurfaceDamage(Display display, Layer layer,
619        const std::vector<IComposerClient::Rect>& damage)
620{
621    mWriter.selectDisplay(display);
622    mWriter.selectLayer(layer);
623    mWriter.setLayerSurfaceDamage(damage);
624    return Error::NONE;
625}
626
627Error Composer::setLayerBlendMode(Display display, Layer layer,
628        IComposerClient::BlendMode mode)
629{
630    mWriter.selectDisplay(display);
631    mWriter.selectLayer(layer);
632    mWriter.setLayerBlendMode(mode);
633    return Error::NONE;
634}
635
636Error Composer::setLayerColor(Display display, Layer layer,
637        const IComposerClient::Color& color)
638{
639    mWriter.selectDisplay(display);
640    mWriter.selectLayer(layer);
641    mWriter.setLayerColor(color);
642    return Error::NONE;
643}
644
645Error Composer::setLayerCompositionType(Display display, Layer layer,
646        IComposerClient::Composition type)
647{
648    mWriter.selectDisplay(display);
649    mWriter.selectLayer(layer);
650    mWriter.setLayerCompositionType(type);
651    return Error::NONE;
652}
653
654Error Composer::setLayerDataspace(Display display, Layer layer,
655        Dataspace dataspace)
656{
657    mWriter.selectDisplay(display);
658    mWriter.selectLayer(layer);
659    mWriter.setLayerDataspace(dataspace);
660    return Error::NONE;
661}
662
663Error Composer::setLayerDisplayFrame(Display display, Layer layer,
664        const IComposerClient::Rect& frame)
665{
666    mWriter.selectDisplay(display);
667    mWriter.selectLayer(layer);
668    mWriter.setLayerDisplayFrame(frame);
669    return Error::NONE;
670}
671
672Error Composer::setLayerPlaneAlpha(Display display, Layer layer,
673        float alpha)
674{
675    mWriter.selectDisplay(display);
676    mWriter.selectLayer(layer);
677    mWriter.setLayerPlaneAlpha(alpha);
678    return Error::NONE;
679}
680
681Error Composer::setLayerSidebandStream(Display display, Layer layer,
682        const native_handle_t* stream)
683{
684    mWriter.selectDisplay(display);
685    mWriter.selectLayer(layer);
686    mWriter.setLayerSidebandStream(stream);
687    return Error::NONE;
688}
689
690Error Composer::setLayerSourceCrop(Display display, Layer layer,
691        const IComposerClient::FRect& crop)
692{
693    mWriter.selectDisplay(display);
694    mWriter.selectLayer(layer);
695    mWriter.setLayerSourceCrop(crop);
696    return Error::NONE;
697}
698
699Error Composer::setLayerTransform(Display display, Layer layer,
700        Transform transform)
701{
702    mWriter.selectDisplay(display);
703    mWriter.selectLayer(layer);
704    mWriter.setLayerTransform(transform);
705    return Error::NONE;
706}
707
708Error Composer::setLayerVisibleRegion(Display display, Layer layer,
709        const std::vector<IComposerClient::Rect>& visible)
710{
711    mWriter.selectDisplay(display);
712    mWriter.selectLayer(layer);
713    mWriter.setLayerVisibleRegion(visible);
714    return Error::NONE;
715}
716
717Error Composer::setLayerZOrder(Display display, Layer layer, uint32_t z)
718{
719    mWriter.selectDisplay(display);
720    mWriter.selectLayer(layer);
721    mWriter.setLayerZOrder(z);
722    return Error::NONE;
723}
724
725Error Composer::setLayerInfo(Display display, Layer layer, uint32_t type,
726                             uint32_t appId)
727{
728    if (mIsUsingVrComposer) {
729        mWriter.selectDisplay(display);
730        mWriter.selectLayer(layer);
731        mWriter.setLayerInfo(type, appId);
732    }
733    return Error::NONE;
734}
735
736Error Composer::execute()
737{
738    // prepare input command queue
739    bool queueChanged = false;
740    uint32_t commandLength = 0;
741    hidl_vec<hidl_handle> commandHandles;
742    if (!mWriter.writeQueue(&queueChanged, &commandLength, &commandHandles)) {
743        mWriter.reset();
744        return Error::NO_RESOURCES;
745    }
746
747    // set up new input command queue if necessary
748    if (queueChanged) {
749        auto ret = mClient->setInputCommandQueue(*mWriter.getMQDescriptor());
750        auto error = unwrapRet(ret);
751        if (error != Error::NONE) {
752            mWriter.reset();
753            return error;
754        }
755    }
756
757    Error error = kDefaultError;
758    auto ret = mClient->executeCommands(commandLength, commandHandles,
759            [&](const auto& tmpError, const auto& tmpOutChanged,
760                const auto& tmpOutLength, const auto& tmpOutHandles)
761            {
762                error = tmpError;
763
764                // set up new output command queue if necessary
765                if (error == Error::NONE && tmpOutChanged) {
766                    error = kDefaultError;
767                    mClient->getOutputCommandQueue(
768                            [&](const auto& tmpError,
769                                const auto& tmpDescriptor)
770                            {
771                                error = tmpError;
772                                if (error != Error::NONE) {
773                                    return;
774                                }
775
776                                mReader.setMQDescriptor(tmpDescriptor);
777                            });
778                }
779
780                if (error != Error::NONE) {
781                    return;
782                }
783
784                if (mReader.readQueue(tmpOutLength, tmpOutHandles)) {
785                    error = mReader.parse();
786                    mReader.reset();
787                } else {
788                    error = Error::NO_RESOURCES;
789                }
790            });
791    // executeCommands can fail because of out-of-fd and we do not want to
792    // abort() in that case
793    if (!ret.isOk()) {
794        ALOGE("executeCommands failed because of %s", ret.description().c_str());
795    }
796
797    if (error == Error::NONE) {
798        std::vector<CommandReader::CommandError> commandErrors =
799            mReader.takeErrors();
800
801        for (const auto& cmdErr : commandErrors) {
802            auto command = mWriter.getCommand(cmdErr.location);
803
804            if (command == IComposerClient::Command::VALIDATE_DISPLAY ||
805                command == IComposerClient::Command::PRESENT_DISPLAY ||
806                command == IComposerClient::Command::PRESENT_OR_VALIDATE_DISPLAY) {
807                error = cmdErr.error;
808            } else {
809                ALOGW("command 0x%x generated error %d",
810                        command, cmdErr.error);
811            }
812        }
813    }
814
815    mWriter.reset();
816
817    return error;
818}
819
820CommandReader::~CommandReader()
821{
822    resetData();
823}
824
825Error CommandReader::parse()
826{
827    resetData();
828
829    IComposerClient::Command command;
830    uint16_t length = 0;
831
832    while (!isEmpty()) {
833        if (!beginCommand(&command, &length)) {
834            break;
835        }
836
837        bool parsed = false;
838        switch (command) {
839        case IComposerClient::Command::SELECT_DISPLAY:
840            parsed = parseSelectDisplay(length);
841            break;
842        case IComposerClient::Command::SET_ERROR:
843            parsed = parseSetError(length);
844            break;
845        case IComposerClient::Command::SET_CHANGED_COMPOSITION_TYPES:
846            parsed = parseSetChangedCompositionTypes(length);
847            break;
848        case IComposerClient::Command::SET_DISPLAY_REQUESTS:
849            parsed = parseSetDisplayRequests(length);
850            break;
851        case IComposerClient::Command::SET_PRESENT_FENCE:
852            parsed = parseSetPresentFence(length);
853            break;
854        case IComposerClient::Command::SET_RELEASE_FENCES:
855            parsed = parseSetReleaseFences(length);
856            break;
857        case IComposerClient::Command ::SET_PRESENT_OR_VALIDATE_DISPLAY_RESULT:
858            parsed = parseSetPresentOrValidateDisplayResult(length);
859            break;
860        default:
861            parsed = false;
862            break;
863        }
864
865        endCommand();
866
867        if (!parsed) {
868            ALOGE("failed to parse command 0x%x length %" PRIu16,
869                    command, length);
870            break;
871        }
872    }
873
874    return isEmpty() ? Error::NONE : Error::NO_RESOURCES;
875}
876
877bool CommandReader::parseSelectDisplay(uint16_t length)
878{
879    if (length != CommandWriterBase::kSelectDisplayLength) {
880        return false;
881    }
882
883    mCurrentReturnData = &mReturnData[read64()];
884
885    return true;
886}
887
888bool CommandReader::parseSetError(uint16_t length)
889{
890    if (length != CommandWriterBase::kSetErrorLength) {
891        return false;
892    }
893
894    auto location = read();
895    auto error = static_cast<Error>(readSigned());
896
897    mErrors.emplace_back(CommandError{location, error});
898
899    return true;
900}
901
902bool CommandReader::parseSetChangedCompositionTypes(uint16_t length)
903{
904    // (layer id, composition type) pairs
905    if (length % 3 != 0 || !mCurrentReturnData) {
906        return false;
907    }
908
909    uint32_t count = length / 3;
910    mCurrentReturnData->changedLayers.reserve(count);
911    mCurrentReturnData->compositionTypes.reserve(count);
912    while (count > 0) {
913        auto layer = read64();
914        auto type = static_cast<IComposerClient::Composition>(readSigned());
915
916        mCurrentReturnData->changedLayers.push_back(layer);
917        mCurrentReturnData->compositionTypes.push_back(type);
918
919        count--;
920    }
921
922    return true;
923}
924
925bool CommandReader::parseSetDisplayRequests(uint16_t length)
926{
927    // display requests followed by (layer id, layer requests) pairs
928    if (length % 3 != 1 || !mCurrentReturnData) {
929        return false;
930    }
931
932    mCurrentReturnData->displayRequests = read();
933
934    uint32_t count = (length - 1) / 3;
935    mCurrentReturnData->requestedLayers.reserve(count);
936    mCurrentReturnData->requestMasks.reserve(count);
937    while (count > 0) {
938        auto layer = read64();
939        auto layerRequestMask = read();
940
941        mCurrentReturnData->requestedLayers.push_back(layer);
942        mCurrentReturnData->requestMasks.push_back(layerRequestMask);
943
944        count--;
945    }
946
947    return true;
948}
949
950bool CommandReader::parseSetPresentFence(uint16_t length)
951{
952    if (length != CommandWriterBase::kSetPresentFenceLength ||
953            !mCurrentReturnData) {
954        return false;
955    }
956
957    if (mCurrentReturnData->presentFence >= 0) {
958        close(mCurrentReturnData->presentFence);
959    }
960    mCurrentReturnData->presentFence = readFence();
961
962    return true;
963}
964
965bool CommandReader::parseSetReleaseFences(uint16_t length)
966{
967    // (layer id, release fence index) pairs
968    if (length % 3 != 0 || !mCurrentReturnData) {
969        return false;
970    }
971
972    uint32_t count = length / 3;
973    mCurrentReturnData->releasedLayers.reserve(count);
974    mCurrentReturnData->releaseFences.reserve(count);
975    while (count > 0) {
976        auto layer = read64();
977        auto fence = readFence();
978
979        mCurrentReturnData->releasedLayers.push_back(layer);
980        mCurrentReturnData->releaseFences.push_back(fence);
981
982        count--;
983    }
984
985    return true;
986}
987
988bool CommandReader::parseSetPresentOrValidateDisplayResult(uint16_t length)
989{
990    if (length != CommandWriterBase::kPresentOrValidateDisplayResultLength || !mCurrentReturnData) {
991        return false;
992    }
993    mCurrentReturnData->presentOrValidateState = read();
994    return true;
995}
996
997void CommandReader::resetData()
998{
999    mErrors.clear();
1000
1001    for (auto& data : mReturnData) {
1002        if (data.second.presentFence >= 0) {
1003            close(data.second.presentFence);
1004        }
1005        for (auto fence : data.second.releaseFences) {
1006            if (fence >= 0) {
1007                close(fence);
1008            }
1009        }
1010    }
1011
1012    mReturnData.clear();
1013    mCurrentReturnData = nullptr;
1014}
1015
1016std::vector<CommandReader::CommandError> CommandReader::takeErrors()
1017{
1018    return std::move(mErrors);
1019}
1020
1021bool CommandReader::hasChanges(Display display,
1022        uint32_t* outNumChangedCompositionTypes,
1023        uint32_t* outNumLayerRequestMasks) const
1024{
1025    auto found = mReturnData.find(display);
1026    if (found == mReturnData.end()) {
1027        *outNumChangedCompositionTypes = 0;
1028        *outNumLayerRequestMasks = 0;
1029        return false;
1030    }
1031
1032    const ReturnData& data = found->second;
1033
1034    *outNumChangedCompositionTypes = data.compositionTypes.size();
1035    *outNumLayerRequestMasks = data.requestMasks.size();
1036
1037    return !(data.compositionTypes.empty() && data.requestMasks.empty());
1038}
1039
1040void CommandReader::takeChangedCompositionTypes(Display display,
1041        std::vector<Layer>* outLayers,
1042        std::vector<IComposerClient::Composition>* outTypes)
1043{
1044    auto found = mReturnData.find(display);
1045    if (found == mReturnData.end()) {
1046        outLayers->clear();
1047        outTypes->clear();
1048        return;
1049    }
1050
1051    ReturnData& data = found->second;
1052
1053    *outLayers = std::move(data.changedLayers);
1054    *outTypes = std::move(data.compositionTypes);
1055}
1056
1057void CommandReader::takeDisplayRequests(Display display,
1058        uint32_t* outDisplayRequestMask, std::vector<Layer>* outLayers,
1059        std::vector<uint32_t>* outLayerRequestMasks)
1060{
1061    auto found = mReturnData.find(display);
1062    if (found == mReturnData.end()) {
1063        *outDisplayRequestMask = 0;
1064        outLayers->clear();
1065        outLayerRequestMasks->clear();
1066        return;
1067    }
1068
1069    ReturnData& data = found->second;
1070
1071    *outDisplayRequestMask = data.displayRequests;
1072    *outLayers = std::move(data.requestedLayers);
1073    *outLayerRequestMasks = std::move(data.requestMasks);
1074}
1075
1076void CommandReader::takeReleaseFences(Display display,
1077        std::vector<Layer>* outLayers, std::vector<int>* outReleaseFences)
1078{
1079    auto found = mReturnData.find(display);
1080    if (found == mReturnData.end()) {
1081        outLayers->clear();
1082        outReleaseFences->clear();
1083        return;
1084    }
1085
1086    ReturnData& data = found->second;
1087
1088    *outLayers = std::move(data.releasedLayers);
1089    *outReleaseFences = std::move(data.releaseFences);
1090}
1091
1092void CommandReader::takePresentFence(Display display, int* outPresentFence)
1093{
1094    auto found = mReturnData.find(display);
1095    if (found == mReturnData.end()) {
1096        *outPresentFence = -1;
1097        return;
1098    }
1099
1100    ReturnData& data = found->second;
1101
1102    *outPresentFence = data.presentFence;
1103    data.presentFence = -1;
1104}
1105
1106void CommandReader::takePresentOrValidateStage(Display display, uint32_t* state) {
1107    auto found = mReturnData.find(display);
1108    if (found == mReturnData.end()) {
1109        *state= -1;
1110        return;
1111    }
1112    ReturnData& data = found->second;
1113    *state = data.presentOrValidateState;
1114}
1115
1116} // namespace Hwc2
1117
1118} // namespace android
1119