v811_spc009/hardware/qcom/sm7250/display/composer/QtiComposerCommandBuffer.h

/*
 * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
 * Not a Contribution.
 *
 * Copyright (C) 2017 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.
 */

#ifndef __QTICOMPOSERCOMMANDBUFFER_H__
#define __QTICOMPOSERCOMMANDBUFFER_H__

#include <log/log.h>
#include <sync/sync.h>
#include <fmq/MessageQueue.h>
#include <hidl/MQDescriptor.h>
#include <utils/fence.h>

#include <limits>
#include <algorithm>
#include <vector>
#include <string>

namespace vendor {
namespace qti {
namespace hardware {
namespace display {
namespace composer {
namespace V3_0 {

using ::android::hardware::graphics::common::V1_0::ColorTransform;
using ::android::hardware::graphics::common::V1_0::Dataspace;
using ::android::hardware::graphics::common::V1_0::Transform;
using ::android::hardware::graphics::composer::V2_1::Error;
using ::android::hardware::graphics::composer::V2_1::Display;
using ::android::hardware::graphics::composer::V2_1::Layer;
using ::android::hardware::MessageQueue;
using ::android::hardware::MQDescriptorSync;
using ::android::hardware::hidl_vec;
using ::android::hardware::hidl_handle;

using CommandQueueType = MessageQueue<uint32_t, ::android::hardware::kSynchronizedReadWrite>;

using std::shared_ptr;
using std::string;
using sdm::Fence;

// This class helps build a command queue.  Note that all sizes/lengths are in units of uint32_t's.
class CommandWriter {
 public:
  explicit CommandWriter(uint32_t initialMaxSize) : mDataMaxSize(initialMaxSize) {
    mData = std::make_unique<uint32_t[]>(mDataMaxSize);
    reset();
  }

  ~CommandWriter() { reset(); }

  void reset() {
    mDataWritten = 0;
    mCommandEnd = 0;

    // handles in mDataHandles are owned by the caller
    mDataHandles.clear();

    // handles in mTemporaryHandles are owned by the writer
    for (auto handle : mTemporaryHandles) {
      native_handle_close(handle);
      native_handle_delete(handle);
    }
    mTemporaryHandles.clear();
  }

  IQtiComposerClient::Command getCommand(uint32_t offset) {
    uint32_t val = (offset < mDataWritten) ? mData[offset] : 0;
    return static_cast<IQtiComposerClient::Command>(val &
      static_cast<uint32_t>(IQtiComposerClient::Command::OPCODE_MASK));
  }

  bool writeQueue(bool& queueChanged, uint32_t& commandLength,
                  hidl_vec<hidl_handle>& commandHandles) {
    if (mDataWritten == 0) {
      queueChanged = false;
      commandLength = 0;
      commandHandles.setToExternal(nullptr, 0);
      return true;
    }

    // After data are written to the queue, it may not be read by the
    // remote reader when
    //
    //  - the writer does not send them (because of other errors)
    //  - the hwbinder transaction fails
    //  - the reader does not read them (because of other errors)
    //
    // Discard the stale data here.
    size_t staleDataSize = mQueue ? mQueue->availableToRead() : 0;
    if (staleDataSize > 0) {
      ALOGW("discarding stale data from message queue");
      CommandQueueType::MemTransaction tx;
      if (mQueue->beginRead(staleDataSize, &tx)) {
        mQueue->commitRead(staleDataSize);
      }
    }
    // write data to queue, optionally resizing it
    if (mQueue && (mDataMaxSize <= mQueue->getQuantumCount())) {
      if (!mQueue->write(mData.get(), mDataWritten)) {
        ALOGE("failed to write commands to message queue");
        return false;
      }

      queueChanged = false;
    } else {
      auto newQueue = std::make_unique<CommandQueueType>(mDataMaxSize);
      if (!newQueue->isValid() || !newQueue->write(mData.get(), mDataWritten)) {
        ALOGE("failed to prepare a new message queue ");
        return false;
      }

      mQueue = std::move(newQueue);
      queueChanged = true;
    }

    commandLength = mDataWritten;
    commandHandles.setToExternal(const_cast<hidl_handle*>(mDataHandles.data()),
                                 mDataHandles.size());

    return true;
  }

  const MQDescriptorSync<uint32_t>* getMQDescriptor() const {
    return (mQueue) ? mQueue->getDesc() : nullptr;
  }

  // Commands from ::android::hardware::graphics::composer::V2_1::IComposerClient follow.
  static constexpr uint16_t kSelectDisplayLength = 2;
  void selectDisplay(Display display) {
    beginCommand(IQtiComposerClient::Command::SELECT_DISPLAY, kSelectDisplayLength);
    write64(display);
    endCommand();
  }

  static constexpr uint16_t kSelectLayerLength = 2;
  void selectLayer(Layer layer) {
    beginCommand(IQtiComposerClient::Command::SELECT_LAYER, kSelectLayerLength);
    write64(layer);
    endCommand();
  }

  static constexpr uint16_t kSetErrorLength = 2;
  void setError(uint32_t location, Error error) {
    beginCommand(IQtiComposerClient::Command::SET_ERROR, kSetErrorLength);
    write(location);
    writeSigned(static_cast<int32_t>(error));
    endCommand();
  }

  static constexpr uint32_t kPresentOrValidateDisplayResultLength = 1;
  void setPresentOrValidateResult(uint32_t state) {
    beginCommand(IQtiComposerClient::Command::SET_PRESENT_OR_VALIDATE_DISPLAY_RESULT,
                 kPresentOrValidateDisplayResultLength);
    write(state);
    endCommand();
  }

  void setChangedCompositionTypes(const std::vector<Layer>& layers,
                                  const std::vector<IQtiComposerClient::Composition>& types) {
    size_t totalLayers = std::min(layers.size(), types.size());
    size_t currentLayer = 0;

    while (currentLayer < totalLayers) {
      size_t count = std::min(totalLayers - currentLayer, static_cast<size_t>(kMaxLength) / 3);

      beginCommand(IQtiComposerClient::Command::SET_CHANGED_COMPOSITION_TYPES, count * 3);
      for (size_t i = 0; i < count; i++) {
        write64(layers[currentLayer + i]);
        writeSigned(static_cast<int32_t>(types[currentLayer + i]));
      }
      endCommand();

      currentLayer += count;
    }
  }

  void setDisplayRequests(uint32_t displayRequestMask, const std::vector<Layer>& layers,
                          const std::vector<uint32_t>& layerRequestMasks) {
    size_t totalLayers = std::min(layers.size(), layerRequestMasks.size());
    size_t currentLayer = 0;

    while (currentLayer < totalLayers) {
      size_t count = std::min(totalLayers - currentLayer, static_cast<size_t>(kMaxLength - 1) / 3);

      beginCommand(IQtiComposerClient::Command::SET_DISPLAY_REQUESTS, 1 + count * 3);
      write(displayRequestMask);
      for (size_t i = 0; i < count; i++) {
        write64(layers[currentLayer + i]);
        write(static_cast<int32_t>(layerRequestMasks[currentLayer + i]));
      }
      endCommand();

      currentLayer += count;
    }
  }

  static constexpr uint16_t kSetPresentFenceLength = 1;
  void setPresentFence(const shared_ptr<Fence> &presentFence) {
    beginCommand(IQtiComposerClient::Command::SET_PRESENT_FENCE, kSetPresentFenceLength);
    writeFence(presentFence);
    endCommand();
  }

  void setReleaseFences(const std::vector<Layer>& layers,
                        const std::vector<shared_ptr<Fence>>& releaseFences) {
    size_t totalLayers = std::min(layers.size(), releaseFences.size());
    size_t currentLayer = 0;

    while (currentLayer < totalLayers) {
      size_t count = std::min(totalLayers - currentLayer, static_cast<size_t>(kMaxLength) / 3);

      beginCommand(IQtiComposerClient::Command::SET_RELEASE_FENCES, count * 3);
      for (size_t i = 0; i < count; i++) {
        write64(layers[currentLayer + i]);
        writeFence(releaseFences[currentLayer + i]);
      }
      endCommand();

      currentLayer += count;
    }
  }

  static constexpr uint16_t kSetColorTransformLength = 17;
  void setColorTransform(const float* matrix, ColorTransform hint) {
    beginCommand(IQtiComposerClient::Command::SET_COLOR_TRANSFORM, kSetColorTransformLength);
    for (int i = 0; i < 16; i++) {
      writeFloat(matrix[i]);
    }
    writeSigned(static_cast<int32_t>(hint));
    endCommand();
  }

  void setClientTarget(uint32_t slot, const native_handle_t* target,
                       const shared_ptr<Fence>& acquireFence, Dataspace dataspace,
                       const std::vector<IQtiComposerClient::Rect>& damage) {
    bool doWrite = (damage.size() <= (kMaxLength - 4) / 4);
    size_t length = 4 + ((doWrite) ? damage.size() * 4 : 0);

    beginCommand(IQtiComposerClient::Command::SET_CLIENT_TARGET, length);
    write(slot);
    writeHandle(target, true);
    writeFence(acquireFence);
    writeSigned(static_cast<int32_t>(dataspace));
    // When there are too many rectangles in the damage region and doWrite
    // is false, we write no rectangle at all which means the entire
    // client target is damaged.
    if (doWrite) {
      writeRegion(damage);
    }
    endCommand();
  }

  static constexpr uint16_t kSetOutputBufferLength = 3;
  void setOutputBuffer(uint32_t slot, const native_handle_t* buffer,
                       const shared_ptr<Fence>& releaseFence) {
    beginCommand(IQtiComposerClient::Command::SET_OUTPUT_BUFFER, kSetOutputBufferLength);
    write(slot);
    writeHandle(buffer, true);
    writeFence(releaseFence);
    endCommand();
  }

  static constexpr uint16_t kValidateDisplayLength = 0;
  void validateDisplay() {
    beginCommand(IQtiComposerClient::Command::VALIDATE_DISPLAY, kValidateDisplayLength);
    endCommand();
  }

  static constexpr uint16_t kPresentOrValidateDisplayLength = 0;
  void presentOrvalidateDisplay() {
    beginCommand(IQtiComposerClient::Command::PRESENT_OR_VALIDATE_DISPLAY,
                 kPresentOrValidateDisplayLength);
    endCommand();
  }

  static constexpr uint16_t kAcceptDisplayChangesLength = 0;
  void acceptDisplayChanges() {
    beginCommand(IQtiComposerClient::Command::ACCEPT_DISPLAY_CHANGES, kAcceptDisplayChangesLength);
    endCommand();
  }

  static constexpr uint16_t kPresentDisplayLength = 0;
  void presentDisplay() {
    beginCommand(IQtiComposerClient::Command::PRESENT_DISPLAY, kPresentDisplayLength);
    endCommand();
  }

  static constexpr uint16_t kSetLayerCursorPositionLength = 2;
  void setLayerCursorPosition(int32_t x, int32_t y) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_CURSOR_POSITION,
                 kSetLayerCursorPositionLength);
    writeSigned(x);
    writeSigned(y);
    endCommand();
  }

  static constexpr uint16_t kSetLayerBufferLength = 3;
  void setLayerBuffer(uint32_t slot, const native_handle_t* buffer,
                      const shared_ptr<Fence>& acquireFence) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_BUFFER, kSetLayerBufferLength);
    write(slot);
    writeHandle(buffer, true);
    writeFence(acquireFence);
    endCommand();
  }

  void setLayerSurfaceDamage(const std::vector<IQtiComposerClient::Rect>& damage) {
    bool doWrite = (damage.size() <= kMaxLength / 4);
    size_t length = (doWrite) ? damage.size() * 4 : 0;

    beginCommand(IQtiComposerClient::Command::SET_LAYER_SURFACE_DAMAGE, length);
    // When there are too many rectangles in the damage region and doWrite
    // is false, we write no rectangle at all which means the entire
    // layer is damaged.
    if (doWrite) {
      writeRegion(damage);
    }
    endCommand();
  }

  static constexpr uint16_t kSetLayerBlendModeLength = 1;
  void setLayerBlendMode(IQtiComposerClient::BlendMode mode) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_BLEND_MODE, kSetLayerBlendModeLength);
    writeSigned(static_cast<int32_t>(mode));
    endCommand();
  }

  static constexpr uint16_t kSetLayerColorLength = 1;
  void setLayerColor(IQtiComposerClient::Color color) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_COLOR, kSetLayerColorLength);
    writeColor(color);
    endCommand();
  }

  static constexpr uint16_t kSetLayerCompositionTypeLength = 1;
  void setLayerCompositionType(IQtiComposerClient::Composition type) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_COMPOSITION_TYPE,
                 kSetLayerCompositionTypeLength);
    writeSigned(static_cast<int32_t>(type));
    endCommand();
  }

  static constexpr uint16_t kSetLayerDataspaceLength = 1;
  void setLayerDataspace(Dataspace dataspace) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_DATASPACE, kSetLayerDataspaceLength);
    writeSigned(static_cast<int32_t>(dataspace));
    endCommand();
  }

  static constexpr uint16_t kSetLayerDisplayFrameLength = 4;
  void setLayerDisplayFrame(const IQtiComposerClient::Rect& frame) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_DISPLAY_FRAME, kSetLayerDisplayFrameLength);
    writeRect(frame);
    endCommand();
  }

  static constexpr uint16_t kSetLayerPlaneAlphaLength = 1;
  void setLayerPlaneAlpha(float alpha) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_PLANE_ALPHA, kSetLayerPlaneAlphaLength);
    writeFloat(alpha);
    endCommand();
  }

  static constexpr uint16_t kSetLayerSidebandStreamLength = 1;
  void setLayerSidebandStream(const native_handle_t* stream) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_SIDEBAND_STREAM,
                 kSetLayerSidebandStreamLength);
    writeHandle(stream);
    endCommand();
  }

  static constexpr uint16_t kSetLayerSourceCropLength = 4;
  void setLayerSourceCrop(const IQtiComposerClient::FRect& crop) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_SOURCE_CROP, kSetLayerSourceCropLength);
    writeFRect(crop);
    endCommand();
  }

  static constexpr uint16_t kSetLayerTransformLength = 1;
  void setLayerTransform(Transform transform) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_TRANSFORM, kSetLayerTransformLength);
    writeSigned(static_cast<int32_t>(transform));
    endCommand();
  }

  void setLayerVisibleRegion(const std::vector<IQtiComposerClient::Rect>& visible) {
    bool doWrite = (visible.size() <= kMaxLength / 4);
    size_t length = (doWrite) ? visible.size() * 4 : 0;

    beginCommand(IQtiComposerClient::Command::SET_LAYER_VISIBLE_REGION, length);
    // When there are too many rectangles in the visible region and
    // doWrite is false, we write no rectangle at all which means the
    // entire layer is visible.
    if (doWrite) {
      writeRegion(visible);
    }
    endCommand();
  }

  static constexpr uint16_t kSetLayerZOrderLength = 1;
  void setLayerZOrder(uint32_t z) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_Z_ORDER, kSetLayerZOrderLength);
    write(z);
    endCommand();
  }

  static constexpr uint16_t kSetLayerTypeLength = 1;
  void setLayerType(uint32_t z) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_TYPE, kSetLayerTypeLength);
    write(z);
    endCommand();
  }

  // Commands from ::android::hardware::graphics::composer::V2_2::IComposerClient follow.
  static constexpr uint16_t kSetLayerFloatColorLength = 4;
  void setLayerFloatColor(IQtiComposerClient::FloatColor color) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_FLOAT_COLOR, kSetLayerFloatColorLength);
    writeFloatColor(color);
    endCommand();
  }

  void setLayerPerFrameMetadata(const hidl_vec<IQtiComposerClient::PerFrameMetadata>& metadataVec) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_PER_FRAME_METADATA,
                 metadataVec.size() * 2);
    for (const auto& metadata : metadataVec) {
      writeSigned(static_cast<int32_t>(metadata.key));
      writeFloat(metadata.value);
    }
    endCommand();
  }

  // Commands from ::android::hardware::graphics::composer::V2_3::IComposerClient follow.
  static constexpr uint16_t kSetLayerColorTransformLength = 16;
  void setLayerColorTransform(const float* matrix) {
    beginCommand(IQtiComposerClient::Command::SET_LAYER_COLOR_TRANSFORM,
                 kSetLayerColorTransformLength);
    for (int i = 0; i < 16; i++) {
      writeFloat(matrix[i]);
    }
    endCommand();
  }

  void setLayerPerFrameMetadataBlobs(
    const hidl_vec<IQtiComposerClient::PerFrameMetadataBlob>& metadata) {
    size_t commandLength = 0;

    if (metadata.size() > std::numeric_limits<uint32_t>::max()) {
      LOG_FATAL("too many metadata blobs - dynamic metadata size is too large");
      return;
    }

    // number of blobs
    commandLength += metadata.size();

    for (auto metadataBlob : metadata) {
      commandLength += sizeof(int32_t);  // key of metadata blob
      commandLength += 1;                // size information of metadata blob

      // metadata content size
      size_t metadataSize = metadataBlob.blob.size() / sizeof(uint32_t);
      commandLength += metadataSize;
      commandLength += (metadataBlob.blob.size() - (metadataSize * sizeof(uint32_t)) > 0) ? 1 : 0;
    }

    if (commandLength > std::numeric_limits<uint16_t>::max()) {
      LOG_FATAL("dynamic metadata size is too large");
      return;
    }

    // Blobs are written as:
    // {numElements, key1, size1, blob1, key2, size2, blob2, key3, size3...}
    uint16_t length = static_cast<uint16_t>(commandLength);
    beginCommand(IQtiComposerClient::Command::SET_LAYER_PER_FRAME_METADATA_BLOBS, length);
    write(static_cast<uint32_t>(metadata.size()));
    for (auto metadataBlob : metadata) {
      writeSigned(static_cast<int32_t>(metadataBlob.key));
      write(static_cast<uint32_t>(metadataBlob.blob.size()));
      writeBlob(static_cast<uint32_t>(metadataBlob.blob.size()), metadataBlob.blob.data());
    }
    endCommand();
  }

  static constexpr uint16_t kSetDisplayElapseTime = 2;
  void setDisplayElapseTime(uint64_t time) {
    beginCommand(IQtiComposerClient::Command::SET_DISPLAY_ELAPSE_TIME, kSetDisplayElapseTime);
    write64(time);
    endCommand();
  }

 protected:
  // Commands from ::android::hardware::graphics::composer::V2_1::IComposerClient follow.
  void beginCommand(IQtiComposerClient::Command command, uint16_t length) {
    if (mCommandEnd) {
      LOG_FATAL("endCommand was not called before command 0x%x", command);
    }

    growData(1 + length);
    write(static_cast<uint32_t>(command) | length);

    mCommandEnd = mDataWritten + length;
  }

  void endCommand() {
    if (!mCommandEnd) {
      LOG_FATAL("beginCommand was not called");
    } else if (mDataWritten > mCommandEnd) {
      LOG_FATAL("too much data written");
      mDataWritten = mCommandEnd;
    } else if (mDataWritten < mCommandEnd) {
      LOG_FATAL("too little data written");
      while (mDataWritten < mCommandEnd) {
        write(0);
      }
    }

    mCommandEnd = 0;
  }

  void write(uint32_t val) { mData[mDataWritten++] = val; }

  void writeSigned(int32_t val) { memcpy(&mData[mDataWritten++], &val, sizeof(val)); }

  void writeFloat(float val) { memcpy(&mData[mDataWritten++], &val, sizeof(val)); }

  void write64(uint64_t val) {
    uint32_t lo = static_cast<uint32_t>(val & 0xffffffff);
    uint32_t hi = static_cast<uint32_t>(val >> 32);
    write(lo);
    write(hi);
  }

  void writeRect(const IQtiComposerClient::Rect& rect) {
    writeSigned(rect.left);
    writeSigned(rect.top);
    writeSigned(rect.right);
    writeSigned(rect.bottom);
  }

  void writeRegion(const std::vector<IQtiComposerClient::Rect>& region) {
    for (const auto& rect : region) {
      writeRect(rect);
    }
  }

  void writeFRect(const IQtiComposerClient::FRect& rect) {
    writeFloat(rect.left);
    writeFloat(rect.top);
    writeFloat(rect.right);
    writeFloat(rect.bottom);
  }

  void writeColor(const IQtiComposerClient::Color& color) {
    write((color.r <<  0) | (color.g <<  8) | (color.b << 16) | (color.a << 24));
  }

  // ownership of handle is not transferred
  void writeHandle(const native_handle_t* handle, bool useCache) {
    if (!handle) {
      writeSigned(static_cast<int32_t>((useCache) ?
                IQtiComposerClient::HandleIndex::CACHED : IQtiComposerClient::HandleIndex::EMPTY));
      return;
    }

    mDataHandles.push_back(handle);
    writeSigned(mDataHandles.size() - 1);
  }

  void writeHandle(const native_handle_t* handle) {
    writeHandle(handle, false);
  }

  // Handle would own fence hereafter. Hence provide a dupped fd.
  void writeFence(const shared_ptr<Fence>& fence) {
    native_handle_t* handle = nullptr;
    if (fence) {
      handle = getTemporaryHandle(1, 0);
      if (handle) {
        handle->data[0] = Fence::Dup(fence);
      } else {
        ALOGW("failed to get temporary handle for fence %s", Fence::GetStr(fence).c_str());
        Fence::Wait(fence);
      }
    }

    writeHandle(handle);
  }

  native_handle_t* getTemporaryHandle(int numFds, int numInts) {
    native_handle_t* handle = native_handle_create(numFds, numInts);
    if (handle) {
      mTemporaryHandles.push_back(handle);
    }
    return handle;
  }

  static constexpr uint16_t kMaxLength = std::numeric_limits<uint16_t>::max();

  // Commands from ::android::hardware::graphics::composer::V2_2::IComposerClient follow.
  void writeFloatColor(const IQtiComposerClient::FloatColor& color) {
    writeFloat(color.r);
    writeFloat(color.g);
    writeFloat(color.b);
    writeFloat(color.a);
  }

  // Commands from ::android::hardware::graphics::composer::V2_3::IComposerClient follow.
  void writeBlob(uint32_t length, const unsigned char* blob) {
    memcpy(&mData[mDataWritten], blob, length);
    uint32_t numElements = length / 4;
    mDataWritten += numElements;
    mDataWritten += (length - (numElements * 4) > 0) ? 1 : 0;
  }

 private:
  void growData(uint32_t grow) {
    uint32_t newWritten = mDataWritten + grow;
    if (newWritten < mDataWritten) {
      LOG_ALWAYS_FATAL("buffer overflowed; data written %" PRIu32
                       ", growing by %" PRIu32, mDataWritten, grow);
    }

    if (newWritten <= mDataMaxSize) {
      return;
    }

    uint32_t newMaxSize = mDataMaxSize << 1;
    if (newMaxSize < newWritten) {
      newMaxSize = newWritten;
    }

    auto newData = std::make_unique<uint32_t[]>(newMaxSize);
    std::copy_n(mData.get(), mDataWritten, newData.get());
    mDataMaxSize = newMaxSize;
    mData = std::move(newData);
  }

  uint32_t mDataMaxSize;
  std::unique_ptr<uint32_t[]> mData;

  uint32_t mDataWritten;
  // end offset of the current command
  uint32_t mCommandEnd;

  std::vector<hidl_handle> mDataHandles;
  std::vector<native_handle_t *> mTemporaryHandles;

  std::unique_ptr<CommandQueueType> mQueue;
};

// This class helps parse a command queue.  Note that all sizes/lengths are in units of uint32_t's.
class CommandReaderBase {
 public:
  CommandReaderBase() : mDataMaxSize(0) { reset(); }

  bool setMQDescriptor(const MQDescriptorSync<uint32_t>& descriptor) {
    mQueue = std::make_unique<CommandQueueType>(descriptor, false);
    if (mQueue->isValid()) {
      return true;
    } else {
      mQueue = nullptr;
      return false;
    }
  }

  bool readQueue(uint32_t commandLength, const hidl_vec<hidl_handle>& commandHandles) {
    if (!mQueue) {
      return false;
    }

    auto quantumCount = mQueue->getQuantumCount();
    if (mDataMaxSize < quantumCount) {
      mDataMaxSize = quantumCount;
      mData = std::make_unique<uint32_t[]>(mDataMaxSize);
    }

    if (commandLength > mDataMaxSize || !mQueue->read(mData.get(), commandLength)) {
      ALOGE("failed to read commands from message queue");
      return false;
    }

    mDataSize = commandLength;
    mDataRead = 0;
    mCommandBegin = 0;
    mCommandEnd = 0;
    mDataHandles.setToExternal(const_cast<hidl_handle*>(commandHandles.data()),
                               commandHandles.size());

    return true;
  }

  void reset() {
    mDataSize = 0;
    mDataRead = 0;
    mCommandBegin = 0;
    mCommandEnd = 0;
    mDataHandles.setToExternal(nullptr, 0);
  }

 protected:
  bool isEmpty() const { return (mDataRead >= mDataSize); }

  bool beginCommand(IQtiComposerClient::Command& command, uint16_t& length) {
    if (mCommandEnd) {
      LOG_FATAL("endCommand was not called before command 0x%x", command);
    }

    constexpr uint32_t opcode_mask =
      static_cast<uint32_t>(IQtiComposerClient::Command::OPCODE_MASK);
    constexpr uint32_t length_mask =
      static_cast<uint32_t>(IQtiComposerClient::Command::LENGTH_MASK);

    uint32_t val = read();
    command = static_cast<IQtiComposerClient::Command>(val & opcode_mask);
    length = static_cast<uint16_t>(val & length_mask);

    if (mDataRead + length > mDataSize) {
      ALOGE("command 0x%x has invalid command length %" PRIu16, command, length);
      // undo the read() above
      mDataRead--;
      return false;
    }

    mCommandEnd = mDataRead + length;

    return true;
  }

  void endCommand() {
    if (!mCommandEnd) {
      LOG_FATAL("beginCommand was not called");
    } else if (mDataRead > mCommandEnd) {
      LOG_FATAL("too much data read");
      mDataRead = mCommandEnd;
    } else if (mDataRead < mCommandEnd) {
      LOG_FATAL("too little data read");
      mDataRead = mCommandEnd;
    }

    mCommandBegin = mCommandEnd;
    mCommandEnd = 0;
  }

  uint32_t getCommandLoc() const { return mCommandBegin; }

  uint32_t read() { return mData[mDataRead++]; }

  int32_t readSigned() {
    int32_t val;
    memcpy(&val, &mData[mDataRead++], sizeof(val));
    return val;
  }

  float readFloat() {
    float val;
    memcpy(&val, &mData[mDataRead++], sizeof(val));
    return val;
  }

  uint64_t read64() {
    uint32_t lo = read();
    uint32_t hi = read();
    return (static_cast<uint64_t>(hi) << 32) | lo;
  }

  void readBlob(uint32_t size, void* blob) {
    memcpy(blob, &mData[mDataRead], size);
    uint32_t numElements = size / sizeof(uint32_t);
    mDataRead += numElements;
    mDataRead += (size - numElements * sizeof(uint32_t) != 0) ? 1 : 0;
  }

  IQtiComposerClient::Color readColor() {
    uint32_t val = read();
    return IQtiComposerClient::Color{
      static_cast<uint8_t>((val >>  0) & 0xff),
      static_cast<uint8_t>((val >>  8) & 0xff),
      static_cast<uint8_t>((val >> 16) & 0xff),
      static_cast<uint8_t>((val >> 24) & 0xff),
    };
  }

  // ownership of handle is not transferred
  const native_handle_t* readHandle(bool& useCache) {
    const native_handle_t* handle = nullptr;

    int32_t index = readSigned();
    switch (index) {
    case static_cast<int32_t>(IQtiComposerClient::HandleIndex::EMPTY):
      useCache = false;
      break;
    case static_cast<int32_t>(IQtiComposerClient::HandleIndex::CACHED):
      useCache = true;
      break;
    default:
      if (static_cast<size_t>(index) < mDataHandles.size()) {
        handle = mDataHandles[index].getNativeHandle();
      } else {
        ALOGE("invalid handle index %zu", static_cast<size_t>(index));
      }
      useCache = false;
      break;
    }

    return handle;
  }

  const native_handle_t* readHandle() {
    bool useCache;
    return readHandle(useCache);
  }

  // Handle would still own original fence. Hence create a Fence object on duped fd.
  void readFence(shared_ptr<Fence>* fence, const string &name) {
    auto handle = readHandle();
    if (!handle || handle->numFds == 0) {
      return;
    }

    if (handle->numFds != 1) {
      ALOGE("invalid fence handle with %d fds", handle->numFds);
      return;
    }

    *fence = Fence::Create(dup(handle->data[0]), name);
    if (*fence == nullptr) {
      ALOGW("failed to dup fence %d", handle->data[0]);
      sync_wait(handle->data[0], -1);
    }
  }

 private:
  std::unique_ptr<CommandQueueType> mQueue;
  uint32_t mDataMaxSize;
  std::unique_ptr<uint32_t[]> mData;

  uint32_t mDataSize;
  uint32_t mDataRead;

  // begin/end offsets of the current command
  uint32_t mCommandBegin;
  uint32_t mCommandEnd;

  hidl_vec<hidl_handle> mDataHandles;
};

}  // namespace V3_0
}  // namespace composer
}  // namespace display
}  // namespace hardware
}  // namespace qti
}  // namespace vendor

#endif  // __QTICOMPOSERCOMMANDBUFFER_H__