mpp-nyanmisaka/mpp/hal/common/hal_info.c

/*
 * Copyright 2020 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 <string.h>

#include "mpp_mem.h"
#include "mpp_2str.h"
#include "mpp_debug.h"
#include "mpp_common.h"

#include "hal_info.h"

typedef struct HalInfoImpl_t {
    MppCtxType      type;
    MppCodingType   coding;

    RK_U32          updated;
    RK_U32          elem_nb;
    /* info data for output */
    MppDevInfoCfg   *elems;
} HalInfoImpl;

MPP_RET hal_info_init(HalInfo *ctx, MppCtxType type, MppCodingType coding)
{
    if (NULL == ctx) {
        mpp_err_f("found NULL input ctx\n");
        return MPP_ERR_NULL_PTR;
    }

    MPP_RET ret = MPP_NOK;
    RK_U32 elem_nb = (type == MPP_CTX_DEC) ? (ENC_INFO_BUTT) : (DEC_INFO_BUTT);
    HalInfoImpl *impl = mpp_calloc_size(HalInfoImpl, sizeof(HalInfoImpl) +
                                        sizeof(MppDevInfoCfg) * elem_nb);
    if (impl) {
        impl->type = type;
        impl->coding = coding;
        impl->elem_nb = elem_nb;
        impl->elems = (MppDevInfoCfg *)(impl + 1);
        ret = MPP_OK;
    }

    *ctx = impl;

    return ret;
}

MPP_RET hal_info_deinit(HalInfo ctx)
{
    MPP_FREE(ctx);
    return MPP_OK;
}

MPP_RET hal_info_set(HalInfo ctx, RK_U32 type, RK_U32 flag, RK_U64 data)
{
    if (NULL == ctx) {
        mpp_err_f("found NULL input ctx\n");
        return MPP_ERR_NULL_PTR;
    }

    if (flag <= CODEC_INFO_FLAG_NULL || flag >= CODEC_INFO_FLAG_BUTT) {
        mpp_err_f("found invalid flag %d\n", flag);
        return MPP_ERR_VALUE;
    }

    HalInfoImpl *info = (HalInfoImpl *)ctx;
    MppDevInfoCfg *elems = NULL;

    switch (info->type) {
    case MPP_CTX_DEC : {
        if (type <= DEC_INFO_BASE || type >= DEC_INFO_BUTT) {
            mpp_err_f("found invalid dec info type %d [%d:%d]\n",
                      type, DEC_INFO_BASE, DEC_INFO_BUTT);
            return MPP_ERR_VALUE;
        }

        /* shift enum base */
        type -= DEC_INFO_BASE;
    } break;
    case MPP_CTX_ENC : {
        if (type <= ENC_INFO_BASE || type >= ENC_INFO_BUTT) {
            mpp_err_f("found invalid enc info type %d [%d:%d]\n",
                      type, ENC_INFO_BASE, ENC_INFO_BUTT);
            return MPP_ERR_VALUE;
        }

        /* shift enum base */
        type -= ENC_INFO_BASE;
    } break;
    default : {
        mpp_err_f("found invalid ctx type %d\n", info->type);
        return MPP_ERR_VALUE;
    } break;
    }

    elems = &info->elems[type];

    if (elems->type != type || elems->flag != flag || elems->data != data) {
        /* set enc info */
        elems->type = type;
        elems->flag = flag;
        elems->data = data;
        info->updated |= (1 << type);
    }

    return MPP_OK;
}

MPP_RET hal_info_get(HalInfo ctx, MppDevInfoCfg *data, RK_S32 *size)
{
    if (NULL == ctx) {
        mpp_err_f("found NULL input ctx\n");
        return MPP_ERR_NULL_PTR;
    }

    if (NULL == data || NULL == size || *size == 0) {
        mpp_err_f("found invalid output cfg data %p size %p\n", data, size);
        return MPP_ERR_NULL_PTR;
    }

    HalInfoImpl *info = (HalInfoImpl *)ctx;
    if (!info->updated) {
        *size = 0;
        return MPP_OK;
    }

    RK_S32 max_size = *size;
    RK_S32 elem_size = sizeof(info->elems[0]);
    RK_S32 out_size = 0;
    RK_S32 type_max = 0;
    RK_S32 i;

    switch (info->type) {
    case MPP_CTX_DEC : {
        type_max = DEC_INFO_BUTT - DEC_INFO_BASE;
    } break;
    case MPP_CTX_ENC : {
        type_max = ENC_INFO_BUTT - ENC_INFO_BASE;
    } break;
    default : {
        mpp_err_f("found invalid ctx type %d\n", info->type);
        return MPP_ERR_VALUE;
    } break;
    }

    for (i = 0; i < type_max; i++) {
        if (!(info->updated & (1 << i)))
            continue;

        if (out_size + elem_size > max_size) {
            mpp_err_f("out data size %d is too small for %d\n",
                      max_size, out_size + elem_size);
            break;
        }

        memcpy(data, &info->elems[i], elem_size);
        data++;
        out_size += elem_size;
        info->updated &= ~(1 << i);
    }

    *size = out_size;
    return MPP_OK;
}

RK_U64 hal_info_to_string(HalInfo ctx, RK_U32 type, void *val)
{
    RK_U64 ret = 0;

    if (NULL == ctx || NULL == val) {
        mpp_err_f("found NULL input ctx %p val %p\n", ctx, val);
        return ret;
    }

    HalInfoImpl *info = (HalInfoImpl *)ctx;
    const char *str = NULL;

    switch (info->type) {
    case MPP_CTX_DEC : {
        switch (type) {
        case DEC_INFO_FORMAT : {
            MppCodingType coding = *((MppCodingType *)val);

            mpp_assert(coding == info->coding);
            str = strof_coding_type(coding);
        } break;
        default : {
        } break;
        }
    } break;
    case MPP_CTX_ENC : {
        switch (type) {
        case ENC_INFO_FORMAT : {
            MppCodingType coding = *((MppCodingType *)val);

            mpp_assert(coding == info->coding);
            str = strof_coding_type(coding);
        } break;
        case ENC_INFO_RC_MODE : {
            MppEncRcMode rc_mode = *((MppEncRcMode *)val);

            str = strof_rc_mode(rc_mode);
        } break;
        case ENC_INFO_PROFILE : {
            RK_U32 profile = *((RK_U32 *)val);

            str = strof_profle(info->coding, profile);
        } break;
        default : {
        } break;
        }
    } break;
    default : {
        mpp_err_f("found invalid ctx type %d\n", info->type);
        return MPP_ERR_VALUE;
    } break;
    }

    if (str)
        snprintf((void *)&ret, sizeof(ret) - 1, "%s", str);

    return ret;
}

RK_U64 hal_info_to_float(RK_S32 num, RK_S32 denorm)
{
    RK_U64 ret = 0;

    if (!denorm)
        snprintf((void *)&ret, sizeof(ret) - 1, "%d", num);
    else
        snprintf((void *)&ret, sizeof(ret) - 1, "%.2f", (float)num / denorm);

    return ret;
}

MPP_RET hal_info_from_enc_cfg(HalInfo ctx, MppEncCfgSet *cfg)
{
    MppEncRcCfg *rc = &cfg->rc;
    MppEncPrepCfg *prep = &cfg->prep;
    MppEncCodecCfg *codec = &cfg->codec;
    HalInfoImpl *info = (HalInfoImpl *)ctx;
    RK_U32 profile = 0;
    RK_U64 val = 0;

    hal_info_set(ctx, ENC_INFO_WIDTH, CODEC_INFO_FLAG_NUMBER, prep->width);
    hal_info_set(ctx, ENC_INFO_HEIGHT, CODEC_INFO_FLAG_NUMBER, prep->height);

    val = hal_info_to_string(ctx, ENC_INFO_FORMAT, &info->coding);

    hal_info_set(ctx, ENC_INFO_FORMAT, CODEC_INFO_FLAG_STRING, val);
    hal_info_set(ctx, ENC_INFO_FPS_IN, CODEC_INFO_FLAG_NUMBER,
                 rc->fps_in_num / rc->fps_in_denorm);
    hal_info_set(ctx, ENC_INFO_FPS_OUT, CODEC_INFO_FLAG_NUMBER,
                 rc->fps_out_num / rc->fps_out_denorm);

    val = hal_info_to_string(ctx, ENC_INFO_RC_MODE, &rc->rc_mode);
    hal_info_set(ctx, ENC_INFO_RC_MODE, CODEC_INFO_FLAG_STRING, val);

    hal_info_set(ctx, ENC_INFO_BITRATE, CODEC_INFO_FLAG_NUMBER, rc->bps_target);
    hal_info_set(ctx, ENC_INFO_GOP_SIZE, CODEC_INFO_FLAG_NUMBER, rc->gop);

    switch (info->coding) {
    case MPP_VIDEO_CodingAVC : {
        profile = codec->h264.profile;
    } break;
    case MPP_VIDEO_CodingHEVC : {
        profile = codec->h265.profile;
    } break;
    case MPP_VIDEO_CodingMJPEG :
    case MPP_VIDEO_CodingVP8 :
    default : {
    } break;
    }
    val = hal_info_to_string(ctx, ENC_INFO_PROFILE, &profile);
    hal_info_set(ctx, ENC_INFO_PROFILE, CODEC_INFO_FLAG_STRING, val);

    return MPP_OK;
}