/*
 * cac_algo_adaptor.h
 *
 *  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.
 *
 * Author: Cody Xie <cody.xie@rock-chips.com>
 */
#include "cac_adaptor.h"

#include <fstream>
#include <iostream>

#include "rk_aiq_types_priv.h"
#include "xcam_log.h"
#include <fcntl.h> 

#define __STDC_FORMAT_MACROS
#include <inttypes.h>

using namespace XCam;

namespace RkCam {

#define BITS_PER_BYTE  8
#define BYTES_PER_WORD 4
#define BITS_PER_WORD  (BITS_PER_BYTE * BYTES_PER_WORD)

#define INTERP_CAC(x0, x1, ratio) ((ratio) * ((x1) - (x0)) + (x0))

#define DIV_ROUND_UP(n, d) (((n) + (d)-1) / (d))

enum class LutBufferState {
    kInitial   = MESH_BUF_INIT,
    kWait2Chip = MESH_BUF_WAIT2CHIP,
    kChipInUse = MESH_BUF_CHIPINUSE,
};

struct LutBufferConfig {
    bool IsBigMode;
    uint32_t Width;
    uint32_t Height;
    uint32_t LutHCount;
    uint32_t LutVCount;
    uint8_t ScaleFactor;
    uint16_t PsfCfgCount;
};

static const uint32_t IspBigModeWidthLimit = 2688;
static const uint32_t IspBigModeSizeLimit  = IspBigModeWidthLimit * 1536;
static const uint8_t CacScaleFactorDefault = 64;
static const uint8_t CacScaleFactorBigMode = 128;
static const uint8_t CacStrengthDistance   = 128;
static const uint8_t CacPsfKernelSize      = 7 * 5;
static const uint8_t CacPsfKernelWordSizeInMemory =
    DIV_ROUND_UP((CacPsfKernelSize - 1) * BITS_PER_BYTE, BITS_PER_WORD);
static const uint8_t CacChannelCount   = 2;
static const uint32_t CacPsfCountLimit = 1632;

static const uint8_t CacPsfBufferCount = ISP2X_MESH_BUF_NUM;

static inline bool IsIspBigMode(uint32_t width, uint32_t height, bool is_multi_sensor) {
    if (is_multi_sensor || width > IspBigModeWidthLimit || width * height > IspBigModeSizeLimit)
        return true;
    else
        return false;
};

/**
 * cac_wsize=bigmode_en ? (pic_width+126)>>7 : (pic_width+62)>>6;
 * cac_hsize=bigmode_en ? (pic_height+126)>>7 : (pic_height+62)>>6;
 * lut_h_wsize = cac_wsize*9
 * lut_v_size = cac_hsize*2
 */
static inline void CalcCacLutConfig(uint32_t width, uint32_t height, bool is_big_mode,
                                    LutBufferConfig& config) {
    config.Width     = width;
    config.Height    = height;
    config.IsBigMode = is_big_mode;
    if (config.IsBigMode) {
        config.ScaleFactor = CacScaleFactorBigMode;
    } else {
        config.ScaleFactor = CacScaleFactorDefault;
    }
    /**
     * CAC only processes R & B channels, that means for R or R channels,
     * which have only half size of full picture, only need to div round up by 32(scale==64) or
     * 64(scale==128). For calculate convinient, use full picture size to calculate
     */
    config.LutHCount   = is_big_mode ? (width + 126) >> 7 : (width + 62) >> 6;
    config.LutVCount   = is_big_mode ? (height + 126) >> 7 : (height + 62) >> 6;
    config.PsfCfgCount = config.LutHCount * config.LutVCount;
    XCAM_ASSERT(config.PsfCfgCount <= CacPsfCountLimit);
    /**
     * CAC stores one PSF point's kernel in 9 words, one kernel size is 8 bytes.
     * (8bytes*8bits/byte + 32 - 1) / 32bits/word = 9 words.
     */
}

struct LutBuffer {
    LutBuffer() = delete;
    LutBuffer(const LutBufferConfig& config)
        : State(LutBufferState::kInitial), Config(config), Fd(-1), Size(0), Addr(0) {}
    LutBuffer(const LutBufferConfig& config, const rk_aiq_cac_share_mem_info_t* mem_info)
        : Config(config) {
        State = static_cast<LutBufferState>(*mem_info->state);
        Fd    = mem_info->fd;
        Addr  = mem_info->addr;
        Size  = mem_info->size;
    }
    LutBuffer(const LutBuffer&) = delete;
    LutBuffer& operator=(const LutBuffer&) = delete;

    LutBufferState State;
    LutBufferConfig Config;
    int Fd;
    int Size;
    void* Addr;
};

class LutBufferManager {
 public:
    LutBufferManager() = delete;
    LutBufferManager(const LutBufferConfig& config, const isp_drv_share_mem_ops_t* mem_ops)
        : config_(config), mem_ops_(mem_ops) {}
    LutBufferManager(const LutBufferManager&) = delete;
    LutBufferManager& operator=(const LutBufferManager&) = delete;
    ~LutBufferManager() {
        // TODO(Cody)
        ReleaseHwBuffers(0);
        ReleaseHwBuffers(1);
    }

    void ImportHwBuffers(uint8_t isp_id) {
        assert(mem_ops_ != nullptr);
        rk_aiq_share_mem_config_t hw_config_;
        hw_config_.mem_type           = MEM_TYPE_CAC;
        hw_config_.alloc_param.width  = config_.Width;
        hw_config_.alloc_param.height = config_.Height;

        mem_ops_->alloc_mem(isp_id, (void*)mem_ops_, &hw_config_, &mem_ctx_);
    }

    void ReleaseHwBuffers(uint8_t isp_id) {
        if (mem_ctx_ && mem_ops_) mem_ops_->release_mem(isp_id, mem_ctx_);
    }

    LutBuffer* GetFreeHwBuffer(uint8_t isp_id) {
        if (mem_ops_ == nullptr || mem_ctx_ == nullptr) {
            return nullptr;
        }

        const auto* mem_info = reinterpret_cast<rk_aiq_cac_share_mem_info_t*>(
            mem_ops_->get_free_item(isp_id, mem_ctx_));
        if (mem_info != nullptr) {
            return new LutBuffer(config_, mem_info);
        }
        return nullptr;
    }

 private:
    const isp_drv_share_mem_ops_t* mem_ops_;
    void* mem_ctx_;
    LutBufferConfig config_;
};

CacAlgoAdaptor::~CacAlgoAdaptor() {
    if (current_lut_[0]) delete current_lut_[0];
    if (current_lut_[1]) delete current_lut_[1];
    if (lut_manger_ != nullptr) delete lut_manger_;
}

XCamReturn CacAlgoAdaptor::Config(const AlgoCtxInstanceCfg* config,
                                  const CalibDbV2_Cac_t* calib) {
    LOGD_ACAC("%s : Enter", __func__);
    enable_ = calib ? calib->SettingPara.enable : false;
    calib_  = calib;
    if (!enable_) {
        return XCAM_RETURN_BYPASS;
    }

    if (access(calib->SettingPara.psf_path, O_RDONLY)) {
        LOGE_ACAC("The PSF file path %s cannot be accessed", calib->SettingPara.psf_path);
        valid_ = false;
        return XCAM_RETURN_ERROR_FILE;
    }
    valid_ = true;
    return XCAM_RETURN_NO_ERROR;
}

XCamReturn CacAlgoAdaptor::Prepare(const RkAiqAlgoConfigAcac* config) {
    LutBufferConfig lut_config;
    LutBufferConfig full_lut_config;
    uint32_t width   = config->width;
    uint32_t height  = config->height;
    bool is_big_mode = IsIspBigMode(width, height, config->is_multi_sensor);

    LOGD_ACAC("%s : Enter", __func__);

    if (!enable_ || !valid_) {
        return XCAM_RETURN_BYPASS;
    }

    config_ = config;
    if (config->is_multi_isp) {
        CalcCacLutConfig(width, height, is_big_mode, full_lut_config);
        width = width / 2 + config->multi_isp_extended_pixel;
        CalcCacLutConfig(width, height, is_big_mode, lut_config);
    } else {
        CalcCacLutConfig(width, height, is_big_mode, lut_config);
    }
    lut_manger_ = new LutBufferManager(lut_config, config->mem_ops);
    lut_manger_->ImportHwBuffers(0);
    current_lut_[0] = lut_manger_->GetFreeHwBuffer(0);
    XCAM_ASSERT(current_lut_[0] != nullptr);
    if (config->is_multi_isp) {
        lut_manger_->ImportHwBuffers(1);
        current_lut_[1] = lut_manger_->GetFreeHwBuffer(1);
        XCAM_ASSERT(current_lut_[1] != nullptr);
    }

    std::ifstream ifs(calib_->SettingPara.psf_path, std::ios::binary);
    if (!ifs.is_open()) {
        LOGE_ACAC("Failed to open PSF file %s", calib_->SettingPara.psf_path);
        valid_ = false;
        return XCAM_RETURN_ERROR_FILE;
    } else {
        if (!config->is_multi_isp) {
            uint32_t line_offset = lut_config.LutHCount * CacPsfKernelWordSizeInMemory * BYTES_PER_WORD;
            uint32_t size = lut_config.LutHCount * lut_config.LutVCount * CacPsfKernelWordSizeInMemory * BYTES_PER_WORD;
            for (int ch = 0; ch < CacChannelCount; ch++) {
                char* addr0 = reinterpret_cast<char*>(current_lut_[0]->Addr) +
                              ch * size;
                ifs.read(addr0, size);
            }
        } else {
            // Read and Split Memory
            //   a == line_size - line_offset
            //   b == line_offset
            //   c == line_offset - a = 2 * line_offset - line_size
            // For each line:
            //   read b size to left
            //   copy c from left to right
            //   read a' to right
            // - +---------------------------+
            // | |<---a---->|  |  |<---a'--->|
            // | |          |<-c->|          |
            // v |<---b---------->|          |
            // | |          |  |  |          |
            // - +---------------------------+
            //   |<---------line_size------->|
            //
            uint32_t line_offset = lut_config.LutHCount * CacPsfKernelWordSizeInMemory * BYTES_PER_WORD;
            uint32_t line_size = full_lut_config.LutHCount * CacPsfKernelWordSizeInMemory * BYTES_PER_WORD;
            for (int ch = 0; ch < CacChannelCount; ch++) {
                char* addr0 = reinterpret_cast<char*>(current_lut_[0]->Addr) +
                              ch * line_offset * lut_config.LutVCount;
                char* addr1 = reinterpret_cast<char*>(current_lut_[1]->Addr) +
                              ch * line_offset * lut_config.LutVCount;
                for (uint32_t i = 0; i < full_lut_config.LutVCount; i++) {
                    ifs.read(addr0 + (i * line_offset), line_offset);
                    memcpy(addr1 + (i * line_offset),
                           addr0 + (i * line_offset) + line_size - line_offset,
                           2 * line_offset - line_size);
                    ifs.read(addr1 + (i * line_size) + line_offset, line_size - line_offset);
                }
            }
        }
    }

    return XCAM_RETURN_NO_ERROR;
}

void CacAlgoAdaptor::OnFrameEvent(const RkAiqAlgoProcAcac* input,
                                  RkAiqAlgoProcResAcac* output) {
    int i;
    int iso_low  = 50;
    int iso_high = 50;
    int gain_high, gain_low;
    float ratio;
    int iso_div      = 50;
    int max_iso_step = RKCAC_MAX_ISO_LEVEL;
    int iso          = input->iso;
    LOGD_ACAC("%s : Enter", __func__);

    if (!enable_ || !valid_) {
        output->config[0].bypass_en = 1;
        output->config[1].bypass_en = 1;
        return;
    }

    for (i = max_iso_step - 1; i >= 0; i--) {
        if (iso < iso_div * (2 << i)) {
            iso_low  = iso_div * (2 << (i)) / 2;
            iso_high = iso_div * (2 << i);
        }
    }
    ratio = (float)(iso - iso_low) / (iso_high - iso_low);
    if (iso_low == iso) {
        iso_high = iso;
        ratio    = 0;
    }
    if (iso_high == iso) {
        iso_low = iso;
        ratio   = 1;
    }
    gain_high = (int)(log((float)iso_high / 50) / log((float)2));
    gain_low  = (int)(log((float)iso_low / 50) / log((float)2));

    gain_low  = MIN(MAX(gain_low, 0), max_iso_step - 1);
    gain_high = MIN(MAX(gain_high, 0), max_iso_step - 1);

    XCAM_ASSERT(gain_low >= 0 && gain_low < max_iso_step);
    XCAM_ASSERT(gain_high >= 0 && gain_high < max_iso_step);

#if 0
    output->config[0].strength[0] = 128;
    output->config[0].strength[1] = 256;
    output->config[0].strength[2] = 384;
    output->config[0].strength[3] = 512;
    output->config[0].strength[4] = 640;
    output->config[0].strength[5] = 768;
    output->config[0].strength[6] = 896;
    output->config[0].strength[7] = 1024;
    output->config[0].strength[8] = 1152;
    output->config[0].strength[9] = 1280;
    output->config[0].strength[10] = 1408;
    output->config[0].strength[11] = 1536;
    output->config[0].strength[12] = 1568;
    output->config[0].strength[13] = 1600;
    output->config[0].strength[14] = 1632;
    output->config[0].strength[15] = 1664;
    output->config[0].strength[16] = 1696;
    output->config[0].strength[17] = 1728;
    output->config[0].strength[18] = 1760;
    output->config[0].strength[19] = 1792;
    output->config[0].strength[20] = 1824;
    output->config[0].strength[21] = 2047;
#endif
    float strength[RKCAC_STRENGTH_TABLE_LEN] = {1.0f};
    for (i = 0; i < RKCAC_STRENGTH_TABLE_LEN; i++) {
        strength[i] =
            INTERP_CAC(calib_->TuningPara.SettingByIso[gain_low].strength_table[i],
                       calib_->TuningPara.SettingByIso[gain_high].strength_table[i], ratio);
        output->config[0].strength[i] = ROUND_F(strength[i] * (1 << RKCAC_STRENGTH_FIX_BITS));
        output->config[0].strength[i] =
            output->config[0].strength[i] > 2047 ? 2047 : output->config[0].strength[i];
    }
    output->config[0].bypass_en =
        INTERP_CAC(calib_->TuningPara.SettingByIso[gain_low].bypass,
                   calib_->TuningPara.SettingByIso[gain_high].bypass, ratio);
    output->config[0].center_en     = calib_->SettingPara.center_en;
    output->config[0].center_width  = calib_->SettingPara.center_x;
    output->config[0].center_height = calib_->SettingPara.center_y;
    output->config[0].psf_sft_bit   = calib_->SettingPara.psf_shift_bits;
    output->config[0].cfg_num       = current_lut_[0]->Config.PsfCfgCount;
    output->config[0].buf_fd        = current_lut_[0]->Fd;
    output->config[0].hsize         = current_lut_[0]->Config.LutHCount * CacPsfKernelWordSizeInMemory;
    output->config[0].vsize         = current_lut_[0]->Config.LutVCount * CacChannelCount;
    if (current_lut_[1]) {
        memcpy(&output->config[1], &output->config[0], sizeof(output->config[0]));
        output->config[1].buf_fd = current_lut_[1]->Fd;
        if (output->config[0].center_en) {
            uint16_t w = config_->width / 4;
            uint16_t e = config_->multi_isp_extended_pixel / 4;
            uint16_t x = calib_->SettingPara.center_x;
            output->config[1].center_width = x - (w / 2 - e);
        }
    }

    LOGD_ACAC("global en : %d", calib_->SettingPara.enable);
    LOGD_ACAC("current bypass: %d", output->config[0].bypass_en);
    LOGD_ACAC("center en: %d", output->config[0].center_en);
    LOGD_ACAC("center x: %u", output->config[0].center_width);
    LOGD_ACAC("center y: %u", output->config[0].center_height);
    LOGD_ACAC("psf shift bits: %u", output->config[0].psf_sft_bit);
    LOGD_ACAC("psf cfg num: %u", output->config[0].cfg_num);
    LOGD_ACAC("psf buf fd: %d", output->config[0].buf_fd);
    if (current_lut_[1]) {
        LOGD_ACAC("psf buf fd right: %d", output->config[1].buf_fd);
        LOGD_ACAC("center x right: %d", output->config[1].center_width);
        LOGD_ACAC("center y right: %d", output->config[1].center_height);
    }
    LOGD_ACAC("psf hwsize: %u", output->config[0].hsize);
    LOGD_ACAC("psf size: %u", output->config[0].vsize);
    for (i = 0; i < RKCAC_STRENGTH_TABLE_LEN; i++) {
        LOGD_ACAC("strength %d: %u", i, output->config[0].strength[i]);
    }
}

}  // namespace RkCam