// Copyright 2019 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "media_config.h"

#include <sstream>
#include <strings.h>

#include "encoder.h"
#include "key_string.h"
#include "media_type.h"
#include "utils.h"

namespace easymedia
{

    const char* rc_quality_strings[7] = {KEY_LOWEST, KEY_LOWER, KEY_LOW, KEY_MEDIUM, KEY_HIGH, KEY_HIGHER, KEY_HIGHEST};

    const char* rc_mode_strings[3] = {KEY_VBR, KEY_CBR, KEY_FIXQP};

    static const char* convert2constchar(const std::string& s, const char* array[], size_t array_len)
    {
        for (size_t i = 0; i < array_len; i++)
            if (!strcasecmp(s.c_str(), array[i])) {
                return array[i];
            }
        return nullptr;
    }

    const char* ConvertRcQuality(const std::string& s)
    {
        return convert2constchar(s, rc_quality_strings, ARRAY_ELEMS(rc_quality_strings));
    }

    const char* ConvertRcMode(const std::string& s)
    {
        return convert2constchar(s, rc_mode_strings, ARRAY_ELEMS(rc_mode_strings));
    }

    static int ParseMediaConfigFps(std::map<std::string, std::string>& params, VideoConfig& vid_cfg)
    {
        std::string value = params[KEY_FPS];
        char* num = NULL;
        char* den = NULL;

        if (value.empty()) {
            LOG("ERROR: MediaCfg: fps: KEY_FPS is null!\n");
            return -1;
        }
        num = strtok((char*)value.c_str(), "/");
        den = strtok(NULL, "/");
        if (!num || !den || (strlen(num) > 2) || (strlen(den) > 2)) {
            LOG("ERROR: MediaCfg: fps: KEY_FPS=%s is invalid!\n", value.c_str());
            return -1;
        }
        vid_cfg.frame_rate = std::atoi(num);
        vid_cfg.frame_rate_den = std::atoi(den);

        value = params[KEY_FPS_IN];
        if (value.empty()) {
            LOG("ERROR: MediaCfg: fps: KEY_FPS_IN is null!\n");
            return -1;
        }
        num = strtok((char*)value.c_str(), "/");
        den = strtok(NULL, "/");
        if (!num || !den || (strlen(num) > 2) || (strlen(den) > 2)) {
            LOG("ERROR: MediaCfg: fps: KEY_FPS_IN(%s) is null!\n", value.c_str());
            return -1;
        }

        vid_cfg.frame_in_rate = std::atoi(num);
        vid_cfg.frame_in_rate_den = std::atoi(den);

        return 0;
    }

    bool ParseMediaConfigFromMap(std::map<std::string, std::string>& params, MediaConfig& mc)
    {
        std::string value = params[KEY_OUTPUTDATATYPE];
        if (value.empty()) {
            LOG("miss %s\n", KEY_OUTPUTDATATYPE);
            return false;
        }
        bool image_in = string_start_withs(value, IMAGE_PREFIX);
        bool video_in = string_start_withs(value, VIDEO_PREFIX);
        bool audio_in = string_start_withs(value, AUDIO_PREFIX);
        if (!image_in && !video_in && !audio_in) {
            LOG("unsupport outtype %s\n", value.c_str());
            return false;
        }
        ImageInfo info;
        CodecType codec_type = StringToCodecType(value.c_str());
        if (codec_type == CODEC_TYPE_NONE) {
            LOG("ERROR: unsupport outtype %s\n", value.c_str());
            return false;
        }

        if (image_in || video_in) {
            if (!ParseImageInfoFromMap(params, info)) {
                return false;
            }
        } else {
            // audio
            AudioConfig& aud_cfg = mc.aud_cfg;
            if (!ParseSampleInfoFromMap(params, aud_cfg.sample_info)) {
                return false;
            }
            CHECK_EMPTY(value, params, KEY_COMPRESS_BITRATE)
            aud_cfg.bit_rate = std::stoi(value);
            CHECK_EMPTY(value, params, KEY_FLOAT_QUALITY)
            aud_cfg.quality = std::stof(value);
            // CHECK_EMPTY(value, params, KEY_CODECTYPE)
            aud_cfg.codec_type = codec_type;
            mc.type = Type::Audio;
            return true;
        }
        if (image_in) {
            ImageConfig& img_cfg = mc.img_cfg;
            img_cfg.image_info = info;
            GET_STRING_TO_INT(img_cfg.qfactor, params, KEY_JPEG_QFACTOR, 0)
            img_cfg.codec_type = codec_type;
            mc.type = Type::Image;
        } else if (video_in) {
            VideoConfig& vid_cfg = mc.vid_cfg;
            ImageConfig& img_cfg = vid_cfg.image_cfg;
            img_cfg.image_info = info;
            img_cfg.codec_type = codec_type;
            GET_STRING_TO_INT(img_cfg.qfactor, params, KEY_JPEG_QFACTOR, 0)
            GET_STRING_TO_INT(vid_cfg.qp_init, params, KEY_COMPRESS_QP_INIT, 0)
            GET_STRING_TO_INT(vid_cfg.qp_step, params, KEY_COMPRESS_QP_STEP, 0)
            GET_STRING_TO_INT(vid_cfg.qp_min, params, KEY_COMPRESS_QP_MIN, 0)
            GET_STRING_TO_INT(vid_cfg.qp_max, params, KEY_COMPRESS_QP_MAX, 0)
            GET_STRING_TO_INT(vid_cfg.bit_rate, params, KEY_COMPRESS_BITRATE, 0)
            GET_STRING_TO_INT(vid_cfg.bit_rate_min, params, KEY_COMPRESS_BITRATE_MIN, 0)
            GET_STRING_TO_INT(vid_cfg.bit_rate_max, params, KEY_COMPRESS_BITRATE_MAX, 0)
            GET_STRING_TO_INT(vid_cfg.qp_max_i, params, KEY_COMPRESS_QP_MAX_I, 0)
            GET_STRING_TO_INT(vid_cfg.qp_min_i, params, KEY_COMPRESS_QP_MIN_I, 0)
            GET_STRING_TO_INT(vid_cfg.trans_8x8, params, KEY_H264_TRANS_8x8, 0)
            GET_STRING_TO_INT(vid_cfg.level, params, KEY_LEVEL, 0)
            GET_STRING_TO_INT(vid_cfg.gop_size, params, KEY_VIDEO_GOP, 0)
            GET_STRING_TO_INT(vid_cfg.profile, params, KEY_PROFILE, 0)
            GET_STRING_TO_INT(vid_cfg.full_range, params, KEY_FULL_RANGE, 0)
            GET_STRING_TO_INT(vid_cfg.ref_frm_cfg, params, KEY_REF_FRM_CFG, 0)
            GET_STRING_TO_INT(vid_cfg.rotation, params, KEY_ROTATION, 0)

            if (ParseMediaConfigFps(params, vid_cfg) < 0) {
                return false;
            }

            const std::string rc_q = params[KEY_COMPRESS_RC_QUALITY];
            if (rc_q.empty()) {
                vid_cfg.rc_quality = NULL;
            } else {
                vid_cfg.rc_quality = ConvertRcQuality(rc_q);
            }

            const std::string rc_m = params[KEY_COMPRESS_RC_MODE];
            if (rc_m.empty()) {
                vid_cfg.rc_mode = NULL;
            } else {
                vid_cfg.rc_mode = ConvertRcMode(rc_m);
            }

            mc.type = Type::Video;
        }
        return true;
    }

    // roi_regions:(x,x,x,x,x,x,x,x,x)(x,x,x,x,x,x,x,x,x)...
    std::vector<EncROIRegion> StringToRoiRegions(const std::string& str_regions)
    {
        std::vector<EncROIRegion> ret;
        const char* start = nullptr;
        if (str_regions.empty()) {
            return std::move(ret);
        }

        start = str_regions.c_str();
        while (start) {
            EncROIRegion region = {0, 0, 0, 0, 0, 0, 0, 0, 0};
            start = strstr(start, "(");
            if (!start) {
                break;
            }
            const char* end = strstr(start, ")");
            if (!end) {
                LOG("ERROR: RoiRegions string is invalid! end error! Value:%s\n", str_regions.c_str());
                break;
            }

            int commas_cnt = 0;
            const char* commas_str = start;
            while (commas_str && (commas_str < end)) {
                commas_str = strstr(commas_str, ",");
                if (!commas_str) {
                    break;
                } else if (commas_str < end) {
                    commas_cnt++;
                }
                commas_str++;
            }

            if (commas_cnt != 8) {
                LOG("ERROR: RoiRegions string is invalid! Value:%s\n", str_regions.c_str());
                break;
            }
            int x, y, w, h, intra, quality, qp_area_idx, area_map_en, abs_qp_en;
            int r = sscanf(start, "(%d,%d,%d,%d,%d,%d,%d,%d,%d)", &x, &y, &w, &h, &intra, &quality, &qp_area_idx,
                           &area_map_en, &abs_qp_en);
            if (r != 9) {
                LOG("ERROR: Fail to sscanf(ret=%d) : %m\n", r);
                ret.clear();
                return std::move(ret);
            }
            region.x = (uint16_t)x;
            region.y = (uint16_t)y;
            region.w = (uint16_t)w;
            region.h = (uint16_t)h;
            region.intra = (uint16_t)intra;
            region.quality = (int16_t)quality;
            region.qp_area_idx = (uint16_t)qp_area_idx;
            region.area_map_en = (uint8_t)area_map_en;
            region.abs_qp_en = (uint8_t)abs_qp_en;
            ret.push_back(std::move(region));
            start = end;
        }

        return std::move(ret);
    }

    std::string to_param_string(const ImageConfig& img_cfg)
    {
        std::string ret = to_param_string(img_cfg.image_info);
        PARAM_STRING_APPEND_TO(ret, KEY_JPEG_QFACTOR, img_cfg.qfactor);
        PARAM_STRING_APPEND_TO(ret, KEY_CODECTYPE, img_cfg.codec_type);
        return ret;
    }

    std::string to_param_string(const VideoConfig& vid_cfg)
    {
        const ImageConfig& img_cfg = vid_cfg.image_cfg;
        std::string ret = to_param_string(img_cfg);
        PARAM_STRING_APPEND_TO(ret, KEY_COMPRESS_QP_INIT, vid_cfg.qp_init);
        PARAM_STRING_APPEND_TO(ret, KEY_COMPRESS_QP_STEP, vid_cfg.qp_step);
        PARAM_STRING_APPEND_TO(ret, KEY_COMPRESS_QP_MIN, vid_cfg.qp_min);
        PARAM_STRING_APPEND_TO(ret, KEY_COMPRESS_QP_MAX, vid_cfg.qp_max);
        PARAM_STRING_APPEND_TO(ret, KEY_COMPRESS_BITRATE, vid_cfg.bit_rate);
        PARAM_STRING_APPEND_TO(ret, KEY_COMPRESS_BITRATE_MAX, vid_cfg.bit_rate_max);
        PARAM_STRING_APPEND_TO(ret, KEY_COMPRESS_BITRATE_MIN, vid_cfg.bit_rate_min);
        std::stringstream str_stream;
        std::string fps;
        str_stream << vid_cfg.frame_rate;
        str_stream << "/";
        str_stream << vid_cfg.frame_rate_den;
        str_stream >> fps;
        PARAM_STRING_APPEND(ret, KEY_FPS, fps);
        str_stream.clear();
        str_stream << vid_cfg.frame_in_rate;
        str_stream << "/";
        str_stream << vid_cfg.frame_in_rate_den;
        str_stream >> fps;
        PARAM_STRING_APPEND(ret, KEY_FPS_IN, fps);
        PARAM_STRING_APPEND_TO(ret, KEY_LEVEL, vid_cfg.level);
        PARAM_STRING_APPEND_TO(ret, KEY_VIDEO_GOP, vid_cfg.gop_size);
        PARAM_STRING_APPEND_TO(ret, KEY_PROFILE, vid_cfg.profile);
        if (vid_cfg.rc_quality) {
            PARAM_STRING_APPEND(ret, KEY_COMPRESS_RC_QUALITY, vid_cfg.rc_quality);
        }
        if (vid_cfg.rc_mode) {
            PARAM_STRING_APPEND(ret, KEY_COMPRESS_RC_MODE, vid_cfg.rc_mode);
        }
        PARAM_STRING_APPEND_TO(ret, KEY_COMPRESS_QP_MAX_I, vid_cfg.qp_max_i);
        PARAM_STRING_APPEND_TO(ret, KEY_COMPRESS_QP_MIN_I, vid_cfg.qp_min_i);
        PARAM_STRING_APPEND_TO(ret, KEY_H264_TRANS_8x8, vid_cfg.trans_8x8);
        PARAM_STRING_APPEND_TO(ret, KEY_FULL_RANGE, vid_cfg.full_range);
        PARAM_STRING_APPEND_TO(ret, KEY_REF_FRM_CFG, vid_cfg.ref_frm_cfg);
        PARAM_STRING_APPEND_TO(ret, KEY_ROTATION, vid_cfg.rotation);
        return ret;
    }

    std::string to_param_string(const AudioConfig& aud_cfg)
    {
        std::string ret = to_param_string(aud_cfg.sample_info);
        PARAM_STRING_APPEND_TO(ret, KEY_COMPRESS_BITRATE, aud_cfg.bit_rate);
        PARAM_STRING_APPEND_TO(ret, KEY_FLOAT_QUALITY, aud_cfg.quality);
        PARAM_STRING_APPEND_TO(ret, KEY_CODECTYPE, aud_cfg.codec_type);
        return ret;
    }

    std::string to_param_string(const MediaConfig& mc, const std::string& out_type)
    {
        std::string ret;
        MediaConfig mc_temp = mc;
        bool image_in = string_start_withs(out_type, IMAGE_PREFIX);
        bool video_in = string_start_withs(out_type, VIDEO_PREFIX);
        bool audio_in = string_start_withs(out_type, AUDIO_PREFIX);
        if (!image_in && !video_in && !audio_in) {
            LOG("unsupport outtype %s\n", out_type.c_str());
            return ret;
        }

        PARAM_STRING_APPEND(ret, KEY_OUTPUTDATATYPE, out_type);
        if (image_in) {
            mc_temp.img_cfg.codec_type = StringToCodecType(out_type.c_str());
            ret.append(to_param_string(mc_temp.img_cfg));
        }

        if (video_in) {
            mc_temp.vid_cfg.image_cfg.codec_type = StringToCodecType(out_type.c_str());
            ret.append(to_param_string(mc_temp.vid_cfg));
        }

        if (audio_in) {
            mc_temp.aud_cfg.codec_type = StringToCodecType(out_type.c_str());
            ret.append(to_param_string(mc_temp.aud_cfg));
        }

        return ret;
    }

    std::string get_video_encoder_config_string(const ImageInfo& info, const VideoEncoderCfg& cfg)
    {
        if (!info.width || !info.height || (info.pix_fmt >= PIX_FMT_NB) || (info.pix_fmt <= PIX_FMT_NONE)) {
            LOG("ERROR: %s image info is wrong!\n", __func__);
            return NULL;
        }

        if (StringToCodecType(cfg.type) < 0) {
            LOG("ERROR: %s not support enc type:%s!\n", __func__, cfg.type);
            return NULL;
        }

        if (cfg.rc_quality && strcmp(cfg.rc_quality, KEY_HIGHEST) && strcmp(cfg.rc_quality, KEY_HIGHER) &&
            strcmp(cfg.rc_quality, KEY_HIGH) && strcmp(cfg.rc_quality, KEY_MEDIUM) && strcmp(cfg.rc_quality, KEY_LOW) &&
            strcmp(cfg.rc_quality, KEY_LOWER) && strcmp(cfg.rc_quality, KEY_LOWEST)) {
            LOG("ERROR: %s rc_quality is invalid!"
                "should be [KEY_LOWEST, KEY_HIGHEST]\n",
                __func__);
            return NULL;
        }

        if (cfg.rc_mode && strcmp(cfg.rc_mode, KEY_VBR) && strcmp(cfg.rc_mode, KEY_CBR)) {
            LOG("ERROR: %s rc_mode is invalid! should be KEY_VBR/KEY_VBR\n", __func__);
            return NULL;
        }

        MediaConfig enc_config;
        memset(&enc_config, 0, sizeof(enc_config));
        VideoConfig& vid_cfg = enc_config.vid_cfg;
        ImageConfig& img_cfg = vid_cfg.image_cfg;
        img_cfg.image_info.pix_fmt = info.pix_fmt;
        img_cfg.image_info.width = info.width;
        img_cfg.image_info.height = info.height;
        img_cfg.image_info.vir_width = info.vir_width;
        img_cfg.image_info.vir_height = info.vir_height;
        img_cfg.codec_type = StringToCodecType(cfg.type);

        if (cfg.fps) {
            vid_cfg.frame_rate = vid_cfg.frame_in_rate = cfg.fps;
        } else {
            vid_cfg.frame_rate = vid_cfg.frame_in_rate = 30;
            LOG("INFO: VideoEnc: frame rate use defalut value:30\n");
        }

        vid_cfg.gop_size = cfg.gop;

        if (cfg.max_bps) {
            vid_cfg.bit_rate_max = cfg.max_bps;
        } else {
            int den, num;
            GetPixFmtNumDen(info.pix_fmt, num, den);
            int wh_product = info.width * info.height;
            if (wh_product > 2073600) {
                vid_cfg.bit_rate_max = wh_product * vid_cfg.frame_rate * num / den / 20;
            } else if (wh_product > 921600) {
                vid_cfg.bit_rate_max = wh_product * vid_cfg.frame_rate * num / den / 17;
            } else if (wh_product > 101376) {
                vid_cfg.bit_rate_max = wh_product * vid_cfg.frame_rate * num / den / 15;
            } else {
                vid_cfg.bit_rate_max = wh_product * vid_cfg.frame_rate * num / den / 8;
            }
            LOG("INFO: VideoEnc: maxbps use defalut value:%d\n", vid_cfg.bit_rate);
        }

        vid_cfg.rc_quality = cfg.rc_quality;
        vid_cfg.rc_mode = cfg.rc_mode;

        std::string enc_param = "";
        enc_param.append(easymedia::to_param_string(enc_config, cfg.type));
        return enc_param;
    }

    int video_encoder_set_bps(std::shared_ptr<Flow>& enc_flow, unsigned int target, unsigned int min, unsigned int max)
    {
        if (!enc_flow) {
            return -EINVAL;
        }

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        int* bps_array = (int*)malloc(3 * sizeof(int));
        bps_array[0] = min;
        bps_array[1] = target;
        bps_array[2] = max;

        pbuff->SetPtr(bps_array, 3 * sizeof(int));
        enc_flow->Control(VideoEncoder::kBitRateChange, pbuff);

        return 0;
    }

    int video_encoder_set_rc_quality(std::shared_ptr<Flow>& enc_flow, const char* rc_quality)
    {
        if (!enc_flow || !rc_quality) {
            return -EINVAL;
        }

        if (strcmp(rc_quality, KEY_HIGHEST) && strcmp(rc_quality, KEY_HIGHER) && strcmp(rc_quality, KEY_HIGH) &&
            strcmp(rc_quality, KEY_MEDIUM) && strcmp(rc_quality, KEY_LOW) && strcmp(rc_quality, KEY_LOWER) &&
            strcmp(rc_quality, KEY_LOWEST)) {
            LOG("ERROR: %s rc_quality:%s is invalid! "
                "should be [KEY_LOWEST, KEY_HIGHEST]\n",
                __func__, rc_quality);
            return -EINVAL;
        }

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        int str_len = strlen(rc_quality);
        char* quality = (char*)malloc(str_len + 1);
        memcpy(quality, rc_quality, strlen(rc_quality));
        quality[str_len] = '\0';
        pbuff->SetPtr(quality, strlen(rc_quality));
        enc_flow->Control(VideoEncoder::kRcQualityChange, pbuff);

        return 0;
    }

    int video_encoder_set_rc_mode(std::shared_ptr<Flow>& enc_flow, const char* rc_mode)
    {
        if (!enc_flow || !rc_mode) {
            return -EINVAL;
        }

        if (strcmp(rc_mode, KEY_VBR) && strcmp(rc_mode, KEY_CBR)) {
            LOG("ERROR: %s rc_mode is invalid! should be KEY_VBR/KEY_VBR\n", __func__);
            return -EINVAL;
        }

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        int str_len = strlen(rc_mode);
        char* mode = (char*)malloc(str_len + 1);
        memcpy(mode, rc_mode, strlen(rc_mode));
        mode[str_len] = '\0';
        pbuff->SetPtr(mode, strlen(rc_mode));
        enc_flow->Control(VideoEncoder::kRcModeChange, pbuff);

        return 0;
    }

    int video_encoder_set_qp(std::shared_ptr<Flow>& enc_flow, VideoEncoderQp& qps)
    {
        if (!enc_flow) {
            return -EINVAL;
        }

        // qp_max       - 8 ~ 51
        // qp_min       - 0 ~ 48
        if ((qps.qp_max && ((qps.qp_max > 51) || (qps.qp_max < 8))) ||
            (qps.qp_max_i && ((qps.qp_max_i > 51) || (qps.qp_max_i < 8))) || (qps.qp_min < 0) || (qps.qp_min > 48) ||
            (qps.qp_min_i < 0) || (qps.qp_min_i > 48) || (qps.qp_min > qps.qp_max) || (qps.qp_min_i > qps.qp_max_i)) {
            LOG("ERROR: qp range error. qp_min:[0, 48]; qp_max:[8, 51]\n");
            return -EINVAL;
        }

        if ((qps.qp_init > qps.qp_max) || (qps.qp_init < qps.qp_min)) {
            LOG("ERROR: qp_init should be within [qp_min, qp_max]\n");
            return -EINVAL;
        }

        if (!qps.qp_step || (qps.qp_step > (qps.qp_max - qps.qp_min))) {
            LOG("ERROR: qp_step should be within (0, qp_max - qp_min]\n");
            return -EINVAL;
        }

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        VideoEncoderQp* qp_struct = (VideoEncoderQp*)malloc(sizeof(VideoEncoderQp));
        memcpy(qp_struct, &qps, sizeof(VideoEncoderQp));
        pbuff->SetPtr(qp_struct, sizeof(VideoEncoderQp));
        enc_flow->Control(VideoEncoder::kQPChange, pbuff);

        return 0;
    }

    int jpeg_encoder_set_qfactor(std::shared_ptr<Flow>& enc_flow, int qfactor)
    {
        if (!enc_flow) {
            return -EINVAL;
        }

        if ((qfactor > 99) || (qfactor < 1)) {
            LOG("ERROR: %s: qfactor should be within [1, 99]\n", __func__);
            return -EINVAL;
        }

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        pbuff->SetValue(qfactor);
        enc_flow->Control(VideoEncoder::kQPChange, pbuff);

        return 0;
    }

    int video_encoder_force_idr(std::shared_ptr<Flow>& enc_flow)
    {
        if (!enc_flow) {
            return -EINVAL;
        }

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        enc_flow->Control(VideoEncoder::kForceIdrFrame, pbuff);

        return 0;
    }

    int video_encoder_set_fps(std::shared_ptr<Flow>& enc_flow, uint8_t out_num, uint8_t out_den, uint8_t in_num,
                              uint8_t in_den)
    {
        if (!enc_flow) {
            return -EINVAL;
        }

        if (!out_den || !out_num || (out_den > 16) || (out_num > 120) || (in_den > 16) || (in_num > 120)) {
            LOG("ERROR: fps(%d/%d) is invalid! num:[1,120], den:[1, 16].\n", out_num, out_den);
            return -EINVAL;
        }

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        uint8_t* fps_array = (uint8_t*)malloc(4 * sizeof(uint8_t));
        fps_array[0] = in_num;
        fps_array[1] = in_den;
        fps_array[2] = out_num;
        fps_array[3] = out_den;

        pbuff->SetPtr(fps_array, 4);
        enc_flow->Control(VideoEncoder::kFrameRateChange, pbuff);

        return 0;
    }

    // input palette should be yuva formate.
    int video_encoder_set_osd_plt(std::shared_ptr<Flow>& enc_flow, const uint32_t* yuv_plt)
    {
        if (!enc_flow) {
            return -EINVAL;
        }

        uint32_t* plt = (uint32_t*)malloc(256 * sizeof(uint32_t));
        memcpy(plt, yuv_plt, 256 * sizeof(uint32_t));

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        pbuff->SetPtr(plt, 256 * sizeof(uint32_t));
        enc_flow->Control(VideoEncoder::kOSDPltChange, pbuff);

        return 0;
    }

    int video_encoder_set_gop_size(std::shared_ptr<Flow>& enc_flow, int gop)
    {
        if (!enc_flow || (gop < 0)) {
            return -EINVAL;
        }

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        pbuff->SetValue(gop);
        enc_flow->Control(VideoEncoder::kGopChange, pbuff);

        return 0;
    }

    int video_encoder_set_osd_region(std::shared_ptr<Flow>& enc_flow, OsdRegionData* region_data)
    {
        if (!enc_flow || !region_data) {
            return -EINVAL;
        }

        if (region_data->enable && ((region_data->width % 16) || (region_data->height % 16))) {
            LOG("ERROR: osd region size must be a multiple of 16x16.");
            return -EINVAL;
        }

        int buffer_size = region_data->width * region_data->height;
        OsdRegionData* rdata = (OsdRegionData*)malloc(sizeof(OsdRegionData) + buffer_size);
        memcpy((void*)rdata, (void*)region_data, sizeof(OsdRegionData));
        if (buffer_size) {
            rdata->buffer = (uint8_t*)rdata + sizeof(OsdRegionData);
            memcpy(rdata->buffer, region_data->buffer, buffer_size);
        }

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        pbuff->SetPtr(rdata, sizeof(OsdRegionData) + buffer_size);
        enc_flow->Control(VideoEncoder::kOSDDataChange, pbuff);

        return 0;
    }

    int video_encoder_set_move_detection(std::shared_ptr<Flow>& enc_flow, std::shared_ptr<Flow>& md_flow)
    {
        int ret = 0;
        void** rdata = (void**)malloc(sizeof(void*));
        *rdata = md_flow.get();

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        pbuff->SetPtr(rdata, sizeof(sizeof(void*)));
        ret = enc_flow->Control(easymedia::VideoEncoder::kMoveDetectionFlow, pbuff);

        return ret;
    }

    int video_encoder_set_roi_regions(std::shared_ptr<Flow>& enc_flow, EncROIRegion* regions, int region_cnt)
    {
        if (!enc_flow) {
            return -EINVAL;
        }

        int rsize = 0;
        void* rdata = NULL;
        if (regions && region_cnt) {
            rsize = sizeof(EncROIRegion) * region_cnt;
            rdata = (void*)malloc(rsize);
            memcpy(rdata, (void*)regions, rsize);
        }
        auto pbuff = std::make_shared<ParameterBuffer>(0);
        pbuff->SetPtr(rdata, rsize);
        enc_flow->Control(VideoEncoder::kROICfgChange, pbuff);
        return 0;
    }

    int video_encoder_set_roi_regions(std::shared_ptr<Flow>& enc_flow, std::string roi_param)
    {
        if (!enc_flow) {
            return -EINVAL;
        }

        auto regions = StringToRoiRegions(roi_param);
        int region_cnt = regions.size();
        if (!region_cnt) {
            return -EINVAL;
        }

        EncROIRegion* rdata = NULL;
        int rsize = sizeof(EncROIRegion) * region_cnt;
        rdata = (EncROIRegion*)malloc(rsize);
        if (!rdata) {
            return -EINVAL;
        }

        int i = 0;
        for (auto iter : regions) {
            memcpy((void*)&rdata[i++], (void*)&iter, sizeof(EncROIRegion));
        }

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        pbuff->SetPtr(rdata, rsize);
        enc_flow->Control(VideoEncoder::kROICfgChange, pbuff);
        return 0;
    }

    int video_move_detect_set_rects(std::shared_ptr<Flow>& md_flow, ImageRect* rects, int rect_cnt)
    {
        if (!md_flow || !rects || !rect_cnt) {
            return -EINVAL;
        }

        return md_flow->Control(easymedia::S_MD_ROI_RECTS, rects, rect_cnt);
    }

    int video_move_detect_set_rects(std::shared_ptr<Flow>& md_flow, std::string rects_param)
    {
        if (!md_flow) {
            return -EINVAL;
        }

        std::vector<ImageRect> rect_vector;
        rect_vector = StringToImageRect(rects_param);
        if (rect_vector.empty()) {
            return -EINVAL;
        }

        int rect_cnt = (int)rect_vector.size();
        ImageRect* rects = (ImageRect*)malloc(rect_cnt * sizeof(ImageRect));
        if (!rects) {
            return -ENOSPC;
        }

        int i = 0;
        for (auto iter : rect_vector) {
            memcpy((void*)&rects[i++], (void*)&iter, sizeof(ImageRect));
        }

        int ret = md_flow->Control(easymedia::S_MD_ROI_RECTS, rects, rect_cnt);
        free(rects);
        return ret;
    }

    int video_encoder_set_split(std::shared_ptr<Flow>& enc_flow, unsigned int mode, unsigned int size)
    {
        if (!enc_flow) {
            return -EINVAL;
        }

        uint32_t* param = (uint32_t*)malloc(2 * sizeof(uint32_t));
        *param = mode;
        *(param + 1) = size;
        auto pbuff = std::make_shared<ParameterBuffer>(0);
        pbuff->SetPtr(param, 2 * sizeof(uint32_t));
        enc_flow->Control(VideoEncoder::kSplitChange, pbuff);

        return 0;
    }

    int video_encoder_set_gop_mode(std::shared_ptr<Flow>& enc_flow, EncGopModeParam* mode_params)
    {
        if (!enc_flow || !mode_params) {
            return -EINVAL;
        }

        uint8_t* param = (uint8_t*)malloc(sizeof(EncGopModeParam));
        if (!param) {
            return -ENOSPC;
        }

        memcpy(param, mode_params, sizeof(EncGopModeParam));
        auto pbuff = std::make_shared<ParameterBuffer>(0);
        pbuff->SetPtr(param, sizeof(EncGopModeParam));
        enc_flow->Control(VideoEncoder::kGopModeChange, pbuff);

        return 0;
    }

    int video_encoder_set_avc_profile(std::shared_ptr<Flow>& enc_flow, int profile_idc, int level)
    {
        if (!enc_flow) {
            return -EINVAL;
        }

        if ((profile_idc != 66) && (profile_idc != 77) && (profile_idc != 100)) {
            LOG("ERROR: %s profile_idc:%d is invalid!"
                "Only supprot: 66:Baseline, 77:Main Profile, 100: High Profile\n",
                __func__, profile_idc);
            return -EINVAL;
        }

        int* param = (int*)malloc(2 * sizeof(int));
        *param = profile_idc;
        *(param + 1) = level;
        auto pbuff = std::make_shared<ParameterBuffer>(0);
        pbuff->SetPtr(param, 2 * sizeof(int));
        enc_flow->Control(VideoEncoder::kProfileChange, pbuff);

        return 0;
    }

    int video_encoder_set_userdata(std::shared_ptr<Flow>& enc_flow, void* data, int len, int all_frames)
    {
        if (!enc_flow) {
            return -EINVAL;
        }

        if (!data && len) {
            LOG("ERROR: invalid userdata size!\n");
            return -EINVAL;
        }

        // Param formate: allFrameEnableFlag(8bit) + dataPoint
        uint8_t* param = (uint8_t*)malloc(len + 1);
        *param = all_frames ? 1 : 0;
        if (len) {
            memcpy(param + 1, data, len);
        }

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        pbuff->SetPtr(param, len + 1);
        enc_flow->Control(VideoEncoder::kUserDataChange, pbuff);

        return 0;
    }

    int video_encoder_enable_statistics(std::shared_ptr<Flow>& enc_flow, int enable)
    {
        if (!enc_flow) {
            return -EINVAL;
        }

        auto pbuff = std::make_shared<ParameterBuffer>(0);
        pbuff->SetValue(enable);
        enc_flow->Control(VideoEncoder::kEnableStatistics, pbuff);

        return 0;
    }

} // namespace easymedia