1033 lines
43 KiB
C++
1033 lines
43 KiB
C++
/*
|
|
* Copyright (C) 2022 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 "C2SoftAomEnc"
|
|
#include <log/log.h>
|
|
|
|
#include <media/stagefright/foundation/AUtils.h>
|
|
#include <media/stagefright/foundation/MediaDefs.h>
|
|
|
|
#include <C2Debug.h>
|
|
#include <Codec2CommonUtils.h>
|
|
#include <Codec2Mapper.h>
|
|
#include <C2PlatformSupport.h>
|
|
#include <SimpleC2Interface.h>
|
|
|
|
#include "C2SoftAomEnc.h"
|
|
|
|
namespace android {
|
|
|
|
constexpr char COMPONENT_NAME[] = "c2.android.av1.encoder";
|
|
|
|
#define DEFAULT_SPEED 10
|
|
|
|
C2SoftAomEnc::IntfImpl::IntfImpl(const std::shared_ptr<C2ReflectorHelper>& helper)
|
|
: SimpleInterface<void>::BaseParams(helper, COMPONENT_NAME, C2Component::KIND_ENCODER,
|
|
C2Component::DOMAIN_VIDEO, MEDIA_MIMETYPE_VIDEO_AV1) {
|
|
noPrivateBuffers(); // TODO: account for our buffers here
|
|
noInputReferences();
|
|
noOutputReferences();
|
|
noInputLatency();
|
|
noTimeStretch();
|
|
setDerivedInstance(this);
|
|
|
|
addParameter(DefineParam(mUsage, C2_PARAMKEY_INPUT_STREAM_USAGE)
|
|
.withConstValue(new C2StreamUsageTuning::input(
|
|
0u, (uint64_t)C2MemoryUsage::CPU_READ))
|
|
.build());
|
|
|
|
addParameter(DefineParam(mSize, C2_PARAMKEY_PICTURE_SIZE)
|
|
.withDefault(new C2StreamPictureSizeInfo::input(0u, 320, 240))
|
|
.withFields({
|
|
C2F(mSize, width).inRange(2, 2048, 2),
|
|
C2F(mSize, height).inRange(2, 2048, 2),
|
|
})
|
|
.withSetter(SizeSetter)
|
|
.build());
|
|
|
|
addParameter(DefineParam(mBitrateMode, C2_PARAMKEY_BITRATE_MODE)
|
|
.withDefault(new C2StreamBitrateModeTuning::output(
|
|
0u, C2Config::BITRATE_VARIABLE))
|
|
.withFields({C2F(mBitrateMode, value)
|
|
.oneOf({C2Config::BITRATE_CONST,
|
|
C2Config::BITRATE_VARIABLE,
|
|
C2Config::BITRATE_IGNORE})})
|
|
.withSetter(Setter<decltype(*mBitrateMode)>::StrictValueWithNoDeps)
|
|
.build());
|
|
|
|
addParameter(DefineParam(mFrameRate, C2_PARAMKEY_FRAME_RATE)
|
|
.withDefault(new C2StreamFrameRateInfo::output(0u, 30.))
|
|
// TODO: More restriction?
|
|
.withFields({C2F(mFrameRate, value).greaterThan(0.)})
|
|
.withSetter(Setter<decltype(*mFrameRate)>::StrictValueWithNoDeps)
|
|
.build());
|
|
|
|
addParameter(DefineParam(mSyncFramePeriod, C2_PARAMKEY_SYNC_FRAME_INTERVAL)
|
|
.withDefault(new C2StreamSyncFrameIntervalTuning::output(0u, 1000000))
|
|
.withFields({C2F(mSyncFramePeriod, value).any()})
|
|
.withSetter(Setter<decltype(*mSyncFramePeriod)>::StrictValueWithNoDeps)
|
|
.build());
|
|
|
|
addParameter(DefineParam(mBitrate, C2_PARAMKEY_BITRATE)
|
|
.withDefault(new C2StreamBitrateInfo::output(0u, 64000))
|
|
.withFields({C2F(mBitrate, value).inRange(4096, 40000000)})
|
|
.withSetter(BitrateSetter)
|
|
.build());
|
|
|
|
addParameter(DefineParam(mComplexity, C2_PARAMKEY_COMPLEXITY)
|
|
.withDefault(new C2StreamComplexityTuning::output(0u, 0))
|
|
.withFields({C2F(mComplexity, value).inRange(0, 5)})
|
|
.withSetter(Setter<decltype(*mComplexity)>::NonStrictValueWithNoDeps)
|
|
.build());
|
|
|
|
addParameter(DefineParam(mQuality, C2_PARAMKEY_QUALITY)
|
|
.withDefault(new C2StreamQualityTuning::output(0u, 80))
|
|
.withFields({C2F(mQuality, value).inRange(0, 100)})
|
|
.withSetter(Setter<decltype(*mQuality)>::NonStrictValueWithNoDeps)
|
|
.build());
|
|
|
|
addParameter(DefineParam(mIntraRefresh, C2_PARAMKEY_INTRA_REFRESH)
|
|
.withConstValue(new C2StreamIntraRefreshTuning::output(
|
|
0u, C2Config::INTRA_REFRESH_DISABLED, 0.))
|
|
.build());
|
|
|
|
addParameter(DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL)
|
|
.withDefault(new C2StreamProfileLevelInfo::output(0u, PROFILE_AV1_0,
|
|
LEVEL_AV1_4_1))
|
|
.withFields({
|
|
C2F(mProfileLevel, profile).equalTo(PROFILE_AV1_0),
|
|
C2F(mProfileLevel, level)
|
|
.oneOf({LEVEL_AV1_2, LEVEL_AV1_2_1, LEVEL_AV1_2_2,
|
|
LEVEL_AV1_2_3, LEVEL_AV1_3, LEVEL_AV1_3_1,
|
|
LEVEL_AV1_3_2, LEVEL_AV1_3_3, LEVEL_AV1_4,
|
|
LEVEL_AV1_4_1}),
|
|
})
|
|
.withSetter(ProfileLevelSetter)
|
|
.build());
|
|
|
|
std::vector<uint32_t> pixelFormats = {HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED,
|
|
HAL_PIXEL_FORMAT_YCBCR_420_888};
|
|
if (isHalPixelFormatSupported((AHardwareBuffer_Format)HAL_PIXEL_FORMAT_YCBCR_P010)) {
|
|
pixelFormats.push_back(HAL_PIXEL_FORMAT_YCBCR_P010);
|
|
}
|
|
addParameter(DefineParam(mPixelFormat, C2_PARAMKEY_PIXEL_FORMAT)
|
|
.withDefault(new C2StreamPixelFormatInfo::input(
|
|
0u, HAL_PIXEL_FORMAT_YCBCR_420_888))
|
|
.withFields({C2F(mPixelFormat, value).oneOf({pixelFormats})})
|
|
.withSetter((Setter<decltype(*mPixelFormat)>::StrictValueWithNoDeps))
|
|
.build());
|
|
|
|
addParameter(DefineParam(mRequestSync, C2_PARAMKEY_REQUEST_SYNC_FRAME)
|
|
.withDefault(new C2StreamRequestSyncFrameTuning::output(0u, C2_FALSE))
|
|
.withFields({C2F(mRequestSync, value).oneOf({C2_FALSE, C2_TRUE})})
|
|
.withSetter(Setter<decltype(*mRequestSync)>::NonStrictValueWithNoDeps)
|
|
.build());
|
|
addParameter(
|
|
DefineParam(mColorAspects, C2_PARAMKEY_COLOR_ASPECTS)
|
|
.withDefault(new C2StreamColorAspectsInfo::input(
|
|
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(ColorAspectsSetter)
|
|
.build());
|
|
|
|
addParameter(
|
|
DefineParam(mCodedColorAspects, C2_PARAMKEY_VUI_COLOR_ASPECTS)
|
|
.withDefault(new C2StreamColorAspectsInfo::output(
|
|
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(CodedColorAspectsSetter, mColorAspects)
|
|
.build());
|
|
}
|
|
|
|
C2R C2SoftAomEnc::IntfImpl::BitrateSetter(bool mayBlock, C2P<C2StreamBitrateInfo::output>& me) {
|
|
(void)mayBlock;
|
|
C2R res = C2R::Ok();
|
|
if (me.v.value < 4096) {
|
|
me.set().value = 4096;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
C2R C2SoftAomEnc::IntfImpl::SizeSetter(bool mayBlock,
|
|
const C2P<C2StreamPictureSizeInfo::input>& oldMe,
|
|
C2P<C2StreamPictureSizeInfo::input>& 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;
|
|
}
|
|
|
|
C2R C2SoftAomEnc::IntfImpl::ProfileLevelSetter(bool mayBlock,
|
|
C2P<C2StreamProfileLevelInfo::output>& me) {
|
|
(void)mayBlock;
|
|
if (!me.F(me.v.profile).supportsAtAll(me.v.profile)) {
|
|
me.set().profile = PROFILE_AV1_0;
|
|
}
|
|
if (!me.F(me.v.level).supportsAtAll(me.v.level)) {
|
|
me.set().level = LEVEL_AV1_4_1;
|
|
}
|
|
return C2R::Ok();
|
|
}
|
|
|
|
uint32_t C2SoftAomEnc::IntfImpl::getSyncFramePeriod() const {
|
|
if (mSyncFramePeriod->value < 0 || mSyncFramePeriod->value == INT64_MAX) {
|
|
return 0;
|
|
}
|
|
double period = mSyncFramePeriod->value / 1e6 * mFrameRate->value;
|
|
return (uint32_t)c2_max(c2_min(period + 0.5, double(UINT32_MAX)), 1.);
|
|
}
|
|
|
|
C2R C2SoftAomEnc::IntfImpl::ColorAspectsSetter(bool mayBlock,
|
|
C2P<C2StreamColorAspectsInfo::input>& 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();
|
|
}
|
|
C2R C2SoftAomEnc::IntfImpl::CodedColorAspectsSetter(
|
|
bool mayBlock, C2P<C2StreamColorAspectsInfo::output>& me,
|
|
const C2P<C2StreamColorAspectsInfo::input>& coded) {
|
|
(void)mayBlock;
|
|
me.set().range = coded.v.range;
|
|
me.set().primaries = coded.v.primaries;
|
|
me.set().transfer = coded.v.transfer;
|
|
me.set().matrix = coded.v.matrix;
|
|
return C2R::Ok();
|
|
}
|
|
|
|
C2SoftAomEnc::C2SoftAomEnc(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),
|
|
mCodecContext(nullptr),
|
|
mCodecConfiguration(nullptr),
|
|
mCodecInterface(nullptr),
|
|
mStrideAlign(2),
|
|
mBitrateControlMode(AOM_VBR),
|
|
mMinQuantizer(0),
|
|
mMaxQuantizer(0),
|
|
mLastTimestamp(INT64_MAX),
|
|
mSignalledOutputEos(false),
|
|
mSignalledError(false),
|
|
mHeadersReceived(false),
|
|
mIs10Bit(false) {
|
|
ALOGV("Constructor");
|
|
}
|
|
|
|
C2SoftAomEnc::~C2SoftAomEnc() {
|
|
ALOGV("Destructor");
|
|
onRelease();
|
|
}
|
|
|
|
c2_status_t C2SoftAomEnc::onInit() {
|
|
return C2_OK;
|
|
}
|
|
|
|
c2_status_t C2SoftAomEnc::onStop() {
|
|
onRelease();
|
|
return C2_OK;
|
|
}
|
|
|
|
void C2SoftAomEnc::onReset() {
|
|
(void)onStop();
|
|
}
|
|
|
|
void C2SoftAomEnc::onRelease() {
|
|
if (mCodecContext) {
|
|
aom_codec_destroy(mCodecContext);
|
|
delete mCodecContext;
|
|
mCodecContext = nullptr;
|
|
}
|
|
|
|
if (mCodecConfiguration) {
|
|
delete mCodecConfiguration;
|
|
mCodecConfiguration = nullptr;
|
|
}
|
|
|
|
// this one is not allocated by us
|
|
mCodecInterface = nullptr;
|
|
mHeadersReceived = false;
|
|
}
|
|
|
|
c2_status_t C2SoftAomEnc::onFlush_sm() {
|
|
return onStop();
|
|
}
|
|
|
|
// c2Quality is in range of 0-100 (the more - the better),
|
|
// for AOM quality we are using a range of 15-50 (the less - the better)
|
|
static int MapC2QualityToAOMQuality (int c2Quality) {
|
|
return 15 + 35 * (100 - c2Quality) / 100;
|
|
}
|
|
|
|
static int MapC2ComplexityToAOMSpeed (int c2Complexity) {
|
|
int mapping[6] = {10, 9, 8, 7, 6, 6};
|
|
if (c2Complexity > 5 || c2Complexity < 0) {
|
|
ALOGW("Wrong complexity setting. Falling back to speed 10");
|
|
return 10;
|
|
}
|
|
return mapping[c2Complexity];
|
|
}
|
|
|
|
aom_codec_err_t C2SoftAomEnc::setupCodecParameters() {
|
|
aom_codec_err_t codec_return = AOM_CODEC_OK;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AOME_SET_CPUUSED,
|
|
MapC2ComplexityToAOMSpeed(mComplexity->value));
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ROW_MT, 1);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_CDEF, 1);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_TPL_MODEL, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_DELTAQ_MODE, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_ORDER_HINT, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_AQ_MODE, 3);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_COEFF_COST_UPD_FREQ, 3);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_MODE_COST_UPD_FREQ, 3);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_MV_COST_UPD_FREQ, 3);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_PALETTE, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_OBMC, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_NOISE_SENSITIVITY, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_WARPED_MOTION, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_GLOBAL_MOTION, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_REF_FRAME_MVS, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_CFL_INTRA, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_SMOOTH_INTRA, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_ANGLE_DELTA, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_FILTER_INTRA, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_INTRA_DEFAULT_TX_ONLY, 1);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_DISABLE_TRELLIS_QUANT, 1);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_DIST_WTD_COMP, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_DIFF_WTD_COMP, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_DUAL_FILTER, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_INTERINTRA_COMP, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_INTERINTRA_WEDGE, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_INTRA_EDGE_FILTER, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_INTRABC, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_MASKED_COMP, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_PAETH_INTRA, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_QM, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_RECT_PARTITIONS, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_RESTORATION, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_SMOOTH_INTERINTRA, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_ENABLE_TX64, 0);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_MAX_REFERENCE_FRAMES, 3);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
if (mBitrateControlMode == AOM_Q) {
|
|
const int aomCQLevel = MapC2QualityToAOMQuality(mQuality->value);
|
|
ALOGV("Set Q from %d to CQL %d",
|
|
mQuality->value, aomCQLevel);
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AOME_SET_CQ_LEVEL, aomCQLevel);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
}
|
|
|
|
ColorAspects sfAspects;
|
|
if (!C2Mapper::map(mColorAspects->primaries, &sfAspects.mPrimaries)) {
|
|
sfAspects.mPrimaries = android::ColorAspects::PrimariesUnspecified;
|
|
}
|
|
if (!C2Mapper::map(mColorAspects->range, &sfAspects.mRange)) {
|
|
sfAspects.mRange = android::ColorAspects::RangeUnspecified;
|
|
}
|
|
if (!C2Mapper::map(mColorAspects->matrix, &sfAspects.mMatrixCoeffs)) {
|
|
sfAspects.mMatrixCoeffs = android::ColorAspects::MatrixUnspecified;
|
|
}
|
|
if (!C2Mapper::map(mColorAspects->transfer, &sfAspects.mTransfer)) {
|
|
sfAspects.mTransfer = android::ColorAspects::TransferUnspecified;
|
|
}
|
|
int32_t primaries, transfer, matrixCoeffs;
|
|
bool range;
|
|
ColorUtils::convertCodecColorAspectsToIsoAspects(sfAspects,
|
|
&primaries,
|
|
&transfer,
|
|
&matrixCoeffs,
|
|
&range);
|
|
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_COLOR_RANGE, range);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_COLOR_PRIMARIES, primaries);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_TRANSFER_CHARACTERISTICS, transfer);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
codec_return = aom_codec_control(mCodecContext, AV1E_SET_MATRIX_COEFFICIENTS, matrixCoeffs);
|
|
if (codec_return != AOM_CODEC_OK) goto BailOut;
|
|
|
|
BailOut:
|
|
return codec_return;
|
|
}
|
|
|
|
status_t C2SoftAomEnc::initEncoder() {
|
|
aom_codec_err_t codec_return;
|
|
status_t result = UNKNOWN_ERROR;
|
|
{
|
|
IntfImpl::Lock lock = mIntf->lock();
|
|
// Fetch config
|
|
mSize = mIntf->getSize_l();
|
|
mBitrate = mIntf->getBitrate_l();
|
|
mBitrateMode = mIntf->getBitrateMode_l();
|
|
mFrameRate = mIntf->getFrameRate_l();
|
|
mIntraRefresh = mIntf->getIntraRefresh_l();
|
|
mRequestSync = mIntf->getRequestSync_l();
|
|
mColorAspects = mIntf->getCodedColorAspects_l();
|
|
mQuality = mIntf->getQuality_l();
|
|
mComplexity = mIntf->getComplexity_l();
|
|
}
|
|
|
|
|
|
switch (mBitrateMode->value) {
|
|
case C2Config::BITRATE_CONST:
|
|
mBitrateControlMode = AOM_CBR;
|
|
break;
|
|
case C2Config::BITRATE_IGNORE:
|
|
mBitrateControlMode = AOM_Q;
|
|
break;
|
|
case C2Config::BITRATE_VARIABLE:
|
|
[[fallthrough]];
|
|
default:
|
|
mBitrateControlMode = AOM_VBR;
|
|
break;
|
|
}
|
|
|
|
mCodecInterface = aom_codec_av1_cx();
|
|
if (!mCodecInterface) goto CleanUp;
|
|
|
|
ALOGD("AOM: initEncoder. BRMode: %u. KF: %u. QP: %u - %u, 10Bit: %d, comlexity %d",
|
|
(uint32_t)mBitrateControlMode,
|
|
mIntf->getSyncFramePeriod(), mMinQuantizer, mMaxQuantizer, mIs10Bit, mComplexity->value);
|
|
|
|
mCodecConfiguration = new aom_codec_enc_cfg_t;
|
|
if (!mCodecConfiguration) goto CleanUp;
|
|
|
|
codec_return = aom_codec_enc_config_default(mCodecInterface, mCodecConfiguration,
|
|
AOM_USAGE_REALTIME); // RT mode
|
|
if (codec_return != AOM_CODEC_OK) {
|
|
ALOGE("Error populating default configuration for aom encoder.");
|
|
goto CleanUp;
|
|
}
|
|
|
|
mCodecConfiguration->g_w = mSize->width;
|
|
mCodecConfiguration->g_h = mSize->height;
|
|
mCodecConfiguration->g_bit_depth = mIs10Bit ? AOM_BITS_10 : AOM_BITS_8;
|
|
mCodecConfiguration->g_input_bit_depth = mIs10Bit ? 10 : 8;
|
|
|
|
|
|
mCodecConfiguration->g_threads = 0;
|
|
mCodecConfiguration->g_error_resilient = 0;
|
|
|
|
// timebase unit is microsecond
|
|
// g_timebase is in seconds (i.e. 1/1000000 seconds)
|
|
mCodecConfiguration->g_timebase.num = 1;
|
|
mCodecConfiguration->g_timebase.den = 1000000;
|
|
// rc_target_bitrate is in kbps, mBitrate in bps
|
|
mCodecConfiguration->rc_target_bitrate = (mBitrate->value + 500) / 1000;
|
|
mCodecConfiguration->rc_end_usage = mBitrateControlMode == AOM_Q ? AOM_Q : AOM_CBR;
|
|
// Disable frame drop - not allowed in MediaCodec now.
|
|
mCodecConfiguration->rc_dropframe_thresh = 0;
|
|
// Disable lagged encoding.
|
|
mCodecConfiguration->g_lag_in_frames = 0;
|
|
|
|
// Disable spatial resizing.
|
|
mCodecConfiguration->rc_resize_mode = 0;
|
|
// Single-pass mode.
|
|
mCodecConfiguration->g_pass = AOM_RC_ONE_PASS;
|
|
|
|
// Maximum key frame interval - for CBR boost to 3000
|
|
mCodecConfiguration->kf_max_dist = 3000;
|
|
// Encoder determines optimal key frame placement automatically.
|
|
mCodecConfiguration->kf_mode = AOM_KF_AUTO;
|
|
// The amount of data that may be buffered by the decoding
|
|
// application in ms.
|
|
mCodecConfiguration->rc_buf_sz = 1000;
|
|
|
|
if (mBitrateControlMode == AOM_CBR) {
|
|
// Initial value of the buffer level in ms.
|
|
mCodecConfiguration->rc_buf_initial_sz = 500;
|
|
// Amount of data that the encoder should try to maintain in ms.
|
|
mCodecConfiguration->rc_buf_optimal_sz = 600;
|
|
// Maximum amount of bits that can be subtracted from the target
|
|
// bitrate - expressed as percentage of the target bitrate.
|
|
mCodecConfiguration->rc_undershoot_pct = 100;
|
|
// Maximum amount of bits that can be added to the target
|
|
// bitrate - expressed as percentage of the target bitrate.
|
|
mCodecConfiguration->rc_overshoot_pct = 10;
|
|
} else {
|
|
// Maximum amount of bits that can be subtracted from the target
|
|
// bitrate - expressed as percentage of the target bitrate.
|
|
mCodecConfiguration->rc_undershoot_pct = 100;
|
|
// Maximum amount of bits that can be added to the target
|
|
// bitrate - expressed as percentage of the target bitrate.
|
|
mCodecConfiguration->rc_overshoot_pct = 100;
|
|
}
|
|
|
|
if (mIntf->getSyncFramePeriod() >= 0) {
|
|
mCodecConfiguration->kf_max_dist = mIntf->getSyncFramePeriod();
|
|
mCodecConfiguration->kf_min_dist = mIntf->getSyncFramePeriod();
|
|
mCodecConfiguration->kf_mode = AOM_KF_AUTO;
|
|
}
|
|
if (mMinQuantizer > 0) {
|
|
mCodecConfiguration->rc_min_quantizer = mMinQuantizer;
|
|
}
|
|
if (mMaxQuantizer > 0) {
|
|
mCodecConfiguration->rc_max_quantizer = mMaxQuantizer;
|
|
} else {
|
|
if (mBitrateControlMode == AOM_VBR) {
|
|
// For VBR we are limiting MaxQP to 52 (down 11 steps) to maintain quality
|
|
// 52 comes from experiments done on libaom standalone app
|
|
mCodecConfiguration->rc_max_quantizer = 52;
|
|
}
|
|
}
|
|
|
|
mCodecContext = new aom_codec_ctx_t;
|
|
if (!mCodecContext) goto CleanUp;
|
|
codec_return = aom_codec_enc_init(mCodecContext, mCodecInterface, mCodecConfiguration,
|
|
mIs10Bit ? AOM_CODEC_USE_HIGHBITDEPTH : 0);
|
|
if (codec_return != AOM_CODEC_OK) {
|
|
ALOGE("Error initializing aom encoder");
|
|
goto CleanUp;
|
|
}
|
|
|
|
codec_return = setupCodecParameters();
|
|
if (codec_return != AOM_CODEC_OK) {
|
|
ALOGE("Error setting up codec parameters");
|
|
goto CleanUp;
|
|
}
|
|
|
|
mHeadersReceived = false;
|
|
|
|
{
|
|
uint32_t width = mSize->width;
|
|
uint32_t height = mSize->height;
|
|
if (((uint64_t)width * height) > ((uint64_t)INT32_MAX / 3)) {
|
|
ALOGE("b/25812794, Buffer size is too big, width=%u, height=%u.", width, height);
|
|
} else {
|
|
uint32_t stride = (width + mStrideAlign - 1) & ~(mStrideAlign - 1);
|
|
uint32_t vstride = (height + mStrideAlign - 1) & ~(mStrideAlign - 1);
|
|
mConversionBuffer = MemoryBlock::Allocate(stride * vstride * 3 / (mIs10Bit? 1 : 2));
|
|
if (!mConversionBuffer.size()) {
|
|
ALOGE("Allocating conversion buffer failed.");
|
|
} else {
|
|
mNumInputFrames = -1;
|
|
return OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
CleanUp:
|
|
onRelease();
|
|
return result;
|
|
}
|
|
|
|
void C2SoftAomEnc::process(const std::unique_ptr<C2Work>& work,
|
|
const std::shared_ptr<C2BlockPool>& pool) {
|
|
// Initialize output work
|
|
work->result = C2_OK;
|
|
work->workletsProcessed = 1u;
|
|
work->worklets.front()->output.flags = work->input.flags;
|
|
|
|
if (mSignalledError || mSignalledOutputEos) {
|
|
work->result = C2_BAD_VALUE;
|
|
return;
|
|
}
|
|
|
|
std::shared_ptr<C2GraphicView> rView;
|
|
std::shared_ptr<C2Buffer> inputBuffer;
|
|
if (!work->input.buffers.empty()) {
|
|
inputBuffer = work->input.buffers[0];
|
|
rView = std::make_shared<C2GraphicView>(
|
|
inputBuffer->data().graphicBlocks().front().map().get());
|
|
if (rView->error() != C2_OK) {
|
|
ALOGE("graphic view map err = %d", rView->error());
|
|
work->result = C2_CORRUPTED;
|
|
return;
|
|
}
|
|
} else {
|
|
ALOGV("Empty input Buffer");
|
|
uint32_t flags = 0;
|
|
if (work->input.flags & C2FrameData::FLAG_END_OF_STREAM) {
|
|
flags |= C2FrameData::FLAG_END_OF_STREAM;
|
|
}
|
|
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;
|
|
return;
|
|
}
|
|
|
|
bool end_of_stream = ((work->input.flags & C2FrameData::FLAG_END_OF_STREAM) != 0);
|
|
aom_image_t raw_frame;
|
|
const C2PlanarLayout& layout = rView->layout();
|
|
if (!mHeadersReceived) {
|
|
mIs10Bit = (layout.planes[layout.PLANE_Y].bitDepth == 10);
|
|
|
|
// Re-Initialize encoder
|
|
if (mCodecContext){
|
|
onRelease();
|
|
}
|
|
}
|
|
if (!mCodecContext && OK != initEncoder()) {
|
|
ALOGE("Failed to initialize encoder");
|
|
mSignalledError = true;
|
|
work->result = C2_CORRUPTED;
|
|
return;
|
|
}
|
|
|
|
//(b/279387842)
|
|
//workaround for incorrect crop size in view when using surface mode
|
|
rView->setCrop_be(C2Rect(mSize->width, mSize->height));
|
|
|
|
if (!mHeadersReceived) {
|
|
Av1Config av1_config;
|
|
constexpr uint32_t header_length = 2048;
|
|
uint8_t header[header_length];
|
|
size_t header_bytes;
|
|
aom_fixed_buf_t* obu_sequence_header = aom_codec_get_global_headers(mCodecContext);
|
|
int ret = 1;
|
|
if (obu_sequence_header) {
|
|
if (get_av1config_from_obu(reinterpret_cast<const uint8_t*>(obu_sequence_header->buf),
|
|
obu_sequence_header->sz, false, &av1_config) == 0) {
|
|
ret = write_av1config(&av1_config, header_length, &header_bytes, header);
|
|
|
|
} else {
|
|
ALOGE("Can not get config");
|
|
}
|
|
free(obu_sequence_header->buf);
|
|
free(obu_sequence_header);
|
|
}
|
|
|
|
if (ret) {
|
|
ALOGE("Can not write config");
|
|
mSignalledError = true;
|
|
work->result = C2_NO_MEMORY;
|
|
work->workletsProcessed = 1u;
|
|
return;
|
|
}
|
|
|
|
mHeadersReceived = true;
|
|
std::unique_ptr<C2StreamInitDataInfo::output> csd =
|
|
C2StreamInitDataInfo::output::AllocUnique(header_bytes, 0u);
|
|
if (!csd) {
|
|
ALOGE("CSD allocation failed");
|
|
mSignalledError = true;
|
|
work->result = C2_NO_MEMORY;
|
|
work->workletsProcessed = 1u;
|
|
return;
|
|
}
|
|
memcpy(csd->m.value, header, header_bytes);
|
|
work->worklets.front()->output.configUpdate.push_back(std::move(csd));
|
|
ALOGV("CSD Produced of size %zu bytes", header_bytes);
|
|
}
|
|
|
|
const C2ConstGraphicBlock inBuffer = inputBuffer->data().graphicBlocks().front();
|
|
if (inBuffer.width() < mSize->width || inBuffer.height() < mSize->height) {
|
|
ALOGE("unexpected Input buffer attributes %d(%d) x %d(%d)", inBuffer.width(), mSize->width,
|
|
inBuffer.height(), mSize->height);
|
|
mSignalledError = true;
|
|
work->result = C2_BAD_VALUE;
|
|
return;
|
|
}
|
|
|
|
|
|
uint32_t width = mSize->width;
|
|
uint32_t height = mSize->height;
|
|
if (width > 0x8000 || height > 0x8000) {
|
|
ALOGE("Image too big: %u x %u", width, height);
|
|
work->result = C2_BAD_VALUE;
|
|
return;
|
|
}
|
|
uint32_t stride = (width + mStrideAlign - 1) & ~(mStrideAlign - 1);
|
|
uint32_t vstride = (height + mStrideAlign - 1) & ~(mStrideAlign - 1);
|
|
switch (layout.type) {
|
|
case C2PlanarLayout::TYPE_RGB:
|
|
case C2PlanarLayout::TYPE_RGBA: {
|
|
std::shared_ptr<C2StreamColorAspectsInfo::output> colorAspects;
|
|
{
|
|
IntfImpl::Lock lock = mIntf->lock();
|
|
colorAspects = mIntf->getCodedColorAspects_l();
|
|
}
|
|
ConvertRGBToPlanarYUV(mConversionBuffer.data(), stride, vstride,
|
|
mConversionBuffer.size(), *rView.get(), colorAspects->matrix,
|
|
colorAspects->range);
|
|
aom_img_wrap(&raw_frame, AOM_IMG_FMT_I420, width, height, mStrideAlign,
|
|
mConversionBuffer.data());
|
|
break;
|
|
}
|
|
case C2PlanarLayout::TYPE_YUV: {
|
|
const bool isYUV420_10bit = IsYUV420_10bit(*rView);
|
|
if (!IsYUV420(*rView) && !isYUV420_10bit) {
|
|
ALOGE("input is not YUV420");
|
|
work->result = C2_BAD_VALUE;
|
|
return;
|
|
}
|
|
if (!isYUV420_10bit) {
|
|
if (IsI420(*rView)) {
|
|
// I420 compatible - though with custom offset and stride
|
|
aom_img_wrap(&raw_frame, AOM_IMG_FMT_I420, width, height, mStrideAlign,
|
|
(uint8_t*)rView->data()[0]);
|
|
raw_frame.planes[1] = (uint8_t*)rView->data()[1];
|
|
raw_frame.planes[2] = (uint8_t*)rView->data()[2];
|
|
raw_frame.stride[0] = layout.planes[layout.PLANE_Y].rowInc;
|
|
raw_frame.stride[1] = layout.planes[layout.PLANE_U].rowInc;
|
|
raw_frame.stride[2] = layout.planes[layout.PLANE_V].rowInc;
|
|
} else {
|
|
// TODO(kyslov): Add image wrap for NV12
|
|
// copy to I420
|
|
MediaImage2 img = CreateYUV420PlanarMediaImage2(width, height, stride, vstride);
|
|
if (mConversionBuffer.size() >= stride * vstride * 3 / 2) {
|
|
status_t err = ImageCopy(mConversionBuffer.data(), &img, *rView);
|
|
if (err != OK) {
|
|
ALOGE("Buffer conversion failed: %d", err);
|
|
work->result = C2_BAD_VALUE;
|
|
return;
|
|
}
|
|
aom_img_wrap(&raw_frame, AOM_IMG_FMT_I420, stride, vstride, mStrideAlign,
|
|
mConversionBuffer.data());
|
|
aom_img_set_rect(&raw_frame, 0, 0, width, height, 0);
|
|
} else {
|
|
ALOGE("Conversion buffer is too small: %u x %u for %zu", stride, vstride,
|
|
mConversionBuffer.size());
|
|
work->result = C2_BAD_VALUE;
|
|
return;
|
|
}
|
|
}
|
|
} else { // 10 bits
|
|
if (IsP010(*rView)) {
|
|
if (mConversionBuffer.size() >= stride * vstride * 3) {
|
|
uint16_t *dstY, *dstU, *dstV;
|
|
dstY = (uint16_t*)mConversionBuffer.data();
|
|
dstU = dstY + stride * vstride;
|
|
dstV = dstU + (stride * vstride) / 4;
|
|
convertP010ToYUV420Planar16(dstY, dstU, dstV, (uint16_t*)(rView->data()[0]),
|
|
(uint16_t*)(rView->data()[1]),
|
|
layout.planes[layout.PLANE_Y].rowInc / 2,
|
|
layout.planes[layout.PLANE_U].rowInc / 2,
|
|
stride, stride / 2, stride / 2, stride,
|
|
vstride);
|
|
aom_img_wrap(&raw_frame, AOM_IMG_FMT_I42016, stride, vstride, mStrideAlign,
|
|
mConversionBuffer.data());
|
|
aom_img_set_rect(&raw_frame, 0, 0, width, height, 0);
|
|
} else {
|
|
ALOGE("Conversion buffer is too small: %u x %u for %zu", stride, vstride,
|
|
mConversionBuffer.size());
|
|
work->result = C2_BAD_VALUE;
|
|
return;
|
|
}
|
|
} else {
|
|
ALOGE("Image format conversion is not supported.");
|
|
work->result = C2_BAD_VALUE;
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case C2PlanarLayout::TYPE_YUVA: {
|
|
if (mConversionBuffer.size() >= stride * vstride * 3) {
|
|
uint16_t *dstY, *dstU, *dstV;
|
|
dstY = (uint16_t*)mConversionBuffer.data();
|
|
dstU = dstY + stride * vstride;
|
|
dstV = dstU + (stride * vstride) / 4;
|
|
convertRGBA1010102ToYUV420Planar16(dstY, dstU, dstV, (uint32_t*)(rView->data()[0]),
|
|
layout.planes[layout.PLANE_Y].rowInc / 4, stride,
|
|
vstride, mColorAspects->matrix,
|
|
mColorAspects->range);
|
|
aom_img_wrap(&raw_frame, AOM_IMG_FMT_I42016, stride, vstride, mStrideAlign,
|
|
mConversionBuffer.data());
|
|
aom_img_set_rect(&raw_frame, 0, 0, width, height, 0);
|
|
} else {
|
|
ALOGE("Conversion buffer is too small: %u x %u for %zu", stride, vstride,
|
|
mConversionBuffer.size());
|
|
work->result = C2_BAD_VALUE;
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
ALOGE("Unrecognized plane type: %d", layout.type);
|
|
work->result = C2_BAD_VALUE;
|
|
return;
|
|
}
|
|
|
|
aom_enc_frame_flags_t flags = 0;
|
|
// handle dynamic config parameters
|
|
{
|
|
IntfImpl::Lock lock = mIntf->lock();
|
|
std::shared_ptr<C2StreamIntraRefreshTuning::output> intraRefresh =
|
|
mIntf->getIntraRefresh_l();
|
|
std::shared_ptr<C2StreamBitrateInfo::output> bitrate = mIntf->getBitrate_l();
|
|
std::shared_ptr<C2StreamRequestSyncFrameTuning::output> requestSync =
|
|
mIntf->getRequestSync_l();
|
|
lock.unlock();
|
|
|
|
if (intraRefresh != mIntraRefresh) {
|
|
mIntraRefresh = intraRefresh;
|
|
ALOGV("Got mIntraRefresh request");
|
|
}
|
|
|
|
if (requestSync != mRequestSync) {
|
|
// we can handle IDR immediately
|
|
if (requestSync->value) {
|
|
// unset request
|
|
C2StreamRequestSyncFrameTuning::output clearSync(0u, C2_FALSE);
|
|
std::vector<std::unique_ptr<C2SettingResult>> failures;
|
|
mIntf->config({&clearSync}, C2_MAY_BLOCK, &failures);
|
|
ALOGV("Got sync request");
|
|
flags |= AOM_EFLAG_FORCE_KF;
|
|
}
|
|
mRequestSync = requestSync;
|
|
}
|
|
|
|
if (bitrate != mBitrate) {
|
|
mBitrate = bitrate;
|
|
mCodecConfiguration->rc_target_bitrate = (mBitrate->value + 500) / 1000;
|
|
aom_codec_err_t res = aom_codec_enc_config_set(mCodecContext, mCodecConfiguration);
|
|
if (res != AOM_CODEC_OK) {
|
|
ALOGE("aom encoder failed to update bitrate: %s", aom_codec_err_to_string(res));
|
|
mSignalledError = true;
|
|
work->result = C2_CORRUPTED;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
uint64_t input_timestamp = work->input.ordinal.timestamp.peekull();
|
|
uint32_t frame_duration;
|
|
if (input_timestamp > mLastTimestamp) {
|
|
frame_duration = (uint32_t)(input_timestamp - mLastTimestamp);
|
|
} else {
|
|
// Use default of 30 fps in case of 0 frame rate.
|
|
float frame_rate = mFrameRate->value;
|
|
if (frame_rate < 0.001) {
|
|
frame_rate = 30.0;
|
|
}
|
|
frame_duration = (uint32_t)(1000000 / frame_rate + 0.5);
|
|
}
|
|
mLastTimestamp = input_timestamp;
|
|
|
|
aom_codec_err_t codec_return =
|
|
aom_codec_encode(mCodecContext, &raw_frame, input_timestamp, frame_duration, flags);
|
|
if (codec_return != AOM_CODEC_OK) {
|
|
ALOGE("aom encoder failed to encode frame");
|
|
mSignalledError = true;
|
|
work->result = C2_CORRUPTED;
|
|
return;
|
|
}
|
|
|
|
bool populated = false;
|
|
aom_codec_iter_t encoded_packet_iterator = nullptr;
|
|
const aom_codec_cx_pkt_t* encoded_packet;
|
|
while ((encoded_packet = aom_codec_get_cx_data(mCodecContext, &encoded_packet_iterator))) {
|
|
if (encoded_packet->kind == AOM_CODEC_CX_FRAME_PKT) {
|
|
std::shared_ptr<C2LinearBlock> block;
|
|
C2MemoryUsage usage = {C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE};
|
|
c2_status_t err = pool->fetchLinearBlock(encoded_packet->data.frame.sz, usage, &block);
|
|
if (err != C2_OK) {
|
|
ALOGE("fetchLinearBlock for Output failed with status %d", err);
|
|
work->result = C2_NO_MEMORY;
|
|
return;
|
|
}
|
|
C2WriteView wView = block->map().get();
|
|
if (wView.error()) {
|
|
ALOGE("write view map failed %d", wView.error());
|
|
work->result = C2_CORRUPTED;
|
|
return;
|
|
}
|
|
|
|
memcpy(wView.data(), encoded_packet->data.frame.buf, encoded_packet->data.frame.sz);
|
|
++mNumInputFrames;
|
|
|
|
ALOGD("bytes generated %zu", encoded_packet->data.frame.sz);
|
|
uint32_t flags = 0;
|
|
if (end_of_stream) {
|
|
flags |= C2FrameData::FLAG_END_OF_STREAM;
|
|
}
|
|
|
|
work->worklets.front()->output.flags = (C2FrameData::flags_t)flags;
|
|
work->worklets.front()->output.buffers.clear();
|
|
std::shared_ptr<C2Buffer> buffer =
|
|
createLinearBuffer(block, 0, encoded_packet->data.frame.sz);
|
|
if (encoded_packet->data.frame.flags & AOM_FRAME_IS_KEY) {
|
|
buffer->setInfo(std::make_shared<C2StreamPictureTypeMaskInfo::output>(
|
|
0u /* stream id */, C2Config::SYNC_FRAME));
|
|
}
|
|
work->worklets.front()->output.buffers.push_back(buffer);
|
|
work->worklets.front()->output.ordinal = work->input.ordinal;
|
|
work->worklets.front()->output.ordinal.timestamp = encoded_packet->data.frame.pts;
|
|
work->workletsProcessed = 1u;
|
|
populated = true;
|
|
if (end_of_stream) {
|
|
mSignalledOutputEos = true;
|
|
ALOGV("signalled End Of Stream");
|
|
}
|
|
}
|
|
}
|
|
if (!populated) {
|
|
work->workletsProcessed = 0u;
|
|
}
|
|
}
|
|
|
|
c2_status_t C2SoftAomEnc::drain(uint32_t drainMode, const std::shared_ptr<C2BlockPool>& pool) {
|
|
(void)pool;
|
|
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;
|
|
}
|
|
|
|
return C2_OK;
|
|
}
|
|
|
|
class C2SoftAomEncFactory : public C2ComponentFactory {
|
|
public:
|
|
C2SoftAomEncFactory()
|
|
: 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 C2SoftAomEnc(COMPONENT_NAME, id,
|
|
std::make_shared<C2SoftAomEnc::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<C2SoftAomEnc::IntfImpl>(
|
|
COMPONENT_NAME, id, std::make_shared<C2SoftAomEnc::IntfImpl>(mHelper)),
|
|
deleter);
|
|
return C2_OK;
|
|
}
|
|
|
|
virtual ~C2SoftAomEncFactory() override = default;
|
|
|
|
private:
|
|
std::shared_ptr<C2ReflectorHelper> mHelper;
|
|
};
|
|
|
|
} // namespace android
|
|
|
|
__attribute__((cfi_canonical_jump_table)) extern "C" ::C2ComponentFactory* CreateCodec2Factory() {
|
|
ALOGV("in %s", __func__);
|
|
return new ::android::C2SoftAomEncFactory();
|
|
}
|
|
|
|
__attribute__((cfi_canonical_jump_table)) extern "C" void DestroyCodec2Factory(
|
|
::C2ComponentFactory* factory) {
|
|
ALOGV("in %s", __func__);
|
|
delete factory;
|
|
}
|