/*
 * thumbnails.cpp - A service to produce thumbnails for algorithms
 *
 *  Copyright (c) 2021 Rockchip Electronics Co., Ltd.
 *
 * 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.
 *
 */
#include "thumbnails.h"

#include <algorithm>
#include <fstream>
#include <iostream>
#include <mutex>
#include <unordered_map>
#include <vector>

#include "image_processor.h"
#include "xcore/base/xcam_buffer.h"
#include "xcore/base/xcam_log.h"
#include "xcore/drm_buffer.h"
#include "xcore/drm_device.h"
#include "xcore/video_buffer.h"

namespace RkCam {

using namespace XCam;
using namespace RkCam::thumbnails;

namespace thumbnails {
// clang-format off
// Any bits of this mask is '1' means
// the image stream has to be get from SP device
#define RKISP20_MIPITX_S_NODE_MASK \
    RKAIQ_PIPELINE_NODE_FAKE_SHORT

#define RKISP20_MIPITX_M_NODE_MASK \
    RKAIQ_PIPELINE_NODE_FAKE_MIDDLE

#define RKISP20_MIPITX_L_NODE_MASK \
    RKAIQ_PIPELINE_NODE_FAKE_LONG

#define RKISP20_SP_RAW_NODE_MASK \
    RKAIQ_PIPELINE_NODE_FAKE_SHORT | \
    RKAIQ_PIPELINE_NODE_FAKE_MIDDLE | \
    RKAIQ_PIPELINE_NODE_FAKE_LONG

#define RKISP20_SP_NODE_MASK \
    RKISP20_SP_RAW_NODE_MASK | \
    RKAIQ_PIPELINE_NODE_BLC | \
    RKAIQ_PIPELINE_NODE_DPCC | \
    RKAIQ_PIPELINE_NODE_HDRMERGE | \
    RKAIQ_PIPELINE_NODE_RAWNR | \
    RKAIQ_PIPELINE_NODE_LSC | \
    RKAIQ_PIPELINE_NODE_HDRTMO | \
    RKAIQ_PIPELINE_NODE_GIC | \
    RKAIQ_PIPELINE_NODE_DEBAYER | \
    RKAIQ_PIPELINE_NODE_CCM | \
    RKAIQ_PIPELINE_NODE_GAMMA | \
    RKAIQ_PIPELINE_NODE_WDR | \
    RKAIQ_PIPELINE_NODE_DEHAZE | \
    RKAIQ_PIPELINE_NODE_3DLUT | \
    RKAIQ_PIPELINE_NODE_LDCH | \
    RKAIQ_PIPELINE_NODE_CSM | \
    RKAIQ_PIPELINE_NODE_CP | \
    RKAIQ_PIPELINE_NODE_IE

#define RKISP20_TNR_NODE_MASK \
    RKISP20_SP_NODE_MASK | \
    RKAIQ_PIPELINE_NODE_TNR

#define RKISP20_NR_NODE_MASK \
    RKISP20_TNR_NODE_MASK | \
    RKAIQ_PIPELINE_NODE_UVNR | \
    RKAIQ_PIPELINE_NODE_YNR | \
    RKAIQ_PIPELINE_NODE_SHARP | \
    RKAIQ_PIPELINE_NODE_ORB

#define RKISP20_FEC_NODE_MASK \
    RKISP20_NR_NODE_MASK | \
    RKAIQ_PIPELINE_NODE_FEC
// clang-format on

const std::map<rkaiq_stream_type_t, uint64_t> Isp20DevToMaskMap = {
    {RKISP20_STREAM_MIPITX_S, RKISP20_MIPITX_S_NODE_MASK},
    {RKISP20_STREAM_MIPITX_M, RKISP20_MIPITX_M_NODE_MASK},
    {RKISP20_STREAM_MIPITX_L, RKISP20_MIPITX_L_NODE_MASK},
    {RKISP20_STREAM_SP_RAW, RKISP20_SP_RAW_NODE_MASK},
    {RKISP20_STREAM_SP, RKISP20_SP_NODE_MASK},
    {RKISP20_STREAM_NR, RKISP20_NR_NODE_MASK},
    {RKISP20_STREAM_FEC, RKISP20_FEC_NODE_MASK}};

const std::map<rkaiq_stream_type_t, uint64_t> Isp21DevToMaskMap = {
    {RKISP20_STREAM_MIPITX_S, RKISP20_MIPITX_S_NODE_MASK},
    {RKISP20_STREAM_MIPITX_M, RKISP20_MIPITX_M_NODE_MASK},
    {RKISP20_STREAM_MIPITX_L, RKISP20_MIPITX_L_NODE_MASK},
    {RKISP20_STREAM_SP_RAW, RKISP20_SP_RAW_NODE_MASK},
    {RKISP20_STREAM_SP, RKISP20_SP_NODE_MASK}};

bool ConfigLess(const rkaiq_thumbnails_config_t& lhs, const rkaiq_thumbnails_config_t& rhs) {
    if (lhs.width_intfactor <= rhs.width_intfactor &&
        lhs.height_intfactor <= rhs.height_intfactor) {
        return true;
    } else if (lhs.width_intfactor > rhs.width_intfactor &&
               lhs.height_intfactor > rhs.height_intfactor) {
        return false;
    } else {
        // Unsupported
        XCAM_ASSERT(0);
        return true;
    }
}

bool ConfigEqual(const rkaiq_thumbnails_config_t& lhs, const rkaiq_thumbnails_config_t& rhs) {
    return (lhs.width_intfactor == rhs.width_intfactor &&
            lhs.height_intfactor == rhs.height_intfactor &&
            !memcmp(lhs.format, rhs.format, sizeof(lhs.format)) &&
            lhs.after_nodes == rhs.after_nodes);
}

struct RefCountedVideoBuffer : public std::enable_shared_from_this<RefCountedVideoBuffer> {
    RefCountedVideoBuffer() = delete;

    explicit RefCountedVideoBuffer(XCamVideoBuffer* buffer, bool takeRef = true) {
        XCAM_ASSERT(buffer != nullptr);
        this->buffer = buffer;
        this->buffer->ref(this->buffer);
        auto cnt = this->buffer->unref(this->buffer);
        if (takeRef) {
            this->buffer->ref(this->buffer);
            cnt++;
        }
        LOGV_ANALYZER("%p ref count %d", this->buffer, cnt);
    }

    RefCountedVideoBuffer(const RefCountedVideoBuffer& other) {
        if (this->buffer != other.buffer) {
            this->buffer->unref(this->buffer);
            this->buffer = other.buffer;
            this->buffer->ref(this->buffer);
        }
    }

    RefCountedVideoBuffer& operator=(const RefCountedVideoBuffer& other) {
        if (this->buffer != other.buffer) {
            this->buffer->unref(this->buffer);
            this->buffer = other.buffer;
            this->buffer->ref(this->buffer);
        }

        return *this;
    }

    RefCountedVideoBuffer(RefCountedVideoBuffer&& other) {
        if (this->buffer != other.buffer) {
            this->buffer->unref(this->buffer);
            this->buffer = other.buffer;
            // this->buffer->ref(this->buffer);
            // other.buffer->unref(other.buffer);
            other.buffer = nullptr;
        }
    }

    RefCountedVideoBuffer& operator=(RefCountedVideoBuffer&& other) {
        if (this->buffer != other.buffer) {
            this->buffer->unref(this->buffer);
            this->buffer = other.buffer;
            // this->buffer->ref(this->buffer);
            // other.buffer->unref(other.buffer);
            other.buffer = nullptr;
        }

        return *this;
    }

    ~RefCountedVideoBuffer() {
        auto cnt = this->buffer->unref(this->buffer);
        LOGV_ANALYZER("%p unref count %d", this->buffer, cnt);
    }

    void importBuffer(XCamVideoBuffer* buffer) {
        if (this->buffer == buffer) {
            return;
        }
        this->buffer->unref(this->buffer);
        this->buffer = buffer;
        this->buffer->ref(this->buffer);
    }

    XCamVideoBuffer* exportBuffer() {
        this->buffer->ref(this->buffer);
        return this->buffer;
    }

    friend bool operator<(const RefCountedVideoBuffer& lhs, const RefCountedVideoBuffer& rhs) {
        return (lhs.buffer->info.width * lhs.buffer->info.height) <
               (rhs.buffer->info.width * rhs.buffer->info.height);
    }

    friend bool operator>(const RefCountedVideoBuffer& lhs, const RefCountedVideoBuffer& rhs) {
        return (lhs.buffer->info.width * lhs.buffer->info.height) >
               (rhs.buffer->info.width * rhs.buffer->info.height);
    }

    friend bool operator<=(const RefCountedVideoBuffer& lhs, const RefCountedVideoBuffer& rhs) {
        return !(lhs > rhs);
    }

    friend bool operator>=(const RefCountedVideoBuffer& lhs, const RefCountedVideoBuffer& rhs) {
        return !(lhs < rhs);
    }

    friend bool operator!=(const RefCountedVideoBuffer& lhs, const RefCountedVideoBuffer& rhs) {
        return (lhs < rhs) || (lhs > rhs);
    }

    friend bool operator==(const RefCountedVideoBuffer& lhs, const RefCountedVideoBuffer& rhs) {
        return !(lhs < rhs) && !(lhs > rhs);
    }

    static bool IsValid(XCamVideoBuffer* buffer) {
        // TODO(Cody): buffer should support mem type
        return buffer->get_fd(buffer) >= 0;
    }

    XCamVideoBuffer* buffer;
};

struct ScalerParam {
    std::shared_ptr<RefCountedVideoBuffer> src;
    std::pair<rkaiq_thumbnails_config_t, std::shared_ptr<RefCountedVideoBuffer>> thumbnail;
};

class ThumbnailsConfig {
 public:
    ThumbnailsConfig()                        = default;
    ~ThumbnailsConfig()                       = default;
    ThumbnailsConfig(const ThumbnailsConfig&) = delete;
    ThumbnailsConfig& operator=(const ThumbnailsConfig&) = delete;

    bool ParseRequests(const CalibDbV2_Thumbnails_Param_t* configs);
    void DumpConfig(const rkaiq_thumbnails_config_t& config);
    void DumpConfigs();
    std::vector<rkaiq_stream_type_t> GetEnabledStream();
    const std::vector<rkaiq_thumbnails_config_t> GetStreamConfig(
        const rkaiq_stream_type_t type) const;

 private:
    rkaiq_stream_type_t PipeNodesToStreamType(const rkaiq_thumbnails_config_t& config);
    void GetStreamNodeMask(const rkaiq_stream_type_t type, uint64_t& after_nodes);

    std::unordered_map<int, std::vector<rkaiq_thumbnails_config_t>> stream_configs_;
};

class ThumbnailsBufferManager {
 public:
    ThumbnailsBufferManager(const std::shared_ptr<ThumbnailsConfig>& config);
    ~ThumbnailsBufferManager() = default;

    XCamReturn InitializeBufferPools(const rkaiq_stream_type_t& type,
                                     const XCamVideoBufferInfo& fullImageInfo);
    void ReleasePools();
    XCamVideoBuffer* GetBufferByConfig(const rkaiq_stream_type_t type,
                                       const rkaiq_thumbnails_config_t& config);

 private:
    std::mutex mutex_;
    std::shared_ptr<ThumbnailsConfig> config_;
    std::vector<std::pair<rkaiq_thumbnails_config_t, SmartPtr<XCam::BufferPool>>> pools_;
};

class ScalerTask final : public XCam::ServiceTask<ScalerParam> {
 public:
    ScalerTask() = delete;
    explicit ScalerTask(std::unique_ptr<ImageProcessor> proc);
    ~ScalerTask()                 = default;
    ScalerTask(const ScalerTask&) = delete;
    const ScalerTask& operator=(const ScalerTask&) = delete;

    XCam::TaskResult operator()(XCam::ServiceParam<ScalerParam>& p);

 private:
    std::unique_ptr<ImageProcessor> proc_;
};

void ThumbnailsConfig::GetStreamNodeMask(const rkaiq_stream_type_t type, uint64_t& after_nodes) {
    after_nodes = Isp20DevToMaskMap.at(type);
}

rkaiq_stream_type_t ThumbnailsConfig::PipeNodesToStreamType(
    const rkaiq_thumbnails_config_t& config) {
    rkaiq_stream_type_t type = RKISP_STREAM_NONE;

    for (auto it : Isp20DevToMaskMap) {
        LOGD_ANALYZER("type %d, mask %" PRIx64 "", it.first, it.second);
    }

    for (auto it : Isp20DevToMaskMap) {
        if ((config.after_nodes & it.second) &&
            (config.before_node != (config.before_node & it.second))) {
            type = it.first;
            LOGI_ANALYZER("owner %d matched type %d, before %" PRIx64 " after %" PRIx64 "",
                          config.owner_cookies, type, config.before_node, config.after_nodes);
            break;
        } else {
            continue;
        }
    }

    return type;
}

bool ThumbnailsConfig::ParseRequests(const CalibDbV2_Thumbnails_Param_t* db) {
    XCAM_ASSERT(db != nullptr);

    LOGD_ANALYZER("Dump configs db: ");
    for (uint32_t j = 0; j < db->thumbnail_configs_len; j++) {
        auto config = db->thumbnail_configs[j];
        DumpConfig(config);
    }

    for (uint32_t j = 0; j < db->thumbnail_configs_len; j++) {
        auto config = db->thumbnail_configs[j];
        auto type   = PipeNodesToStreamType(config);
        if (type == RKISP_STREAM_NONE) {
            LOGD_ANALYZER("Cannot find suitable stream for %d nodes after %" PRIx64 " before %" PRIx64 "",
                 config.owner_cookies, config.after_nodes, config.before_node);
            continue;
        }
        if (!stream_configs_.count(static_cast<int>(type))) {
            stream_configs_.emplace(type, std::vector<rkaiq_thumbnails_config_t>());
        }
        config.stream_type = type;
        GetStreamNodeMask(type, config.after_nodes);
        stream_configs_.at(type).push_back(config);
    }

    for (auto& stream_config : stream_configs_) {
        auto& configs = stream_config.second;
        std::sort(configs.begin(), configs.end(), ConfigLess);
        configs.erase(std::unique(configs.begin(), configs.end(), ConfigEqual), configs.end());
    }

    return true;
}

void ThumbnailsConfig::DumpConfig(const rkaiq_thumbnails_config_t& config) {
    LOGD_ANALYZER("type: %u, before: %" PRIx64 ", after: %" PRIx64
                  ", format: %c%c%c%c, w: 1/%u, h: 1/%u, count: %d",
                  config.stream_type, config.before_node, config.after_nodes, config.format[0],
                  config.format[1], config.format[2], config.format[3], config.width_intfactor,
                  config.height_intfactor, config.buffer_count);
}

void ThumbnailsConfig::DumpConfigs() {
    for (auto& stream_config : stream_configs_) {
        LOGD_ANALYZER("Dump stream %d configs:", stream_config.first);
        for (auto config : stream_config.second) {
            LOGD_ANALYZER("type: %u, before: %" PRIx64 ", after: %" PRIx64
                          ", format: %c%c%c%c, w: 1/%u, h: 1/%u, count: %d",
                          config.stream_type, config.before_node, config.after_nodes,
                          config.format[0], config.format[1], config.format[2], config.format[3],
                          config.width_intfactor, config.height_intfactor, config.buffer_count);
        }
    }
}

std::vector<rkaiq_stream_type_t> ThumbnailsConfig::GetEnabledStream() {
    std::vector<rkaiq_stream_type_t> types;

    for (auto stream_config : stream_configs_) {
        types.push_back(static_cast<rkaiq_stream_type_t>(stream_config.first));
    }

    return types;
}

const std::vector<rkaiq_thumbnails_config_t> ThumbnailsConfig::GetStreamConfig(
    const rkaiq_stream_type_t type) const {
    auto config_iter = stream_configs_.find(type);
    if (config_iter != stream_configs_.end()) {
        return config_iter->second;
    } else {
        return {};
    }
}

ThumbnailsBufferManager::ThumbnailsBufferManager(const std::shared_ptr<ThumbnailsConfig>& config)
    : config_(config) {}

XCamReturn ThumbnailsBufferManager::InitializeBufferPools(
    const rkaiq_stream_type_t& type, const XCamVideoBufferInfo& fullImageInfo) {
    std::unique_lock<std::mutex> lock(mutex_);
#if HAS_LIBDRM
    if (!DrmDevice::Available()) {
        LOGE_ANALYZER("drm device is not available!");
        return XCAM_RETURN_ERROR_FAILED;
    }

    auto dev = std::make_shared<DrmDevice>();
    if (dev == nullptr) {
        LOGE_ANALYZER("Failed get drm device");
        return XCAM_RETURN_ERROR_MEM;
    }

    for (auto& config : config_->GetStreamConfig(type)) {
        VideoBufferInfo info;
        info.width          = fullImageInfo.width / config.width_intfactor;
        info.height         = fullImageInfo.height / config.height_intfactor;
#if 0
        info.width          = XCAM_ALIGN_UP(info.width, 2);
        info.height         = XCAM_ALIGN_UP(info.height, 2);
        info.aligned_width  = XCAM_ALIGN_UP(info.width, 16);
        info.aligned_height = XCAM_ALIGN_UP(info.height, 4);
#endif
        info.format =
            rk_fmt_fourcc(config.format[0], config.format[1], config.format[2], config.format[3]);
        info.init(info.format, info.width, info.height, info.aligned_width, info.aligned_height);
        LOGE_ANALYZER("Initialize thumb: wxh: %dx%d, %dx%d", info.width, info.height,
                      info.aligned_width, info.aligned_height);
        auto pool = SmartPtr<DrmBufferPool>(new DrmBufferPool(dev));
        pool->set_video_info(info);
        pool->reserve(config.buffer_count);
        pools_.push_back(std::make_pair(config, std::move(pool)));
    }

    return XCAM_RETURN_NO_ERROR;
#else
    return XCAM_RETURN_ERROR_MEM;
#endif
}

void ThumbnailsBufferManager::ReleasePools() {
    std::unique_lock<std::mutex> lock(mutex_);
    pools_.clear();
}

XCamVideoBuffer* ThumbnailsBufferManager::GetBufferByConfig(
    const rkaiq_stream_type_t type, const rkaiq_thumbnails_config_t& config) {
    std::unique_lock<std::mutex> lock(mutex_);
    auto poolIt = std::find_if(
        pools_.begin(), pools_.end(),
        [&type, &config](const std::pair<rkaiq_thumbnails_config_t, SmartPtr<BufferPool>>& pool) {
            return ((type == pool.first.stream_type) && ConfigEqual(config, pool.first));
        });
    if (poolIt != pools_.end()) {
        auto& pool = poolIt->second;
        LOGD_ANALYZER("thumbnail pool size %d", pool->get_free_buffer_size());
        if (pool->has_free_buffers()) {
            auto buffer = pool->get_buffer();
            return convert_to_external_buffer(buffer);
        }
    }
    LOGE_ANALYZER("thumbnail cannot find available buffer pool");
    return nullptr;
}

template <typename To, typename From>
To convert(From&);

template <>
img_buffer_t convert(std::shared_ptr<RefCountedVideoBuffer>& dma) {
    auto& info       = dma->buffer->info;
    img_buffer_t buf = {
        .width   = (int)info.width,
        .height  = (int)info.height,
        .wstride = (int)info.aligned_width,
        .hstride = (int)info.aligned_height,
    };

    buf.fd     = dma->buffer->get_fd(dma->buffer);
    buf.format = static_cast<rk_aiq_format_t>(info.format);

    return buf;
}

ScalerTask::ScalerTask(std::unique_ptr<ImageProcessor> proc) : proc_(std::move(proc)) {}

TaskResult ScalerTask::operator()(ServiceParam<ScalerParam>& p) {
    auto& full       = p.payload->src;
    auto& scaled     = p.payload->thumbnail.second;
    auto& config     = p.payload->thumbnail.first;
    img_buffer_t src = convert<img_buffer_t>(full);
    img_buffer_t dst = convert<img_buffer_t>(scaled);
    auto ret         = proc_->resize(src, dst, 0, 0);
    LOGD_ANALYZER("thumbnail processed id:%d type: %d 1/%dx1/%d %dx%d->%dx%d, result: %d",
                  p.unique_id, config.stream_type, config.width_intfactor, config.height_intfactor,
                  full->buffer->info.width, full->buffer->info.height, scaled->buffer->info.width,
                  scaled->buffer->info.height, ret);
    return ret == XCAM_RETURN_NO_ERROR ? TaskResult::kSuccess : TaskResult::kFailed;
}

};  // namespace thumbnails

ThumbnailsService::ThumbnailsService() : config_(new ThumbnailsConfig()), stopped_(true) {}

ThumbnailsService::~ThumbnailsService() = default;

XCamReturn ThumbnailsService::Prepare(const CalibDbV2_Thumbnails_Param_t* calib) {
    config_->ParseRequests(calib);
    config_->DumpConfigs();

    auto types = config_->GetEnabledStream();
    if (types.size() > 0) {
        bufferManager_ =
            std::unique_ptr<ThumbnailsBufferManager>(new ThumbnailsBufferManager(config_));
        for (auto t : types) {
            std::unique_ptr<ImageProcessor> proc(new ImageProcessor());
            proc->set_operator("rga");
            auto scaler = std::unique_ptr<ScalerService>(new ScalerService(
                std::unique_ptr<ScalerTask>(new ScalerTask(std::move(proc))), false, 0));
            scalers_[static_cast<int>(t)] = std::move(scaler);
            LOGV_ANALYZER("Created scaler for type %d", t);
        }
    } else {
        LOGW_ANALYZER("thumbnail disabled");
        return XCAM_RETURN_BYPASS;
    }

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn ThumbnailsService::Start() {
    // TODO(Cody): Add get full stream info from HWI
    // Use buffer manager to initialize buffer pool
    if (!stopped_) {
        LOGW_ANALYZER("thumbnail already started");
        return XCAM_RETURN_ERROR_PARAM;
    }
    for (auto t : config_->GetEnabledStream()) {
        XCamVideoBufferInfo fullImageInfo = {
            .format         = RK_PIX_FMT_NV12,
            .width          = 2688,
            .height         = 1520,
            .aligned_width  = 2688,
            .aligned_height = 1520,
        };
        bufferManager_->InitializeBufferPools(t, fullImageInfo);
        LOGD_ANALYZER("Initialize buffer for type %d", t);
    }

    for (auto& scaler : scalers_) {
        scaler.second->start();
    }

    stopped_ = false;
    LOGV_ANALYZER("thumbnail started");

    return XCAM_RETURN_NO_ERROR;
}

XCamReturn ThumbnailsService::Stop() {
    if (stopped_) {
        LOGW_ANALYZER("thumbnail stopped");
        return XCAM_RETURN_ERROR_PARAM;
    }

    stopped_ = true;

    for (auto& scaler : scalers_) {
        scaler.second->stop();
    }

    bufferManager_->ReleasePools();

    LOGV_ANALYZER("thumbnail stopped");
    return XCAM_RETURN_NO_ERROR;
}

void ThumbnailsService::SetResultCallback(const ResultCallback& cb) { callback_ = cb; }

void ThumbnailsService::OnFrameEvent(const rkaiq_image_source_t& source) {
    if (stopped_ || !scalers_.count(source.src_type)) {
        LOGE_ANALYZER("Unsuported image source type %d or stopped", source.src_type);
        return;
    }

#if 1
    if (source.frame_id == 1) {
        std::string path = "/data/source_";
        path.append(std::to_string(source.frame_id));
        path.append("_");
        path.append(std::to_string(source.image_source->info.width));
        path.append(std::to_string(source.image_source->info.height));
        path.append(".yuv");
        std::ofstream ofs(path, std::ios::binary);
        char* ptr   = reinterpret_cast<char*>(source.image_source->map(source.image_source));
        size_t size = source.image_source->info.size;
        ofs.write(ptr, size);
    }
#endif

    if (RefCountedVideoBuffer::IsValid(source.image_source)) {
        LOGD_ANALYZER(">>>>>> source type %d , w %d h %d", source.src_type, source.image_source->info.width,
             source.image_source->info.height);
        auto src = std::make_shared<RefCountedVideoBuffer>(source.image_source);
        auto& scaler  = scalers_.at(source.src_type);
        auto& configs = config_->GetStreamConfig(source.src_type);
        for (auto& config : configs) {
            auto* buf = bufferManager_->GetBufferByConfig(source.src_type, config);
            if (buf) {
                auto dst = std::make_shared<RefCountedVideoBuffer>(buf, false);
                if (*(src) <= *(dst)) {
                    LOGW_ANALYZER("thumbnail src %dx%d is smaller than or equal to dst %dx%d",
                         src->buffer->info.width, src->buffer->info.height, dst->buffer->info.width,
                         dst->buffer->info.height);
                    continue;
                }
                ServiceParam<ScalerParam> param;
                param.state              = XCam::ParamState::kAllocated;
                param.unique_id          = source.frame_id;
                param.payload            = std::make_shared<ScalerParam>();
                param.payload->src       = src;
                src                      = dst;
                param.payload->thumbnail = std::make_pair(config, dst);
                scaler->enqueue(param);
                LOGI_ANALYZER("thumbnail enqueue id %d type %d 1/%d x 1/%d to scaler",
                              source.frame_id, source.src_type, config.width_intfactor,
                              config.height_intfactor);
            } else {
                LOGE_ANALYZER("Cannot get buffer for config : ");
                config_->DumpConfig(config);
            }
        }
    }

    for (auto& s : scalers_) {
        while (true) {
            auto p = s.second->dequeue();
            if (p.state == ParamState::kProcessedSuccess) {
                auto& config = p.payload->thumbnail.first;
                auto& buf    = p.payload->thumbnail.second;
                LOGD_ANALYZER("thumbnail dequeue id %d type %d 1/%d x 1/%d from scaler",
                              p.unique_id, config.stream_type, config.width_intfactor,
                              config.height_intfactor);
                rkaiq_thumbnails_t result;
                result.config   = config;
                result.frame_id = p.unique_id;
                result.buffer   = buf->exportBuffer();
                callback_(result);
                result.buffer->unref(result.buffer);
            } else {
                break;
            }
        }
    }
}

};  // namespace RkCam