Merge pie-platform-release to aosp-master - DO NOT MERGE
Change-Id: I7992ad34499f84f164aedb02f25d7be31210f969
diff --git a/Android.bp b/Android.bp
deleted file mode 100644
index db4d39f..0000000
--- a/Android.bp
+++ /dev/null
@@ -1,32 +0,0 @@
-cc_library_shared {
- name: "libv4l2_codec2_arcva_factory",
- vendor_available: true,
- product_variables: {
- arc: {
- srcs: ["C2ArcVideoAcceleratorFactory.cpp"],
-
- shared_libs: [
- "libarcbridge",
- "libarcbridgeservice",
- "libarcvideobridge",
- "libbinder",
- "libchrome",
- "liblog",
- "libmojo",
- "libutils",
- ],
-
- // -Wno-unused-parameter is needed for libchrome/base codes
- cflags: [
- "-Wall",
- "-Werror",
- "-Wno-unused-parameter",
- "-std=c++14",
- ],
- },
- },
- clang: true,
- export_include_dirs: [
- "include",
- ],
-}
diff --git a/Android.mk b/Android.mk
index bff4409..b2304fb 100644
--- a/Android.mk
+++ b/Android.mk
@@ -29,6 +29,8 @@
liblog \
libmedia \
libstagefright \
+ libstagefright_bufferqueue_helper \
+ libstagefright_ccodec_ext \
libstagefright_codec2 \
libstagefright_codec2_vndk \
libstagefright_simple_c2component \
@@ -55,7 +57,7 @@
LOCAL_SHARED_LIBRARIES += libarcbridge \
libarcbridgeservice \
libmojo \
- libv4l2_codec2_arcva_factory \
+ libcodec2_arcva_factory \
endif # ifneq (,$(findstring cheets_,$(TARGET_PRODUCT)))
diff --git a/C2ArcVideoAcceleratorFactory.cpp b/C2ArcVideoAcceleratorFactory.cpp
deleted file mode 100644
index 07997d1..0000000
--- a/C2ArcVideoAcceleratorFactory.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// #define LOG_NDEBUG 0
-#define LOG_TAG "C2ArcVideoAcceleratorFactory"
-
-#include <C2ArcVideoAcceleratorFactory.h>
-
-#include <base/bind.h>
-#include <binder/IServiceManager.h>
-#include <mojo/edk/embedder/embedder.h>
-#include <mojo/public/cpp/bindings/interface_request.h>
-#include <mojo/public/cpp/system/handle.h>
-#include <utils/Log.h>
-
-namespace android {
-
-ANDROID_SINGLETON_STATIC_INSTANCE(C2ArcVideoAcceleratorFactory)
-
-bool C2ArcVideoAcceleratorFactory::createVideoDecodeAccelerator(
- ::arc::mojom::VideoDecodeAcceleratorRequest request) {
- if (!mRemoteFactory) {
- ALOGE("Factory is not ready");
- return false;
- }
- mRemoteFactory->CreateDecodeAccelerator(std::move(request));
- return true;
-}
-
-bool C2ArcVideoAcceleratorFactory::createVideoEncodeAccelerator(
- ::arc::mojom::VideoEncodeAcceleratorRequest request) {
- if (!mRemoteFactory) {
- ALOGE("Factory is not ready");
- return false;
- }
- mRemoteFactory->CreateEncodeAccelerator(std::move(request));
- return true;
-}
-
-bool C2ArcVideoAcceleratorFactory::createVideoProtectedBufferAllocator(
- ::arc::mojom::VideoProtectedBufferAllocatorRequest request) {
- if (!mRemoteFactory) {
- ALOGE("Factory is not ready");
- return false;
- }
- mRemoteFactory->CreateProtectedBufferAllocator(std::move(request));
- return true;
-}
-
-int32_t C2ArcVideoAcceleratorFactory::hostVersion() const {
- return mHostVersion;
-}
-
-C2ArcVideoAcceleratorFactory::C2ArcVideoAcceleratorFactory() : mHostVersion(0) {
- sp<IBinder> binder =
- defaultServiceManager()->getService(String16("android.os.IArcVideoBridge"));
- if (binder == nullptr) {
- ALOGE("Failed to find IArcVideoBridge service");
- return;
- }
- mArcVideoBridge = interface_cast<IArcVideoBridge>(binder);
- mHostVersion = mArcVideoBridge->hostVersion();
- if (mHostVersion < 4) {
- ALOGW("HostVersion(%d) is outdated", mHostVersion);
- return;
- }
-
- ALOGV("HostVersion: %d", mHostVersion);
-
- ::arc::MojoBootstrapResult bootstrapResult =
- mArcVideoBridge->bootstrapVideoAcceleratorFactory();
- if (!bootstrapResult.is_valid()) {
- ALOGE("bootstrapVideoAcceleratorFactory returns invalid result");
- return;
- }
- mojo::edk::ScopedPlatformHandle handle(
- mojo::edk::PlatformHandle(bootstrapResult.releaseFd().release()));
- ALOGV("SetParentPipeHandle(fd=%d)", handle.get().handle);
- mojo::edk::SetParentPipeHandle(std::move(handle));
- mojo::ScopedMessagePipeHandle server_pipe =
- mojo::edk::CreateChildMessagePipe(bootstrapResult.releaseToken());
- mRemoteFactory.Bind(mojo::InterfacePtrInfo<::arc::mojom::VideoAcceleratorFactory>(
- std::move(server_pipe), 7u));
-}
-
-} // namespace android
diff --git a/C2VDAAdaptorProxy.cpp b/C2VDAAdaptorProxy.cpp
index 2c44e6b..4c493d1 100644
--- a/C2VDAAdaptorProxy.cpp
+++ b/C2VDAAdaptorProxy.cpp
@@ -64,7 +64,7 @@
}
void C2VDAAdaptorProxy::establishChannelOnMojoThread(std::shared_ptr<::arc::Future<bool>> future) {
- C2ArcVideoAcceleratorFactory& factory = ::android::C2ArcVideoAcceleratorFactory::getInstance();
+ auto& factory = ::android::GetC2ArcVideoAcceleratorFactory();
if (!factory.createVideoDecodeAccelerator(mojo::MakeRequest(&mVDAPtr))) {
future->set(false);
diff --git a/C2VDAComponent.cpp b/C2VDAComponent.cpp
index 2b3abde..5eec1ef 100644
--- a/C2VDAComponent.cpp
+++ b/C2VDAComponent.cpp
@@ -12,11 +12,14 @@
#endif
#define __C2_GENERATE_GLOBAL_VARS__
+#include <C2VDAAllocatorStore.h>
+#include <C2VdaBqBlockPool.h>
#include <C2VDAComponent.h>
#include <C2VDASupport.h> // to getParamReflector from vda store
#include <videodev2.h>
+#include <C2AllocatorGralloc.h>
#include <C2ComponentFactory.h>
#include <C2PlatformSupport.h>
@@ -52,6 +55,16 @@
const C2String kVP8DecoderName = "c2.vda.vp8.decoder";
const C2String kVP9DecoderName = "c2.vda.vp9.decoder";
+const uint32_t kDpbOutputBufferExtraCount = 3; // Use the same number as ACodec.
+const int kDequeueRetryDelayUs = 10000; // Wait time of dequeue buffer retry in microseconds.
+
+// Hack(b/79239042): Max size of mMockBufferQueueInClient.
+// This value is empirically picked from previous CTS try-run. If this value is too big, it may
+// cause VDA deadlock when it requires more buffers to decode and dequeue a new one. On the other
+// hand, too small value may produce wrong display picture because recycling goes faster than
+// rendering.
+const size_t kMockMaxBuffersInClient = 5;
+
} // namespace
C2VDAComponent::IntfImpl::IntfImpl(C2String name, const std::shared_ptr<C2ReflectorHelper>& helper)
@@ -134,7 +147,7 @@
.build());
C2Allocator::id_t inputAllocators[] = {C2PlatformAllocatorStore::ION};
- C2Allocator::id_t outputAllocators[] = {C2PlatformAllocatorStore::GRALLOC};
+ C2Allocator::id_t outputAllocators[] = {C2VDAAllocatorStore::V4L2_BUFFERQUEUE};
addParameter(
DefineParam(mInputAllocatorIds, C2_PARAMKEY_INPUT_ALLOCATORS)
@@ -170,28 +183,6 @@
CHECK_NE(mComponentState, ComponentState::UNINITIALIZED); \
} while (0)
-class C2VDAGraphicBuffer : public C2Buffer {
-public:
- C2VDAGraphicBuffer(const std::shared_ptr<C2GraphicBlock>& block, const media::Rect& visibleRect,
- const base::Closure& releaseCB);
- ~C2VDAGraphicBuffer() override;
-
-private:
- base::Closure mReleaseCB;
-};
-
-C2VDAGraphicBuffer::C2VDAGraphicBuffer(const std::shared_ptr<C2GraphicBlock>& block,
- const media::Rect& visibleRect,
- const base::Closure& releaseCB)
- : C2Buffer({block->share(C2Rect(visibleRect.width(), visibleRect.height()), C2Fence())}),
- mReleaseCB(releaseCB) {}
-
-C2VDAGraphicBuffer::~C2VDAGraphicBuffer() {
- if (!mReleaseCB.is_null()) {
- mReleaseCB.Run();
- }
-}
-
C2VDAComponent::VideoFormat::VideoFormat(HalPixelFormat pixelFormat, uint32_t minNumBuffers,
media::Size codedSize, media::Rect visibleRect)
: mPixelFormat(pixelFormat),
@@ -199,15 +190,27 @@
mCodedSize(codedSize),
mVisibleRect(visibleRect) {}
+static uint32_t getSlotFromGraphicBlockHandle(const C2Handle* const handle) {
+ uint32_t width, height, format, stride, igbp_slot, generation;
+ uint64_t usage, igbp_id;
+ _UnwrapNativeCodec2GrallocMetadata(
+ handle, &width, &height, &format, &usage, &stride, &generation, &igbp_id, &igbp_slot);
+ ALOGV("Unwrap Metadata: igbp[%" PRIu64 ", %u] (%u*%u, fmt %#x, usage %" PRIx64 ", stride %u)",
+ igbp_id, igbp_slot, width, height, format, usage, stride);
+ return igbp_slot;
+}
+
C2VDAComponent::C2VDAComponent(C2String name, c2_node_id_t id,
const std::shared_ptr<C2ReflectorHelper>& helper)
: mIntfImpl(std::make_shared<IntfImpl>(name, helper)),
mIntf(std::make_shared<SimpleInterface<IntfImpl>>(name.c_str(), id, mIntfImpl)),
mThread("C2VDAComponentThread"),
+ mDequeueThread("C2VDAComponentDequeueThread"),
mVDAInitResult(VideoDecodeAcceleratorAdaptor::Result::ILLEGAL_STATE),
mComponentState(ComponentState::UNINITIALIZED),
- mDrainWithEOS(false),
+ mPendingOutputEOS(false),
mLastOutputTimestamp(-1),
+ mSurfaceMode(true),
mCodecProfile(media::VIDEO_CODEC_PROFILE_UNKNOWN),
mState(State::UNLOADED),
mWeakThisFactory(this) {
@@ -229,7 +232,7 @@
if (mThread.IsRunning()) {
mTaskRunner->PostTask(FROM_HERE,
- base::Bind(&C2VDAComponent::onDestroy, base::Unretained(this)));
+ ::base::Bind(&C2VDAComponent::onDestroy, ::base::Unretained(this)));
mThread.Stop();
}
}
@@ -241,9 +244,10 @@
mVDAAdaptor->destroy();
mVDAAdaptor.reset(nullptr);
}
+ stopDequeueThread();
}
-void C2VDAComponent::onStart(media::VideoCodecProfile profile, base::WaitableEvent* done) {
+void C2VDAComponent::onStart(media::VideoCodecProfile profile, ::base::WaitableEvent* done) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onStart");
CHECK_EQ(mComponentState, ComponentState::UNINITIALIZED);
@@ -269,8 +273,6 @@
ALOGV("onQueueWork: flags=0x%x, index=%llu, timestamp=%llu", work->input.flags,
work->input.ordinal.frameIndex.peekull(), work->input.ordinal.timestamp.peekull());
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
- // It is illegal for client to put new works while component is still flushing.
- CHECK_NE(mComponentState, ComponentState::FLUSHING);
uint32_t drainMode = NO_DRAIN;
if (work->input.flags & C2FrameData::FLAG_END_OF_STREAM) {
@@ -280,7 +282,7 @@
// TODO(johnylin): set a maximum size of mQueue and check if mQueue is already full.
mTaskRunner->PostTask(FROM_HERE,
- base::Bind(&C2VDAComponent::onDequeueWork, base::Unretained(this)));
+ ::base::Bind(&C2VDAComponent::onDequeueWork, ::base::Unretained(this)));
}
void C2VDAComponent::onDequeueWork() {
@@ -290,8 +292,9 @@
if (mQueue.empty()) {
return;
}
- if (mComponentState == ComponentState::DRAINING) {
- ALOGV("Temporarily stop dequeueing works since component is draining.");
+ if (mComponentState == ComponentState::DRAINING ||
+ mComponentState == ComponentState::FLUSHING) {
+ ALOGV("Temporarily stop dequeueing works since component is draining/flushing.");
return;
}
if (mComponentState != ComponentState::STARTED) {
@@ -304,10 +307,15 @@
auto drainMode = mQueue.front().mDrainMode;
mQueue.pop();
- CHECK_EQ(work->input.buffers.size(), 1u);
- C2ConstLinearBlock linearBlock = work->input.buffers.front()->data().linearBlocks().front();
- // linearBlock.size() == 0 means this is a dummy work. No decode needed.
- if (linearBlock.size() > 0) {
+ CHECK_LE(work->input.buffers.size(), 1u);
+ if (work->input.buffers.empty()) {
+ // Client may queue an EOS work with no input buffer, otherwise every work must have one
+ // input buffer.
+ CHECK(drainMode != NO_DRAIN);
+ } else {
+ // If input.buffers is not empty, the buffer should have meaningful content inside.
+ C2ConstLinearBlock linearBlock = work->input.buffers.front()->data().linearBlocks().front();
+ CHECK_GT(linearBlock.size(), 0u);
// Send input buffer to VDA for decode.
// Use frameIndex as bitstreamId.
int32_t bitstreamId = frameIndexToBitstreamId(work->input.ordinal.frameIndex);
@@ -322,15 +330,15 @@
if (drainMode != NO_DRAIN) {
mVDAAdaptor->flush();
mComponentState = ComponentState::DRAINING;
- mDrainWithEOS = drainMode == DRAIN_COMPONENT_WITH_EOS;
+ mPendingOutputEOS = drainMode == DRAIN_COMPONENT_WITH_EOS;
}
// Put work to mPendingWorks.
mPendingWorks.emplace_back(std::move(work));
if (!mQueue.empty()) {
- mTaskRunner->PostTask(FROM_HERE,
- base::Bind(&C2VDAComponent::onDequeueWork, base::Unretained(this)));
+ mTaskRunner->PostTask(FROM_HERE, ::base::Bind(&C2VDAComponent::onDequeueWork,
+ ::base::Unretained(this)));
}
}
@@ -351,16 +359,9 @@
reportFinishedWorkIfAny();
}
-// This is used as callback while output buffer is released by client.
-// TODO(johnylin): consider to use C2Buffer::registerOnDestroyNotify instead
-void C2VDAComponent::returnOutputBuffer(int32_t pictureBufferId) {
- mTaskRunner->PostTask(FROM_HERE, base::Bind(&C2VDAComponent::onOutputBufferReturned,
- base::Unretained(this), pictureBufferId));
-}
-
-void C2VDAComponent::onOutputBufferReturned(int32_t pictureBufferId) {
+void C2VDAComponent::onOutputBufferReturned(uint32_t slotId) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
- ALOGV("onOutputBufferReturned: picture id=%d", pictureBufferId);
+ ALOGV("onOutputBufferReturned: slot id=%u", slotId);
if (mComponentState == ComponentState::UNINITIALIZED) {
// Output buffer is returned from client after component is stopped. Just let the buffer be
// released.
@@ -369,7 +370,7 @@
// TODO(johnylin): when buffer is returned, we should confirm that output format is not changed
// yet. If changed, just let the buffer be released.
- GraphicBlockInfo* info = getGraphicBlockById(pictureBufferId);
+ GraphicBlockInfo* info = getGraphicBlockBySlot(slotId);
if (!info) {
reportError(C2_CORRUPTED);
return;
@@ -402,15 +403,28 @@
CHECK_EQ(info->mState, GraphicBlockInfo::State::OWNED_BY_ACCELERATOR);
// Output buffer will be passed to client soon along with mListener->onWorkDone_nb().
info->mState = GraphicBlockInfo::State::OWNED_BY_CLIENT;
+ if (mSurfaceMode) {
+ mBuffersInClient++;
+ } else { // byte-buffer mode
+ // Hack(b/79239042)
+ mMockBufferQueueInClient.push_back(info->mSlotId);
+ if (mMockBufferQueueInClient.size() > kMockMaxBuffersInClient) {
+ mTaskRunner->PostTask(FROM_HERE, ::base::Bind(&C2VDAComponent::onOutputBufferReturned,
+ ::base::Unretained(this),
+ mMockBufferQueueInClient.front()));
+ mMockBufferQueueInClient.pop_front();
+ }
+ }
// Attach output buffer to the work corresponded to bitstreamId.
- work->worklets.front()->output.buffers.emplace_back(std::make_shared<C2VDAGraphicBuffer>(
- info->mGraphicBlock, mOutputFormat.mVisibleRect,
- base::Bind(&C2VDAComponent::returnOutputBuffer, mWeakThisFactory.GetWeakPtr(),
- pictureBufferId)));
+ auto block = info->mGraphicBlock;
+ work->worklets.front()->output.buffers.emplace_back(C2Buffer::CreateGraphicBuffer(
+ block->share(C2Rect(mOutputFormat.mVisibleRect.width(),
+ mOutputFormat.mVisibleRect.height()),
+ C2Fence())));
// TODO: this does not work for timestamps as they can wrap around
- int64_t currentTimestamp = base::checked_cast<int64_t>(work->input.ordinal.timestamp.peek());
+ int64_t currentTimestamp = ::base::checked_cast<int64_t>(work->input.ordinal.timestamp.peek());
CHECK_GE(currentTimestamp, mLastOutputTimestamp);
mLastOutputTimestamp = currentTimestamp;
@@ -434,7 +448,7 @@
if (mComponentState == ComponentState::STARTED) {
mVDAAdaptor->flush();
mComponentState = ComponentState::DRAINING;
- mDrainWithEOS = drainMode == DRAIN_COMPONENT_WITH_EOS;
+ mPendingOutputEOS = drainMode == DRAIN_COMPONENT_WITH_EOS;
} else {
ALOGV("Neglect drain. Component in state: %d", mComponentState);
}
@@ -452,13 +466,15 @@
} else if (mComponentState == ComponentState::STOPPING) {
// The client signals stop right before VDA notifies drain done. Let stop process goes.
return;
- } else {
+ } else if (mComponentState != ComponentState::FLUSHING) {
+ // It is reasonable to get onDrainDone in FLUSHING, which means flush is already signaled
+ // and component should still expect onFlushDone callback from VDA.
ALOGE("Unexpected state while onDrainDone(). State=%d", mComponentState);
reportError(C2_BAD_STATE);
return;
}
- if (mDrainWithEOS) {
+ if (mPendingOutputEOS) {
// Return EOS work.
reportEOSWork();
}
@@ -470,27 +486,28 @@
// Work dequeueing was stopped while component draining. Restart it.
mTaskRunner->PostTask(FROM_HERE,
- base::Bind(&C2VDAComponent::onDequeueWork, base::Unretained(this)));
+ ::base::Bind(&C2VDAComponent::onDequeueWork, ::base::Unretained(this)));
}
void C2VDAComponent::onFlush() {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onFlush");
- if (mComponentState == ComponentState::FLUSHING) {
- return; // Ignore other flush request when component is flushing.
+ if (mComponentState == ComponentState::FLUSHING ||
+ mComponentState == ComponentState::STOPPING) {
+ return; // Ignore other flush request when component is flushing or stopping.
}
- EXPECT_STATE_OR_RETURN_ON_ERROR(STARTED);
+ EXPECT_RUNNING_OR_RETURN_ON_ERROR();
mVDAAdaptor->reset();
- // Pop all works in mQueue and put into mPendingWorks.
+ // Pop all works in mQueue and put into mAbandonedWorks.
while (!mQueue.empty()) {
- mPendingWorks.emplace_back(std::move(mQueue.front().mWork));
+ mAbandonedWorks.emplace_back(std::move(mQueue.front().mWork));
mQueue.pop();
}
mComponentState = ComponentState::FLUSHING;
}
-void C2VDAComponent::onStop(base::WaitableEvent* done) {
+void C2VDAComponent::onStop(::base::WaitableEvent* done) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onStop");
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
@@ -501,9 +518,9 @@
mVDAAdaptor->reset();
}
- // Pop all works in mQueue and put into mPendingWorks.
+ // Pop all works in mQueue and put into mAbandonedWorks.
while (!mQueue.empty()) {
- mPendingWorks.emplace_back(std::move(mQueue.front().mWork));
+ mAbandonedWorks.emplace_back(std::move(mQueue.front().mWork));
mQueue.pop();
}
@@ -531,15 +548,16 @@
// Reset the timestamp record.
mLastOutputTimestamp = -1;
mComponentState = ComponentState::STARTED;
+
+ // Work dequeueing was stopped while component flushing. Restart it.
+ mTaskRunner->PostTask(FROM_HERE,
+ ::base::Bind(&C2VDAComponent::onDequeueWork, ::base::Unretained(this)));
}
void C2VDAComponent::onStopDone() {
ALOGV("onStopDone");
CHECK(mStopDoneEvent);
- // Release the graphic block allocator object.
- mOutputBlockPool.reset();
-
// TODO(johnylin): At this moment, there may be C2Buffer still owned by client, do we need to
// do something for them?
reportAbandonedWorks();
@@ -552,6 +570,9 @@
mGraphicBlocks.clear();
+ mMockBufferQueueInClient.clear(); // Hack(b/79239042)
+ stopDequeueThread();
+
mStopDoneEvent->Signal();
mStopDoneEvent = nullptr;
mComponentState = ComponentState::UNINITIALIZED;
@@ -606,6 +627,19 @@
return &mGraphicBlocks[blockId];
}
+C2VDAComponent::GraphicBlockInfo* C2VDAComponent::getGraphicBlockBySlot(uint32_t slotId) {
+ auto blockIter = std::find_if(mGraphicBlocks.begin(), mGraphicBlocks.end(),
+ [slotId](const GraphicBlockInfo& gb) {
+ return gb.mSlotId == slotId;
+ });
+
+ if (blockIter == mGraphicBlocks.end()) {
+ ALOGE("getGraphicBlockBySlot failed: slot=%u", slotId);
+ return nullptr;
+ }
+ return &(*blockIter);
+}
+
void C2VDAComponent::onOutputFormatChanged(std::unique_ptr<VideoFormat> format) {
DCHECK(mTaskRunner->BelongsToCurrentThread());
ALOGV("onOutputFormatChanged");
@@ -666,30 +700,55 @@
uint32_t pixelFormat) {
ALOGV("allocateBuffersFromBlockAllocator(%s, 0x%x)", size.ToString().c_str(), pixelFormat);
+ mMockBufferQueueInClient.clear(); // Hack(b/79239042)
+ stopDequeueThread();
+
size_t bufferCount = mOutputFormat.mMinNumBuffers + kDpbOutputBufferExtraCount;
// Allocate the output buffers.
mVDAAdaptor->assignPictureBuffers(bufferCount);
// Get block pool ID configured from the client.
+ std::shared_ptr<C2BlockPool> blockPool;
auto poolId = mIntfImpl->getBlockPoolId();
ALOGI("Using C2BlockPool ID = %" PRIu64 " for allocating output buffers", poolId);
- c2_status_t err;
- if (!mOutputBlockPool || mOutputBlockPool->getLocalId() != poolId) {
- err = GetCodec2BlockPool(poolId, shared_from_this(), &mOutputBlockPool);
- if (err != C2_OK) {
- ALOGE("Graphic block allocator is invalid");
- reportError(err);
- return err;
- }
+ auto err = GetCodec2BlockPool(poolId, shared_from_this(), &blockPool);
+ if (err != C2_OK) {
+ ALOGE("Graphic block allocator is invalid");
+ reportError(err);
+ return err;
}
mGraphicBlocks.clear();
+
+ if (blockPool->getAllocatorId() == C2PlatformAllocatorStore::BUFFERQUEUE) {
+ // Set requested buffer count to C2VdaBqBlockPool.
+ std::shared_ptr<C2VdaBqBlockPool> bqPool =
+ std::static_pointer_cast<C2VdaBqBlockPool>(blockPool);
+ if (bqPool) {
+ err = bqPool->requestNewBufferSet(static_cast<int32_t>(bufferCount));
+ if (err == C2_NO_INIT) {
+ ALOGD("No surface in block pool, output is byte-buffer mode...");
+ mSurfaceMode = false;
+ } else if (err != C2_OK) {
+ ALOGE("failed to set buffer count magic to block pool: %d", err);
+ reportError(err);
+ return err;
+ }
+ } else {
+ ALOGE("static_pointer_cast C2VdaBqBlockPool failed...");
+ reportError(C2_CORRUPTED);
+ return C2_CORRUPTED;
+ }
+ } else { // CCodec falls back to use C2BasicGraphicBlockPool
+ ALOGD("CCodec falls back to use C2BasicGraphicBlockPool...");
+ mSurfaceMode = false;
+ }
+
for (size_t i = 0; i < bufferCount; ++i) {
std::shared_ptr<C2GraphicBlock> block;
C2MemoryUsage usage = {C2MemoryUsage::CPU_READ, 0};
- err = mOutputBlockPool->fetchGraphicBlock(size.width(), size.height(), pixelFormat, usage,
- &block);
+ err = blockPool->fetchGraphicBlock(size.width(), size.height(), pixelFormat, usage, &block);
if (err != C2_OK) {
mGraphicBlocks.clear();
ALOGE("failed to allocate buffer: %d", err);
@@ -699,6 +758,11 @@
appendOutputBuffer(std::move(block));
}
mOutputFormat.mMinNumBuffers = bufferCount;
+
+ if (mSurfaceMode && !startDequeueThread(size, pixelFormat, std::move(blockPool))) {
+ reportError(C2_CORRUPTED);
+ return C2_CORRUPTED;
+ }
return C2_OK;
}
@@ -752,7 +816,7 @@
#endif
ALOGV("HAL pixel format: 0x%x", static_cast<uint32_t>(info.mPixelFormat));
- base::ScopedFD passedHandle(dup(info.mGraphicBlock->handle()->data[0]));
+ ::base::ScopedFD passedHandle(dup(info.mGraphicBlock->handle()->data[0]));
if (!passedHandle.is_valid()) {
ALOGE("Failed to dup(%d), errno=%d", info.mGraphicBlock->handle()->data[0], errno);
reportError(C2_CORRUPTED);
@@ -766,6 +830,12 @@
info.mHandle = std::move(passedHandle);
info.mPlanes = std::move(passedPlanes);
+ if (mSurfaceMode) {
+ info.mSlotId = getSlotFromGraphicBlockHandle(info.mGraphicBlock->handle());
+ } else { // byte-buffer mode
+ info.mSlotId = static_cast<uint32_t>(info.mBlockId);
+ }
+
mGraphicBlocks.push_back(std::move(info));
}
@@ -808,8 +878,8 @@
}
while (!items->empty()) {
mTaskRunner->PostTask(FROM_HERE,
- base::Bind(&C2VDAComponent::onQueueWork, base::Unretained(this),
- base::Passed(&items->front())));
+ ::base::Bind(&C2VDAComponent::onQueueWork, ::base::Unretained(this),
+ ::base::Passed(&items->front())));
items->pop_front();
}
return C2_OK;
@@ -828,7 +898,8 @@
if (mState.load() != State::RUNNING) {
return C2_BAD_STATE;
}
- mTaskRunner->PostTask(FROM_HERE, base::Bind(&C2VDAComponent::onFlush, base::Unretained(this)));
+ mTaskRunner->PostTask(FROM_HERE, ::base::Bind(&C2VDAComponent::onFlush,
+ ::base::Unretained(this)));
// Instead of |flushedWork|, abandoned works will be returned via onWorkDone_nb() callback.
return C2_OK;
}
@@ -840,8 +911,9 @@
if (mState.load() != State::RUNNING) {
return C2_BAD_STATE;
}
- mTaskRunner->PostTask(FROM_HERE, base::Bind(&C2VDAComponent::onDrain, base::Unretained(this),
- static_cast<uint32_t>(mode)));
+ mTaskRunner->PostTask(FROM_HERE,
+ ::base::Bind(&C2VDAComponent::onDrain, ::base::Unretained(this),
+ static_cast<uint32_t>(mode)));
return C2_OK;
}
@@ -856,10 +928,11 @@
mCodecProfile = mIntfImpl->getCodecProfile();
ALOGI("get parameter: mCodecProfile = %d", static_cast<int>(mCodecProfile));
- base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
- base::WaitableEvent::InitialState::NOT_SIGNALED);
- mTaskRunner->PostTask(FROM_HERE, base::Bind(&C2VDAComponent::onStart, base::Unretained(this),
- mCodecProfile, &done));
+ ::base::WaitableEvent done(::base::WaitableEvent::ResetPolicy::AUTOMATIC,
+ ::base::WaitableEvent::InitialState::NOT_SIGNALED);
+ mTaskRunner->PostTask(FROM_HERE,
+ ::base::Bind(&C2VDAComponent::onStart, ::base::Unretained(this),
+ mCodecProfile, &done));
done.Wait();
if (mVDAInitResult != VideoDecodeAcceleratorAdaptor::Result::SUCCESS) {
ALOGE("Failed to start component due to VDA error: %d", static_cast<int>(mVDAInitResult));
@@ -878,10 +951,10 @@
return C2_OK; // Component is already in stopped state.
}
- base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
- base::WaitableEvent::InitialState::NOT_SIGNALED);
+ ::base::WaitableEvent done(::base::WaitableEvent::ResetPolicy::AUTOMATIC,
+ ::base::WaitableEvent::InitialState::NOT_SIGNALED);
mTaskRunner->PostTask(FROM_HERE,
- base::Bind(&C2VDAComponent::onStop, base::Unretained(this), &done));
+ ::base::Bind(&C2VDAComponent::onStop, ::base::Unretained(this), &done));
done.Wait();
mState.store(State::LOADED);
return C2_OK;
@@ -910,8 +983,9 @@
// Set mRequestedVisibleRect to default.
mRequestedVisibleRect = media::Rect();
- mTaskRunner->PostTask(FROM_HERE, base::Bind(&C2VDAComponent::onOutputFormatChanged,
- base::Unretained(this), base::Passed(&format)));
+ mTaskRunner->PostTask(FROM_HERE, ::base::Bind(&C2VDAComponent::onOutputFormatChanged,
+ ::base::Unretained(this),
+ ::base::Passed(&format)));
}
void C2VDAComponent::dismissPictureBuffer(int32_t pictureBufferId) {
@@ -926,28 +1000,28 @@
if (mRequestedVisibleRect != cropRect) {
mRequestedVisibleRect = cropRect;
- mTaskRunner->PostTask(FROM_HERE, base::Bind(&C2VDAComponent::onVisibleRectChanged,
- base::Unretained(this), cropRect));
+ mTaskRunner->PostTask(FROM_HERE, ::base::Bind(&C2VDAComponent::onVisibleRectChanged,
+ ::base::Unretained(this), cropRect));
}
- mTaskRunner->PostTask(FROM_HERE,
- base::Bind(&C2VDAComponent::onOutputBufferDone, base::Unretained(this),
- pictureBufferId, bitstreamId));
+ mTaskRunner->PostTask(FROM_HERE, ::base::Bind(&C2VDAComponent::onOutputBufferDone,
+ ::base::Unretained(this),
+ pictureBufferId, bitstreamId));
}
void C2VDAComponent::notifyEndOfBitstreamBuffer(int32_t bitstreamId) {
- mTaskRunner->PostTask(FROM_HERE, base::Bind(&C2VDAComponent::onInputBufferDone,
- base::Unretained(this), bitstreamId));
+ mTaskRunner->PostTask(FROM_HERE, ::base::Bind(&C2VDAComponent::onInputBufferDone,
+ ::base::Unretained(this), bitstreamId));
}
void C2VDAComponent::notifyFlushDone() {
mTaskRunner->PostTask(FROM_HERE,
- base::Bind(&C2VDAComponent::onDrainDone, base::Unretained(this)));
+ ::base::Bind(&C2VDAComponent::onDrainDone, ::base::Unretained(this)));
}
void C2VDAComponent::notifyResetDone() {
mTaskRunner->PostTask(FROM_HERE,
- base::Bind(&C2VDAComponent::onResetDone, base::Unretained(this)));
+ ::base::Bind(&C2VDAComponent::onResetDone, ::base::Unretained(this)));
}
void C2VDAComponent::notifyError(VideoDecodeAcceleratorAdaptor::Result error) {
@@ -1003,16 +1077,17 @@
}
bool C2VDAComponent::isWorkDone(const C2Work* work) const {
- if (work->input.buffers.front()) {
- // Input buffer is still owned by VDA.
- // This condition could also recognize dummy EOS work since it won't get
- // onInputBufferDone(), input buffer won't be reset until reportEOSWork().
+ if (work->input.buffers.empty()) {
+ // This is EOS work with no input buffer and should be processed by reportEOSWork().
return false;
}
- if (mComponentState == ComponentState::DRAINING && mDrainWithEOS &&
- mPendingWorks.size() == 1u) {
- // If component is in DRAINING state and mDrainWithEOS is true. The last returned work
- // should be marked EOS flag and returned by reportEOSWork() instead.
+ if (work->input.buffers.front()) {
+ // Input buffer is still owned by VDA.
+ return false;
+ }
+ if (mPendingOutputEOS && mPendingWorks.size() == 1u) {
+ // If mPendingOutputEOS is true, the last returned work should be marked EOS flag and
+ // returned by reportEOSWork() instead.
return false;
}
if (mLastOutputTimestamp < 0) {
@@ -1034,9 +1109,13 @@
return;
}
+ mPendingOutputEOS = false;
+
std::unique_ptr<C2Work> eosWork(std::move(mPendingWorks.front()));
mPendingWorks.pop_front();
- eosWork->input.buffers.front().reset();
+ if (!eosWork->input.buffers.empty()) {
+ eosWork->input.buffers.front().reset();
+ }
eosWork->result = C2_OK;
eosWork->workletsProcessed = static_cast<uint32_t>(eosWork->worklets.size());
eosWork->worklets.front()->output.flags = C2FrameData::FLAG_END_OF_STREAM;
@@ -1056,11 +1135,27 @@
// TODO: correlate the definition of flushed work result to framework.
work->result = C2_NOT_FOUND;
- // When the work is abandoned, the input.buffers.front() shall reset by component.
- work->input.buffers.front().reset();
+ // When the work is abandoned, buffer in input.buffers shall reset by component.
+ if (!work->input.buffers.empty()) {
+ work->input.buffers.front().reset();
+ }
abandonedWorks.emplace_back(std::move(work));
}
+ for (auto& work : mAbandonedWorks) {
+ // TODO: correlate the definition of flushed work result to framework.
+ work->result = C2_NOT_FOUND;
+ // When the work is abandoned, buffer in input.buffers shall reset by component.
+ if (!work->input.buffers.empty()) {
+ work->input.buffers.front().reset();
+ }
+ abandonedWorks.emplace_back(std::move(work));
+ }
+ mAbandonedWorks.clear();
+
+ // Pending EOS work will be abandoned here due to component flush if any.
+ mPendingOutputEOS = false;
+
if (!abandonedWorks.empty()) {
mListener->onWorkDone_nb(shared_from_this(), std::move(abandonedWorks));
}
@@ -1070,6 +1165,58 @@
mListener->onError_nb(shared_from_this(), static_cast<uint32_t>(error));
}
+bool C2VDAComponent::startDequeueThread(const media::Size& size, uint32_t pixelFormat,
+ std::shared_ptr<C2BlockPool> blockPool) {
+ CHECK(!mDequeueThread.IsRunning());
+ if (!mDequeueThread.Start()) {
+ ALOGE("failed to start dequeue thread!!");
+ return false;
+ }
+ mDequeueLoopStop.store(false);
+ mBuffersInClient.store(0u);
+ mDequeueThread.task_runner()->PostTask(
+ FROM_HERE, ::base::Bind(&C2VDAComponent::dequeueThreadLoop, ::base::Unretained(this),
+ size, pixelFormat, std::move(blockPool)));
+ return true;
+}
+
+void C2VDAComponent::stopDequeueThread() {
+ if (mDequeueThread.IsRunning()) {
+ mDequeueLoopStop.store(true);
+ mDequeueThread.Stop();
+ }
+}
+
+void C2VDAComponent::dequeueThreadLoop(const media::Size& size, uint32_t pixelFormat,
+ std::shared_ptr<C2BlockPool> blockPool) {
+ ALOGV("dequeueThreadLoop starts");
+ DCHECK(mDequeueThread.task_runner()->BelongsToCurrentThread());
+
+ while (!mDequeueLoopStop.load()) {
+ if (mBuffersInClient.load() == 0) {
+ ::usleep(kDequeueRetryDelayUs); // wait for retry
+ continue;
+ }
+ std::shared_ptr<C2GraphicBlock> block;
+ C2MemoryUsage usage = {C2MemoryUsage::CPU_READ, 0};
+ auto err = blockPool->fetchGraphicBlock(size.width(), size.height(), pixelFormat, usage,
+ &block);
+ if (err == C2_TIMED_OUT) {
+ continue; // wait for retry
+ }
+ if (err == C2_OK) {
+ auto slot = getSlotFromGraphicBlockHandle(block->handle());
+ mTaskRunner->PostTask(FROM_HERE, ::base::Bind(&C2VDAComponent::onOutputBufferReturned,
+ ::base::Unretained(this), slot));
+ mBuffersInClient--;
+ } else {
+ ALOGE("dequeueThreadLoop got error: %d", err);
+ break;
+ }
+ }
+ ALOGV("dequeueThreadLoop terminates");
+}
+
class C2VDAComponentFactory : public C2ComponentFactory {
public:
C2VDAComponentFactory(C2String decoderName)
diff --git a/include/C2ArcVideoAcceleratorFactory.h b/include/C2ArcVideoAcceleratorFactory.h
deleted file mode 100644
index 9cdaf37..0000000
--- a/include/C2ArcVideoAcceleratorFactory.h
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef ANDROID_C2_ARC_VIDEO_ACCELERATOR_FACTORY_H
-#define ANDROID_C2_ARC_VIDEO_ACCELERATOR_FACTORY_H
-
-#include <media/arcvideobridge/IArcVideoBridge.h>
-#include <utils/Singleton.h>
-
-#include <components/arc/common/video.mojom.h>
-#include <components/arc/common/video_decode_accelerator.mojom.h>
-#include <components/arc/common/video_encode_accelerator.mojom.h>
-
-namespace android {
-// Helper class to create message pipe to the ArcVideoAccelerator.
-// This class should only be used in the Mojo thread.
-class C2ArcVideoAcceleratorFactory : public Singleton<C2ArcVideoAcceleratorFactory> {
-public:
- bool createVideoDecodeAccelerator(::arc::mojom::VideoDecodeAcceleratorRequest request);
- bool createVideoEncodeAccelerator(::arc::mojom::VideoEncodeAcceleratorRequest request);
- bool createVideoProtectedBufferAllocator(
- ::arc::mojom::VideoProtectedBufferAllocatorRequest request);
- int32_t hostVersion() const;
-
-private:
- C2ArcVideoAcceleratorFactory();
-
- uint32_t mHostVersion;
- sp<IArcVideoBridge> mArcVideoBridge;
- ::arc::mojom::VideoAcceleratorFactoryPtr mRemoteFactory;
-
- friend class Singleton<C2ArcVideoAcceleratorFactory>;
-};
-} // namespace android
-
-#endif // ANDROID_C2_ARC_VIDEO_ACCELERATOR_FACTORY_H
diff --git a/include/C2VDAComponent.h b/include/C2VDAComponent.h
index 6df3fe7..fcca0c9 100644
--- a/include/C2VDAComponent.h
+++ b/include/C2VDAComponent.h
@@ -132,10 +132,6 @@
ERROR,
};
- enum {
- kDpbOutputBufferExtraCount = 3, // Use the same number as ACodec.
- };
-
// This constant is used to tell apart from drain_mode_t enumerations in C2Component.h, which
// means no drain request.
// Note: this value must be different than all enumerations in drain_mode_t.
@@ -156,13 +152,14 @@
};
int32_t mBlockId = -1;
+ uint32_t mSlotId = 0;
State mState = State::OWNED_BY_COMPONENT;
// Graphic block buffer allocated from allocator. This should be reused.
std::shared_ptr<C2GraphicBlock> mGraphicBlock;
// HAL pixel format used while importing to VDA.
HalPixelFormat mPixelFormat;
// The handle dupped from graphic block for importing to VDA.
- base::ScopedFD mHandle;
+ ::base::ScopedFD mHandle;
// VideoFramePlane information for importing to VDA.
std::vector<VideoFramePlane> mPlanes;
};
@@ -178,12 +175,9 @@
media::Rect visibleRect);
};
- // Used as the release callback for C2VDAGraphicBuffer to get back the output buffer.
- void returnOutputBuffer(int32_t pictureBufferId);
-
// These tasks should be run on the component thread |mThread|.
void onDestroy();
- void onStart(media::VideoCodecProfile profile, base::WaitableEvent* done);
+ void onStart(media::VideoCodecProfile profile, ::base::WaitableEvent* done);
void onQueueWork(std::unique_ptr<C2Work> work);
void onDequeueWork();
void onInputBufferDone(int32_t bitstreamId);
@@ -191,13 +185,13 @@
void onDrain(uint32_t drainMode);
void onDrainDone();
void onFlush();
- void onStop(base::WaitableEvent* done);
+ void onStop(::base::WaitableEvent* done);
void onResetDone();
void onFlushDone();
void onStopDone();
void onOutputFormatChanged(std::unique_ptr<VideoFormat> format);
void onVisibleRectChanged(const media::Rect& cropRect);
- void onOutputBufferReturned(int32_t pictureBufferId);
+ void onOutputBufferReturned(uint32_t slotId);
// Send input buffer to accelerator with specified bitstream id.
void sendInputBufferToAccelerator(const C2ConstLinearBlock& input, int32_t bitstreamId);
@@ -207,6 +201,8 @@
void setOutputFormatCrop(const media::Rect& cropRect);
// Helper function to get the specified GraphicBlockInfo object by its id.
GraphicBlockInfo* getGraphicBlockById(int32_t blockId);
+ // Helper function to get the specified GraphicBlockInfo object by its slot index.
+ GraphicBlockInfo* getGraphicBlockBySlot(uint32_t slotId);
// Helper function to get the specified work in mPendingWorks by bitstream id.
C2Work* getPendingWorkByBitstreamId(int32_t bitstreamId);
// Try to apply the output format change.
@@ -220,13 +216,22 @@
void reportFinishedWorkIfAny();
// Make onWorkDone call to listener for reporting EOS work in mPendingWorks.
void reportEOSWork();
- // Abandon all works in mPendingWorks.
+ // Abandon all works in mPendingWorks and mAbandonedWorks.
void reportAbandonedWorks();
// Make onError call to listener for reporting errors.
void reportError(c2_status_t error);
// Helper function to determine if the work is finished.
bool isWorkDone(const C2Work* work) const;
+ // Start dequeue thread, return true on success.
+ bool startDequeueThread(const media::Size& size, uint32_t pixelFormat,
+ std::shared_ptr<C2BlockPool> blockPool);
+ // Stop dequeue thread.
+ void stopDequeueThread();
+ // The rountine task running on dequeue thread.
+ void dequeueThreadLoop(const media::Size& size, uint32_t pixelFormat,
+ std::shared_ptr<C2BlockPool> blockPool);
+
// The pointer of component interface implementation.
std::shared_ptr<IntfImpl> mIntfImpl;
// The pointer of component interface.
@@ -235,9 +240,16 @@
std::shared_ptr<Listener> mListener;
// The main component thread.
- base::Thread mThread;
+ ::base::Thread mThread;
// The task runner on component thread.
- scoped_refptr<base::SingleThreadTaskRunner> mTaskRunner;
+ scoped_refptr<::base::SingleThreadTaskRunner> mTaskRunner;
+
+ // The dequeue buffer loop thread.
+ ::base::Thread mDequeueThread;
+ // The stop signal for dequeue loop which should be atomic (toggled by main thread).
+ std::atomic<bool> mDequeueLoopStop;
+ // The count of buffers owned by client which should be atomic.
+ std::atomic<uint32_t> mBuffersInClient;
// The following members should be utilized on component thread |mThread|.
@@ -247,12 +259,13 @@
std::unique_ptr<VideoDecodeAcceleratorAdaptor> mVDAAdaptor;
// The done event pointer of stop procedure. It should be restored in onStop() and signaled in
// onStopDone().
- base::WaitableEvent* mStopDoneEvent;
+ ::base::WaitableEvent* mStopDoneEvent;
// The state machine on component thread.
ComponentState mComponentState;
- // The indicator of drain mode (true for draining with EOS). This should be always set along
- // with component going to DRAINING state, and only regarded under DRAINING state.
- bool mDrainWithEOS;
+ // The indicator of draining with EOS. This should be always set along with component going to
+ // DRAINING state, and will be unset either after reportEOSWork() (EOS is outputted), or
+ // reportAbandonedWorks() (drain is cancelled and works are abandoned).
+ bool mPendingOutputEOS;
// The vector of storing allocated output graphic block information.
std::vector<GraphicBlockInfo> mGraphicBlocks;
// The work queue. Works are queued along with drain mode from component API queue_nb and
@@ -261,6 +274,9 @@
// Store all pending works. The dequeued works are placed here until they are finished and then
// sent out by onWorkDone call to listener.
std::deque<std::unique_ptr<C2Work>> mPendingWorks;
+ // Store all abandoned works. When component gets flushed/stopped, remaining works in queue are
+ // dumped here and sent out by onWorkDone call to listener after flush/stop is finished.
+ std::vector<std::unique_ptr<C2Work>> mAbandonedWorks;
// Store the visible rect provided from VDA. If this is changed, component should issue a
// visible size change event.
media::Rect mRequestedVisibleRect;
@@ -272,8 +288,13 @@
// Record the timestamp of the last output buffer. This is used to determine if the work is
// finished.
int64_t mLastOutputTimestamp;
- // The pointer of output block pool.
- std::shared_ptr<C2BlockPool> mOutputBlockPool;
+ // Hack(b/79239042): We do not have a solution to recycle buffers in byte-buffer mode now. This
+ // is a fake buffer queue to record buffers outputted to client, and regard buffer is returned
+ // when it is popped by a new push of the queue (size: kMockMaxBuffersInClient).
+ // TODO: provide proper solution and get rid of this hack.
+ std::list<uint32_t> mMockBufferQueueInClient;
+ // The indicator of whether output has surface.
+ bool mSurfaceMode;
// The following members should be utilized on parent thread.
@@ -285,7 +306,7 @@
std::mutex mStartStopLock;
// The WeakPtrFactory for getting weak pointer of this.
- base::WeakPtrFactory<C2VDAComponent> mWeakThisFactory;
+ ::base::WeakPtrFactory<C2VDAComponent> mWeakThisFactory;
DISALLOW_COPY_AND_ASSIGN(C2VDAComponent);
};
diff --git a/tests/Android.mk b/tests/Android.mk
index 4bafb4a..3b384b4 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -21,6 +21,7 @@
libv4l2_codec2_vda \
LOCAL_C_INCLUDES += \
+ $(TOP)/device/google/cheets2/codec2/vdastore/include \
$(TOP)/external/v4l2_codec2/include \
$(TOP)/external/v4l2_codec2/vda \
$(TOP)/hardware/google/av/codec2/include \
diff --git a/tests/C2VDACompIntf_test.cpp b/tests/C2VDACompIntf_test.cpp
index 6ed0753..f08ee50 100644
--- a/tests/C2VDACompIntf_test.cpp
+++ b/tests/C2VDACompIntf_test.cpp
@@ -5,6 +5,7 @@
//#define LOG_NDEBUG 0
#define LOG_TAG "C2VDACompIntf_test"
+#include <C2VDAAllocatorStore.h>
#include <C2VDAComponent.h>
#include <C2PlatformSupport.h>
@@ -30,7 +31,7 @@
const char* MEDIA_MIMETYPE_VIDEO_AVC = "video/avc";
const C2Allocator::id_t kInputAllocators[] = {C2PlatformAllocatorStore::ION};
-const C2Allocator::id_t kOutputAllocators[] = {C2PlatformAllocatorStore::GRALLOC};
+const C2Allocator::id_t kOutputAllocators[] = {C2VDAAllocatorStore::V4L2_BUFFERQUEUE};
const C2BlockPool::local_id_t kDefaultOutputBlockPool = C2BlockPool::BASIC_GRAPHIC;
class C2VDACompIntfTest : public ::testing::Test {
diff --git a/vda/Android.bp b/vda/Android.bp
index 5f84535..adba0ef 100644
--- a/vda/Android.bp
+++ b/vda/Android.bp
@@ -36,6 +36,7 @@
"-Wall",
"-Werror",
"-Wno-unused-parameter",
+ "-Wno-implicit-fallthrough", // at h264_decoder.cc:1374
],
clang: true,
sanitize: {
