// Copyright 2017 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 "C2VDAComponent"
|
|
#ifdef V4L2_CODEC2_ARC
|
#include <C2VDAAdaptorProxy.h>
|
#else
|
#include <C2VDAAdaptor.h>
|
#endif
|
|
#define __C2_GENERATE_GLOBAL_VARS__
|
#include <C2VDAAllocatorStore.h>
|
#include <C2VDAComponent.h>
|
#include <C2VDAPixelFormat.h>
|
#include <C2VDASupport.h> // to getParamReflector from vda store
|
#include <C2VdaBqBlockPool.h>
|
#include <C2VdaPooledBlockPool.h>
|
|
#include <h264_parser.h>
|
|
#include <C2AllocatorGralloc.h>
|
#include <C2ComponentFactory.h>
|
#include <C2PlatformSupport.h>
|
#include <Codec2Mapper.h>
|
|
#include <base/bind.h>
|
#include <base/bind_helpers.h>
|
|
#include <media/stagefright/MediaDefs.h>
|
#include <media/stagefright/foundation/ColorUtils.h>
|
#include <utils/Log.h>
|
#include <utils/misc.h>
|
|
#include <inttypes.h>
|
#include <string.h>
|
#include <algorithm>
|
#include <string>
|
|
#define UNUSED(expr) \
|
do { \
|
(void)(expr); \
|
} while (0)
|
|
namespace android {
|
|
namespace {
|
|
// Mask against 30 bits to avoid (undefined) wraparound on signed integer.
|
int32_t frameIndexToBitstreamId(c2_cntr64_t frameIndex) {
|
return static_cast<int32_t>(frameIndex.peeku() & 0x3FFFFFFF);
|
}
|
|
// Use basic graphic block pool/allocator as default.
|
const C2BlockPool::local_id_t kDefaultOutputBlockPool = C2BlockPool::BASIC_GRAPHIC;
|
|
const C2String kH264DecoderName = "c2.vda.avc.decoder";
|
const C2String kVP8DecoderName = "c2.vda.vp8.decoder";
|
const C2String kVP9DecoderName = "c2.vda.vp9.decoder";
|
const C2String kH264SecureDecoderName = "c2.vda.avc.decoder.secure";
|
const C2String kVP8SecureDecoderName = "c2.vda.vp8.decoder.secure";
|
const C2String kVP9SecureDecoderName = "c2.vda.vp9.decoder.secure";
|
|
const uint32_t kDpbOutputBufferExtraCount = 3; // Use the same number as ACodec.
|
const int kDequeueRetryDelayUs = 10000; // Wait time of dequeue buffer retry in microseconds.
|
const int32_t kAllocateBufferMaxRetries = 10; // Max retry time for fetchGraphicBlock timeout.
|
} // namespace
|
|
static c2_status_t adaptorResultToC2Status(VideoDecodeAcceleratorAdaptor::Result result) {
|
switch (result) {
|
case VideoDecodeAcceleratorAdaptor::Result::SUCCESS:
|
return C2_OK;
|
case VideoDecodeAcceleratorAdaptor::Result::ILLEGAL_STATE:
|
ALOGE("Got error: ILLEGAL_STATE");
|
return C2_BAD_STATE;
|
case VideoDecodeAcceleratorAdaptor::Result::INVALID_ARGUMENT:
|
ALOGE("Got error: INVALID_ARGUMENT");
|
return C2_BAD_VALUE;
|
case VideoDecodeAcceleratorAdaptor::Result::UNREADABLE_INPUT:
|
ALOGE("Got error: UNREADABLE_INPUT");
|
return C2_BAD_VALUE;
|
case VideoDecodeAcceleratorAdaptor::Result::PLATFORM_FAILURE:
|
ALOGE("Got error: PLATFORM_FAILURE");
|
return C2_CORRUPTED;
|
case VideoDecodeAcceleratorAdaptor::Result::INSUFFICIENT_RESOURCES:
|
ALOGE("Got error: INSUFFICIENT_RESOURCES");
|
return C2_NO_MEMORY;
|
default:
|
ALOGE("Unrecognizable adaptor result (value = %d)...", result);
|
return C2_CORRUPTED;
|
}
|
}
|
|
// static
|
C2R C2VDAComponent::IntfImpl::ProfileLevelSetter(bool mayBlock,
|
C2P<C2StreamProfileLevelInfo::input>& info) {
|
(void)mayBlock;
|
return info.F(info.v.profile)
|
.validatePossible(info.v.profile)
|
.plus(info.F(info.v.level).validatePossible(info.v.level));
|
}
|
|
// static
|
C2R C2VDAComponent::IntfImpl::SizeSetter(bool mayBlock,
|
C2P<C2StreamPictureSizeInfo::output>& videoSize) {
|
(void)mayBlock;
|
// TODO: maybe apply block limit?
|
return videoSize.F(videoSize.v.width)
|
.validatePossible(videoSize.v.width)
|
.plus(videoSize.F(videoSize.v.height).validatePossible(videoSize.v.height));
|
}
|
|
// static
|
template <typename T>
|
C2R C2VDAComponent::IntfImpl::DefaultColorAspectsSetter(bool mayBlock, C2P<T>& def) {
|
(void)mayBlock;
|
if (def.v.range > C2Color::RANGE_OTHER) {
|
def.set().range = C2Color::RANGE_OTHER;
|
}
|
if (def.v.primaries > C2Color::PRIMARIES_OTHER) {
|
def.set().primaries = C2Color::PRIMARIES_OTHER;
|
}
|
if (def.v.transfer > C2Color::TRANSFER_OTHER) {
|
def.set().transfer = C2Color::TRANSFER_OTHER;
|
}
|
if (def.v.matrix > C2Color::MATRIX_OTHER) {
|
def.set().matrix = C2Color::MATRIX_OTHER;
|
}
|
return C2R::Ok();
|
}
|
|
// static
|
C2R C2VDAComponent::IntfImpl::MergedColorAspectsSetter(
|
bool mayBlock, C2P<C2StreamColorAspectsInfo::output>& merged,
|
const C2P<C2StreamColorAspectsTuning::output>& def,
|
const C2P<C2StreamColorAspectsInfo::input>& coded) {
|
(void)mayBlock;
|
// Take coded values for all specified fields, and default values for unspecified ones.
|
merged.set().range = coded.v.range == RANGE_UNSPECIFIED ? def.v.range : coded.v.range;
|
merged.set().primaries =
|
coded.v.primaries == PRIMARIES_UNSPECIFIED ? def.v.primaries : coded.v.primaries;
|
merged.set().transfer =
|
coded.v.transfer == TRANSFER_UNSPECIFIED ? def.v.transfer : coded.v.transfer;
|
merged.set().matrix = coded.v.matrix == MATRIX_UNSPECIFIED ? def.v.matrix : coded.v.matrix;
|
return C2R::Ok();
|
}
|
|
C2VDAComponent::IntfImpl::IntfImpl(C2String name, const std::shared_ptr<C2ReflectorHelper>& helper)
|
: C2InterfaceHelper(helper), mInitStatus(C2_OK) {
|
setDerivedInstance(this);
|
|
// TODO(johnylin): use factory function to determine whether V4L2 stream or slice API is.
|
char inputMime[128];
|
if (name == kH264DecoderName || name == kH264SecureDecoderName) {
|
strcpy(inputMime, MEDIA_MIMETYPE_VIDEO_AVC);
|
mInputCodec = InputCodec::H264;
|
addParameter(
|
DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL)
|
.withDefault(new C2StreamProfileLevelInfo::input(
|
0u, C2Config::PROFILE_AVC_MAIN, C2Config::LEVEL_AVC_4))
|
.withFields(
|
{C2F(mProfileLevel, profile)
|
.oneOf({C2Config::PROFILE_AVC_BASELINE,
|
C2Config::PROFILE_AVC_CONSTRAINED_BASELINE,
|
C2Config::PROFILE_AVC_MAIN,
|
C2Config::PROFILE_AVC_HIGH,
|
C2Config::PROFILE_AVC_CONSTRAINED_HIGH}),
|
C2F(mProfileLevel, level)
|
.oneOf({C2Config::LEVEL_AVC_1, C2Config::LEVEL_AVC_1B,
|
C2Config::LEVEL_AVC_1_1, C2Config::LEVEL_AVC_1_2,
|
C2Config::LEVEL_AVC_1_3, C2Config::LEVEL_AVC_2,
|
C2Config::LEVEL_AVC_2_1, C2Config::LEVEL_AVC_2_2,
|
C2Config::LEVEL_AVC_3, C2Config::LEVEL_AVC_3_1,
|
C2Config::LEVEL_AVC_3_2, C2Config::LEVEL_AVC_4,
|
C2Config::LEVEL_AVC_4_1, C2Config::LEVEL_AVC_4_2,
|
C2Config::LEVEL_AVC_5, C2Config::LEVEL_AVC_5_1,
|
C2Config::LEVEL_AVC_5_2})})
|
.withSetter(ProfileLevelSetter)
|
.build());
|
} else if (name == kVP8DecoderName || name == kVP8SecureDecoderName) {
|
strcpy(inputMime, MEDIA_MIMETYPE_VIDEO_VP8);
|
mInputCodec = InputCodec::VP8;
|
addParameter(DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL)
|
.withConstValue(new C2StreamProfileLevelInfo::input(
|
0u, C2Config::PROFILE_UNUSED, C2Config::LEVEL_UNUSED))
|
.build());
|
} else if (name == kVP9DecoderName || name == kVP9SecureDecoderName) {
|
strcpy(inputMime, MEDIA_MIMETYPE_VIDEO_VP9);
|
mInputCodec = InputCodec::VP9;
|
addParameter(
|
DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL)
|
.withDefault(new C2StreamProfileLevelInfo::input(
|
0u, C2Config::PROFILE_VP9_0, C2Config::LEVEL_VP9_5))
|
.withFields({C2F(mProfileLevel, profile).oneOf({C2Config::PROFILE_VP9_0}),
|
C2F(mProfileLevel, level)
|
.oneOf({C2Config::LEVEL_VP9_1, C2Config::LEVEL_VP9_1_1,
|
C2Config::LEVEL_VP9_2, C2Config::LEVEL_VP9_2_1,
|
C2Config::LEVEL_VP9_3, C2Config::LEVEL_VP9_3_1,
|
C2Config::LEVEL_VP9_4, C2Config::LEVEL_VP9_4_1,
|
C2Config::LEVEL_VP9_5})})
|
.withSetter(ProfileLevelSetter)
|
.build());
|
} else {
|
ALOGE("Invalid component name: %s", name.c_str());
|
mInitStatus = C2_BAD_VALUE;
|
return;
|
}
|
// Get supported profiles from VDA.
|
// TODO: re-think the suitable method of getting supported profiles for both pure Android and
|
// ARC++.
|
media::VideoDecodeAccelerator::SupportedProfiles supportedProfiles;
|
#ifdef V4L2_CODEC2_ARC
|
supportedProfiles = arc::C2VDAAdaptorProxy::GetSupportedProfiles(mInputCodec);
|
#else
|
supportedProfiles = C2VDAAdaptor::GetSupportedProfiles(mInputCodec);
|
#endif
|
if (supportedProfiles.empty()) {
|
ALOGE("No supported profile from input codec: %d", mInputCodec);
|
mInitStatus = C2_BAD_VALUE;
|
return;
|
}
|
|
mCodecProfile = supportedProfiles[0].profile;
|
|
auto minSize = supportedProfiles[0].min_resolution;
|
auto maxSize = supportedProfiles[0].max_resolution;
|
|
addParameter(
|
DefineParam(mInputFormat, C2_PARAMKEY_INPUT_STREAM_BUFFER_TYPE)
|
.withConstValue(new C2StreamBufferTypeSetting::input(0u, C2FormatCompressed))
|
.build());
|
|
addParameter(DefineParam(mOutputFormat, C2_PARAMKEY_OUTPUT_STREAM_BUFFER_TYPE)
|
.withConstValue(new C2StreamBufferTypeSetting::output(0u, C2FormatVideo))
|
.build());
|
|
addParameter(
|
DefineParam(mInputMediaType, C2_PARAMKEY_INPUT_MEDIA_TYPE)
|
.withConstValue(AllocSharedString<C2PortMediaTypeSetting::input>(inputMime))
|
.build());
|
|
addParameter(DefineParam(mOutputMediaType, C2_PARAMKEY_OUTPUT_MEDIA_TYPE)
|
.withConstValue(AllocSharedString<C2PortMediaTypeSetting::output>(
|
MEDIA_MIMETYPE_VIDEO_RAW))
|
.build());
|
|
addParameter(DefineParam(mSize, C2_PARAMKEY_STREAM_PICTURE_SIZE)
|
.withDefault(new C2StreamPictureSizeInfo::output(0u, 176, 144))
|
.withFields({
|
C2F(mSize, width).inRange(minSize.width(), maxSize.width(), 16),
|
C2F(mSize, height).inRange(minSize.height(), maxSize.height(), 16),
|
})
|
.withSetter(SizeSetter)
|
.build());
|
|
// App may set a smaller value for maximum of input buffer size than actually required
|
// by mistake. C2VDAComponent overrides it if the value specified by app is smaller than
|
// the calculated value in MaxSizeCalculator().
|
// This value is the default maximum of linear buffer size (kLinearBufferSize) in
|
// CCodecBufferChannel.cpp.
|
constexpr static size_t kLinearBufferSize = 1048576;
|
struct LocalCalculator {
|
static C2R MaxSizeCalculator(bool mayBlock, C2P<C2StreamMaxBufferSizeInfo::input>& me,
|
const C2P<C2StreamPictureSizeInfo::output>& size) {
|
(void)mayBlock;
|
// TODO: Need larger size?
|
me.set().value = kLinearBufferSize;
|
const uint32_t width = size.v.width;
|
const uint32_t height = size.v.height;
|
// Enlarge the input buffer for 4k video
|
if ((width > 1920 && height > 1080)) {
|
me.set().value = 4 * kLinearBufferSize;
|
}
|
return C2R::Ok();
|
}
|
};
|
addParameter(DefineParam(mMaxInputSize, C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE)
|
.withDefault(new C2StreamMaxBufferSizeInfo::input(0u, kLinearBufferSize))
|
.withFields({
|
C2F(mMaxInputSize, value).any(),
|
})
|
.calculatedAs(LocalCalculator::MaxSizeCalculator, mSize)
|
.build());
|
|
bool secureMode = name.find(".secure") != std::string::npos;
|
C2Allocator::id_t inputAllocators[] = {secureMode ? C2VDAAllocatorStore::SECURE_LINEAR
|
: C2PlatformAllocatorStore::ION};
|
|
C2Allocator::id_t outputAllocators[] = {C2VDAAllocatorStore::V4L2_BUFFERPOOL};
|
|
C2Allocator::id_t surfaceAllocator = secureMode ? C2VDAAllocatorStore::SECURE_GRAPHIC
|
: C2VDAAllocatorStore::V4L2_BUFFERQUEUE;
|
|
addParameter(
|
DefineParam(mInputAllocatorIds, C2_PARAMKEY_INPUT_ALLOCATORS)
|
.withConstValue(C2PortAllocatorsTuning::input::AllocShared(inputAllocators))
|
.build());
|
|
addParameter(
|
DefineParam(mOutputAllocatorIds, C2_PARAMKEY_OUTPUT_ALLOCATORS)
|
.withConstValue(C2PortAllocatorsTuning::output::AllocShared(outputAllocators))
|
.build());
|
|
addParameter(DefineParam(mOutputSurfaceAllocatorId, C2_PARAMKEY_OUTPUT_SURFACE_ALLOCATOR)
|
.withConstValue(new C2PortSurfaceAllocatorTuning::output(surfaceAllocator))
|
.build());
|
|
C2BlockPool::local_id_t outputBlockPools[] = {kDefaultOutputBlockPool};
|
|
addParameter(
|
DefineParam(mOutputBlockPoolIds, C2_PARAMKEY_OUTPUT_BLOCK_POOLS)
|
.withDefault(C2PortBlockPoolsTuning::output::AllocShared(outputBlockPools))
|
.withFields({C2F(mOutputBlockPoolIds, m.values[0]).any(),
|
C2F(mOutputBlockPoolIds, m.values).inRange(0, 1)})
|
.withSetter(Setter<C2PortBlockPoolsTuning::output>::NonStrictValuesWithNoDeps)
|
.build());
|
|
addParameter(
|
DefineParam(mDefaultColorAspects, C2_PARAMKEY_DEFAULT_COLOR_ASPECTS)
|
.withDefault(new C2StreamColorAspectsTuning::output(
|
0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED,
|
C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
|
.withFields(
|
{C2F(mDefaultColorAspects, range)
|
.inRange(C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
|
C2F(mDefaultColorAspects, primaries)
|
.inRange(C2Color::PRIMARIES_UNSPECIFIED,
|
C2Color::PRIMARIES_OTHER),
|
C2F(mDefaultColorAspects, transfer)
|
.inRange(C2Color::TRANSFER_UNSPECIFIED,
|
C2Color::TRANSFER_OTHER),
|
C2F(mDefaultColorAspects, matrix)
|
.inRange(C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)})
|
.withSetter(DefaultColorAspectsSetter)
|
.build());
|
|
addParameter(
|
DefineParam(mCodedColorAspects, C2_PARAMKEY_VUI_COLOR_ASPECTS)
|
.withDefault(new C2StreamColorAspectsInfo::input(
|
0u, C2Color::RANGE_LIMITED, C2Color::PRIMARIES_UNSPECIFIED,
|
C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
|
.withFields(
|
{C2F(mCodedColorAspects, range)
|
.inRange(C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
|
C2F(mCodedColorAspects, primaries)
|
.inRange(C2Color::PRIMARIES_UNSPECIFIED,
|
C2Color::PRIMARIES_OTHER),
|
C2F(mCodedColorAspects, transfer)
|
.inRange(C2Color::TRANSFER_UNSPECIFIED,
|
C2Color::TRANSFER_OTHER),
|
C2F(mCodedColorAspects, matrix)
|
.inRange(C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)})
|
.withSetter(DefaultColorAspectsSetter)
|
.build());
|
|
addParameter(
|
DefineParam(mColorAspects, C2_PARAMKEY_COLOR_ASPECTS)
|
.withDefault(new C2StreamColorAspectsInfo::output(
|
0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED,
|
C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED))
|
.withFields(
|
{C2F(mColorAspects, range)
|
.inRange(C2Color::RANGE_UNSPECIFIED, C2Color::RANGE_OTHER),
|
C2F(mColorAspects, primaries)
|
.inRange(C2Color::PRIMARIES_UNSPECIFIED,
|
C2Color::PRIMARIES_OTHER),
|
C2F(mColorAspects, transfer)
|
.inRange(C2Color::TRANSFER_UNSPECIFIED,
|
C2Color::TRANSFER_OTHER),
|
C2F(mColorAspects, matrix)
|
.inRange(C2Color::MATRIX_UNSPECIFIED, C2Color::MATRIX_OTHER)})
|
.withSetter(MergedColorAspectsSetter, mDefaultColorAspects, mCodedColorAspects)
|
.build());
|
}
|
|
////////////////////////////////////////////////////////////////////////////////
|
#define EXPECT_STATE_OR_RETURN_ON_ERROR(x) \
|
do { \
|
if (mComponentState == ComponentState::ERROR) return; \
|
CHECK_EQ(mComponentState, ComponentState::x); \
|
} while (0)
|
|
#define EXPECT_RUNNING_OR_RETURN_ON_ERROR() \
|
do { \
|
if (mComponentState == ComponentState::ERROR) return; \
|
CHECK_NE(mComponentState, ComponentState::UNINITIALIZED); \
|
} while (0)
|
|
C2VDAComponent::VideoFormat::VideoFormat(HalPixelFormat pixelFormat, uint32_t minNumBuffers,
|
media::Size codedSize, media::Rect visibleRect)
|
: mPixelFormat(pixelFormat),
|
mMinNumBuffers(minNumBuffers),
|
mCodedSize(codedSize),
|
mVisibleRect(visibleRect) {}
|
|
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),
|
mPendingOutputEOS(false),
|
mPendingColorAspectsChange(false),
|
mPendingColorAspectsChangeFrameIndex(0),
|
mCodecProfile(media::VIDEO_CODEC_PROFILE_UNKNOWN),
|
mState(State::UNLOADED),
|
mWeakThisFactory(this) {
|
// TODO(johnylin): the client may need to know if init is failed.
|
if (mIntfImpl->status() != C2_OK) {
|
ALOGE("Component interface init failed (err code = %d)", mIntfImpl->status());
|
return;
|
}
|
|
mSecureMode = name.find(".secure") != std::string::npos;
|
if (!mThread.Start()) {
|
ALOGE("Component thread failed to start.");
|
return;
|
}
|
mTaskRunner = mThread.task_runner();
|
mState.store(State::LOADED);
|
}
|
|
C2VDAComponent::~C2VDAComponent() {
|
if (mThread.IsRunning()) {
|
mTaskRunner->PostTask(FROM_HERE,
|
::base::Bind(&C2VDAComponent::onDestroy, ::base::Unretained(this)));
|
mThread.Stop();
|
}
|
}
|
|
void C2VDAComponent::onDestroy() {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onDestroy");
|
if (mVDAAdaptor.get()) {
|
mVDAAdaptor->destroy();
|
mVDAAdaptor.reset(nullptr);
|
}
|
stopDequeueThread();
|
}
|
|
void C2VDAComponent::onStart(media::VideoCodecProfile profile, ::base::WaitableEvent* done) {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onStart");
|
CHECK_EQ(mComponentState, ComponentState::UNINITIALIZED);
|
|
#ifdef V4L2_CODEC2_ARC
|
mVDAAdaptor.reset(new arc::C2VDAAdaptorProxy());
|
#else
|
mVDAAdaptor.reset(new C2VDAAdaptor());
|
#endif
|
|
mVDAInitResult = mVDAAdaptor->initialize(profile, mSecureMode, this);
|
if (mVDAInitResult == VideoDecodeAcceleratorAdaptor::Result::SUCCESS) {
|
mComponentState = ComponentState::STARTED;
|
}
|
|
if (!mSecureMode && mIntfImpl->getInputCodec() == InputCodec::H264) {
|
// Get default color aspects on start.
|
updateColorAspects();
|
mPendingColorAspectsChange = false;
|
}
|
|
done->Signal();
|
}
|
|
void C2VDAComponent::onQueueWork(std::unique_ptr<C2Work> work) {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
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();
|
|
uint32_t drainMode = NO_DRAIN;
|
if (work->input.flags & C2FrameData::FLAG_END_OF_STREAM) {
|
drainMode = DRAIN_COMPONENT_WITH_EOS;
|
}
|
mQueue.push({std::move(work), drainMode});
|
// 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)));
|
}
|
|
void C2VDAComponent::onDequeueWork() {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onDequeueWork");
|
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
|
if (mQueue.empty()) {
|
return;
|
}
|
if (mComponentState == ComponentState::DRAINING ||
|
mComponentState == ComponentState::FLUSHING) {
|
ALOGV("Temporarily stop dequeueing works since component is draining/flushing.");
|
return;
|
}
|
if (mComponentState != ComponentState::STARTED) {
|
ALOGE("Work queue should be empty if the component is not in STARTED state.");
|
return;
|
}
|
|
// Dequeue a work from mQueue.
|
std::unique_ptr<C2Work> work(std::move(mQueue.front().mWork));
|
auto drainMode = mQueue.front().mDrainMode;
|
mQueue.pop();
|
|
CHECK_LE(work->input.buffers.size(), 1u);
|
bool isEmptyCSDWork = false;
|
// Use frameIndex as bitstreamId.
|
int32_t bitstreamId = frameIndexToBitstreamId(work->input.ordinal.frameIndex);
|
if (work->input.buffers.empty()) {
|
// Client may queue a work with no input buffer for either it's EOS or empty CSD, otherwise
|
// every work must have one input buffer.
|
isEmptyCSDWork = work->input.flags & C2FrameData::FLAG_CODEC_CONFIG;
|
CHECK(drainMode != NO_DRAIN || isEmptyCSDWork);
|
// Emplace a nullptr to unify the check for work done.
|
ALOGV("Got a work with no input buffer! Emplace a nullptr inside.");
|
work->input.buffers.emplace_back(nullptr);
|
} 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);
|
|
// Call parseCodedColorAspects() to try to parse color aspects from bitstream only if:
|
// 1) This is non-secure decoding.
|
// 2) This is H264 codec.
|
// 3) This input is CSD buffer (with flags FLAG_CODEC_CONFIG).
|
if (!mSecureMode && (mIntfImpl->getInputCodec() == InputCodec::H264) &&
|
(work->input.flags & C2FrameData::FLAG_CODEC_CONFIG)) {
|
if (parseCodedColorAspects(linearBlock)) {
|
// Record current frame index, color aspects should be updated only for output
|
// buffers whose frame indices are not less than this one.
|
mPendingColorAspectsChange = true;
|
mPendingColorAspectsChangeFrameIndex = work->input.ordinal.frameIndex.peeku();
|
}
|
}
|
// Send input buffer to VDA for decode.
|
sendInputBufferToAccelerator(linearBlock, bitstreamId);
|
}
|
|
CHECK_EQ(work->worklets.size(), 1u);
|
work->worklets.front()->output.flags = static_cast<C2FrameData::flags_t>(0);
|
work->worklets.front()->output.buffers.clear();
|
work->worklets.front()->output.ordinal = work->input.ordinal;
|
|
if (drainMode != NO_DRAIN) {
|
mVDAAdaptor->flush();
|
mComponentState = ComponentState::DRAINING;
|
mPendingOutputEOS = drainMode == DRAIN_COMPONENT_WITH_EOS;
|
}
|
|
// Put work to mPendingWorks.
|
mPendingWorks.emplace_back(std::move(work));
|
if (isEmptyCSDWork) {
|
// Directly report the empty CSD work as finished.
|
reportWorkIfFinished(bitstreamId);
|
}
|
|
if (!mQueue.empty()) {
|
mTaskRunner->PostTask(FROM_HERE, ::base::Bind(&C2VDAComponent::onDequeueWork,
|
::base::Unretained(this)));
|
}
|
}
|
|
void C2VDAComponent::onInputBufferDone(int32_t bitstreamId) {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onInputBufferDone: bitstream id=%d", bitstreamId);
|
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
|
|
C2Work* work = getPendingWorkByBitstreamId(bitstreamId);
|
if (!work) {
|
reportError(C2_CORRUPTED);
|
return;
|
}
|
|
// When the work is done, the input buffer shall be reset by component.
|
work->input.buffers.front().reset();
|
|
reportWorkIfFinished(bitstreamId);
|
}
|
|
void C2VDAComponent::onOutputBufferReturned(std::shared_ptr<C2GraphicBlock> block,
|
uint32_t poolId) {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onOutputBufferReturned: pool id=%u", poolId);
|
if (mComponentState == ComponentState::UNINITIALIZED) {
|
// Output buffer is returned from client after component is stopped. Just let the buffer be
|
// released.
|
return;
|
}
|
|
if (block->width() != static_cast<uint32_t>(mOutputFormat.mCodedSize.width()) ||
|
block->height() != static_cast<uint32_t>(mOutputFormat.mCodedSize.height())) {
|
// Output buffer is returned after we changed output resolution. Just let the buffer be
|
// released.
|
ALOGV("Discard obsolete graphic block: pool id=%u", poolId);
|
return;
|
}
|
|
GraphicBlockInfo* info = getGraphicBlockByPoolId(poolId);
|
if (!info) {
|
reportError(C2_CORRUPTED);
|
return;
|
}
|
CHECK_EQ(info->mState, GraphicBlockInfo::State::OWNED_BY_CLIENT);
|
info->mGraphicBlock = std::move(block);
|
info->mState = GraphicBlockInfo::State::OWNED_BY_COMPONENT;
|
|
if (mPendingOutputFormat) {
|
tryChangeOutputFormat();
|
} else {
|
// Do not pass the ownership to accelerator if this buffer will still be reused under
|
// |mPendingBuffersToWork|.
|
auto existingFrame = std::find_if(
|
mPendingBuffersToWork.begin(), mPendingBuffersToWork.end(),
|
[id = info->mBlockId](const OutputBufferInfo& o) { return o.mBlockId == id; });
|
bool ownByAccelerator = existingFrame == mPendingBuffersToWork.end();
|
sendOutputBufferToAccelerator(info, ownByAccelerator);
|
sendOutputBufferToWorkIfAny(false /* dropIfUnavailable */);
|
}
|
}
|
|
void C2VDAComponent::onOutputBufferDone(int32_t pictureBufferId, int32_t bitstreamId) {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onOutputBufferDone: picture id=%d, bitstream id=%d", pictureBufferId, bitstreamId);
|
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
|
|
GraphicBlockInfo* info = getGraphicBlockById(pictureBufferId);
|
if (!info) {
|
reportError(C2_CORRUPTED);
|
return;
|
}
|
|
if (info->mState == GraphicBlockInfo::State::OWNED_BY_ACCELERATOR) {
|
info->mState = GraphicBlockInfo::State::OWNED_BY_COMPONENT;
|
}
|
mPendingBuffersToWork.push_back({bitstreamId, pictureBufferId});
|
sendOutputBufferToWorkIfAny(false /* dropIfUnavailable */);
|
}
|
|
void C2VDAComponent::sendOutputBufferToWorkIfAny(bool dropIfUnavailable) {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
|
while (!mPendingBuffersToWork.empty()) {
|
auto nextBuffer = mPendingBuffersToWork.front();
|
GraphicBlockInfo* info = getGraphicBlockById(nextBuffer.mBlockId);
|
CHECK_NE(info->mState, GraphicBlockInfo::State::OWNED_BY_ACCELERATOR);
|
|
C2Work* work = getPendingWorkByBitstreamId(nextBuffer.mBitstreamId);
|
if (!work) {
|
reportError(C2_CORRUPTED);
|
return;
|
}
|
|
if (info->mState == GraphicBlockInfo::State::OWNED_BY_CLIENT) {
|
// This buffer is the existing frame and still owned by client.
|
if (!dropIfUnavailable &&
|
std::find(mUndequeuedBlockIds.begin(), mUndequeuedBlockIds.end(),
|
nextBuffer.mBlockId) == mUndequeuedBlockIds.end()) {
|
ALOGV("Still waiting for existing frame returned from client...");
|
return;
|
}
|
ALOGV("Drop this frame...");
|
sendOutputBufferToAccelerator(info, false /* ownByAccelerator */);
|
work->worklets.front()->output.flags = C2FrameData::FLAG_DROP_FRAME;
|
} else {
|
// This buffer is ready to push into the corresponding work.
|
// Output buffer will be passed to client soon along with mListener->onWorkDone_nb().
|
info->mState = GraphicBlockInfo::State::OWNED_BY_CLIENT;
|
mBuffersInClient++;
|
updateUndequeuedBlockIds(info->mBlockId);
|
|
// Attach output buffer to the work corresponded to bitstreamId.
|
C2ConstGraphicBlock constBlock = info->mGraphicBlock->share(
|
C2Rect(mOutputFormat.mVisibleRect.width(),
|
mOutputFormat.mVisibleRect.height()),
|
C2Fence());
|
MarkBlockPoolDataAsShared(constBlock);
|
|
std::shared_ptr<C2Buffer> buffer = C2Buffer::CreateGraphicBuffer(std::move(constBlock));
|
if (mPendingColorAspectsChange &&
|
work->input.ordinal.frameIndex.peeku() >= mPendingColorAspectsChangeFrameIndex) {
|
updateColorAspects();
|
mPendingColorAspectsChange = false;
|
}
|
if (mCurrentColorAspects) {
|
buffer->setInfo(mCurrentColorAspects);
|
}
|
work->worklets.front()->output.buffers.emplace_back(std::move(buffer));
|
info->mGraphicBlock.reset();
|
}
|
reportWorkIfFinished(nextBuffer.mBitstreamId);
|
mPendingBuffersToWork.pop_front();
|
}
|
}
|
|
void C2VDAComponent::updateUndequeuedBlockIds(int32_t blockId) {
|
// The size of |mUndequedBlockIds| will always be the minimum buffer count for display.
|
mUndequeuedBlockIds.push_back(blockId);
|
mUndequeuedBlockIds.pop_front();
|
}
|
|
void C2VDAComponent::onDrain(uint32_t drainMode) {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onDrain: mode = %u", drainMode);
|
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
|
|
if (!mQueue.empty()) {
|
// Mark last queued work as "drain-till-here" by setting drainMode. Do not change drainMode
|
// if last work already has one.
|
if (mQueue.back().mDrainMode == NO_DRAIN) {
|
mQueue.back().mDrainMode = drainMode;
|
}
|
} else if (!mPendingWorks.empty()) {
|
// Neglect drain request if component is not in STARTED mode. Otherwise, enters DRAINING
|
// mode and signal VDA flush immediately.
|
if (mComponentState == ComponentState::STARTED) {
|
mVDAAdaptor->flush();
|
mComponentState = ComponentState::DRAINING;
|
mPendingOutputEOS = drainMode == DRAIN_COMPONENT_WITH_EOS;
|
} else {
|
ALOGV("Neglect drain. Component in state: %d", mComponentState);
|
}
|
} else {
|
// Do nothing.
|
ALOGV("No buffers in VDA, drain takes no effect.");
|
}
|
}
|
|
void C2VDAComponent::onDrainDone() {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onDrainDone");
|
if (mComponentState == ComponentState::DRAINING) {
|
mComponentState = ComponentState::STARTED;
|
} else if (mComponentState == ComponentState::STOPPING) {
|
// The client signals stop right before VDA notifies drain done. Let stop process goes.
|
return;
|
} 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;
|
}
|
|
// Drop all pending existing frames and return all finished works before drain done.
|
sendOutputBufferToWorkIfAny(true /* dropIfUnavailable */);
|
CHECK(mPendingBuffersToWork.empty());
|
|
if (mPendingOutputEOS) {
|
// Return EOS work.
|
reportEOSWork();
|
}
|
// mPendingWorks must be empty after draining is finished.
|
CHECK(mPendingWorks.empty());
|
|
// Work dequeueing was stopped while component draining. Restart it.
|
mTaskRunner->PostTask(FROM_HERE,
|
::base::Bind(&C2VDAComponent::onDequeueWork, ::base::Unretained(this)));
|
}
|
|
void C2VDAComponent::onFlush() {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onFlush");
|
if (mComponentState == ComponentState::FLUSHING ||
|
mComponentState == ComponentState::STOPPING) {
|
return; // Ignore other flush request when component is flushing or stopping.
|
}
|
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
|
|
mVDAAdaptor->reset();
|
// Pop all works in mQueue and put into mAbandonedWorks.
|
while (!mQueue.empty()) {
|
mAbandonedWorks.emplace_back(std::move(mQueue.front().mWork));
|
mQueue.pop();
|
}
|
mComponentState = ComponentState::FLUSHING;
|
}
|
|
void C2VDAComponent::onStop(::base::WaitableEvent* done) {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onStop");
|
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
|
|
// Do not request VDA reset again before the previous one is done. If reset is already sent by
|
// onFlush(), just regard the following NotifyResetDone callback as for stopping.
|
if (mComponentState != ComponentState::FLUSHING) {
|
mVDAAdaptor->reset();
|
}
|
|
// Pop all works in mQueue and put into mAbandonedWorks.
|
while (!mQueue.empty()) {
|
mAbandonedWorks.emplace_back(std::move(mQueue.front().mWork));
|
mQueue.pop();
|
}
|
|
mStopDoneEvent = done; // restore done event which shoud be signaled in onStopDone().
|
mComponentState = ComponentState::STOPPING;
|
}
|
|
void C2VDAComponent::onResetDone() {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
if (mComponentState == ComponentState::ERROR) {
|
return;
|
}
|
if (mComponentState == ComponentState::FLUSHING) {
|
onFlushDone();
|
} else if (mComponentState == ComponentState::STOPPING) {
|
onStopDone();
|
} else {
|
reportError(C2_CORRUPTED);
|
}
|
}
|
|
void C2VDAComponent::onFlushDone() {
|
ALOGV("onFlushDone");
|
reportAbandonedWorks();
|
mPendingBuffersToWork.clear();
|
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);
|
|
// TODO(johnylin): At this moment, there may be C2Buffer still owned by client, do we need to
|
// do something for them?
|
reportAbandonedWorks();
|
mPendingOutputFormat.reset();
|
mPendingBuffersToWork.clear();
|
if (mVDAAdaptor.get()) {
|
mVDAAdaptor->destroy();
|
mVDAAdaptor.reset(nullptr);
|
}
|
|
stopDequeueThread();
|
mGraphicBlocks.clear();
|
|
mStopDoneEvent->Signal();
|
mStopDoneEvent = nullptr;
|
mComponentState = ComponentState::UNINITIALIZED;
|
}
|
|
c2_status_t C2VDAComponent::setListener_vb(const std::shared_ptr<C2Component::Listener>& listener,
|
c2_blocking_t mayBlock) {
|
UNUSED(mayBlock);
|
// TODO(johnylin): API says this method must be supported in all states, however I'm quite not
|
// sure what is the use case.
|
if (mState.load() != State::LOADED) {
|
return C2_BAD_STATE;
|
}
|
mListener = listener;
|
return C2_OK;
|
}
|
|
void C2VDAComponent::sendInputBufferToAccelerator(const C2ConstLinearBlock& input,
|
int32_t bitstreamId) {
|
ALOGV("sendInputBufferToAccelerator");
|
int dupFd = dup(input.handle()->data[0]);
|
if (dupFd < 0) {
|
ALOGE("Failed to dup(%d) input buffer (bitstreamId=%d), errno=%d", input.handle()->data[0],
|
bitstreamId, errno);
|
reportError(C2_CORRUPTED);
|
return;
|
}
|
ALOGV("Decode bitstream ID: %d, offset: %u size: %u", bitstreamId, input.offset(),
|
input.size());
|
mVDAAdaptor->decode(bitstreamId, dupFd, input.offset(), input.size());
|
}
|
|
std::deque<std::unique_ptr<C2Work>>::iterator C2VDAComponent::findPendingWorkByBitstreamId(
|
int32_t bitstreamId) {
|
return std::find_if(mPendingWorks.begin(), mPendingWorks.end(),
|
[bitstreamId](const std::unique_ptr<C2Work>& w) {
|
return frameIndexToBitstreamId(w->input.ordinal.frameIndex) ==
|
bitstreamId;
|
});
|
}
|
|
C2Work* C2VDAComponent::getPendingWorkByBitstreamId(int32_t bitstreamId) {
|
auto workIter = findPendingWorkByBitstreamId(bitstreamId);
|
if (workIter == mPendingWorks.end()) {
|
ALOGE("Can't find pending work by bitstream ID: %d", bitstreamId);
|
return nullptr;
|
}
|
return workIter->get();
|
}
|
|
C2VDAComponent::GraphicBlockInfo* C2VDAComponent::getGraphicBlockById(int32_t blockId) {
|
if (blockId < 0 || blockId >= static_cast<int32_t>(mGraphicBlocks.size())) {
|
ALOGE("getGraphicBlockById failed: id=%d", blockId);
|
return nullptr;
|
}
|
return &mGraphicBlocks[blockId];
|
}
|
|
C2VDAComponent::GraphicBlockInfo* C2VDAComponent::getGraphicBlockByPoolId(uint32_t poolId) {
|
auto blockIter = std::find_if(mGraphicBlocks.begin(), mGraphicBlocks.end(),
|
[poolId](const GraphicBlockInfo& gb) {
|
return gb.mPoolId == poolId;
|
});
|
|
if (blockIter == mGraphicBlocks.end()) {
|
ALOGE("getGraphicBlockByPoolId failed: poolId=%u", poolId);
|
return nullptr;
|
}
|
return &(*blockIter);
|
}
|
|
void C2VDAComponent::onOutputFormatChanged(std::unique_ptr<VideoFormat> format) {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onOutputFormatChanged");
|
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
|
|
ALOGV("New output format(pixel_format=0x%x, min_num_buffers=%u, coded_size=%s, crop_rect=%s)",
|
static_cast<uint32_t>(format->mPixelFormat), format->mMinNumBuffers,
|
format->mCodedSize.ToString().c_str(), format->mVisibleRect.ToString().c_str());
|
|
for (auto& info : mGraphicBlocks) {
|
if (info.mState == GraphicBlockInfo::State::OWNED_BY_ACCELERATOR)
|
info.mState = GraphicBlockInfo::State::OWNED_BY_COMPONENT;
|
}
|
|
CHECK(!mPendingOutputFormat);
|
mPendingOutputFormat = std::move(format);
|
tryChangeOutputFormat();
|
}
|
|
void C2VDAComponent::tryChangeOutputFormat() {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("tryChangeOutputFormat");
|
CHECK(mPendingOutputFormat);
|
|
// At this point, all output buffers should not be owned by accelerator. The component is not
|
// able to know when a client will release all owned output buffers by now. But it is ok to
|
// leave them to client since componenet won't own those buffers anymore.
|
// TODO(johnylin): we may also set a parameter for component to keep dequeueing buffers and
|
// change format only after the component owns most buffers. This may prevent
|
// too many buffers are still on client's hand while component starts to
|
// allocate more buffers. However, it leads latency on output format change.
|
for (const auto& info : mGraphicBlocks) {
|
CHECK(info.mState != GraphicBlockInfo::State::OWNED_BY_ACCELERATOR);
|
}
|
|
// Drop all pending existing frames and return all finished works before changing output format.
|
sendOutputBufferToWorkIfAny(true /* dropIfUnavailable */);
|
CHECK(mPendingBuffersToWork.empty());
|
|
CHECK_EQ(mPendingOutputFormat->mPixelFormat, HalPixelFormat::YCbCr_420_888);
|
|
mOutputFormat.mPixelFormat = mPendingOutputFormat->mPixelFormat;
|
mOutputFormat.mMinNumBuffers = mPendingOutputFormat->mMinNumBuffers;
|
mOutputFormat.mCodedSize = mPendingOutputFormat->mCodedSize;
|
|
setOutputFormatCrop(mPendingOutputFormat->mVisibleRect);
|
|
c2_status_t err = allocateBuffersFromBlockAllocator(
|
mPendingOutputFormat->mCodedSize,
|
static_cast<uint32_t>(mPendingOutputFormat->mPixelFormat));
|
if (err != C2_OK) {
|
reportError(err);
|
return;
|
}
|
|
for (auto& info : mGraphicBlocks) {
|
sendOutputBufferToAccelerator(&info, true /* ownByAccelerator */);
|
}
|
mPendingOutputFormat.reset();
|
}
|
|
c2_status_t C2VDAComponent::allocateBuffersFromBlockAllocator(const media::Size& size,
|
uint32_t pixelFormat) {
|
ALOGV("allocateBuffersFromBlockAllocator(%s, 0x%x)", size.ToString().c_str(), pixelFormat);
|
|
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);
|
auto err = GetCodec2BlockPool(poolId, shared_from_this(), &blockPool);
|
if (err != C2_OK) {
|
ALOGE("Graphic block allocator is invalid");
|
reportError(err);
|
return err;
|
}
|
|
mGraphicBlocks.clear();
|
|
bool useBufferQueue = blockPool->getAllocatorId() == C2PlatformAllocatorStore::BUFFERQUEUE;
|
size_t minBuffersForDisplay = 0;
|
if (useBufferQueue) {
|
ALOGV("Bufferqueue-backed block pool is used.");
|
// 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_OK) {
|
ALOGE("failed to request new buffer set to block pool: %d", err);
|
reportError(err);
|
return err;
|
}
|
err = bqPool->getMinBuffersForDisplay(&minBuffersForDisplay);
|
if (err != C2_OK) {
|
ALOGE("failed to query minimum undequeued buffer count from block pool: %d", err);
|
reportError(err);
|
return err;
|
}
|
} else {
|
ALOGE("static_pointer_cast C2VdaBqBlockPool failed...");
|
reportError(C2_CORRUPTED);
|
return C2_CORRUPTED;
|
}
|
} else {
|
ALOGV("Bufferpool-backed block pool is used.");
|
// Set requested buffer count to C2VdaPooledBlockPool.
|
std::shared_ptr<C2VdaPooledBlockPool> bpPool =
|
std::static_pointer_cast<C2VdaPooledBlockPool>(blockPool);
|
if (bpPool) {
|
err = bpPool->requestNewBufferSet(static_cast<int32_t>(bufferCount));
|
if (err != C2_OK) {
|
ALOGE("failed to request new buffer set to block pool: %d", err);
|
reportError(err);
|
return err;
|
}
|
minBuffersForDisplay = 0; // no undequeued buffer restriction for bufferpool.
|
} else {
|
ALOGE("static_pointer_cast C2VdaPooledBlockPool failed...");
|
reportError(C2_CORRUPTED);
|
return C2_CORRUPTED;
|
}
|
}
|
|
ALOGV("Minimum undequeued buffer count = %zu", minBuffersForDisplay);
|
mUndequeuedBlockIds.resize(minBuffersForDisplay, -1);
|
|
for (size_t i = 0; i < bufferCount; ++i) {
|
std::shared_ptr<C2GraphicBlock> block;
|
C2MemoryUsage usage = {
|
mSecureMode ? C2MemoryUsage::READ_PROTECTED : C2MemoryUsage::CPU_READ, 0};
|
|
int32_t retries_left = kAllocateBufferMaxRetries;
|
err = C2_NO_INIT;
|
while (err != C2_OK) {
|
err = blockPool->fetchGraphicBlock(size.width(), size.height(), pixelFormat, usage,
|
&block);
|
if (err == C2_TIMED_OUT && retries_left > 0) {
|
ALOGD("allocate buffer timeout, %d retry time(s) left...", retries_left);
|
retries_left--;
|
} else if (err != C2_OK) {
|
mGraphicBlocks.clear();
|
ALOGE("failed to allocate buffer: %d", err);
|
reportError(err);
|
return err;
|
}
|
}
|
|
uint32_t poolId;
|
if (useBufferQueue) {
|
err = C2VdaBqBlockPool::getPoolIdFromGraphicBlock(block, &poolId);
|
} else { // use bufferpool
|
err = C2VdaPooledBlockPool::getPoolIdFromGraphicBlock(block, &poolId);
|
}
|
if (err != C2_OK) {
|
mGraphicBlocks.clear();
|
ALOGE("failed to getPoolIdFromGraphicBlock: %d", err);
|
reportError(err);
|
return err;
|
}
|
if (mSecureMode) {
|
appendSecureOutputBuffer(std::move(block), poolId);
|
} else {
|
appendOutputBuffer(std::move(block), poolId);
|
}
|
}
|
mOutputFormat.mMinNumBuffers = bufferCount;
|
|
if (!startDequeueThread(size, pixelFormat, std::move(blockPool),
|
true /* resetBuffersInClient */)) {
|
reportError(C2_CORRUPTED);
|
return C2_CORRUPTED;
|
}
|
return C2_OK;
|
}
|
|
void C2VDAComponent::appendOutputBuffer(std::shared_ptr<C2GraphicBlock> block, uint32_t poolId) {
|
GraphicBlockInfo info;
|
info.mBlockId = static_cast<int32_t>(mGraphicBlocks.size());
|
info.mGraphicBlock = std::move(block);
|
info.mPoolId = poolId;
|
|
C2ConstGraphicBlock constBlock = info.mGraphicBlock->share(
|
C2Rect(info.mGraphicBlock->width(), info.mGraphicBlock->height()), C2Fence());
|
|
const C2GraphicView& view = constBlock.map().get();
|
const uint8_t* const* data = view.data();
|
CHECK_NE(data, nullptr);
|
const C2PlanarLayout& layout = view.layout();
|
|
ALOGV("allocate graphic buffer: %p, id: %d, size: %dx%d", info.mGraphicBlock->handle(),
|
info.mBlockId, info.mGraphicBlock->width(), info.mGraphicBlock->height());
|
|
// get offset from data pointers
|
uint32_t offsets[C2PlanarLayout::MAX_NUM_PLANES];
|
auto baseAddress = reinterpret_cast<intptr_t>(data[0]);
|
for (uint32_t i = 0; i < layout.numPlanes; ++i) {
|
auto planeAddress = reinterpret_cast<intptr_t>(data[i]);
|
offsets[i] = static_cast<uint32_t>(planeAddress - baseAddress);
|
}
|
|
bool crcb = false;
|
if (layout.numPlanes == 3 &&
|
offsets[C2PlanarLayout::PLANE_U] > offsets[C2PlanarLayout::PLANE_V]) {
|
// YCrCb format
|
std::swap(offsets[C2PlanarLayout::PLANE_U], offsets[C2PlanarLayout::PLANE_V]);
|
crcb = true;
|
}
|
|
bool semiplanar = false;
|
uint32_t passedNumPlanes = layout.numPlanes;
|
if (layout.planes[C2PlanarLayout::PLANE_U].colInc == 2) { // chroma_step
|
// Semi-planar format
|
passedNumPlanes--;
|
semiplanar = true;
|
}
|
|
for (uint32_t i = 0; i < passedNumPlanes; ++i) {
|
ALOGV("plane %u: stride: %d, offset: %u", i, layout.planes[i].rowInc, offsets[i]);
|
}
|
info.mPixelFormat = resolveBufferFormat(crcb, semiplanar);
|
ALOGV("HAL pixel format: 0x%x", static_cast<uint32_t>(info.mPixelFormat));
|
|
::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);
|
return;
|
}
|
std::vector<VideoFramePlane> passedPlanes;
|
for (uint32_t i = 0; i < passedNumPlanes; ++i) {
|
CHECK_GT(layout.planes[i].rowInc, 0);
|
passedPlanes.push_back({offsets[i], static_cast<uint32_t>(layout.planes[i].rowInc)});
|
}
|
info.mHandle = std::move(passedHandle);
|
info.mPlanes = std::move(passedPlanes);
|
|
mGraphicBlocks.push_back(std::move(info));
|
}
|
|
void C2VDAComponent::appendSecureOutputBuffer(std::shared_ptr<C2GraphicBlock> block,
|
uint32_t poolId) {
|
#ifdef V4L2_CODEC2_ARC
|
const C2Handle* const handle = block->handle();
|
const int handleFd = handle->data[0];
|
::base::ScopedFD passedHandle(dup(handleFd));
|
if (!passedHandle.is_valid()) {
|
ALOGE("Failed to dup(%d), errno=%d", handleFd, errno);
|
reportError(C2_CORRUPTED);
|
return;
|
}
|
|
android::HalPixelFormat pixelFormat = getPlatformPixelFormat();
|
if (pixelFormat == android::HalPixelFormat::UNKNOWN) {
|
ALOGE("Failed to get pixel format on platform.");
|
reportError(C2_CORRUPTED);
|
return;
|
}
|
CHECK(pixelFormat == android::HalPixelFormat::YV12 ||
|
pixelFormat == android::HalPixelFormat::NV12);
|
ALOGV("HAL pixel format: 0x%x", static_cast<uint32_t>(pixelFormat));
|
|
GraphicBlockInfo info;
|
info.mBlockId = static_cast<int32_t>(mGraphicBlocks.size());
|
info.mGraphicBlock = std::move(block);
|
info.mPoolId = poolId;
|
info.mHandle = std::move(passedHandle);
|
info.mPixelFormat = pixelFormat;
|
// In secure mode, since planes are not referred in Chrome side, empty plane is valid.
|
info.mPlanes.clear();
|
mGraphicBlocks.push_back(std::move(info));
|
#else
|
ALOGE("appendSecureOutputBuffer() is not supported...");
|
reportError(C2_OMITTED);
|
#endif // V4L2_CODEC2_ARC
|
}
|
|
void C2VDAComponent::sendOutputBufferToAccelerator(GraphicBlockInfo* info, bool ownByAccelerator) {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("sendOutputBufferToAccelerator index=%d ownByAccelerator=%d", info->mBlockId,
|
ownByAccelerator);
|
|
if (ownByAccelerator) {
|
CHECK_EQ(info->mState, GraphicBlockInfo::State::OWNED_BY_COMPONENT);
|
info->mState = GraphicBlockInfo::State::OWNED_BY_ACCELERATOR;
|
}
|
|
// is_valid() is true for the first time the buffer is passed to VDA. In that case, VDA needs to
|
// import the buffer first.
|
if (info->mHandle.is_valid()) {
|
mVDAAdaptor->importBufferForPicture(info->mBlockId, info->mPixelFormat,
|
info->mHandle.release(), info->mPlanes);
|
} else {
|
mVDAAdaptor->reusePictureBuffer(info->mBlockId);
|
}
|
}
|
|
bool C2VDAComponent::parseCodedColorAspects(const C2ConstLinearBlock& input) {
|
C2ReadView view = input.map().get();
|
const uint8_t* data = view.data();
|
const uint32_t size = view.capacity();
|
|
std::unique_ptr<media::H264Parser> h264Parser = std::make_unique<media::H264Parser>();
|
h264Parser->SetStream(data, static_cast<off_t>(size));
|
media::H264NALU nalu;
|
media::H264Parser::Result parRes = h264Parser->AdvanceToNextNALU(&nalu);
|
if (parRes != media::H264Parser::kEOStream && parRes != media::H264Parser::kOk) {
|
ALOGE("H264 AdvanceToNextNALU error: %d", static_cast<int>(parRes));
|
return false;
|
}
|
if (nalu.nal_unit_type != media::H264NALU::kSPS) {
|
ALOGV("NALU is not SPS");
|
return false;
|
}
|
|
int spsId;
|
parRes = h264Parser->ParseSPS(&spsId);
|
if (parRes != media::H264Parser::kEOStream && parRes != media::H264Parser::kOk) {
|
ALOGE("H264 ParseSPS error: %d", static_cast<int>(parRes));
|
return false;
|
}
|
|
// Parse ISO color aspects from H264 SPS bitstream.
|
const media::H264SPS* sps = h264Parser->GetSPS(spsId);
|
if (!sps->colour_description_present_flag) {
|
ALOGV("No Color Description in SPS");
|
return false;
|
}
|
int32_t primaries = sps->colour_primaries;
|
int32_t transfer = sps->transfer_characteristics;
|
int32_t coeffs = sps->matrix_coefficients;
|
bool fullRange = sps->video_full_range_flag;
|
|
// Convert ISO color aspects to ColorUtils::ColorAspects.
|
ColorAspects colorAspects;
|
ColorUtils::convertIsoColorAspectsToCodecAspects(primaries, transfer, coeffs, fullRange,
|
colorAspects);
|
ALOGV("Parsed ColorAspects from bitstream: (R:%d, P:%d, M:%d, T:%d)", colorAspects.mRange,
|
colorAspects.mPrimaries, colorAspects.mMatrixCoeffs, colorAspects.mTransfer);
|
|
// Map ColorUtils::ColorAspects to C2StreamColorAspectsInfo::input parameter.
|
C2StreamColorAspectsInfo::input codedAspects = {0u};
|
if (!C2Mapper::map(colorAspects.mPrimaries, &codedAspects.primaries)) {
|
codedAspects.primaries = C2Color::PRIMARIES_UNSPECIFIED;
|
}
|
if (!C2Mapper::map(colorAspects.mRange, &codedAspects.range)) {
|
codedAspects.range = C2Color::RANGE_UNSPECIFIED;
|
}
|
if (!C2Mapper::map(colorAspects.mMatrixCoeffs, &codedAspects.matrix)) {
|
codedAspects.matrix = C2Color::MATRIX_UNSPECIFIED;
|
}
|
if (!C2Mapper::map(colorAspects.mTransfer, &codedAspects.transfer)) {
|
codedAspects.transfer = C2Color::TRANSFER_UNSPECIFIED;
|
}
|
// Configure to interface.
|
std::vector<std::unique_ptr<C2SettingResult>> failures;
|
c2_status_t status = mIntfImpl->config({&codedAspects}, C2_MAY_BLOCK, &failures);
|
if (status != C2_OK) {
|
ALOGE("Failed to config color aspects to interface, error: %d", status);
|
return false;
|
}
|
return true;
|
}
|
|
c2_status_t C2VDAComponent::updateColorAspects() {
|
ALOGV("updateColorAspects");
|
std::unique_ptr<C2StreamColorAspectsInfo::output> colorAspects =
|
std::make_unique<C2StreamColorAspectsInfo::output>(
|
0u, C2Color::RANGE_UNSPECIFIED, C2Color::PRIMARIES_UNSPECIFIED,
|
C2Color::TRANSFER_UNSPECIFIED, C2Color::MATRIX_UNSPECIFIED);
|
c2_status_t status = mIntfImpl->query({colorAspects.get()}, {}, C2_DONT_BLOCK, nullptr);
|
if (status != C2_OK) {
|
ALOGE("Failed to query color aspects, error: %d", status);
|
return status;
|
}
|
mCurrentColorAspects = std::move(colorAspects);
|
return C2_OK;
|
}
|
|
void C2VDAComponent::onVisibleRectChanged(const media::Rect& cropRect) {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onVisibleRectChanged");
|
EXPECT_RUNNING_OR_RETURN_ON_ERROR();
|
|
// We should make sure there is no pending output format change. That is, the input cropRect is
|
// corresponding to current output format.
|
CHECK(mPendingOutputFormat == nullptr);
|
setOutputFormatCrop(cropRect);
|
}
|
|
void C2VDAComponent::setOutputFormatCrop(const media::Rect& cropRect) {
|
ALOGV("setOutputFormatCrop(%dx%d)", cropRect.width(), cropRect.height());
|
// This visible rect should be set as crop window for each C2ConstGraphicBlock passed to
|
// framework.
|
mOutputFormat.mVisibleRect = cropRect;
|
}
|
|
void C2VDAComponent::onSurfaceChanged() {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
ALOGV("onSurfaceChanged");
|
|
if (mComponentState == ComponentState::UNINITIALIZED) {
|
return; // Component is already stopped, no need to update graphic blocks.
|
}
|
|
stopDequeueThread();
|
|
// Get block pool ID configured from the client.
|
std::shared_ptr<C2BlockPool> blockPool;
|
auto blockPoolId = mIntfImpl->getBlockPoolId();
|
ALOGI("Retrieving C2BlockPool ID = %" PRIu64 " for updating output buffers", blockPoolId);
|
auto err = GetCodec2BlockPool(blockPoolId, shared_from_this(), &blockPool);
|
if (err != C2_OK) {
|
ALOGE("Graphic block allocator is invalid");
|
reportError(err);
|
return;
|
}
|
if (blockPool->getAllocatorId() != C2PlatformAllocatorStore::BUFFERQUEUE) {
|
ALOGE("Only Bufferqueue-backed block pool would need to change surface.");
|
reportError(C2_CORRUPTED);
|
return;
|
}
|
|
std::shared_ptr<C2VdaBqBlockPool> bqPool =
|
std::static_pointer_cast<C2VdaBqBlockPool>(blockPool);
|
if (!bqPool) {
|
ALOGE("static_pointer_cast C2VdaBqBlockPool failed...");
|
reportError(C2_CORRUPTED);
|
return;
|
}
|
|
size_t minBuffersForDisplay = 0;
|
err = bqPool->getMinBuffersForDisplay(&minBuffersForDisplay);
|
if (err != C2_OK) {
|
ALOGE("failed to query minimum undequeued buffer count from block pool: %d", err);
|
reportError(err);
|
return;
|
}
|
ALOGV("Minimum undequeued buffer count = %zu", minBuffersForDisplay);
|
mUndequeuedBlockIds.resize(minBuffersForDisplay, -1);
|
|
for (auto& info : mGraphicBlocks) {
|
bool willCancel = (info.mGraphicBlock == nullptr);
|
uint32_t oldSlot = info.mPoolId;
|
ALOGV("Updating graphic block #%d: slot = %u, willCancel = %d", info.mBlockId, oldSlot,
|
willCancel);
|
uint32_t newSlot;
|
std::shared_ptr<C2GraphicBlock> block;
|
err = bqPool->updateGraphicBlock(willCancel, oldSlot, &newSlot, &block);
|
if (err == C2_CANCELED) {
|
// There may be a chance that a task in task runner before onSurfaceChange triggers
|
// output format change. If so, block pool will return C2_CANCELED and no need to
|
// updateGraphicBlock anymore.
|
return;
|
}
|
if (err != C2_OK) {
|
ALOGE("failed to update graphic block from block pool: %d", err);
|
reportError(err);
|
return;
|
}
|
|
// Update slot index.
|
info.mPoolId = newSlot;
|
// Update C2GraphicBlock if |willCancel| is false. Note that although the old C2GraphicBlock
|
// will be released, the block pool data destructor won't do detachBuffer to new surface
|
// because the producer ID is not matched.
|
if (!willCancel) {
|
info.mGraphicBlock = std::move(block);
|
}
|
}
|
|
if (!startDequeueThread(mOutputFormat.mCodedSize,
|
static_cast<uint32_t>(mOutputFormat.mPixelFormat), std::move(blockPool),
|
false /* resetBuffersInClient */)) {
|
reportError(C2_CORRUPTED);
|
}
|
}
|
|
c2_status_t C2VDAComponent::queue_nb(std::list<std::unique_ptr<C2Work>>* const items) {
|
if (mState.load() != State::RUNNING) {
|
return C2_BAD_STATE;
|
}
|
while (!items->empty()) {
|
mTaskRunner->PostTask(FROM_HERE,
|
::base::Bind(&C2VDAComponent::onQueueWork, ::base::Unretained(this),
|
::base::Passed(&items->front())));
|
items->pop_front();
|
}
|
return C2_OK;
|
}
|
|
c2_status_t C2VDAComponent::announce_nb(const std::vector<C2WorkOutline>& items) {
|
UNUSED(items);
|
return C2_OMITTED; // Tunneling is not supported by now
|
}
|
|
c2_status_t C2VDAComponent::flush_sm(flush_mode_t mode,
|
std::list<std::unique_ptr<C2Work>>* const flushedWork) {
|
if (mode != FLUSH_COMPONENT) {
|
return C2_OMITTED; // Tunneling is not supported by now
|
}
|
if (mState.load() != State::RUNNING) {
|
return C2_BAD_STATE;
|
}
|
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;
|
}
|
|
c2_status_t C2VDAComponent::drain_nb(drain_mode_t mode) {
|
if (mode != DRAIN_COMPONENT_WITH_EOS && mode != DRAIN_COMPONENT_NO_EOS) {
|
return C2_OMITTED; // Tunneling is not supported by now
|
}
|
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)));
|
return C2_OK;
|
}
|
|
c2_status_t C2VDAComponent::start() {
|
// Use mStartStopLock to block other asynchronously start/stop calls.
|
std::lock_guard<std::mutex> lock(mStartStopLock);
|
|
if (mState.load() != State::LOADED) {
|
return C2_BAD_STATE; // start() is only supported when component is in LOADED state.
|
}
|
|
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));
|
done.Wait();
|
c2_status_t c2Status = adaptorResultToC2Status(mVDAInitResult);
|
if (c2Status != C2_OK) {
|
ALOGE("Failed to start component due to VDA error...");
|
return c2Status;
|
}
|
mState.store(State::RUNNING);
|
return C2_OK;
|
}
|
|
c2_status_t C2VDAComponent::stop() {
|
// Use mStartStopLock to block other asynchronously start/stop calls.
|
std::lock_guard<std::mutex> lock(mStartStopLock);
|
|
auto state = mState.load();
|
if (!(state == State::RUNNING || state == State::ERROR)) {
|
return C2_OK; // Component is already in stopped state.
|
}
|
|
::base::WaitableEvent done(::base::WaitableEvent::ResetPolicy::AUTOMATIC,
|
::base::WaitableEvent::InitialState::NOT_SIGNALED);
|
mTaskRunner->PostTask(FROM_HERE,
|
::base::Bind(&C2VDAComponent::onStop, ::base::Unretained(this), &done));
|
done.Wait();
|
mState.store(State::LOADED);
|
return C2_OK;
|
}
|
|
c2_status_t C2VDAComponent::reset() {
|
return stop();
|
// TODO(johnylin): reset is different than stop that it could be called in any state.
|
// TODO(johnylin): when reset is called, set ComponentInterface to default values.
|
}
|
|
c2_status_t C2VDAComponent::release() {
|
return reset();
|
}
|
|
std::shared_ptr<C2ComponentInterface> C2VDAComponent::intf() {
|
return mIntf;
|
}
|
|
void C2VDAComponent::providePictureBuffers(uint32_t minNumBuffers, const media::Size& codedSize) {
|
// Always use fexible pixel 420 format YCbCr_420_888 in Android.
|
// Uses coded size for crop rect while it is not available.
|
auto format = std::make_unique<VideoFormat>(HalPixelFormat::YCbCr_420_888, minNumBuffers,
|
codedSize, media::Rect(codedSize));
|
|
// Set mRequestedVisibleRect to default.
|
mRequestedVisibleRect = media::Rect();
|
|
mTaskRunner->PostTask(FROM_HERE, ::base::Bind(&C2VDAComponent::onOutputFormatChanged,
|
::base::Unretained(this),
|
::base::Passed(&format)));
|
}
|
|
void C2VDAComponent::dismissPictureBuffer(int32_t pictureBufferId) {
|
UNUSED(pictureBufferId);
|
// no ops
|
}
|
|
void C2VDAComponent::pictureReady(int32_t pictureBufferId, int32_t bitstreamId,
|
const media::Rect& cropRect) {
|
UNUSED(pictureBufferId);
|
UNUSED(bitstreamId);
|
|
if (mRequestedVisibleRect != cropRect) {
|
mRequestedVisibleRect = 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));
|
}
|
|
void C2VDAComponent::notifyEndOfBitstreamBuffer(int32_t 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)));
|
}
|
|
void C2VDAComponent::notifyResetDone() {
|
mTaskRunner->PostTask(FROM_HERE,
|
::base::Bind(&C2VDAComponent::onResetDone, ::base::Unretained(this)));
|
}
|
|
void C2VDAComponent::notifyError(VideoDecodeAcceleratorAdaptor::Result error) {
|
ALOGE("Got notifyError from VDA...");
|
c2_status_t err = adaptorResultToC2Status(error);
|
if (err == C2_OK) {
|
ALOGW("Shouldn't get SUCCESS err code in NotifyError(). Skip it...");
|
return;
|
}
|
reportError(err);
|
}
|
|
void C2VDAComponent::reportWorkIfFinished(int32_t bitstreamId) {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
|
auto workIter = findPendingWorkByBitstreamId(bitstreamId);
|
if (workIter == mPendingWorks.end()) {
|
reportError(C2_CORRUPTED);
|
return;
|
}
|
|
// EOS work will not be reported here. reportEOSWork() does it.
|
auto work = workIter->get();
|
if (isWorkDone(work)) {
|
if (work->worklets.front()->output.flags & C2FrameData::FLAG_DROP_FRAME) {
|
// TODO: actually framework does not handle FLAG_DROP_FRAME, use C2_NOT_FOUND result to
|
// let framework treat this as flushed work.
|
work->result = C2_NOT_FOUND;
|
} else {
|
work->result = C2_OK;
|
}
|
work->workletsProcessed = static_cast<uint32_t>(work->worklets.size());
|
|
ALOGV("Reported finished work index=%llu", work->input.ordinal.frameIndex.peekull());
|
std::list<std::unique_ptr<C2Work>> finishedWorks;
|
finishedWorks.emplace_back(std::move(*workIter));
|
mListener->onWorkDone_nb(shared_from_this(), std::move(finishedWorks));
|
mPendingWorks.erase(workIter);
|
}
|
}
|
|
bool C2VDAComponent::isWorkDone(const C2Work* work) const {
|
if (work->input.flags & C2FrameData::FLAG_END_OF_STREAM) {
|
// This is EOS work and should be processed by reportEOSWork().
|
return false;
|
}
|
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 (!(work->input.flags & C2FrameData::FLAG_CODEC_CONFIG) &&
|
!(work->worklets.front()->output.flags & C2FrameData::FLAG_DROP_FRAME) &&
|
work->worklets.front()->output.buffers.empty()) {
|
// Unless the input is CSD or the output is dropped, this work is not done because the
|
// output buffer is not returned from VDA yet.
|
return false;
|
}
|
return true; // This work is done.
|
}
|
|
void C2VDAComponent::reportEOSWork() {
|
ALOGV("reportEOSWork");
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
// In this moment all works prior to EOS work should be done and returned to listener.
|
if (mPendingWorks.size() != 1u) { // only EOS work left
|
ALOGE("It shouldn't have remaining works in mPendingWorks except EOS work.");
|
reportError(C2_CORRUPTED);
|
return;
|
}
|
|
mPendingOutputEOS = false;
|
|
std::unique_ptr<C2Work> eosWork(std::move(mPendingWorks.front()));
|
mPendingWorks.pop_front();
|
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;
|
|
std::list<std::unique_ptr<C2Work>> finishedWorks;
|
finishedWorks.emplace_back(std::move(eosWork));
|
mListener->onWorkDone_nb(shared_from_this(), std::move(finishedWorks));
|
}
|
|
void C2VDAComponent::reportAbandonedWorks() {
|
DCHECK(mTaskRunner->BelongsToCurrentThread());
|
std::list<std::unique_ptr<C2Work>> abandonedWorks;
|
|
while (!mPendingWorks.empty()) {
|
std::unique_ptr<C2Work> work(std::move(mPendingWorks.front()));
|
mPendingWorks.pop_front();
|
|
// 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));
|
}
|
|
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));
|
}
|
}
|
|
void C2VDAComponent::reportError(c2_status_t error) {
|
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,
|
bool resetBuffersInClient) {
|
CHECK(!mDequeueThread.IsRunning());
|
if (!mDequeueThread.Start()) {
|
ALOGE("failed to start dequeue thread!!");
|
return false;
|
}
|
mDequeueLoopStop.store(false);
|
if (resetBuffersInClient) {
|
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 = {
|
mSecureMode ? C2MemoryUsage::READ_PROTECTED : C2MemoryUsage::CPU_READ, 0};
|
auto err = blockPool->fetchGraphicBlock(size.width(), size.height(), pixelFormat, usage,
|
&block);
|
if (err == C2_TIMED_OUT) {
|
// Mutexes often do not care for FIFO. Practically the thread who is locking the mutex
|
// usually will be granted to lock again right thereafter. To make this loop not too
|
// bossy, the simpliest way is to add a short delay to the next time acquiring the
|
// lock. TODO (b/118354314): replace this if there is better solution.
|
::usleep(1);
|
continue; // wait for retry
|
}
|
if (err == C2_BAD_STATE) {
|
ALOGV("Got informed from block pool surface is changed.");
|
mTaskRunner->PostTask(FROM_HERE, ::base::Bind(&C2VDAComponent::onSurfaceChanged,
|
::base::Unretained(this)));
|
break; // terminate the loop, will be resumed after onSurfaceChanged().
|
}
|
if (err == C2_OK) {
|
uint32_t poolId;
|
if (blockPool->getAllocatorId() == C2PlatformAllocatorStore::BUFFERQUEUE) {
|
err = C2VdaBqBlockPool::getPoolIdFromGraphicBlock(block, &poolId);
|
} else { // bufferpool
|
err = C2VdaPooledBlockPool::getPoolIdFromGraphicBlock(block, &poolId);
|
}
|
|
if (err != C2_OK) {
|
ALOGE("dequeueThreadLoop got error on getPoolIdFromGraphicBlock: %d", err);
|
break;
|
}
|
mTaskRunner->PostTask(FROM_HERE,
|
::base::Bind(&C2VDAComponent::onOutputBufferReturned,
|
::base::Unretained(this), std::move(block), poolId));
|
mBuffersInClient--;
|
} else {
|
ALOGE("dequeueThreadLoop got error: %d", err);
|
break;
|
}
|
}
|
ALOGV("dequeueThreadLoop terminates");
|
}
|
|
class C2VDAComponentFactory : public C2ComponentFactory {
|
public:
|
C2VDAComponentFactory(C2String decoderName)
|
: mDecoderName(decoderName),
|
mReflector(std::static_pointer_cast<C2ReflectorHelper>(
|
GetCodec2VDAComponentStore()->getParamReflector())){};
|
|
c2_status_t createComponent(c2_node_id_t id, std::shared_ptr<C2Component>* const component,
|
ComponentDeleter deleter) override {
|
UNUSED(deleter);
|
*component = std::shared_ptr<C2Component>(new C2VDAComponent(mDecoderName, id, mReflector));
|
return C2_OK;
|
}
|
c2_status_t createInterface(c2_node_id_t id,
|
std::shared_ptr<C2ComponentInterface>* const interface,
|
InterfaceDeleter deleter) override {
|
UNUSED(deleter);
|
*interface =
|
std::shared_ptr<C2ComponentInterface>(new SimpleInterface<C2VDAComponent::IntfImpl>(
|
mDecoderName.c_str(), id,
|
std::make_shared<C2VDAComponent::IntfImpl>(mDecoderName, mReflector)));
|
return C2_OK;
|
}
|
~C2VDAComponentFactory() override = default;
|
|
private:
|
const C2String mDecoderName;
|
std::shared_ptr<C2ReflectorHelper> mReflector;
|
};
|
} // namespace android
|
|
extern "C" ::C2ComponentFactory* CreateC2VDAH264Factory(bool secureMode) {
|
ALOGV("in %s (secureMode=%d)", __func__, secureMode);
|
return secureMode ? new ::android::C2VDAComponentFactory(android::kH264SecureDecoderName)
|
: new ::android::C2VDAComponentFactory(android::kH264DecoderName);
|
}
|
|
extern "C" void DestroyC2VDAH264Factory(::C2ComponentFactory* factory) {
|
ALOGV("in %s", __func__);
|
delete factory;
|
}
|
|
extern "C" ::C2ComponentFactory* CreateC2VDAVP8Factory(bool secureMode) {
|
ALOGV("in %s (secureMode=%d)", __func__, secureMode);
|
return secureMode ? new ::android::C2VDAComponentFactory(android::kVP8SecureDecoderName)
|
: new ::android::C2VDAComponentFactory(android::kVP8DecoderName);
|
}
|
|
extern "C" void DestroyC2VDAVP8Factory(::C2ComponentFactory* factory) {
|
ALOGV("in %s", __func__);
|
delete factory;
|
}
|
|
extern "C" ::C2ComponentFactory* CreateC2VDAVP9Factory(bool secureMode) {
|
ALOGV("in %s (secureMode=%d)", __func__, secureMode);
|
return secureMode ? new ::android::C2VDAComponentFactory(android::kVP9SecureDecoderName)
|
: new ::android::C2VDAComponentFactory(android::kVP9DecoderName);
|
}
|
|
extern "C" void DestroyC2VDAVP9Factory(::C2ComponentFactory* factory) {
|
ALOGV("in %s", __func__);
|
delete factory;
|
}
|
