/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "C2SoftVpxDec"
#include <log/log.h>
#include <algorithm>
#include <media/stagefright/foundation/AUtils.h>
#include <media/stagefright/foundation/MediaDefs.h>
#include <C2Debug.h>
#include <C2PlatformSupport.h>
#include <SimpleC2Interface.h>
#include "C2SoftVpxDec.h"
namespace android {
#ifdef VP9
constexpr char COMPONENT_NAME[] = "c2.android.vp9.decoder";
#else
constexpr char COMPONENT_NAME[] = "c2.android.vp8.decoder";
#endif
class C2SoftVpxDec::IntfImpl : public SimpleInterface<void>::BaseParams {
public:
explicit IntfImpl(const std::shared_ptr<C2ReflectorHelper> &helper)
: SimpleInterface<void>::BaseParams(
helper,
COMPONENT_NAME,
C2Component::KIND_DECODER,
C2Component::DOMAIN_VIDEO,
#ifdef VP9
MEDIA_MIMETYPE_VIDEO_VP9
#else
MEDIA_MIMETYPE_VIDEO_VP8
#endif
) {
noPrivateBuffers(); // TODO: account for our buffers here
noInputReferences();
noOutputReferences();
noInputLatency();
noTimeStretch();
// TODO: output latency and reordering
addParameter(
DefineParam(mAttrib, C2_PARAMKEY_COMPONENT_ATTRIBUTES)
.withConstValue(new C2ComponentAttributesSetting(C2Component::ATTRIB_IS_TEMPORAL))
.build());
addParameter(
DefineParam(mSize, C2_PARAMKEY_PICTURE_SIZE)
.withDefault(new C2StreamPictureSizeInfo::output(0u, 320, 240))
.withFields({
C2F(mSize, width).inRange(2, 2048, 2),
C2F(mSize, height).inRange(2, 2048, 2),
})
.withSetter(SizeSetter)
.build());
#ifdef VP9
// TODO: Add C2Config::PROFILE_VP9_2HDR ??
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,
C2Config::PROFILE_VP9_2}),
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, mSize)
.build());
mHdr10PlusInfoInput = C2StreamHdr10PlusInfo::input::AllocShared(0);
addParameter(
DefineParam(mHdr10PlusInfoInput, C2_PARAMKEY_INPUT_HDR10_PLUS_INFO)
.withDefault(mHdr10PlusInfoInput)
.withFields({
C2F(mHdr10PlusInfoInput, m.value).any(),
})
.withSetter(Hdr10PlusInfoInputSetter)
.build());
mHdr10PlusInfoOutput = C2StreamHdr10PlusInfo::output::AllocShared(0);
addParameter(
DefineParam(mHdr10PlusInfoOutput, C2_PARAMKEY_OUTPUT_HDR10_PLUS_INFO)
.withDefault(mHdr10PlusInfoOutput)
.withFields({
C2F(mHdr10PlusInfoOutput, m.value).any(),
})
.withSetter(Hdr10PlusInfoOutputSetter)
.build());
#if 0
// sample BT.2020 static info
mHdrStaticInfo = std::make_shared<C2StreamHdrStaticInfo::output>();
mHdrStaticInfo->mastering = {
.red = { .x = 0.708, .y = 0.292 },
.green = { .x = 0.170, .y = 0.797 },
.blue = { .x = 0.131, .y = 0.046 },
.white = { .x = 0.3127, .y = 0.3290 },
.maxLuminance = 1000,
.minLuminance = 0.1,
};
mHdrStaticInfo->maxCll = 1000;
mHdrStaticInfo->maxFall = 120;
mHdrStaticInfo->maxLuminance = 0; // disable static info
helper->addStructDescriptors<C2MasteringDisplayColorVolumeStruct, C2ColorXyStruct>();
addParameter(
DefineParam(mHdrStaticInfo, C2_PARAMKEY_HDR_STATIC_INFO)
.withDefault(mHdrStaticInfo)
.withFields({
C2F(mHdrStaticInfo, mastering.red.x).inRange(0, 1),
// TODO
})
.withSetter(HdrStaticInfoSetter)
.build());
#endif
#else
addParameter(
DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL)
.withConstValue(new C2StreamProfileLevelInfo::input(0u,
C2Config::PROFILE_UNUSED, C2Config::LEVEL_UNUSED))
.build());
#endif
addParameter(
DefineParam(mMaxSize, C2_PARAMKEY_MAX_PICTURE_SIZE)
.withDefault(new C2StreamMaxPictureSizeTuning::output(0u, 320, 240))
.withFields({
C2F(mSize, width).inRange(2, 2048, 2),
C2F(mSize, height).inRange(2, 2048, 2),
})
.withSetter(MaxPictureSizeSetter, mSize)
.build());
addParameter(
DefineParam(mMaxInputSize, C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE)
.withDefault(new C2StreamMaxBufferSizeInfo::input(0u, 320 * 240 * 3 / 4))
.withFields({
C2F(mMaxInputSize, value).any(),
})
.calculatedAs(MaxInputSizeSetter, mMaxSize)
.build());
C2ChromaOffsetStruct locations[1] = { C2ChromaOffsetStruct::ITU_YUV_420_0() };
std::shared_ptr<C2StreamColorInfo::output> defaultColorInfo =
C2StreamColorInfo::output::AllocShared(
1u, 0u, 8u /* bitDepth */, C2Color::YUV_420);
memcpy(defaultColorInfo->m.locations, locations, sizeof(locations));
defaultColorInfo =
C2StreamColorInfo::output::AllocShared(
{ C2ChromaOffsetStruct::ITU_YUV_420_0() },
0u, 8u /* bitDepth */, C2Color::YUV_420);
helper->addStructDescriptors<C2ChromaOffsetStruct>();
addParameter(
DefineParam(mColorInfo, C2_PARAMKEY_CODED_COLOR_INFO)
.withConstValue(defaultColorInfo)
.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());
// TODO: support more formats?
addParameter(
DefineParam(mPixelFormat, C2_PARAMKEY_PIXEL_FORMAT)
.withConstValue(new C2StreamPixelFormatInfo::output(
0u, HAL_PIXEL_FORMAT_YCBCR_420_888))
.build());
}
static C2R SizeSetter(bool mayBlock, const C2P<C2StreamPictureSizeInfo::output> &oldMe,
C2P<C2StreamPictureSizeInfo::output> &me) {
(void)mayBlock;
C2R res = C2R::Ok();
if (!me.F(me.v.width).supportsAtAll(me.v.width)) {
res = res.plus(C2SettingResultBuilder::BadValue(me.F(me.v.width)));
me.set().width = oldMe.v.width;
}
if (!me.F(me.v.height).supportsAtAll(me.v.height)) {
res = res.plus(C2SettingResultBuilder::BadValue(me.F(me.v.height)));
me.set().height = oldMe.v.height;
}
return res;
}
static C2R MaxPictureSizeSetter(bool mayBlock, C2P<C2StreamMaxPictureSizeTuning::output> &me,
const C2P<C2StreamPictureSizeInfo::output> &size) {
(void)mayBlock;
// TODO: get max width/height from the size's field helpers vs. hardcoding
me.set().width = c2_min(c2_max(me.v.width, size.v.width), 2048u);
me.set().height = c2_min(c2_max(me.v.height, size.v.height), 2048u);
return C2R::Ok();
}
static C2R MaxInputSizeSetter(bool mayBlock, C2P<C2StreamMaxBufferSizeInfo::input> &me,
const C2P<C2StreamMaxPictureSizeTuning::output> &maxSize) {
(void)mayBlock;
// assume compression ratio of 2
me.set().value = (((maxSize.v.width + 63) / 64) * ((maxSize.v.height + 63) / 64) * 3072);
return C2R::Ok();
}
static C2R DefaultColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsTuning::output> &me) {
(void)mayBlock;
if (me.v.range > C2Color::RANGE_OTHER) {
me.set().range = C2Color::RANGE_OTHER;
}
if (me.v.primaries > C2Color::PRIMARIES_OTHER) {
me.set().primaries = C2Color::PRIMARIES_OTHER;
}
if (me.v.transfer > C2Color::TRANSFER_OTHER) {
me.set().transfer = C2Color::TRANSFER_OTHER;
}
if (me.v.matrix > C2Color::MATRIX_OTHER) {
me.set().matrix = C2Color::MATRIX_OTHER;
}
return C2R::Ok();
}
static C2R ProfileLevelSetter(bool mayBlock, C2P<C2StreamProfileLevelInfo::input> &me,
const C2P<C2StreamPictureSizeInfo::output> &size) {
(void)mayBlock;
(void)size;
(void)me; // TODO: validate
return C2R::Ok();
}
std::shared_ptr<C2StreamColorAspectsTuning::output> getDefaultColorAspects_l() {
return mDefaultColorAspects;
}
static C2R Hdr10PlusInfoInputSetter(bool mayBlock, C2P<C2StreamHdr10PlusInfo::input> &me) {
(void)mayBlock;
(void)me; // TODO: validate
return C2R::Ok();
}
static C2R Hdr10PlusInfoOutputSetter(bool mayBlock, C2P<C2StreamHdr10PlusInfo::output> &me) {
(void)mayBlock;
(void)me; // TODO: validate
return C2R::Ok();
}
private:
std::shared_ptr<C2StreamProfileLevelInfo::input> mProfileLevel;
std::shared_ptr<C2StreamPictureSizeInfo::output> mSize;
std::shared_ptr<C2StreamMaxPictureSizeTuning::output> mMaxSize;
std::shared_ptr<C2StreamMaxBufferSizeInfo::input> mMaxInputSize;
std::shared_ptr<C2StreamColorInfo::output> mColorInfo;
std::shared_ptr<C2StreamPixelFormatInfo::output> mPixelFormat;
std::shared_ptr<C2StreamColorAspectsTuning::output> mDefaultColorAspects;
#ifdef VP9
#if 0
std::shared_ptr<C2StreamHdrStaticInfo::output> mHdrStaticInfo;
#endif
std::shared_ptr<C2StreamHdr10PlusInfo::input> mHdr10PlusInfoInput;
std::shared_ptr<C2StreamHdr10PlusInfo::output> mHdr10PlusInfoOutput;
#endif
};
C2SoftVpxDec::ConverterThread::ConverterThread(
const std::shared_ptr<Mutexed<ConversionQueue>> &queue)
: Thread(false), mQueue(queue) {}
bool C2SoftVpxDec::ConverterThread::threadLoop() {
Mutexed<ConversionQueue>::Locked queue(*mQueue);
if (queue->entries.empty()) {
queue.waitForCondition(queue->cond);
if (queue->entries.empty()) {
return true;
}
}
std::function<void()> convert = queue->entries.front();
queue->entries.pop_front();
if (!queue->entries.empty()) {
queue->cond.signal();
}
queue.unlock();
convert();
queue.lock();
if (--queue->numPending == 0u) {
queue->cond.broadcast();
}
return true;
}
C2SoftVpxDec::C2SoftVpxDec(
const char *name,
c2_node_id_t id,
const std::shared_ptr<IntfImpl> &intfImpl)
: SimpleC2Component(std::make_shared<SimpleInterface<IntfImpl>>(name, id, intfImpl)),
mIntf(intfImpl),
mCodecCtx(nullptr),
mCoreCount(1),
mQueue(new Mutexed<ConversionQueue>) {
}
C2SoftVpxDec::~C2SoftVpxDec() {
onRelease();
}
c2_status_t C2SoftVpxDec::onInit() {
status_t err = initDecoder();
return err == OK ? C2_OK : C2_CORRUPTED;
}
c2_status_t C2SoftVpxDec::onStop() {
mSignalledError = false;
mSignalledOutputEos = false;
return C2_OK;
}
void C2SoftVpxDec::onReset() {
(void)onStop();
c2_status_t err = onFlush_sm();
if (err != C2_OK)
{
ALOGW("Failed to flush decoder. Try to hard reset decoder");
destroyDecoder();
(void)initDecoder();
}
}
void C2SoftVpxDec::onRelease() {
destroyDecoder();
}
c2_status_t C2SoftVpxDec::onFlush_sm() {
if (mFrameParallelMode) {
// Flush decoder by passing nullptr data ptr and 0 size.
// Ideally, this should never fail.
if (vpx_codec_decode(mCodecCtx, nullptr, 0, nullptr, 0)) {
ALOGE("Failed to flush on2 decoder.");
return C2_CORRUPTED;
}
}
// Drop all the decoded frames in decoder.
vpx_codec_iter_t iter = nullptr;
while (vpx_codec_get_frame(mCodecCtx, &iter)) {
}
mSignalledError = false;
mSignalledOutputEos = false;
return C2_OK;
}
static int GetCPUCoreCount() {
int cpuCoreCount = 1;
#if defined(_SC_NPROCESSORS_ONLN)
cpuCoreCount = sysconf(_SC_NPROCESSORS_ONLN);
#else
// _SC_NPROC_ONLN must be defined...
cpuCoreCount = sysconf(_SC_NPROC_ONLN);
#endif
CHECK(cpuCoreCount >= 1);
ALOGV("Number of CPU cores: %d", cpuCoreCount);
return cpuCoreCount;
}
status_t C2SoftVpxDec::initDecoder() {
#ifdef VP9
mMode = MODE_VP9;
#else
mMode = MODE_VP8;
#endif
mWidth = 320;
mHeight = 240;
mFrameParallelMode = false;
mSignalledOutputEos = false;
mSignalledError = false;
if (!mCodecCtx) {
mCodecCtx = new vpx_codec_ctx_t;
}
if (!mCodecCtx) {
ALOGE("mCodecCtx is null");
return NO_MEMORY;
}
vpx_codec_dec_cfg_t cfg;
memset(&cfg, 0, sizeof(vpx_codec_dec_cfg_t));
cfg.threads = mCoreCount = GetCPUCoreCount();
vpx_codec_flags_t flags;
memset(&flags, 0, sizeof(vpx_codec_flags_t));
if (mFrameParallelMode) flags |= VPX_CODEC_USE_FRAME_THREADING;
vpx_codec_err_t vpx_err;
if ((vpx_err = vpx_codec_dec_init(
mCodecCtx, mMode == MODE_VP8 ? &vpx_codec_vp8_dx_algo : &vpx_codec_vp9_dx_algo,
&cfg, flags))) {
ALOGE("on2 decoder failed to initialize. (%d)", vpx_err);
return UNKNOWN_ERROR;
}
if (mMode == MODE_VP9) {
using namespace std::string_literals;
for (int i = 0; i < mCoreCount; ++i) {
sp<ConverterThread> thread(new ConverterThread(mQueue));
mConverterThreads.push_back(thread);
if (thread->run(("vp9conv #"s + std::to_string(i)).c_str(),
ANDROID_PRIORITY_AUDIO) != OK) {
return UNKNOWN_ERROR;
}
}
}
return OK;
}
status_t C2SoftVpxDec::destroyDecoder() {
if (mCodecCtx) {
vpx_codec_destroy(mCodecCtx);
delete mCodecCtx;
mCodecCtx = nullptr;
}
bool running = true;
for (const sp<ConverterThread> &thread : mConverterThreads) {
thread->requestExit();
}
while (running) {
mQueue->lock()->cond.broadcast();
running = false;
for (const sp<ConverterThread> &thread : mConverterThreads) {
if (thread->isRunning()) {
running = true;
break;
}
}
}
mConverterThreads.clear();
return OK;
}
void fillEmptyWork(const std::unique_ptr<C2Work> &work) {
uint32_t flags = 0;
if (work->input.flags & C2FrameData::FLAG_END_OF_STREAM) {
flags |= C2FrameData::FLAG_END_OF_STREAM;
ALOGV("signalling eos");
}
work->worklets.front()->output.flags = (C2FrameData::flags_t)flags;
work->worklets.front()->output.buffers.clear();
work->worklets.front()->output.ordinal = work->input.ordinal;
work->workletsProcessed = 1u;
}
void C2SoftVpxDec::finishWork(uint64_t index, const std::unique_ptr<C2Work> &work,
const std::shared_ptr<C2GraphicBlock> &block) {
std::shared_ptr<C2Buffer> buffer = createGraphicBuffer(block,
C2Rect(mWidth, mHeight));
auto fillWork = [buffer, index, intf = this->mIntf](
const std::unique_ptr<C2Work> &work) {
uint32_t flags = 0;
if ((work->input.flags & C2FrameData::FLAG_END_OF_STREAM) &&
(c2_cntr64_t(index) == work->input.ordinal.frameIndex)) {
flags |= C2FrameData::FLAG_END_OF_STREAM;
ALOGV("signalling eos");
}
work->worklets.front()->output.flags = (C2FrameData::flags_t)flags;
work->worklets.front()->output.buffers.clear();
work->worklets.front()->output.buffers.push_back(buffer);
work->worklets.front()->output.ordinal = work->input.ordinal;
work->workletsProcessed = 1u;
for (const std::unique_ptr<C2Param> ¶m: work->input.configUpdate) {
if (param) {
C2StreamHdr10PlusInfo::input *hdr10PlusInfo =
C2StreamHdr10PlusInfo::input::From(param.get());
if (hdr10PlusInfo != nullptr) {
std::vector<std::unique_ptr<C2SettingResult>> failures;
std::unique_ptr<C2Param> outParam = C2Param::CopyAsStream(
*param.get(), true /*output*/, param->stream());
c2_status_t err = intf->config(
{ outParam.get() }, C2_MAY_BLOCK, &failures);
if (err == C2_OK) {
work->worklets.front()->output.configUpdate.push_back(
C2Param::Copy(*outParam.get()));
} else {
ALOGE("finishWork: Config update size failed");
}
break;
}
}
}
};
if (work && c2_cntr64_t(index) == work->input.ordinal.frameIndex) {
fillWork(work);
} else {
finish(index, fillWork);
}
}
void C2SoftVpxDec::process(
const std::unique_ptr<C2Work> &work,
const std::shared_ptr<C2BlockPool> &pool) {
// Initialize output work
work->result = C2_OK;
work->workletsProcessed = 0u;
work->worklets.front()->output.configUpdate.clear();
work->worklets.front()->output.flags = work->input.flags;
if (mSignalledError || mSignalledOutputEos) {
work->result = C2_BAD_VALUE;
return;
}
size_t inOffset = 0u;
size_t inSize = 0u;
C2ReadView rView = mDummyReadView;
if (!work->input.buffers.empty()) {
rView = work->input.buffers[0]->data().linearBlocks().front().map().get();
inSize = rView.capacity();
if (inSize && rView.error()) {
ALOGE("read view map failed %d", rView.error());
work->result = C2_CORRUPTED;
return;
}
}
bool codecConfig = ((work->input.flags & C2FrameData::FLAG_CODEC_CONFIG) !=0);
bool eos = ((work->input.flags & C2FrameData::FLAG_END_OF_STREAM) != 0);
ALOGV("in buffer attr. size %zu timestamp %d frameindex %d, flags %x",
inSize, (int)work->input.ordinal.timestamp.peeku(),
(int)work->input.ordinal.frameIndex.peeku(), work->input.flags);
// Software VP9 Decoder does not need the Codec Specific Data (CSD)
// (specified in http://www.webmproject.org/vp9/profiles/). Ignore it if
// it was passed.
if (codecConfig) {
// Ignore CSD buffer for VP9.
if (mMode == MODE_VP9) {
fillEmptyWork(work);
return;
} else {
// Tolerate the CSD buffer for VP8. This is a workaround
// for b/28689536. continue
ALOGW("WARNING: Got CSD buffer for VP8. Continue");
}
}
int64_t frameIndex = work->input.ordinal.frameIndex.peekll();
if (inSize) {
uint8_t *bitstream = const_cast<uint8_t *>(rView.data() + inOffset);
vpx_codec_err_t err = vpx_codec_decode(
mCodecCtx, bitstream, inSize, &frameIndex, 0);
if (err != VPX_CODEC_OK) {
ALOGE("on2 decoder failed to decode frame. err: %d", err);
mSignalledError = true;
work->workletsProcessed = 1u;
work->result = C2_CORRUPTED;
return;
}
}
(void)outputBuffer(pool, work);
if (eos) {
drainInternal(DRAIN_COMPONENT_WITH_EOS, pool, work);
mSignalledOutputEos = true;
} else if (!inSize) {
fillEmptyWork(work);
}
}
static void copyOutputBufferToYuvPlanarFrame(
uint8_t *dst, const uint8_t *srcY, const uint8_t *srcU, const uint8_t *srcV,
size_t srcYStride, size_t srcUStride, size_t srcVStride,
size_t dstYStride, size_t dstUVStride,
uint32_t width, uint32_t height) {
uint8_t *dstStart = dst;
for (size_t i = 0; i < height; ++i) {
memcpy(dst, srcY, width);
srcY += srcYStride;
dst += dstYStride;
}
dst = dstStart + dstYStride * height;
for (size_t i = 0; i < height / 2; ++i) {
memcpy(dst, srcV, width / 2);
srcV += srcVStride;
dst += dstUVStride;
}
dst = dstStart + (dstYStride * height) + (dstUVStride * height / 2);
for (size_t i = 0; i < height / 2; ++i) {
memcpy(dst, srcU, width / 2);
srcU += srcUStride;
dst += dstUVStride;
}
}
static void convertYUV420Planar16ToY410(uint32_t *dst,
const uint16_t *srcY, const uint16_t *srcU, const uint16_t *srcV,
size_t srcYStride, size_t srcUStride, size_t srcVStride,
size_t dstStride, size_t width, size_t height) {
// Converting two lines at a time, slightly faster
for (size_t y = 0; y < height; y += 2) {
uint32_t *dstTop = (uint32_t *) dst;
uint32_t *dstBot = (uint32_t *) (dst + dstStride);
uint16_t *ySrcTop = (uint16_t*) srcY;
uint16_t *ySrcBot = (uint16_t*) (srcY + srcYStride);
uint16_t *uSrc = (uint16_t*) srcU;
uint16_t *vSrc = (uint16_t*) srcV;
uint32_t u01, v01, y01, y23, y45, y67, uv0, uv1;
size_t x = 0;
for (; x < width - 3; x += 4) {
u01 = *((uint32_t*)uSrc); uSrc += 2;
v01 = *((uint32_t*)vSrc); vSrc += 2;
y01 = *((uint32_t*)ySrcTop); ySrcTop += 2;
y23 = *((uint32_t*)ySrcTop); ySrcTop += 2;
y45 = *((uint32_t*)ySrcBot); ySrcBot += 2;
y67 = *((uint32_t*)ySrcBot); ySrcBot += 2;
uv0 = (u01 & 0x3FF) | ((v01 & 0x3FF) << 20);
uv1 = (u01 >> 16) | ((v01 >> 16) << 20);
*dstTop++ = 3 << 30 | ((y01 & 0x3FF) << 10) | uv0;
*dstTop++ = 3 << 30 | ((y01 >> 16) << 10) | uv0;
*dstTop++ = 3 << 30 | ((y23 & 0x3FF) << 10) | uv1;
*dstTop++ = 3 << 30 | ((y23 >> 16) << 10) | uv1;
*dstBot++ = 3 << 30 | ((y45 & 0x3FF) << 10) | uv0;
*dstBot++ = 3 << 30 | ((y45 >> 16) << 10) | uv0;
*dstBot++ = 3 << 30 | ((y67 & 0x3FF) << 10) | uv1;
*dstBot++ = 3 << 30 | ((y67 >> 16) << 10) | uv1;
}
// There should be at most 2 more pixels to process. Note that we don't
// need to consider odd case as the buffer is always aligned to even.
if (x < width) {
u01 = *uSrc;
v01 = *vSrc;
y01 = *((uint32_t*)ySrcTop);
y45 = *((uint32_t*)ySrcBot);
uv0 = (u01 & 0x3FF) | ((v01 & 0x3FF) << 20);
*dstTop++ = ((y01 & 0x3FF) << 10) | uv0;
*dstTop++ = ((y01 >> 16) << 10) | uv0;
*dstBot++ = ((y45 & 0x3FF) << 10) | uv0;
*dstBot++ = ((y45 >> 16) << 10) | uv0;
}
srcY += srcYStride * 2;
srcU += srcUStride;
srcV += srcVStride;
dst += dstStride * 2;
}
return;
}
static void convertYUV420Planar16ToYUV420Planar(uint8_t *dst,
const uint16_t *srcY, const uint16_t *srcU, const uint16_t *srcV,
size_t srcYStride, size_t srcUStride, size_t srcVStride,
size_t dstYStride, size_t dstUVStride, size_t width, size_t height) {
uint8_t *dstY = (uint8_t *)dst;
size_t dstYSize = dstYStride * height;
size_t dstUVSize = dstUVStride * height / 2;
uint8_t *dstV = dstY + dstYSize;
uint8_t *dstU = dstV + dstUVSize;
for (size_t y = 0; y < height; ++y) {
for (size_t x = 0; x < width; ++x) {
dstY[x] = (uint8_t)(srcY[x] >> 2);
}
srcY += srcYStride;
dstY += dstYStride;
}
for (size_t y = 0; y < (height + 1) / 2; ++y) {
for (size_t x = 0; x < (width + 1) / 2; ++x) {
dstU[x] = (uint8_t)(srcU[x] >> 2);
dstV[x] = (uint8_t)(srcV[x] >> 2);
}
srcU += srcUStride;
srcV += srcVStride;
dstU += dstUVStride;
dstV += dstUVStride;
}
return;
}
bool C2SoftVpxDec::outputBuffer(
const std::shared_ptr<C2BlockPool> &pool,
const std::unique_ptr<C2Work> &work)
{
if (!(work && pool)) return false;
vpx_codec_iter_t iter = nullptr;
vpx_image_t *img = vpx_codec_get_frame(mCodecCtx, &iter);
if (!img) return false;
if (img->d_w != mWidth || img->d_h != mHeight) {
mWidth = img->d_w;
mHeight = img->d_h;
C2StreamPictureSizeInfo::output size(0u, mWidth, mHeight);
std::vector<std::unique_ptr<C2SettingResult>> failures;
c2_status_t err = mIntf->config({&size}, C2_MAY_BLOCK, &failures);
if (err == C2_OK) {
work->worklets.front()->output.configUpdate.push_back(
C2Param::Copy(size));
} else {
ALOGE("Config update size failed");
mSignalledError = true;
work->workletsProcessed = 1u;
work->result = C2_CORRUPTED;
return false;
}
}
CHECK(img->fmt == VPX_IMG_FMT_I420 || img->fmt == VPX_IMG_FMT_I42016);
std::shared_ptr<C2GraphicBlock> block;
uint32_t format = HAL_PIXEL_FORMAT_YV12;
if (img->fmt == VPX_IMG_FMT_I42016) {
IntfImpl::Lock lock = mIntf->lock();
std::shared_ptr<C2StreamColorAspectsTuning::output> defaultColorAspects = mIntf->getDefaultColorAspects_l();
if (defaultColorAspects->primaries == C2Color::PRIMARIES_BT2020 &&
defaultColorAspects->matrix == C2Color::MATRIX_BT2020 &&
defaultColorAspects->transfer == C2Color::TRANSFER_ST2084) {
format = HAL_PIXEL_FORMAT_RGBA_1010102;
}
}
C2MemoryUsage usage = { C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE };
c2_status_t err = pool->fetchGraphicBlock(align(mWidth, 16), mHeight, format, usage, &block);
if (err != C2_OK) {
ALOGE("fetchGraphicBlock for Output failed with status %d", err);
work->result = err;
return false;
}
C2GraphicView wView = block->map().get();
if (wView.error()) {
ALOGE("graphic view map failed %d", wView.error());
work->result = C2_CORRUPTED;
return false;
}
ALOGV("provided (%dx%d) required (%dx%d), out frameindex %d",
block->width(), block->height(), mWidth, mHeight, (int)*(int64_t *)img->user_priv);
uint8_t *dst = const_cast<uint8_t *>(wView.data()[C2PlanarLayout::PLANE_Y]);
size_t srcYStride = img->stride[VPX_PLANE_Y];
size_t srcUStride = img->stride[VPX_PLANE_U];
size_t srcVStride = img->stride[VPX_PLANE_V];
C2PlanarLayout layout = wView.layout();
size_t dstYStride = layout.planes[C2PlanarLayout::PLANE_Y].rowInc;
size_t dstUVStride = layout.planes[C2PlanarLayout::PLANE_U].rowInc;
if (img->fmt == VPX_IMG_FMT_I42016) {
const uint16_t *srcY = (const uint16_t *)img->planes[VPX_PLANE_Y];
const uint16_t *srcU = (const uint16_t *)img->planes[VPX_PLANE_U];
const uint16_t *srcV = (const uint16_t *)img->planes[VPX_PLANE_V];
if (format == HAL_PIXEL_FORMAT_RGBA_1010102) {
Mutexed<ConversionQueue>::Locked queue(*mQueue);
size_t i = 0;
constexpr size_t kHeight = 64;
for (; i < mHeight; i += kHeight) {
queue->entries.push_back(
[dst, srcY, srcU, srcV,
srcYStride, srcUStride, srcVStride, dstYStride,
width = mWidth, height = std::min(mHeight - i, kHeight)] {
convertYUV420Planar16ToY410(
(uint32_t *)dst, srcY, srcU, srcV, srcYStride / 2,
srcUStride / 2, srcVStride / 2, dstYStride / sizeof(uint32_t),
width, height);
});
srcY += srcYStride / 2 * kHeight;
srcU += srcUStride / 2 * (kHeight / 2);
srcV += srcVStride / 2 * (kHeight / 2);
dst += dstYStride * kHeight;
}
CHECK_EQ(0u, queue->numPending);
queue->numPending = queue->entries.size();
while (queue->numPending > 0) {
queue->cond.signal();
queue.waitForCondition(queue->cond);
}
} else {
convertYUV420Planar16ToYUV420Planar(dst, srcY, srcU, srcV, srcYStride / 2,
srcUStride / 2, srcVStride / 2,
dstYStride, dstUVStride,
mWidth, mHeight);
}
} else {
const uint8_t *srcY = (const uint8_t *)img->planes[VPX_PLANE_Y];
const uint8_t *srcU = (const uint8_t *)img->planes[VPX_PLANE_U];
const uint8_t *srcV = (const uint8_t *)img->planes[VPX_PLANE_V];
copyOutputBufferToYuvPlanarFrame(
dst, srcY, srcU, srcV,
srcYStride, srcUStride, srcVStride,
dstYStride, dstUVStride,
mWidth, mHeight);
}
finishWork(*(int64_t *)img->user_priv, work, std::move(block));
return true;
}
c2_status_t C2SoftVpxDec::drainInternal(
uint32_t drainMode,
const std::shared_ptr<C2BlockPool> &pool,
const std::unique_ptr<C2Work> &work) {
if (drainMode == NO_DRAIN) {
ALOGW("drain with NO_DRAIN: no-op");
return C2_OK;
}
if (drainMode == DRAIN_CHAIN) {
ALOGW("DRAIN_CHAIN not supported");
return C2_OMITTED;
}
while ((outputBuffer(pool, work))) {
}
if (drainMode == DRAIN_COMPONENT_WITH_EOS &&
work && work->workletsProcessed == 0u) {
fillEmptyWork(work);
}
return C2_OK;
}
c2_status_t C2SoftVpxDec::drain(
uint32_t drainMode,
const std::shared_ptr<C2BlockPool> &pool) {
return drainInternal(drainMode, pool, nullptr);
}
class C2SoftVpxFactory : public C2ComponentFactory {
public:
C2SoftVpxFactory() : mHelper(std::static_pointer_cast<C2ReflectorHelper>(
GetCodec2PlatformComponentStore()->getParamReflector())) {
}
virtual c2_status_t createComponent(
c2_node_id_t id,
std::shared_ptr<C2Component>* const component,
std::function<void(C2Component*)> deleter) override {
*component = std::shared_ptr<C2Component>(
new C2SoftVpxDec(COMPONENT_NAME, id,
std::make_shared<C2SoftVpxDec::IntfImpl>(mHelper)),
deleter);
return C2_OK;
}
virtual c2_status_t createInterface(
c2_node_id_t id,
std::shared_ptr<C2ComponentInterface>* const interface,
std::function<void(C2ComponentInterface*)> deleter) override {
*interface = std::shared_ptr<C2ComponentInterface>(
new SimpleInterface<C2SoftVpxDec::IntfImpl>(
COMPONENT_NAME, id,
std::make_shared<C2SoftVpxDec::IntfImpl>(mHelper)),
deleter);
return C2_OK;
}
virtual ~C2SoftVpxFactory() override = default;
private:
std::shared_ptr<C2ReflectorHelper> mHelper;
};
} // namespace android
extern "C" ::C2ComponentFactory* CreateCodec2Factory() {
ALOGV("in %s", __func__);
return new ::android::C2SoftVpxFactory();
}
extern "C" void DestroyCodec2Factory(::C2ComponentFactory* factory) {
ALOGV("in %s", __func__);
delete factory;
}