codec2/hidl/1.0/utils/InputSurfaceConnection.cpp - platform/hardware/google/av - Git at Google

 /*
  * Copyright (C) 2018 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.
  */

 //#define LOG_NDEBUG 0
 #define LOG_TAG "Codec2-InputSurfaceConnection"
 #include <log/log.h>

 #include <codec2/hidl/1.0/InputSurfaceConnection.h>

 #include <memory>
 #include <list>
 #include <mutex>
 #include <atomic>

 #include <hidl/HidlSupport.h>
 #include <media/stagefright/bqhelper/ComponentWrapper.h>
 #include <system/graphics.h>
 #include <ui/GraphicBuffer.h>
 #include <utils/Errors.h>

 #include <C2.h>
 #include <C2AllocatorGralloc.h>
 #include <C2BlockInternal.h>
 #include <C2Buffer.h>
 #include <C2Component.h>
 #include <C2Config.h>
 #include <C2Debug.h>
 #include <C2PlatformSupport.h>
 #include <C2Work.h>

 namespace hardware {
 namespace google {
 namespace media {
 namespace c2 {
 namespace V1_0 {
 namespace utils {

 constexpr int32_t kBufferCount = 16;

 using namespace ::android;
 using ::android::hardware::hidl_string;
 using ::android::hardware::hidl_vec;
 using ::android::hardware::Return;

 namespace /* unnamed */ {

 class Buffer2D : public C2Buffer {
 public:
     explicit Buffer2D(C2ConstGraphicBlock block) : C2Buffer({ block }) {
     }
 };

 } // unnamed namespace

 struct InputSurfaceConnection::Impl : public ComponentWrapper {
     Impl(const sp<GraphicBufferSource>& source,
          const std::shared_ptr<C2Component>& comp) :
             mSource(source), mComp(comp), mRemoteComp(),
             mFrameIndex(0) {
         std::shared_ptr<C2ComponentInterface> intf = comp->intf();
         mCompName = intf ? intf->getName() : "";
     }

     Impl(const sp<GraphicBufferSource>& source,
          const sp<IComponent>& comp) :
             mSource(source), mComp(), mRemoteComp(comp),
             mFrameIndex(0) {
         Return<void> transStatus = comp->getName(
                 [this](const hidl_string& name) {
                     mCompName = name.c_str();
                 });
         if (!transStatus.isOk()) {
             ALOGD("getName -- Cannot obtain remote component name.");
         }
     }

     virtual ~Impl() = default;

     bool init() {
         sp<GraphicBufferSource> source = mSource.promote();
         if (source == nullptr) {
             return false;
         }
         status_t err = source->initCheck();
         if (err != OK) {
             ALOGD("Impl::init -- GBS init failed: %d", err);
             return false;
         }

         // TODO: read settings properly from the interface
         C2VideoSizeStreamTuning::input inputSize;
         C2StreamUsageTuning::input usage;
         c2_status_t c2Status = compQuery({ &inputSize, &usage },
                                          {},
                                          C2_MAY_BLOCK,
                                          nullptr);
         if (c2Status != C2_OK) {
             ALOGD("Impl::init -- cannot query information from "
                     "the component interface: %s.", asString(c2Status));
             return false;
         }

         // TODO: proper color aspect & dataspace
         android_dataspace dataSpace = HAL_DATASPACE_BT709;

         // TODO: use the usage read from intf
         // uint32_t grallocUsage =
         //         C2AndroidMemoryUsage(C2MemoryUsage(usage.value)).
         //         asGrallocUsage();

         uint32_t grallocUsage =
                 mCompName.compare(0, 11, "c2.android.") == 0 ?
                 GRALLOC_USAGE_SW_READ_OFTEN :
                 GRALLOC_USAGE_HW_VIDEO_ENCODER;

         err = source->configure(
                 this, dataSpace, kBufferCount,
                 inputSize.width, inputSize.height,
                 grallocUsage);
         if (err != OK) {
             ALOGD("Impl::init -- GBS configure failed: %d", err);
             return false;
         }
         for (int32_t i = 0; i < kBufferCount; ++i) {
             if (!source->onInputBufferAdded(i).isOk()) {
                 ALOGD("Impl::init: populating GBS slots failed");
                 return false;
             }
         }
         if (!source->start().isOk()) {
             ALOGD("Impl::init -- GBS start failed");
             return false;
         }
         mAllocatorMutex.lock();
         c2_status_t c2err = GetCodec2PlatformAllocatorStore()->fetchAllocator(
                 C2AllocatorStore::PLATFORM_START + 1,  // GRALLOC
                 &mAllocator);
         mAllocatorMutex.unlock();
         if (c2err != OK) {
             ALOGD("Impl::init -- failed to fetch gralloc allocator: %d", c2err);
             return false;
         }
         return true;
     }

     // From ComponentWrapper
     virtual status_t submitBuffer(
             int32_t bufferId,
             const sp<GraphicBuffer>& buffer,
             int64_t timestamp,
             int fenceFd) override {
         ALOGV("Impl::submitBuffer -- bufferId = %d", bufferId);
         // TODO: Use fd to construct fence
         (void)fenceFd;

         std::shared_ptr<C2GraphicAllocation> alloc;
         C2Handle* handle = WrapNativeCodec2GrallocHandle(
                 buffer->handle,
                 buffer->width, buffer->height,
                 buffer->format, buffer->usage, buffer->stride);
         mAllocatorMutex.lock();
         c2_status_t err = mAllocator->priorGraphicAllocation(handle, &alloc);
         mAllocatorMutex.unlock();
         if (err != OK) {
             return UNKNOWN_ERROR;
         }
         std::shared_ptr<C2GraphicBlock> block =
                 _C2BlockFactory::CreateGraphicBlock(alloc);

         std::unique_ptr<C2Work> work(new C2Work);
         work->input.flags = (C2FrameData::flags_t)0;
         work->input.ordinal.timestamp = timestamp;
         work->input.ordinal.frameIndex = mFrameIndex.fetch_add(
                 1, std::memory_order_relaxed);
         work->input.buffers.clear();
         std::shared_ptr<C2Buffer> c2Buffer(
                 // TODO: fence
                 new Buffer2D(block->share(
                         C2Rect(block->width(), block->height()), ::C2Fence())),
                 [bufferId, src = mSource](C2Buffer* ptr) {
                     delete ptr;
                     sp<GraphicBufferSource> source = src.promote();
                     if (source != nullptr) {
                         // TODO: fence
                         (void)source->onInputBufferEmptied(bufferId, -1);
                     }
                 });
         work->input.buffers.push_back(c2Buffer);
         work->worklets.clear();
         work->worklets.emplace_back(new C2Worklet);
         std::list<std::unique_ptr<C2Work>> items;
         items.push_back(std::move(work));

         err = compQueue(&items);
         return (err == C2_OK) ? OK : UNKNOWN_ERROR;
     }

     virtual status_t submitEos(int32_t /* bufferId */) override {
         ALOGV("Impl::submitEos");

         std::unique_ptr<C2Work> work(new C2Work);
         work->input.flags = (C2FrameData::flags_t)0;
         work->input.ordinal.frameIndex = mFrameIndex.fetch_add(
                 1, std::memory_order_relaxed);
         work->input.buffers.clear();
         work->worklets.clear();
         work->worklets.emplace_back(new C2Worklet);
         std::list<std::unique_ptr<C2Work>> items;
         items.push_back(std::move(work));

         c2_status_t err = compQueue(&items);
         return (err == C2_OK) ? OK : UNKNOWN_ERROR;
     }

     void dispatchDataSpaceChanged(
             int32_t dataSpace, int32_t aspects, int32_t pixelFormat) override {
         // TODO
         (void)dataSpace;
         (void)aspects;
         (void)pixelFormat;
     }

 private:
     c2_status_t compQuery(
             const std::vector<C2Param*> &stackParams,
             const std::vector<C2Param::Index> &heapParamIndices,
             c2_blocking_t mayBlock,
             std::vector<std::unique_ptr<C2Param>>* const heapParams) {
         std::shared_ptr<C2Component> comp = mComp.lock();
         if (comp) {
             std::shared_ptr<C2ComponentInterface> intf = comp->intf();
             if (intf) {
                 return intf->query_vb(stackParams,
                                       heapParamIndices,
                                       mayBlock,
                                       heapParams);
             } else {
                 ALOGD("compQuery -- component does not have an interface.");
                 return C2_BAD_STATE;
             }
         }
         if (!mRemoteComp) {
             ALOGD("compQuery -- component no longer exists.");
             return C2_BAD_STATE;
         }

         hidl_vec<ParamIndex> indices(
                 stackParams.size() + heapParamIndices.size());
         size_t numIndices = 0;
         for (C2Param* const& stackParam : stackParams) {
             if (!stackParam) {
                 ALOGD("compQuery -- null stack param encountered.");
                 continue;
             }
             indices[numIndices++] = static_cast<ParamIndex>(stackParam->index());
         }
         size_t numStackIndices = numIndices;
         for (const C2Param::Index& index : heapParamIndices) {
             indices[numIndices++] =
                     static_cast<ParamIndex>(static_cast<uint32_t>(index));
         }
         indices.resize(numIndices);
         if (heapParams) {
             heapParams->reserve(heapParams->size() + numIndices);
         }
         c2_status_t status;
         Return<void> transStatus = mRemoteComp->query(
                 indices,
                 mayBlock == C2_MAY_BLOCK,
                 [&status, &numStackIndices, &stackParams, heapParams](
                         Status s, const Params& p) {
                     status = static_cast<c2_status_t>(s);
                     if (status != C2_OK && status != C2_BAD_INDEX) {
                         ALOGD("compQuery -- call failed: %s.", asString(status));
                         return;
                     }
                     std::vector<C2Param*> paramPointers;
                     c2_status_t parseStatus = parseParamsBlob(&paramPointers, p);
                     if (parseStatus != C2_OK) {
                         ALOGD("compQuery -- error while parsing params: %s.",
                               asString(parseStatus));
                         status = parseStatus;
                         return;
                     }
                     size_t i = 0;
                     for (auto it = paramPointers.begin();
                             it != paramPointers.end(); ) {
                         C2Param* paramPointer = *it;
                         if (numStackIndices > 0) {
                             --numStackIndices;
                             if (!paramPointer) {
                                 ALOGD("compQuery -- null stack param.");
                                 ++it;
                                 continue;
                             }
                             for (; i < stackParams.size() &&
                                     !stackParams[i]; ) {
                                 ++i;
                             }
                             CHECK(i < stackParams.size());
                             if (stackParams[i]->index() !=
                                     paramPointer->index()) {
                                 ALOGD("compQuery -- param skipped. index = %d",
                                       static_cast<int>(
                                       stackParams[i]->index()));
                                 stackParams[i++]->invalidate();
                                 continue;
                             }
                             if (!stackParams[i++]->updateFrom(*paramPointer)) {
                                 ALOGD("compQuery -- param update failed: "
                                       "index = %d.",
                                       static_cast<int>(paramPointer->index()));
                             }
                         } else {
                             if (!paramPointer) {
                                 ALOGD("compQuery -- null heap param.");
                                 ++it;
                                 continue;
                             }
                             if (!heapParams) {
                                 ALOGD("compQuery -- too many stack params.");
                                 break;
                             }
                             heapParams->emplace_back(C2Param::Copy(*paramPointer));
                         }
                         ++it;
                     }
                 });
         if (!transStatus.isOk()) {
             ALOGD("compQuery -- transaction failed.");
             return C2_CORRUPTED;
         }
         return status;
     }

     c2_status_t compQueue(std::list<std::unique_ptr<C2Work>>* const items) {
         std::shared_ptr<C2Component> comp = mComp.lock();
         if (comp) {
             return comp->queue_nb(items);
         }

         WorkBundle workBundle;
         Status hidlStatus = objcpy(&workBundle, *items, nullptr);
         if (hidlStatus != Status::OK) {
             ALOGD("compQueue -- bad input.");
             return C2_CORRUPTED;
         }
         Return<Status> transStatus = mRemoteComp->queue(workBundle);
         if (!transStatus.isOk()) {
             ALOGD("compQueue -- transaction failed.");
             return C2_CORRUPTED;
         }
         c2_status_t status =
                 static_cast<c2_status_t>(static_cast<Status>(transStatus));
         if (status != C2_OK) {
             ALOGV("compQueue -- call failed: %s.", asString(status));
         }
         return status;
     }

     wp<GraphicBufferSource> mSource;
     std::weak_ptr<C2Component> mComp;
     sp<IComponent> mRemoteComp;
     std::string mCompName;

     // Needed for ComponentWrapper implementation
     std::mutex mAllocatorMutex;
     std::shared_ptr<C2Allocator> mAllocator;
     std::atomic_uint64_t mFrameIndex;
 };

 InputSurfaceConnection::InputSurfaceConnection(
         const sp<GraphicBufferSource>& source,
         const std::shared_ptr<C2Component>& comp) :
     mSource(source),
     mImpl(new Impl(source, comp)) {
 }

 InputSurfaceConnection::InputSurfaceConnection(
         const sp<GraphicBufferSource>& source,
         const sp<IComponent>& comp) :
     mSource(source),
     mImpl(new Impl(source, comp)) {
 }

 InputSurfaceConnection::~InputSurfaceConnection() {
     if (mSource) {
         (void)mSource->stop();
         (void)mSource->release();
         mSource.clear();
     }
     mImpl.clear();
 }

 bool InputSurfaceConnection::init() {
     mMutex.lock();
     sp<Impl> impl = mImpl;
     mMutex.unlock();

     if (!impl) {
         return false;
     }
     return impl->init();
 }

 Return<Status> InputSurfaceConnection::disconnect() {
     ALOGV("disconnect");
     mMutex.lock();
     if (mSource) {
         (void)mSource->stop();
         (void)mSource->release();
         mSource.clear();
     }
     mImpl.clear();
     mMutex.unlock();
     ALOGV("disconnected");
     return Status::OK;
 }

 }  // namespace utils
 }  // namespace V1_0
 }  // namespace c2
 }  // namespace media
 }  // namespace google
 }  // namespace hardware
	/*
	* Copyright (C) 2018 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.
	*/

	//#define LOG_NDEBUG 0
	#define LOG_TAG "Codec2-InputSurfaceConnection"
	#include <log/log.h>

	#include <codec2/hidl/1.0/InputSurfaceConnection.h>

	#include <memory>
	#include <list>
	#include <mutex>
	#include <atomic>

	#include <hidl/HidlSupport.h>
	#include <media/stagefright/bqhelper/ComponentWrapper.h>
	#include <system/graphics.h>
	#include <ui/GraphicBuffer.h>
	#include <utils/Errors.h>

	#include <C2.h>
	#include <C2AllocatorGralloc.h>
	#include <C2BlockInternal.h>
	#include <C2Buffer.h>
	#include <C2Component.h>
	#include <C2Config.h>
	#include <C2Debug.h>
	#include <C2PlatformSupport.h>
	#include <C2Work.h>

	namespace hardware {
	namespace google {
	namespace media {
	namespace c2 {
	namespace V1_0 {
	namespace utils {

	constexpr int32_t kBufferCount = 16;

	using namespace ::android;
	using ::android::hardware::hidl_string;
	using ::android::hardware::hidl_vec;
	using ::android::hardware::Return;

	namespace /* unnamed */ {

	class Buffer2D : public C2Buffer {
	public:
	explicit Buffer2D(C2ConstGraphicBlock block) : C2Buffer({ block }) {
	}
	};

	} // unnamed namespace

	struct InputSurfaceConnection::Impl : public ComponentWrapper {
	Impl(const sp<GraphicBufferSource>& source,
	const std::shared_ptr<C2Component>& comp) :
	mSource(source), mComp(comp), mRemoteComp(),
	mFrameIndex(0) {
	std::shared_ptr<C2ComponentInterface> intf = comp->intf();
	mCompName = intf ? intf->getName() : "";
	}

	Impl(const sp<GraphicBufferSource>& source,
	const sp<IComponent>& comp) :
	mSource(source), mComp(), mRemoteComp(comp),
	mFrameIndex(0) {
	Return<void> transStatus = comp->getName(
	[this](const hidl_string& name) {
	mCompName = name.c_str();
	});
	if (!transStatus.isOk()) {
	ALOGD("getName -- Cannot obtain remote component name.");
	}
	}

	virtual ~Impl() = default;

	bool init() {
	sp<GraphicBufferSource> source = mSource.promote();
	if (source == nullptr) {
	return false;
	}
	status_t err = source->initCheck();
	if (err != OK) {
	ALOGD("Impl::init -- GBS init failed: %d", err);
	return false;
	}

	// TODO: read settings properly from the interface
	C2VideoSizeStreamTuning::input inputSize;
	C2StreamUsageTuning::input usage;
	c2_status_t c2Status = compQuery({ &inputSize, &usage },
	{},
	C2_MAY_BLOCK,
	nullptr);
	if (c2Status != C2_OK) {
	ALOGD("Impl::init -- cannot query information from "
	"the component interface: %s.", asString(c2Status));
	return false;
	}

	// TODO: proper color aspect & dataspace
	android_dataspace dataSpace = HAL_DATASPACE_BT709;

	// TODO: use the usage read from intf
	// uint32_t grallocUsage =
	// C2AndroidMemoryUsage(C2MemoryUsage(usage.value)).
	// asGrallocUsage();

	uint32_t grallocUsage =
	mCompName.compare(0, 11, "c2.android.") == 0 ?
	GRALLOC_USAGE_SW_READ_OFTEN :
	GRALLOC_USAGE_HW_VIDEO_ENCODER;

	err = source->configure(
	this, dataSpace, kBufferCount,
	inputSize.width, inputSize.height,
	grallocUsage);
	if (err != OK) {
	ALOGD("Impl::init -- GBS configure failed: %d", err);
	return false;
	}
	for (int32_t i = 0; i < kBufferCount; ++i) {
	if (!source->onInputBufferAdded(i).isOk()) {
	ALOGD("Impl::init: populating GBS slots failed");
	return false;
	}
	}
	if (!source->start().isOk()) {
	ALOGD("Impl::init -- GBS start failed");
	return false;
	}
	mAllocatorMutex.lock();
	c2_status_t c2err = GetCodec2PlatformAllocatorStore()->fetchAllocator(
	C2AllocatorStore::PLATFORM_START + 1, // GRALLOC
	&mAllocator);
	mAllocatorMutex.unlock();
	if (c2err != OK) {
	ALOGD("Impl::init -- failed to fetch gralloc allocator: %d", c2err);
	return false;
	}
	return true;
	}

	// From ComponentWrapper
	virtual status_t submitBuffer(
	int32_t bufferId,
	const sp<GraphicBuffer>& buffer,
	int64_t timestamp,
	int fenceFd) override {
	ALOGV("Impl::submitBuffer -- bufferId = %d", bufferId);
	// TODO: Use fd to construct fence
	(void)fenceFd;

	std::shared_ptr<C2GraphicAllocation> alloc;
	C2Handle* handle = WrapNativeCodec2GrallocHandle(
	buffer->handle,
	buffer->width, buffer->height,
	buffer->format, buffer->usage, buffer->stride);
	mAllocatorMutex.lock();
	c2_status_t err = mAllocator->priorGraphicAllocation(handle, &alloc);
	mAllocatorMutex.unlock();
	if (err != OK) {
	return UNKNOWN_ERROR;
	}
	std::shared_ptr<C2GraphicBlock> block =
	_C2BlockFactory::CreateGraphicBlock(alloc);

	std::unique_ptr<C2Work> work(new C2Work);
	work->input.flags = (C2FrameData::flags_t)0;
	work->input.ordinal.timestamp = timestamp;
	work->input.ordinal.frameIndex = mFrameIndex.fetch_add(
	1, std::memory_order_relaxed);
	work->input.buffers.clear();
	std::shared_ptr<C2Buffer> c2Buffer(
	// TODO: fence
	new Buffer2D(block->share(
	C2Rect(block->width(), block->height()), ::C2Fence())),
	[bufferId, src = mSource](C2Buffer* ptr) {
	delete ptr;
	sp<GraphicBufferSource> source = src.promote();
	if (source != nullptr) {
	// TODO: fence
	(void)source->onInputBufferEmptied(bufferId, -1);
	}
	});
	work->input.buffers.push_back(c2Buffer);
	work->worklets.clear();
	work->worklets.emplace_back(new C2Worklet);
	std::list<std::unique_ptr<C2Work>> items;
	items.push_back(std::move(work));

	err = compQueue(&items);
	return (err == C2_OK) ? OK : UNKNOWN_ERROR;
	}

	virtual status_t submitEos(int32_t /* bufferId */) override {
	ALOGV("Impl::submitEos");

	std::unique_ptr<C2Work> work(new C2Work);
	work->input.flags = (C2FrameData::flags_t)0;
	work->input.ordinal.frameIndex = mFrameIndex.fetch_add(
	1, std::memory_order_relaxed);
	work->input.buffers.clear();
	work->worklets.clear();
	work->worklets.emplace_back(new C2Worklet);
	std::list<std::unique_ptr<C2Work>> items;
	items.push_back(std::move(work));

	c2_status_t err = compQueue(&items);
	return (err == C2_OK) ? OK : UNKNOWN_ERROR;
	}

	void dispatchDataSpaceChanged(
	int32_t dataSpace, int32_t aspects, int32_t pixelFormat) override {
	// TODO
	(void)dataSpace;
	(void)aspects;
	(void)pixelFormat;
	}

	private:
	c2_status_t compQuery(
	const std::vector<C2Param*> &stackParams,
	const std::vector<C2Param::Index> &heapParamIndices,
	c2_blocking_t mayBlock,
	std::vector<std::unique_ptr<C2Param>>* const heapParams) {
	std::shared_ptr<C2Component> comp = mComp.lock();
	if (comp) {
	std::shared_ptr<C2ComponentInterface> intf = comp->intf();
	if (intf) {
	return intf->query_vb(stackParams,
	heapParamIndices,
	mayBlock,
	heapParams);
	} else {
	ALOGD("compQuery -- component does not have an interface.");
	return C2_BAD_STATE;
	}
	}
	if (!mRemoteComp) {
	ALOGD("compQuery -- component no longer exists.");
	return C2_BAD_STATE;
	}

	hidl_vec<ParamIndex> indices(
	stackParams.size() + heapParamIndices.size());
	size_t numIndices = 0;
	for (C2Param* const& stackParam : stackParams) {
	if (!stackParam) {
	ALOGD("compQuery -- null stack param encountered.");
	continue;
	}
	indices[numIndices++] = static_cast<ParamIndex>(stackParam->index());
	}
	size_t numStackIndices = numIndices;
	for (const C2Param::Index& index : heapParamIndices) {
	indices[numIndices++] =
	static_cast<ParamIndex>(static_cast<uint32_t>(index));
	}
	indices.resize(numIndices);
	if (heapParams) {
	heapParams->reserve(heapParams->size() + numIndices);
	}
	c2_status_t status;
	Return<void> transStatus = mRemoteComp->query(
	indices,
	mayBlock == C2_MAY_BLOCK,
	[&status, &numStackIndices, &stackParams, heapParams](
	Status s, const Params& p) {
	status = static_cast<c2_status_t>(s);
	if (status != C2_OK && status != C2_BAD_INDEX) {
	ALOGD("compQuery -- call failed: %s.", asString(status));
	return;
	}
	std::vector<C2Param*> paramPointers;
	c2_status_t parseStatus = parseParamsBlob(&paramPointers, p);
	if (parseStatus != C2_OK) {
	ALOGD("compQuery -- error while parsing params: %s.",
	asString(parseStatus));
	status = parseStatus;
	return;
	}
	size_t i = 0;
	for (auto it = paramPointers.begin();
	it != paramPointers.end(); ) {
	C2Param* paramPointer = *it;
	if (numStackIndices > 0) {
	--numStackIndices;
	if (!paramPointer) {
	ALOGD("compQuery -- null stack param.");
	++it;
	continue;
	}
	for (; i < stackParams.size() &&
	!stackParams[i]; ) {
	++i;
	}
	CHECK(i < stackParams.size());
	if (stackParams[i]->index() !=
	paramPointer->index()) {
	ALOGD("compQuery -- param skipped. index = %d",
	static_cast<int>(
	stackParams[i]->index()));
	stackParams[i++]->invalidate();
	continue;
	}
	if (!stackParams[i++]->updateFrom(*paramPointer)) {
	ALOGD("compQuery -- param update failed: "
	"index = %d.",
	static_cast<int>(paramPointer->index()));
	}
	} else {
	if (!paramPointer) {
	ALOGD("compQuery -- null heap param.");
	++it;
	continue;
	}
	if (!heapParams) {
	ALOGD("compQuery -- too many stack params.");
	break;
	}
	heapParams->emplace_back(C2Param::Copy(*paramPointer));
	}
	++it;
	}
	});
	if (!transStatus.isOk()) {
	ALOGD("compQuery -- transaction failed.");
	return C2_CORRUPTED;
	}
	return status;
	}

	c2_status_t compQueue(std::list<std::unique_ptr<C2Work>>* const items) {
	std::shared_ptr<C2Component> comp = mComp.lock();
	if (comp) {
	return comp->queue_nb(items);
	}

	WorkBundle workBundle;
	Status hidlStatus = objcpy(&workBundle, *items, nullptr);
	if (hidlStatus != Status::OK) {
	ALOGD("compQueue -- bad input.");
	return C2_CORRUPTED;
	}
	Return<Status> transStatus = mRemoteComp->queue(workBundle);
	if (!transStatus.isOk()) {
	ALOGD("compQueue -- transaction failed.");
	return C2_CORRUPTED;
	}
	c2_status_t status =
	static_cast<c2_status_t>(static_cast<Status>(transStatus));
	if (status != C2_OK) {
	ALOGV("compQueue -- call failed: %s.", asString(status));
	}
	return status;
	}

	wp<GraphicBufferSource> mSource;
	std::weak_ptr<C2Component> mComp;
	sp<IComponent> mRemoteComp;
	std::string mCompName;

	// Needed for ComponentWrapper implementation
	std::mutex mAllocatorMutex;
	std::shared_ptr<C2Allocator> mAllocator;
	std::atomic_uint64_t mFrameIndex;
	};

	InputSurfaceConnection::InputSurfaceConnection(
	const sp<GraphicBufferSource>& source,
	const std::shared_ptr<C2Component>& comp) :
	mSource(source),
	mImpl(new Impl(source, comp)) {
	}

	InputSurfaceConnection::InputSurfaceConnection(
	const sp<GraphicBufferSource>& source,
	const sp<IComponent>& comp) :
	mSource(source),
	mImpl(new Impl(source, comp)) {
	}

	InputSurfaceConnection::~InputSurfaceConnection() {
	if (mSource) {
	(void)mSource->stop();
	(void)mSource->release();
	mSource.clear();
	}
	mImpl.clear();
	}

	bool InputSurfaceConnection::init() {
	mMutex.lock();
	sp<Impl> impl = mImpl;
	mMutex.unlock();

	if (!impl) {
	return false;
	}
	return impl->init();
	}

	Return<Status> InputSurfaceConnection::disconnect() {
	ALOGV("disconnect");
	mMutex.lock();
	if (mSource) {
	(void)mSource->stop();
	(void)mSource->release();
	mSource.clear();
	}
	mImpl.clear();
	mMutex.unlock();
	ALOGV("disconnected");
	return Status::OK;
	}

	} // namespace utils
	} // namespace V1_0
	} // namespace c2
	} // namespace media
	} // namespace google
	} // namespace hardware