media/codec2/components/dav1d/C2SoftDav1dDec.cpp

/*
 * Copyright (C) 2023 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 "C2SoftDav1dDec"
#include <android-base/properties.h>
#include <cutils/properties.h>
#include <thread>

#include <C2Debug.h>
#include <C2PlatformSupport.h>
#include <Codec2BufferUtils.h>
#include <Codec2CommonUtils.h>
#include <Codec2Mapper.h>
#include <SimpleC2Interface.h>
#include <log/log.h>
#include <media/stagefright/foundation/AUtils.h>
#include <media/stagefright/foundation/MediaDefs.h>
#include "C2SoftDav1dDec.h"

namespace android {

// The number of threads used for the dav1d decoder.
static const int NUM_THREADS_DAV1D_DEFAULT = 0;
static const char NUM_THREADS_DAV1D_PROPERTY[] = "debug.dav1d.numthreads";

// codecname set and passed in as a compile flag from Android.bp
constexpr char COMPONENT_NAME[] = CODECNAME;

constexpr size_t kMinInputBufferSize = 2 * 1024 * 1024;

constexpr uint32_t kOutputDelay = 4;

class C2SoftDav1dDec::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, MEDIA_MIMETYPE_VIDEO_AV1) {
        noPrivateBuffers();
        noInputReferences();
        noOutputReferences();
        noInputLatency();
        noTimeStretch();

        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, 4096),
                                     C2F(mSize, height).inRange(2, 4096),
                             })
                             .withSetter(SizeSetter)
                             .build());

        addParameter(DefineParam(mProfileLevel, C2_PARAMKEY_PROFILE_LEVEL)
                             .withDefault(new C2StreamProfileLevelInfo::input(
                                     0u, C2Config::PROFILE_AV1_0, C2Config::LEVEL_AV1_2_1))
                             .withFields({C2F(mProfileLevel, profile)
                                                  .oneOf({C2Config::PROFILE_AV1_0,
                                                          C2Config::PROFILE_AV1_1}),
                                          C2F(mProfileLevel, level)
                                                  .oneOf({
                                                          C2Config::LEVEL_AV1_2,
                                                          C2Config::LEVEL_AV1_2_1,
                                                          C2Config::LEVEL_AV1_2_2,
                                                          C2Config::LEVEL_AV1_2_3,
                                                          C2Config::LEVEL_AV1_3,
                                                          C2Config::LEVEL_AV1_3_1,
                                                          C2Config::LEVEL_AV1_3_2,
                                                          C2Config::LEVEL_AV1_3_3,
                                                          C2Config::LEVEL_AV1_4,
                                                          C2Config::LEVEL_AV1_4_1,
                                                          C2Config::LEVEL_AV1_4_2,
                                                          C2Config::LEVEL_AV1_4_3,
                                                          C2Config::LEVEL_AV1_5,
                                                          C2Config::LEVEL_AV1_5_1,
                                                          C2Config::LEVEL_AV1_5_2,
                                                          C2Config::LEVEL_AV1_5_3,
                                                  })})
                             .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());

        // default static info
        C2HdrStaticMetadataStruct defaultStaticInfo{};
        helper->addStructDescriptors<C2MasteringDisplayColorVolumeStruct, C2ColorXyStruct>();
        addParameter(
                DefineParam(mHdrStaticInfo, C2_PARAMKEY_HDR_STATIC_INFO)
                        .withDefault(new C2StreamHdrStaticInfo::output(0u, defaultStaticInfo))
                        .withFields({C2F(mHdrStaticInfo, mastering.red.x).inRange(0, 1),
                                     C2F(mHdrStaticInfo, mastering.red.y).inRange(0, 1),
                                     C2F(mHdrStaticInfo, mastering.green.x).inRange(0, 1),
                                     C2F(mHdrStaticInfo, mastering.green.y).inRange(0, 1),
                                     C2F(mHdrStaticInfo, mastering.blue.x).inRange(0, 1),
                                     C2F(mHdrStaticInfo, mastering.blue.y).inRange(0, 1),
                                     C2F(mHdrStaticInfo, mastering.white.x).inRange(0, 1),
                                     C2F(mHdrStaticInfo, mastering.white.x).inRange(0, 1),
                                     C2F(mHdrStaticInfo, mastering.maxLuminance).inRange(0, 65535),
                                     C2F(mHdrStaticInfo, mastering.minLuminance).inRange(0, 6.5535),
                                     C2F(mHdrStaticInfo, maxCll).inRange(0, 0XFFFF),
                                     C2F(mHdrStaticInfo, maxFall).inRange(0, 0XFFFF)})
                        .withSetter(HdrStaticInfoSetter)
                        .build());

        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, kMinInputBufferSize))
                        .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());

        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(CodedColorAspectsSetter)
                             .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(ColorAspectsSetter, mDefaultColorAspects, mCodedColorAspects)
                        .build());

        std::vector<uint32_t> pixelFormats = {HAL_PIXEL_FORMAT_YCBCR_420_888};
        if (isHalPixelFormatSupported((AHardwareBuffer_Format)HAL_PIXEL_FORMAT_YCBCR_P010)) {
            pixelFormats.push_back(HAL_PIXEL_FORMAT_YCBCR_P010);
        }
        // If color format surface isn't added to supported formats, there is no way to know
        // when the color-format is configured to surface. This is necessary to be able to
        // choose 10-bit format while decoding 10-bit clips in surface mode.
        pixelFormats.push_back(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED);

        // TODO: support more formats?
        addParameter(DefineParam(mPixelFormat, C2_PARAMKEY_PIXEL_FORMAT)
                             .withDefault(new C2StreamPixelFormatInfo::output(
                                     0u, HAL_PIXEL_FORMAT_YCBCR_420_888))
                             .withFields({C2F(mPixelFormat, value).oneOf(pixelFormats)})
                             .withSetter((Setter<decltype(*mPixelFormat)>::StrictValueWithNoDeps))
                             .build());

        addParameter(
                DefineParam(mActualOutputDelay, C2_PARAMKEY_OUTPUT_DELAY)
                .withDefault(new C2PortActualDelayTuning::output(kOutputDelay))
                .withFields({C2F(mActualOutputDelay, value).inRange(0, kOutputDelay)})
                .withSetter(Setter<decltype(*mActualOutputDelay)>::StrictValueWithNoDeps)
                .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), 4096u);
        me.set().height = c2_min(c2_max(me.v.height, size.v.height), 4096u);
        return C2R::Ok();
    }

    static C2R MaxInputSizeSetter(bool mayBlock, C2P<C2StreamMaxBufferSizeInfo::input>& me,
                                  const C2P<C2StreamMaxPictureSizeTuning::output>& maxSize) {
        (void)mayBlock;
        // assume compression ratio of 2, but enforce a floor
        me.set().value =
                c2_max((((maxSize.v.width + 63) / 64) * ((maxSize.v.height + 63) / 64) * 3072),
                       kMinInputBufferSize);
        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 CodedColorAspectsSetter(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();
    }

    static C2R ColorAspectsSetter(bool mayBlock, C2P<C2StreamColorAspectsInfo::output>& me,
                                  const C2P<C2StreamColorAspectsTuning::output>& def,
                                  const C2P<C2StreamColorAspectsInfo::input>& coded) {
        (void)mayBlock;
        // take default values for all unspecified fields, and coded values for specified ones
        me.set().range = coded.v.range == RANGE_UNSPECIFIED ? def.v.range : coded.v.range;
        me.set().primaries =
                coded.v.primaries == PRIMARIES_UNSPECIFIED ? def.v.primaries : coded.v.primaries;
        me.set().transfer =
                coded.v.transfer == TRANSFER_UNSPECIFIED ? def.v.transfer : coded.v.transfer;
        me.set().matrix = coded.v.matrix == MATRIX_UNSPECIFIED ? def.v.matrix : coded.v.matrix;
        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;
    }

    std::shared_ptr<C2StreamColorAspectsInfo::output> getColorAspects_l() { return mColorAspects; }

    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();
    }

    // unsafe getters
    std::shared_ptr<C2StreamPixelFormatInfo::output> getPixelFormat_l() const {
        return mPixelFormat;
    }

    static C2R HdrStaticInfoSetter(bool mayBlock, C2P<C2StreamHdrStaticInfo::output>& me) {
        (void)mayBlock;
        if (me.v.mastering.red.x > 1) {
            me.set().mastering.red.x = 1;
        }
        if (me.v.mastering.red.y > 1) {
            me.set().mastering.red.y = 1;
        }
        if (me.v.mastering.green.x > 1) {
            me.set().mastering.green.x = 1;
        }
        if (me.v.mastering.green.y > 1) {
            me.set().mastering.green.y = 1;
        }
        if (me.v.mastering.blue.x > 1) {
            me.set().mastering.blue.x = 1;
        }
        if (me.v.mastering.blue.y > 1) {
            me.set().mastering.blue.y = 1;
        }
        if (me.v.mastering.white.x > 1) {
            me.set().mastering.white.x = 1;
        }
        if (me.v.mastering.white.y > 1) {
            me.set().mastering.white.y = 1;
        }
        if (me.v.mastering.maxLuminance > 65535.0) {
            me.set().mastering.maxLuminance = 65535.0;
        }
        if (me.v.mastering.minLuminance > 6.5535) {
            me.set().mastering.minLuminance = 6.5535;
        }
        if (me.v.maxCll > 65535.0) {
            me.set().maxCll = 65535.0;
        }
        if (me.v.maxFall > 65535.0) {
            me.set().maxFall = 65535.0;
        }
        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;
    std::shared_ptr<C2StreamColorAspectsInfo::input> mCodedColorAspects;
    std::shared_ptr<C2StreamColorAspectsInfo::output> mColorAspects;
    std::shared_ptr<C2StreamHdr10PlusInfo::input> mHdr10PlusInfoInput;
    std::shared_ptr<C2StreamHdr10PlusInfo::output> mHdr10PlusInfoOutput;
    std::shared_ptr<C2StreamHdrStaticInfo::output> mHdrStaticInfo;
};

C2SoftDav1dDec::C2SoftDav1dDec(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) {
    mTimeStart = mTimeEnd = systemTime();
}

C2SoftDav1dDec::~C2SoftDav1dDec() {
    onRelease();
}

c2_status_t C2SoftDav1dDec::onInit() {
    return initDecoder() ? C2_OK : C2_CORRUPTED;
}

c2_status_t C2SoftDav1dDec::onStop() {
    // TODO: b/277797541 - investigate if the decoder needs to be flushed.
    mSignalledError = false;
    mSignalledOutputEos = false;
    return C2_OK;
}

void C2SoftDav1dDec::onReset() {
    (void)onStop();
    c2_status_t err = onFlush_sm();
    if (err != C2_OK) {
        ALOGW("Failed to flush the av1 decoder. Trying to hard reset.");
        destroyDecoder();
        if (!initDecoder()) {
            ALOGE("Hard reset failed.");
        }
    }
}

void C2SoftDav1dDec::flushDav1d() {
    if (mDav1dCtx) {
        Dav1dPicture p;

        int res = 0;
        while (true) {
            memset(&p, 0, sizeof(p));

            if ((res = dav1d_get_picture(mDav1dCtx, &p)) < 0) {
                if (res != DAV1D_ERR(EAGAIN)) {
                    ALOGE("Error decoding frame: %s\n", strerror(DAV1D_ERR(res)));
                    break;
                } else {
                    res = 0;
                    break;
                }
            } else {
                dav1d_picture_unref(&p);
            }
        }

        dav1d_flush(mDav1dCtx);
    }
}

void C2SoftDav1dDec::onRelease() {
    destroyDecoder();
}

c2_status_t C2SoftDav1dDec::onFlush_sm() {
    flushDav1d();

    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;
}

bool C2SoftDav1dDec::initDecoder() {
#ifdef FILE_DUMP_ENABLE
    mC2SoftDav1dDump.initDumping();
#endif
    mSignalledError = false;
    mSignalledOutputEos = false;
    mHalPixelFormat = HAL_PIXEL_FORMAT_YV12;
    {
        IntfImpl::Lock lock = mIntf->lock();
        mPixelFormatInfo = mIntf->getPixelFormat_l();
    }

    const char* version = dav1d_version();

    Dav1dSettings lib_settings;
    dav1d_default_settings(&lib_settings);
    int cpu_count = GetCPUCoreCount();
    lib_settings.n_threads = std::max(cpu_count / 2, 1);  // use up to half the cores by default.

    int32_t numThreads =
            android::base::GetIntProperty(NUM_THREADS_DAV1D_PROPERTY, NUM_THREADS_DAV1D_DEFAULT);
    if (numThreads > 0) lib_settings.n_threads = numThreads;

    lib_settings.max_frame_delay = kOutputDelay;

    int res = 0;
    if ((res = dav1d_open(&mDav1dCtx, &lib_settings))) {
        ALOGE("dav1d_open failed. status: %d.", res);
        return false;
    } else {
        ALOGD("dav1d_open succeeded(n_threads=%d,version=%s).", lib_settings.n_threads, version);
    }

    return true;
}

void C2SoftDav1dDec::destroyDecoder() {
    if (mDav1dCtx) {
        dav1d_close(&mDav1dCtx);
        mDav1dCtx = nullptr;
        mOutputBufferIndex = 0;
        mInputBufferIndex = 0;
    }
#ifdef FILE_DUMP_ENABLE
    mC2SoftDav1dDump.destroyDumping();
#endif
}

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 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;
}

void C2SoftDav1dDec::finishWork(uint64_t index, const std::unique_ptr<C2Work>& work,
                                const std::shared_ptr<C2GraphicBlock>& block,
                                const Dav1dPicture &img) {
    std::shared_ptr<C2Buffer> buffer = createGraphicBuffer(block, C2Rect(mWidth, mHeight));
    {
        IntfImpl::Lock lock = mIntf->lock();
        buffer->setInfo(mIntf->getColorAspects_l());
    }

    auto fillWork = [buffer, index, img, this](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 end_of_stream.");
        }
        getHDRStaticParams(&img, work);
        getHDR10PlusInfoData(&img, work);

        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;
    };
    if (work && c2_cntr64_t(index) == work->input.ordinal.frameIndex) {
        fillWork(work);
    } else {
        finish(index, fillWork);
    }
}

void C2SoftDav1dDec::process(const std::unique_ptr<C2Work>& work,
                             const std::shared_ptr<C2BlockPool>& pool) {
    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 end_of_stream = ((work->input.flags & C2FrameData::FLAG_END_OF_STREAM) != 0);

    if (codecConfig) {
        fillEmptyWork(work);
        return;
    }

    int64_t in_frameIndex = work->input.ordinal.frameIndex.peekll();
    if (inSize) {
        mInputBufferIndex = in_frameIndex;

        uint8_t* bitstream = const_cast<uint8_t*>(rView.data() + inOffset);

        mTimeStart = systemTime();
        nsecs_t delay = mTimeStart - mTimeEnd;

        // Send the bitstream data (inputBuffer) to dav1d.
        if (mDav1dCtx) {
            int i_ret = 0;

            Dav1dSequenceHeader seq;
            int res = dav1d_parse_sequence_header(&seq, bitstream, inSize);
            if (res == 0) {
                ALOGV("dav1d found a sequenceHeader (%dx%d) for in_frameIndex=%ld.", seq.max_width,
                      seq.max_height, (long)in_frameIndex);
                if (seq.max_width != mWidth || seq.max_height != mHeight) {
                    drainInternal(DRAIN_COMPONENT_NO_EOS, pool, work);
                    mWidth = seq.max_width;
                    mHeight = seq.max_height;

                    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->result = C2_CORRUPTED;
                        work->workletsProcessed = 1u;
                        return;
                    }
                }
            }

            // insert OBU TD if it is not present.
            // TODO: b/286852962
            uint8_t obu_type = (bitstream[0] >> 3) & 0xf;
            Dav1dData data;

            uint8_t* ptr = (obu_type == DAV1D_OBU_TD) ? dav1d_data_create(&data, inSize)
                                                      : dav1d_data_create(&data, inSize + 2);
            if (ptr == nullptr) {
                ALOGE("dav1d_data_create failed!");
                i_ret = -1;

            } else {
                data.m.timestamp = in_frameIndex;

                int new_Size;
                if (obu_type != DAV1D_OBU_TD) {
                    new_Size = (int)(inSize + 2);

                    // OBU TD
                    ptr[0] = 0x12;
                    ptr[1] = 0;

                    memcpy(ptr + 2, bitstream, inSize);
                } else {
                    new_Size = (int)(inSize);
                    // TODO: b/277797541 - investigate how to wrap this pointer in Dav1dData to
                    // avoid memcopy operations.
                    memcpy(ptr, bitstream, new_Size);
                }

                // ALOGV("memcpy(ptr,bitstream,inSize=%ld,new_Size=%d,in_frameIndex=%ld,timestamp=%ld,"
                //       "ptr[0,1,2,3,4]=%x,%x,%x,%x,%x)",
                //       inSize, new_Size, frameIndex, data.m.timestamp, ptr[0], ptr[1], ptr[2],
                //       ptr[3], ptr[4]);

                // Dump the bitstream data (inputBuffer) if dumping is enabled.
#ifdef FILE_DUMP_ENABLE
                mC2SoftDav1dDump.dumpInput(ptr, new_Size);
#endif

                bool b_draining = false;
                int res;

                do {
                    res = dav1d_send_data(mDav1dCtx, &data);
                    if (res < 0 && res != DAV1D_ERR(EAGAIN)) {
                        ALOGE("Decoder feed error %s!", strerror(DAV1D_ERR(res)));
                        /* bitstream decoding errors (typically DAV1D_ERR(EINVAL), are assumed
                         * to be recoverable. Other errors returned from this function are
                         * either unexpected, or considered critical failures.
                         */
                        i_ret = res == DAV1D_ERR(EINVAL) ? 0 : -1;
                        break;
                    }

                    outputBuffer(pool, work);

                } while (res == DAV1D_ERR(EAGAIN));

                if (data.sz > 0) {
                    ALOGE("unexpected data.sz=%zu after dav1d_send_data", data.sz);
                    dav1d_data_unref(&data);
                }
            }

            mTimeEnd = systemTime();
            nsecs_t decodeTime = mTimeEnd - mTimeStart;
            // ALOGV("decodeTime=%4" PRId64 " delay=%4" PRId64 "\n", decodeTime, delay);

            if (i_ret != 0) {
                ALOGE("av1 decoder failed to decode frame. status: %d.", i_ret);
                work->result = C2_CORRUPTED;
                work->workletsProcessed = 1u;
                mSignalledError = true;
                return;
            }
        }
    }

    if (end_of_stream) {
        drainInternal(DRAIN_COMPONENT_WITH_EOS, pool, work);
        mSignalledOutputEos = true;
    } else if (!inSize) {
        fillEmptyWork(work);
    }
}

void C2SoftDav1dDec::getHDRStaticParams(const Dav1dPicture* picture,
                                        const std::unique_ptr<C2Work>& work) {
    C2StreamHdrStaticMetadataInfo::output hdrStaticMetadataInfo{};
    bool infoPresent = false;

    if (picture != nullptr) {
        if (picture->mastering_display != nullptr) {
            hdrStaticMetadataInfo.mastering.red.x =
                    picture->mastering_display->primaries[0][0] / 65536.0;
            hdrStaticMetadataInfo.mastering.red.y =
                    picture->mastering_display->primaries[0][1] / 65536.0;

            hdrStaticMetadataInfo.mastering.green.x =
                    picture->mastering_display->primaries[1][0] / 65536.0;
            hdrStaticMetadataInfo.mastering.green.y =
                    picture->mastering_display->primaries[1][1] / 65536.0;

            hdrStaticMetadataInfo.mastering.blue.x =
                    picture->mastering_display->primaries[2][0] / 65536.0;
            hdrStaticMetadataInfo.mastering.blue.y =
                    picture->mastering_display->primaries[2][1] / 65536.0;

            hdrStaticMetadataInfo.mastering.white.x =
                    picture->mastering_display->white_point[0] / 65536.0;
            hdrStaticMetadataInfo.mastering.white.y =
                    picture->mastering_display->white_point[1] / 65536.0;

            hdrStaticMetadataInfo.mastering.maxLuminance =
                    picture->mastering_display->max_luminance / 256.0;
            hdrStaticMetadataInfo.mastering.minLuminance =
                    picture->mastering_display->min_luminance / 16384.0;

            infoPresent = true;
        }

        if (picture->content_light != nullptr) {
            hdrStaticMetadataInfo.maxCll = picture->content_light->max_content_light_level;
            hdrStaticMetadataInfo.maxFall = picture->content_light->max_frame_average_light_level;
            infoPresent = true;
        }
    }

    // if (infoPresent) {
    //   ALOGD("received a hdrStaticMetadataInfo (mastering.red=%f,%f mastering.green=%f,%f
    //   mastering.blue=%f,%f mastering.white=%f,%f mastering.maxLuminance=%f
    //   mastering.minLuminance=%f maxCll=%f maxFall=%f) at mOutputBufferIndex=%d.",
    //   hdrStaticMetadataInfo.mastering.red.x,hdrStaticMetadataInfo.mastering.red.y,
    //   hdrStaticMetadataInfo.mastering.green.x,hdrStaticMetadataInfo.mastering.green.y,
    //   hdrStaticMetadataInfo.mastering.blue.x,hdrStaticMetadataInfo.mastering.blue.y,
    //   hdrStaticMetadataInfo.mastering.white.x,hdrStaticMetadataInfo.mastering.white.y,
    //   hdrStaticMetadataInfo.mastering.maxLuminance,hdrStaticMetadataInfo.mastering.minLuminance,
    //   hdrStaticMetadataInfo.maxCll,
    //   hdrStaticMetadataInfo.maxFall,
    //   mOutputBufferIndex);
    // }

    // config if static info has changed
    if (infoPresent && !(hdrStaticMetadataInfo == mHdrStaticMetadataInfo)) {
        mHdrStaticMetadataInfo = hdrStaticMetadataInfo;
        work->worklets.front()->output.configUpdate.push_back(
                C2Param::Copy(mHdrStaticMetadataInfo));
    }
}

void C2SoftDav1dDec::getHDR10PlusInfoData(const Dav1dPicture* picture,
                                          const std::unique_ptr<C2Work>& work) {
    if (picture != nullptr) {
        if (picture->itut_t35 != nullptr) {
            std::vector<uint8_t> payload;
            size_t payloadSize = picture->itut_t35->payload_size;
            if (payloadSize > 0) {
                payload.push_back(picture->itut_t35->country_code);
                if (picture->itut_t35->country_code == 0xFF) {
                    payload.push_back(picture->itut_t35->country_code_extension_byte);
                }
                payload.insert(payload.end(), picture->itut_t35->payload,
                               picture->itut_t35->payload + picture->itut_t35->payload_size);
            }

            std::unique_ptr<C2StreamHdr10PlusInfo::output> hdr10PlusInfo =
                    C2StreamHdr10PlusInfo::output::AllocUnique(payload.size());
            if (!hdr10PlusInfo) {
                ALOGE("Hdr10PlusInfo allocation failed");
                mSignalledError = true;
                work->result = C2_NO_MEMORY;
                return;
            }
            memcpy(hdr10PlusInfo->m.value, payload.data(), payload.size());

            // ALOGD("Received a hdr10PlusInfo from picture->itut_t32
            // (payload_size=%ld,country_code=%d) at mOutputBufferIndex=%d.",
            // picture->itut_t35->payload_size,
            // picture->itut_t35->country_code,
            // mOutputBufferIndex);

            // config if hdr10Plus info has changed
            if (nullptr == mHdr10PlusInfo || !(*hdr10PlusInfo == *mHdr10PlusInfo)) {
                mHdr10PlusInfo = std::move(hdr10PlusInfo);
                work->worklets.front()->output.configUpdate.push_back(std::move(mHdr10PlusInfo));
            }
        }
    }
}

void C2SoftDav1dDec::getVuiParams(const Dav1dPicture* picture) {
    VuiColorAspects vuiColorAspects;

    if (picture) {
        vuiColorAspects.primaries = picture->seq_hdr->pri;
        vuiColorAspects.transfer = picture->seq_hdr->trc;
        vuiColorAspects.coeffs = picture->seq_hdr->mtrx;
        vuiColorAspects.fullRange = picture->seq_hdr->color_range;

        // ALOGD("Received a vuiColorAspects from dav1d
        //       (primaries = % d, transfer = % d, coeffs = % d, fullRange = % d)
        //               at mOutputBufferIndex = % d,
        //       out_frameIndex = % ld.",
        //                          vuiColorAspects.primaries,
        //       vuiColorAspects.transfer, vuiColorAspects.coeffs, vuiColorAspects.fullRange,
        //       mOutputBufferIndex, picture->m.timestamp);
    }

    // convert vui aspects to C2 values if changed
    if (!(vuiColorAspects == mBitstreamColorAspects)) {
        mBitstreamColorAspects = vuiColorAspects;
        ColorAspects sfAspects;
        C2StreamColorAspectsInfo::input codedAspects = {0u};
        ColorUtils::convertIsoColorAspectsToCodecAspects(
                vuiColorAspects.primaries, vuiColorAspects.transfer, vuiColorAspects.coeffs,
                vuiColorAspects.fullRange, sfAspects);
        if (!C2Mapper::map(sfAspects.mPrimaries, &codedAspects.primaries)) {
            codedAspects.primaries = C2Color::PRIMARIES_UNSPECIFIED;
        }
        if (!C2Mapper::map(sfAspects.mRange, &codedAspects.range)) {
            codedAspects.range = C2Color::RANGE_UNSPECIFIED;
        }
        if (!C2Mapper::map(sfAspects.mMatrixCoeffs, &codedAspects.matrix)) {
            codedAspects.matrix = C2Color::MATRIX_UNSPECIFIED;
        }
        if (!C2Mapper::map(sfAspects.mTransfer, &codedAspects.transfer)) {
            codedAspects.transfer = C2Color::TRANSFER_UNSPECIFIED;
        }
        std::vector<std::unique_ptr<C2SettingResult>> failures;
        mIntf->config({&codedAspects}, C2_MAY_BLOCK, &failures);
    }
}

void C2SoftDav1dDec::setError(const std::unique_ptr<C2Work>& work, c2_status_t error) {
    mSignalledError = true;
    work->result = error;
    work->workletsProcessed = 1u;
}

bool C2SoftDav1dDec::allocTmpFrameBuffer(size_t size) {
    if (size > mTmpFrameBufferSize) {
        mTmpFrameBuffer = std::make_unique<uint16_t[]>(size);
        if (mTmpFrameBuffer == nullptr) {
            mTmpFrameBufferSize = 0;
            return false;
        }
        mTmpFrameBufferSize = size;
    }
    return true;
}

bool C2SoftDav1dDec::outputBuffer(const std::shared_ptr<C2BlockPool>& pool,
                                  const std::unique_ptr<C2Work>& work) {
    if (!(work && pool)) return false;
    if (mDav1dCtx == nullptr) return false;

    // Get a decoded picture from dav1d if it is enabled.
    Dav1dPicture img;
    memset(&img, 0, sizeof(img));

    int res = 0;
    res = dav1d_get_picture(mDav1dCtx, &img);
    if (res == DAV1D_ERR(EAGAIN)) {
        ALOGV("Not enough data to output a picture.");
        return false;
    } else if (res != 0) {
        ALOGE("The AV1 decoder failed to get a picture (res=%s).", strerror(DAV1D_ERR(res)));
        return false;
    }

    getVuiParams(&img);

    // out_frameIndex that the decoded picture returns from dav1d.
    int64_t out_frameIndex = img.m.timestamp;

    const bool isMonochrome = img.p.layout == DAV1D_PIXEL_LAYOUT_I400;

    int bitdepth = img.p.bpc;

    std::shared_ptr<C2GraphicBlock> block;
    uint32_t format = HAL_PIXEL_FORMAT_YV12;
    std::shared_ptr<C2StreamColorAspectsInfo::output> codedColorAspects;
    if (bitdepth == 10 && mPixelFormatInfo->value != HAL_PIXEL_FORMAT_YCBCR_420_888) {
        IntfImpl::Lock lock = mIntf->lock();
        codedColorAspects = mIntf->getColorAspects_l();
        bool allowRGBA1010102 = false;
        if (codedColorAspects->primaries == C2Color::PRIMARIES_BT2020 &&
            codedColorAspects->matrix == C2Color::MATRIX_BT2020 &&
            codedColorAspects->transfer == C2Color::TRANSFER_ST2084) {
            allowRGBA1010102 = true;
        }
        format = getHalPixelFormatForBitDepth10(allowRGBA1010102);
    }

    if (mHalPixelFormat != format) {
        C2StreamPixelFormatInfo::output pixelFormat(0u, format);
        std::vector<std::unique_ptr<C2SettingResult>> failures;
        c2_status_t err = mIntf->config({&pixelFormat}, C2_MAY_BLOCK, &failures);
        if (err == C2_OK) {
            work->worklets.front()->output.configUpdate.push_back(C2Param::Copy(pixelFormat));
        } else {
            ALOGE("Config update pixelFormat failed");
            mSignalledError = true;
            work->workletsProcessed = 1u;
            work->result = C2_CORRUPTED;
            return UNKNOWN_ERROR;
        }
        mHalPixelFormat = format;
    }

    C2MemoryUsage usage = {C2MemoryUsage::CPU_READ, C2MemoryUsage::CPU_WRITE};

    // We always create a graphic block that is width aligned to 16 and height
    // aligned to 2. We set the correct "crop" value of the image in the call to
    // createGraphicBuffer() by setting the correct image dimensions.
    c2_status_t err =
            pool->fetchGraphicBlock(align(mWidth, 16), align(mHeight, 2), 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)out_frameIndex);

    mOutputBufferIndex = out_frameIndex;

    uint8_t* dstY = const_cast<uint8_t*>(wView.data()[C2PlanarLayout::PLANE_Y]);
    uint8_t* dstU = const_cast<uint8_t*>(wView.data()[C2PlanarLayout::PLANE_U]);
    uint8_t* dstV = const_cast<uint8_t*>(wView.data()[C2PlanarLayout::PLANE_V]);

    C2PlanarLayout layout = wView.layout();
    size_t dstYStride = layout.planes[C2PlanarLayout::PLANE_Y].rowInc;
    size_t dstUStride = layout.planes[C2PlanarLayout::PLANE_U].rowInc;
    size_t dstVStride = layout.planes[C2PlanarLayout::PLANE_V].rowInc;

    CONV_FORMAT_T convFormat;
    switch (img.p.layout) {
        case DAV1D_PIXEL_LAYOUT_I444:
            convFormat = CONV_FORMAT_I444;
            break;
        case DAV1D_PIXEL_LAYOUT_I422:
            convFormat = CONV_FORMAT_I422;
            break;
        default:
            convFormat = CONV_FORMAT_I420;
            break;
    }

    if (bitdepth == 10) {
        // TODO: b/277797541 - Investigate if we can ask DAV1D to output the required format during
        // decompression to avoid color conversion.
        const uint16_t* srcY = (const uint16_t*)img.data[0];
        const uint16_t* srcU = (const uint16_t*)img.data[1];
        const uint16_t* srcV = (const uint16_t*)img.data[2];
        size_t srcYStride = img.stride[0] / 2;
        size_t srcUStride = img.stride[1] / 2;
        size_t srcVStride = img.stride[1] / 2;

        if (format == HAL_PIXEL_FORMAT_RGBA_1010102) {
            if (isMonochrome) {
                const size_t tmpSize = mWidth;
                const bool needFill = tmpSize > mTmpFrameBufferSize;
                if (!allocTmpFrameBuffer(tmpSize)) {
                    ALOGE("Error allocating temp conversion buffer (%zu bytes)", tmpSize);
                    setError(work, C2_NO_MEMORY);
                    return false;
                }
                srcU = srcV = mTmpFrameBuffer.get();
                srcUStride = srcVStride = 0;
                if (needFill) {
                    std::fill_n(mTmpFrameBuffer.get(), tmpSize, 512);
                }
            }
            convertPlanar16ToY410OrRGBA1010102(
                    dstY, srcY, srcU, srcV, srcYStride, srcUStride, srcVStride,
                    dstYStride, mWidth, mHeight,
                    std::static_pointer_cast<const C2ColorAspectsStruct>(codedColorAspects),
                    convFormat);
        } else if (format == HAL_PIXEL_FORMAT_YCBCR_P010) {
            dstYStride /= 2;
            dstUStride /= 2;
            dstVStride /= 2;
            size_t tmpSize = 0;
            if ((img.p.layout == DAV1D_PIXEL_LAYOUT_I444) ||
                (img.p.layout == DAV1D_PIXEL_LAYOUT_I422)) {
                tmpSize = dstYStride * mHeight + dstUStride * align(mHeight, 2);
                if (!allocTmpFrameBuffer(tmpSize)) {
                    ALOGE("Error allocating temp conversion buffer (%zu bytes)", tmpSize);
                    setError(work, C2_NO_MEMORY);
                    return false;
                }
            }
            convertPlanar16ToP010((uint16_t*)dstY, (uint16_t*)dstU, srcY, srcU, srcV, srcYStride,
                                  srcUStride, srcVStride, dstYStride, dstUStride, dstVStride,
                                  mWidth, mHeight, isMonochrome, convFormat, mTmpFrameBuffer.get(),
                                  tmpSize);
        } else {
            size_t tmpSize = 0;
            if (img.p.layout == DAV1D_PIXEL_LAYOUT_I444) {
                tmpSize = dstYStride * mHeight + dstUStride * align(mHeight, 2);
                if (!allocTmpFrameBuffer(tmpSize)) {
                    ALOGE("Error allocating temp conversion buffer (%zu bytes)", tmpSize);
                    setError(work, C2_NO_MEMORY);
                    return false;
                }
            }
            convertPlanar16ToYV12(dstY, dstU, dstV, srcY, srcU, srcV, srcYStride, srcUStride,
                                  srcVStride, dstYStride, dstUStride, dstVStride, mWidth, mHeight,
                                  isMonochrome, convFormat, mTmpFrameBuffer.get(), tmpSize);
        }

        // if(mOutputBufferIndex % 100 == 0)
        ALOGV("output a 10bit picture %dx%d from dav1d "
              "(mInputBufferIndex=%d,mOutputBufferIndex=%d,format=%d).",
              mWidth, mHeight, mInputBufferIndex, mOutputBufferIndex, format);

        // Dump the output buffer if dumping is enabled (debug only).
#ifdef FILE_DUMP_ENABLE
        mC2SoftDav1dDump.dumpOutput<uint16_t>(srcY, srcU, srcV, srcYStride, srcUStride, srcVStride,
                                              mWidth, mHeight);
#endif
    } else {
        const uint8_t* srcY = (const uint8_t*)img.data[0];
        const uint8_t* srcU = (const uint8_t*)img.data[1];
        const uint8_t* srcV = (const uint8_t*)img.data[2];

        size_t srcYStride = img.stride[0];
        size_t srcUStride = img.stride[1];
        size_t srcVStride = img.stride[1];

        // if(mOutputBufferIndex % 100 == 0)
        ALOGV("output a 8bit picture %dx%d from dav1d "
              "(mInputBufferIndex=%d,mOutputBufferIndex=%d,format=%d).",
              mWidth, mHeight, mInputBufferIndex, mOutputBufferIndex, format);

        // Dump the output buffer is dumping is enabled (debug only)
#ifdef FILE_DUMP_ENABLE
        mC2SoftDav1dDump.dumpOutput<uint8_t>(srcY, srcU, srcV, srcYStride, srcUStride, srcVStride,
                                             mWidth, mHeight);
#endif
        convertPlanar8ToYV12(dstY, dstU, dstV, srcY, srcU, srcV, srcYStride, srcUStride, srcVStride,
                             dstYStride, dstUStride, dstVStride, mWidth, mHeight, isMonochrome,
                             convFormat);
    }

    finishWork(out_frameIndex, work, std::move(block), img);
    dav1d_picture_unref(&img);
    block = nullptr;
    return true;
}

c2_status_t C2SoftDav1dDec::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 C2SoftDav1dDec::drain(uint32_t drainMode, const std::shared_ptr<C2BlockPool>& pool) {
    return drainInternal(drainMode, pool, nullptr);
}

class C2SoftDav1dFactory : public C2ComponentFactory {
  public:
    C2SoftDav1dFactory()
        : 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 C2SoftDav1dDec(COMPONENT_NAME, id,
                                   std::make_shared<C2SoftDav1dDec::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<C2SoftDav1dDec::IntfImpl>(
                        COMPONENT_NAME, id, std::make_shared<C2SoftDav1dDec::IntfImpl>(mHelper)),
                deleter);
        return C2_OK;
    }

    virtual ~C2SoftDav1dFactory() 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::C2SoftDav1dFactory();
}

__attribute__((cfi_canonical_jump_table)) extern "C" void DestroyCodec2Factory(
        ::C2ComponentFactory* factory) {
    ALOGV("in %s", __func__);
    delete factory;
}