编解码

hb_mm_mc_configure

【函数声明】

hb_s32 hb_mm_mc_configure(media_codec_context_t *context)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_PARAMS：无效参数
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INSUFFICIENT_RES：内部内存资源不足
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例

【功能描述】

根据输入信息配置编码或解码器，调用成功后 MediaCodec 进入 MEDIA_CODEC_STATE_CONFIGURED 状态。

【示例代码】

hb_mm_mc_start

【函数声明】

hb_s32 hb_mm_mc_start(media_codec_context_t *context, const mc_av_codec_startup_params_t *info)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] mc_av_codec_startup_params_t *info：指定音视频编解码时的启动参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_PARAMS：无效参数
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INSUFFICIENT_RES：内部内存资源不足
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例

【功能描述】

启动编码/解码流程，MediaCodec 将创建编解码实例、设置序列或解析数据流、注册 Framebuffer、编码头信息等，调用成功后 MediaCodec 进入 MEDIA_CODEC_STATE_STARTED 状态。

【示例代码】

hb_mm_mc_stop

【函数声明】

hb_s32 hb_mm_mc_stop(media_codec_context_t *context)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例

【功能描述】

停止编码/解码流程，退出所有子线程并释放相关资源，调用成功后 MediaCodec 回到 MEDIA_CODEC_STATE_INITIALIZED 状态。

【示例代码】

hb_mm_mc_pause

【函数声明】

hb_s32 hb_mm_mc_pause(media_codec_context_t *context)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例

【功能描述】

停止编码/解码流程，暂停所有子线程，调用成功后 MediaCodec 进入到 MEDIA_CODEC_STATE_PAUSED 状态。

【示例代码】

hb_mm_mc_flush

【函数声明】

hb_s32 hb_mm_mc_flush(media_codec_context_t *context)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例

【功能描述】

刷新输入输出 buffer 缓冲区，强制编码器/解码器刷新未处理的输入输出 buffer，函数调用后 MediaCodec 进入 MEDIA_CODEC_STATE_FLUSHING 状态，操作成功后，MediaCodec 会再次进入 MEDIA_CODEC_STATE_STARTED 状态。

【示例代码】

hb_mm_mc_release

【函数声明】

hb_s32 hb_mm_mc_release(media_codec_context_t *context)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例

【功能描述】

释放 MediaCodec 内部所有资源，用户需要在调用该函数前调用 hb_mm_mc_stop 来停止编解码，操作成功后 MediaCodec 进入 MEDIA_CODEC_STATE_UNINITIALIZED 状态。

【示例代码】

hb_mm_mc_get_state

【函数声明】

hb_s32 hb_mm_mc_get_state(media_codec_context_t *context, media_codec_state_t *state)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] media_codec_state_t *state：MediaCodec 当前状态

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 MediaCodec 当前的状态。

【示例代码】

hb_mm_mc_get_status

【函数声明】

hb_s32 hb_mm_mc_get_status(media_codec_context_t *context, mc_inter_status_t *status)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_inter_status_t *status：MediaCodec 当前内部状态

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 MediaCodec 当前内部的状态信息。

【示例代码】

参考 hb_mm_mc_get_fd

hb_mm_mc_queue_input_buffer

【函数声明】

hb_s32 hb_mm_mc_queue_input_buffer(media_codec_context_t *context, media_codec_buffer_t *buffer, hb_s32 timeout)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] media_codec_buffer_t *buffer：输入的 buffer 信息
[IN] hb_s32 timeout：超时时间

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数
HB_MEDIA_ERR_INVALID_BUFFER：无效 buffer
HB_MEDIA_ERR_WAIT_TIMEOUT：等待超时

【功能描述】

填充需要处理的 buffer 到 MediaCodec 中。

【示例代码】

#include "hb_media_codec.h"

#include "hb_media_error.h"
typedef struct MediaCodecTestContext {
    media_codec_context_t *context;
    char *inputFileName;
    char *outputFileName;
    int32_t duration; // s
} MediaCodecTestContext;
Uint64 osal_gettime(void)
{
    struct timespec tp;
    clock_gettime(CLOCK_MONOTONIC, &tp);
    return ((Uint64)tp.tv_sec*1000 + tp.tv_nsec/1000000);
}
static void do_sync_encoding(void *arg) {
    hb_s32 ret = 0;
    FILE *inFile;
    FILE *outFile;
    int noMoreInput = 0;
    int lastStream = 0;
    Uint64 lastTime = 0;
    Uint64 curTime = 0;
    int needFlush = 1;
    MediaCodecTestContext *ctx = (MediaCodecTestContext *)arg;
    media_codec_context_t *context = ctx->context;
    char *inputFileName = ctx->inputFileName;
    char *outputFileName = ctx->outputFileName;
    media_codec_state_t state = MEDIA_CODEC_STATE_NONE;
    inFile = fopen(inputFileName, "rb");
    if (!inFile) {
        goto ERR;
    }
    outFile = fopen(outputFileName, "wb");
    if (!outFile) {
        goto ERR;
    }
    //get current time
    lastTime = osal_gettime();
    ret = hb_mm_mc_initialize(context);
    if (ret) {
        goto ERR;
    }
    ret = hb_mm_mc_configure(context);
    if (ret) {
        goto ERR;
    }
    mc_av_codec_startup_params_t startup_params;
    startup_params.video_enc_startup_params.receive_frame_number = 0;
    ret = hb_mm_mc_start(context, &startup_params);
    if (ret) {
        goto ERR;
    }
    ret = hb_mm_mc_pause(context);
    if (ret) {
        goto ERR;
    }
    do {
        if (!noMoreInput) {
            media_codec_buffer_t inputBuffer;
            memset(&inputBuffer, 0x00, sizeof(media_codec_buffer_t));
            ret = hb_mm_mc_dequeue_input_buffer(context, &inputBuffer, 100);
            if (!ret) {
                curTime = osal_gettime();
                if ((curTime - lastTime)/1000 < (uint32_t)ctx->duration) {
                    ret = fread(inputBuffer.vframe_buf.vir_ptr[0], 1,
                    inputBuffer.vframe_buf.size, inFile);
                    if (ret <= 0) {
                        if(fseek(inFile, 0, SEEK_SET)) {
                            printf("Failed to rewind input filen");
                        } else {
                        ret = fread(inputBuffer.vframe_buf.vir_ptr[0], 1,
                        inputBuffer.vframe_buf.size, inFile);
                        if (ret <= 0) {
                            printf("Failed to read input filen");
                        }
                }
            }
        } else {
            printf("Time up(%d)n",ctx->duration);
            ret = 0;
        }
        if (!ret) {
            printf("There is no more input data!n");
            inputBuffer.vframe_buf.frame_end = TRUE;
            noMoreInput = 1;
        }
        ret = hb_mm_mc_queue_input_buffer(context, &inputBuffer, 100);
        if (ret) {
            printf("Queue input buffer fail.n");
            break;
        } else {
            if (ret != (int32_t)HB_MEDIA_ERR_WAIT_TIMEOUT) {
                printf("Dequeue input buffer fail.n");
                break;
            }
        }

        if (!lastStream) {
            media_codec_buffer_t outputBuffer;
            media_codec_output_buffer_info_t info;
            memset(&outputBuffer, 0x00, sizeof(media_codec_buffer_t));
            memset(&info, 0x00, sizeof(media_codec_output_buffer_info_t));
            ret = hb_mm_mc_dequeue_output_buffer(context, &outputBuffer, &info,
            3000);
            if (!ret && outFile) {
                fwrite(outputBuffer.vstream_buf.vir_ptr,
                outputBuffer.vstream_buf.size, 1, outFile);
                ret = hb_mm_mc_queue_output_buffer(context, &outputBuffer, 100);
                if (ret) {
                    printf("Queue output buffer fail.n");
                    break;
                }
                if (outputBuffer.vstream_buf.stream_end) {
                    printf("There is no more output data!n");
                    lastStream = 1;
                    break;
                }
            } else {
                if (ret != (int32_t)HB_MEDIA_ERR_WAIT_TIMEOUT) {
                    printf("Dequeue output buffer fail.n");
                    break;
                }
            }
        }
        if (needFlush) {
            ret = hb_mm_mc_flush(context);
            needFlush = 0;
            if (ret) {
                break;
            }
        }
    }while(TRUE);
    hb_mm_mc_stop(context);
    hb_mm_mc_release(context);
    context = NULL;
ERR:
    hb_mm_mc_get_state(context, &state);
    if (context && state !=
        MEDIA_CODEC_STATE_UNINITIALIZED) {
        hb_mm_mc_stop(context);
        hb_mm_mc_release(context);
    }
    if (inFile)
        fclose(inFile);
    if (outFile)
    fclose(outFile);
}
int main(int argc, char *argv[])
{
    hb_s32 ret = 0;
    char outputFileName[MAX_FILE_PATH] = "./tmp.yuv";
    char inputFileName[MAX_FILE_PATH] = "./output.stream";
    mc_video_codec_enc_params_t *params;
    media_codec_context_t context;
    memset(&context, 0x00, sizeof(media_codec_context_t));
    context.codec_id = MEDIA_CODEC_ID_H265;
    context.encoder = TRUE;
    params = &context.video_enc_params;
    params->width = 640;
    params->height = 480;
    params->pix_fmt = MC_PIXEL_FORMAT_YUV420P;
    params->frame_buf_count = 5;
    params->external_frame_buf = FALSE;
    params->bitstream_buf_count = 5;
    params->rc_params.mode = MC_AV_RC_MODE_H265CBR;
    ret = hb_mm_mc_get_rate_control_config(&context, &params->rc_params);
    if (ret) {
        return -1;
    }
    params->rc_params.h265_cbr_params.bit_rate = 5000;
    params->rc_params.h265_cbr_params.frame_rate = 30;
    params->rc_params.h265_cbr_params.intra_period = 30;
    params->gop_params.decoding_refresh_type = 2;
    params->gop_params.gop_preset_idx = 2;
    params->rot_degree = MC_CCW_0;
    params->mir_direction = MC_DIRECTION_NONE;
    params->frame_cropping_flag = FALSE;
    MediaCodecTestContext ctx;
    memset(&ctx, 0x00, sizeof(ctx));
    ctx.context = &context;
    ctx.inputFileName = inputFileName;
    ctx.outputFileName = outputFileName;
    ctx.duration = 5;
    do_sync_encoding(&ctx);
}

hb_mm_mc_dequeue_input_buffer

【函数声明】

hb_s32 hb_mm_mc_dequeue_input_buffer(media_codec_context_t *context, media_codec_buffer_t *buffer, hb_s32 timeout)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] hb_s32 timeout：超时时间
[OUT] media_codec_buffer_t *buffer：输入的 buffer 信息

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数
HB_MEDIA_ERR_INVALID_BUFFER：无效 buffer
HB_MEDIA_ERR_WAIT_TIMEOUT：等待超时

【功能描述】

获取输入的 buffer。

【示例代码】

hb_mm_mc_queue_output_buffer

【函数声明】

hb_s32 hb_mm_mc_queue_output_buffer(media_codec_context_t *context, media_codec_buffer_t *buffer, hb_s32 timeout)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] media_codec_buffer_t *buffer：输出的 buffer 信息
[IN] hb_s32 timeout：超时时间

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数
HB_MEDIA_ERR_INVALID_BUFFER：无效 buffer
HB_MEDIA_ERR_WAIT_TIMEOUT：等待超时

【功能描述】

返还处理完的 output buffer 到 MediaCodec 中。

【示例代码】

hb_mm_mc_dequeue_output_buffer

【函数声明】

hb_s32 hb_mm_mc_dequeue_output_buffer(media_codec_context_t *context, media_codec_buffer_t *buffer, media_codec_output_buffer_info_t *info, hb_s32 timeout)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] hb_s32 timeout：超时时间
[OUT] media_codec_buffer_t *buffer：输出的 buffer 信息
[IN] media_codec_output_buffer_info_t *info：输出数据流的信息

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数
HB_MEDIA_ERR_INVALID_BUFFER：无效 buffer
HB_MEDIA_ERR_WAIT_TIMEOUT：等待超时

【功能描述】

获取输出的 buffer。

【示例代码】

hb_mm_mc_get_longterm_ref_mode

【函数声明】

hb_s32 hb_mm_mc_get_longterm_ref_mode(media_codec_context_t *context, mc_video_longterm_ref_mode_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_video_longterm_ref_mode_t *params：长期参考帧模式参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取长期参考帧模式的参数，适用于 H264/H265。

【示例代码】

#include "hb_media_codec.h"
#include "hb_media_error.h"

typedef enum ENC_CONFIG_MESSAGE {
    ENC_CONFIG_NONE = (0 << 0),
    ENC_CONFIG_LONGTERM_REF = (1 << 0),
    ENC_CONFIG_INTRA_REFRESH = (1 << 1),
    ENC_CONFIG_RATE_CONTROL = (1 << 2),
    ENC_CONFIG_DEBLK_FILTER = (1 << 3),
    ENC_CONFIG_SAO = (1 << 4),
    ENC_CONFIG_ENTROPY = (1 << 5),
    ENC_CONFIG_VUI_TIMING = (1 << 6),
    ENC_CONFIG_SLICE = (1 << 7),
    ENC_CONFIG_REQUEST_IDR = (1 << 8),
    ENC_CONFIG_SKIP_PIC = (1 << 9),
    ENC_CONFIG_SMART_BG = (1 << 10),
    ENC_CONFIG_MONOCHROMA = (1 << 11),
    ENC_CONFIG_PRED_UNIT = (1 << 12),
    ENC_CONFIG_TRANSFORM = (1 << 13),
    ENC_CONFIG_ROI = (1 << 14),
    ENC_CONFIG_MODE_DECISION = (1 << 15),
    ENC_CONFIG_USER_DATA = (1 << 16),
    ENC_CONFIG_MJPEG = (1 << 17),
    ENC_CONFIG_JPEG = (1 << 18),
    ENC_CONFIG_CAMERA = (1 << 19),
    ENC_CONFIG_INSERT_USERDATA = (1 << 20),
    ENC_CONFIG_VUI = (1 << 21),
    ENC_CONFIG_3DNR = (1 << 22),
    ENC_CONFIG_REQUEST_IDR_HEADER = (1 << 23),
    ENC_CONFIG_ENABLE_IDR = (1 << 24),
    ENC_CONFIG_TOTAL = (1 << 25),
} ENC_CONFIG_MESSAGE;

typedef struct MediaCodecTestContext {
    media_codec_context_t *context;
    char *inputFileName;
    char *outputFileName;
    int32_t duration; // s
    ENC_CONFIG_MESSAGE message;
    mc_video_longterm_ref_mode_t ref_mode;
    mc_rate_control_params_t rc_params;
    mc_video_intra_refresh_params_t intra_refr;
    mc_video_deblk_filter_params_t deblk_filter;
    mc_h265_sao_params_t sao;
    mc_h264_entropy_params_t entropy;
    mc_video_vui_params_t vui;
    mc_video_vui_timing_params_t vui_timing;
    mc_video_slice_params_t slice;
    mc_video_3dnr_enc_params_t noise_reduction;
    mc_video_smart_bg_enc_params_t smart_bg;
    mc_video_pred_unit_params_t pred_unit;
    mc_video_transform_params_t transform;
    mc_video_roi_params_t roi;
    mc_video_mode_decision_params_t mode_decision;
} MediaCodecTestContext;

Uint64 osal_gettime(void)
{
    struct timespec tp;

    clock_gettime(CLOCK_MONOTONIC, &tp);

    return ((Uint64)tp.tv_sec*1000 + tp.tv_nsec/1000000);
}
uint8_t uuid[] =
    "dc45e9bd-e6d948b7-962cd820-d923eeef+HorizonAI";
static void set_message(MediaCodecTestContext *ctx) {
    int ret = 0;
    media_codec_context_t *context = ctx->context;

    mc_video_longterm_ref_mode_t *ref_mode = &ctx->ref_mode;
    hb_mm_mc_get_longterm_ref_mode(context, ref_mode);
    ref_mode->use_longterm = TRUE;
    ref_mode->longterm_pic_using_period = 20;
    ref_mode->longterm_pic_period = 30;
    //ctx->message = ENC_CONFIG_LONGTERM_REF;
    if (ctx->message & ENC_CONFIG_LONGTERM_REF) {
        ret = hb_mm_mc_set_longterm_ref_mode(context, &ctx->ref_mode);
    }
if (ctx->message & ENC_CONFIG_INTRA_REFRESH) {
hb_mm_mc_get_intra_refresh_config(context, &ctx->intra_refr)
        ret = hb_mm_mc_set_intra_refresh_config(context, &ctx->intra_refr);
}
if (ctx->message & ENC_CONFIG_SAO) {
hb_mm_mc_get_sao_config(context, &ctx->sao);
        ret = hb_mm_mc_set_sao_config(context, &ctx->sao);
    }

if (ctx->message & ENC_CONFIG_ENTROPY) {
hb_mm_mc_get_entropy_config(context, &ctx->entropy);
        ret = hb_mm_mc_set_entropy_config(context, &ctx->entropy);
    }

if (ctx->message & ENC_CONFIG_VUI) {
hb_mm_mc_get_vui_config(context, &ctx->vui);
    ret = hb_mm_mc_set_vui_config(context, &ctx->vui);
    }

if (ctx->message & ENC_CONFIG_VUI_TIMING) {
hb_mm_mc_get_vui_timing_config(context, &ctx->vui_timing);
        ret = hb_mm_mc_set_vui_timing_config(context, &ctx->vui_timing);
    }
    mc_rate_control_params_t *rc_params = &ctx->rc_params;
    rc_params->mode = context->video_enc_params.rc_params.mode;
    hb_mm_mc_get_rate_control_config(context, rc_params);
    switch (rc_params->mode) {
    case MC_AV_RC_MODE_H264CBR:
        rc_params->h264_cbr_params.bit_rate = 5000;
        rc_params->h264_cbr_params.intra_period = 60;
        break;
    case MC_AV_RC_MODE_H264VBR:
        rc_params->h264_vbr_params.intra_qp = 20;
        rc_params->h264_vbr_params.intra_period = 30;
        break;
    case MC_AV_RC_MODE_H264AVBR:
        rc_params->h264_avbr_params.intra_period = 15;
        rc_params->h264_avbr_params.intra_qp = 25;
        rc_params->h264_avbr_params.bit_rate = 2000;
        rc_params->h264_avbr_params.vbv_buffer_size = 3000;
        rc_params->h264_avbr_params.min_qp_I = 15;
        rc_params->h264_avbr_params.max_qp_I = 50;
        rc_params->h264_avbr_params.min_qp_P = 15;
        rc_params->h264_avbr_params.max_qp_P = 45;
        rc_params->h264_avbr_params.min_qp_B = 15;
        rc_params->h264_avbr_params.max_qp_B = 48;
        rc_params->h264_avbr_params.hvs_qp_enable = 0;
        rc_params->h264_avbr_params.hvs_qp_scale = 2;
        rc_params->h264_avbr_params.max_delta_qp = 5;
        rc_params->h264_avbr_params.qp_map_enable = 0;
        break;
    case MC_AV_RC_MODE_H264FIXQP:
        rc_params->h264_fixqp_params.force_qp_I = 23;
        rc_params->h264_fixqp_params.force_qp_P = 23;
        rc_params->h264_fixqp_params.force_qp_B = 23;
        rc_params->h264_fixqp_params.intra_period = 23;
        break;
    case MC_AV_RC_MODE_H264QPMAP:
        break;
    case MC_AV_RC_MODE_H265CBR:
        rc_params->h265_cbr_params.bit_rate = 5000;
        rc_params->h265_cbr_params.intra_period = 60;
        break;
    case MC_AV_RC_MODE_H265VBR:
        rc_params->h265_vbr_params.intra_qp = 20;
        rc_params->h265_vbr_params.intra_period = 30;
        break;
    case MC_AV_RC_MODE_H265AVBR:
        rc_params->h265_avbr_params.intra_period = 15;
        rc_params->h265_avbr_params.intra_qp = 25;
        rc_params->h265_avbr_params.bit_rate = 2000;
        rc_params->h265_avbr_params.vbv_buffer_size = 3000;
        rc_params->h265_avbr_params.min_qp_I = 15;
        rc_params->h265_avbr_params.max_qp_I = 50;
        rc_params->h265_avbr_params.min_qp_P = 15;
        rc_params->h265_avbr_params.max_qp_P = 45;
        rc_params->h265_avbr_params.min_qp_B = 15;
        rc_params->h265_avbr_params.max_qp_B = 48;
        rc_params->h265_avbr_params.hvs_qp_enable = 0;
        rc_params->h265_avbr_params.hvs_qp_scale = 2;
        rc_params->h265_avbr_params.max_delta_qp = 5;
        rc_params->h265_avbr_params.qp_map_enable = 0;
        break;
    case MC_AV_RC_MODE_H265FIXQP:
        rc_params->h265_fixqp_params.force_qp_I = 23;
        rc_params->h265_fixqp_params.force_qp_P = 23;
        rc_params->h265_fixqp_params.force_qp_B = 23;
        rc_params->h265_fixqp_params.intra_period = 23;
        break;
    case MC_AV_RC_MODE_H265QPMAP:
        break;
    default:
        break;
    }
    //ctx->message = ENC_CONFIG_RATE_CONTROL;
    if (ctx->message & ENC_CONFIG_RATE_CONTROL) {
        ret = hb_mm_mc_set_rate_control_config(context, &ctx->rc_params);
    }

    mc_video_deblk_filter_params_t *deblk_filter = &ctx->deblk_filter;
    hb_mm_mc_get_deblk_filter_config(context, deblk_filter);
    if (context->codec_id == MEDIA_CODEC_ID_H264) {
        deblk_filter->h264_deblk.disable_deblocking_filter_idc = 2;
        deblk_filter->h264_deblk.slice_alpha_c0_offset_div2 = 6;
        deblk_filter->h264_deblk.slice_beta_offset_div2 = 6;
    } else {
        deblk_filter->h265_deblk.slice_deblocking_filter_disabled_flag = 1;
        deblk_filter->h265_deblk.slice_beta_offset_div2 = 6;
        deblk_filter->h265_deblk.slice_tc_offset_div2 = 6;
        deblk_filter->h265_deblk.slice_loop_filter_across_slices_enabled_flag = 1;
    }
    //ctx->message = ENC_CONFIG_DEBLK_FILTER;
    if (ctx->message & ENC_CONFIG_DEBLK_FILTER) {
        ret = hb_mm_mc_set_deblk_filter_config(context, &ctx->deblk_filter);
    }

    if (context->codec_id == MEDIA_CODEC_ID_H264) {
        mc_h264_entropy_params_t *entropy = &ctx->entropy;
        hb_mm_mc_get_entropy_config(context, entropy);
        entropy->entropy_coding_mode = 0;
        ctx->message = ENC_CONFIG_ENTROPY;
        if (ctx->message & ENC_CONFIG_ENTROPY) {
            ret = hb_mm_mc_set_entropy_config(context, &ctx->entropy);
        }
    }

    //ctx->message = ENC_CONFIG_SKIP_PIC;
    if (ctx->message & ENC_CONFIG_SKIP_PIC) {
        ret = hb_mm_mc_skip_pic(context, 0), (int32_t)0);
    }

    //ctx->message = ENC_CONFIG_REQUEST_IDR;
    if (ctx->message & ENC_CONFIG_REQUEST_IDR) {
        ret = hb_mm_mc_request_idr_frame(context);
    }

    mc_video_slice_params_t *slice = &ctx->slice;
    hb_mm_mc_get_slice_config(context, slice);
    if (context->codec_id == MEDIA_CODEC_ID_H264) {
        slice->h264_slice.h264_slice_mode = 0;
        slice->h264_slice.h264_slice_arg = 60;
    } else {
        slice->h265_slice.h265_dependent_slice_mode = 0;
        slice->h265_slice.h265_dependent_slice_arg = 80;
        slice->h265_slice.h265_independent_slice_mode = 1;
        slice->h265_slice.h265_independent_slice_arg = 100;
    }
    //ctx->message = ENC_CONFIG_SLICE;
    if (ctx->message & ENC_CONFIG_SLICE) {
        ret = hb_mm_mc_set_slice_config(context, &ctx->slice);
    }

    mc_video_smart_bg_enc_params_t *smart_bg = &ctx->smart_bg;
    hb_mm_mc_get_smart_bg_enc_config(context, smart_bg);
    smart_bg->bg_detect_enable = 0;
    smart_bg->bg_threshold_diff = 8;
    smart_bg->bg_threshold_mean_diff = 1;
    smart_bg->bg_lambda_qp = 32;
    smart_bg->bg_delta_qp = 3;
    smart_bg->s2fme_disable = 0;
    //ctx->message = ENC_CONFIG_SMART_BG;
    if (ctx->message & ENC_CONFIG_SMART_BG) {
        ret = hb_mm_mc_set_smart_bg_enc_config(context, &ctx->smart_bg);
    }

    mc_video_pred_unit_params_t *pred_unit = &ctx->pred_unit;
    hb_mm_mc_get_pred_unit_config(context, pred_unit);
    if (context->codec_id == MEDIA_CODEC_ID_H264) {
        pred_unit->h264_intra_pred.constrained_intra_pred_flag = 1;
    } else {
        pred_unit->h265_pred_unit.intra_nxn_enable = 1;
        pred_unit->h265_pred_unit.constrained_intra_pred_flag = 1;
        pred_unit->h265_pred_unit.strong_intra_smoothing_enabled_flag = 0;
        pred_unit->h265_pred_unit.max_num_merge = 2;
    }
    //ctx->message = ENC_CONFIG_PRED_UNIT;
    if (ctx->message & ENC_CONFIG_PRED_UNIT) {
        ret = hb_mm_mc_set_pred_unit_config(context, &ctx->pred_unit);
    }

    mc_video_transform_params_t *transform = &ctx->transform;
    hb_mm_mc_get_transform_config(context, transform);
    if (context->codec_id == MEDIA_CODEC_ID_H264) {
        transform->h264_transform.transform_8x8_enable = 1;
        transform->h264_transform.chroma_cb_qp_offset = 4;
        transform->h264_transform.chroma_cr_qp_offset = 3;
        transform->h264_transform.user_scaling_list_enable = 0;
    } else {
        transform->h265_transform.chroma_cb_qp_offset = 6;
        transform->h265_transform.chroma_cr_qp_offset = 5;
        transform->h265_transform.user_scaling_list_enable = 0;
    }
    //ctx->message = ENC_CONFIG_TRANSFORM;
    if (ctx->message & ENC_CONFIG_TRANSFORM) {
        ret = hb_mm_mc_set_transform_config(context, &ctx->transform);
    }

    mc_video_roi_params_t *roi = &ctx->roi;
    hb_mm_mc_get_roi_config(context, roi);
    roi->roi_enable = 0;
    //ctx->message = ENC_CONFIG_ROI;
    if (ctx->message & ENC_CONFIG_ROI) {
        ret = hb_mm_mc_set_roi_config(context, &ctx->roi);
    }

    mc_video_mode_decision_params_t *mode_decision = &ctx->mode_decision;
    hb_mm_mc_get_mode_decision_config(context, mode_decision);
    mode_decision->mode_decision_enable = FALSE;
    mode_decision->pu04_delta_rate = 76;
    mode_decision->pu08_delta_rate = 80;
    mode_decision->pu16_delta_rate = 86;
    mode_decision->pu32_delta_rate = 87;
    mode_decision->pu04_intra_planar_delta_rate = 0;
    mode_decision->pu04_intra_dc_delta_rate = 0;
    mode_decision->pu04_intra_angle_delta_rate = 0;
    mode_decision->pu08_intra_planar_delta_rate = 0;
    mode_decision->pu08_intra_dc_delta_rate = 0;
    mode_decision->pu08_intra_angle_delta_rate = 0;
    mode_decision->pu16_intra_planar_delta_rate = 0;
    mode_decision->pu16_intra_dc_delta_rate = 0;
    mode_decision->pu16_intra_angle_delta_rate = 0;
    mode_decision->pu32_intra_planar_delta_rate = 0;
    mode_decision->pu32_intra_dc_delta_rate = 0;
    mode_decision->pu32_intra_angle_delta_rate = 0;
    mode_decision->cu08_intra_delta_rate = 0;
    mode_decision->cu08_inter_delta_rate = 0;
    mode_decision->cu08_merge_delta_rate = 0;
    mode_decision->cu16_intra_delta_rate = 0;
    mode_decision->cu16_inter_delta_rate = 0;
    mode_decision->cu16_merge_delta_rate = 0;
    mode_decision->cu32_intra_delta_rate = 0;
    mode_decision->cu32_inter_delta_rate = 0;
    mode_decision->cu32_merge_delta_rate = 0;
    //ctx->message = ENC_CONFIG_MODE_DECISION;
    if (ctx->message & ENC_CONFIG_MODE_DECISION) {
        ret = hb_mm_mc_set_mode_decision_config(context, &ctx->mode_decision);
}
    if (ctx->message & ENC_CONFIG_INSERT_USERDATA) {
        hb_u32 length = sizeof(uuid)/sizeof(uuid[0]);
        ret = hb_mm_mc_insert_user_data(context, uuid, length);
}
if (ctx->message & ENC_CONFIG_3DNR) {
hb_mm_mc_get_3dnr_enc_config(context, &ctx->noise_reduction);
        ret = hb_mm_mc_set_3dnr_enc_config(context, &ctx->noise_reduction);
}
    if (ctx->message & ENC_CONFIG_ENABLE_IDR) {
        // disable idr frame first
        if (ctx->enable_idr_num) {
            ret = hb_mm_mc_enable_idr_frame(context, 0);
        }
    }

    if (ctx->message & ENC_CONFIG_REQUEST_IDR_HEADER) {
        ret = hb_mm_mc_request_idr_header(context, ctx->force_idr_header);
    }
}

static void do_sync_encoding(void *arg) {
    hb_s32 ret = 0;
    FILE *inFile;
    FILE *outFile;
    int noMoreInput = 0;
    int lastStream = 0;
    Uint64 lastTime = 0;
    Uint64 curTime = 0;
    int needFlush = 1;
    MediaCodecTestContext *ctx = (MediaCodecTestContext *)arg;
    media_codec_context_t *context = ctx->context;
    char *inputFileName = ctx->inputFileName;
    char *outputFileName = ctx->outputFileName;
    media_codec_state_t state = MEDIA_CODEC_STATE_NONE;
    inFile = fopen(inputFileName, "rb");
    if (!inFile) {
        goto ERR;
    }
    outFile = fopen(outputFileName, "wb");
    if (!outFile) {
        goto ERR;
    }

    //get current time
    lastTime = osal_gettime();

    ret = hb_mm_mc_initialize(context);
    if (ret) {
        goto ERR;
    }

    ret = hb_mm_mc_configure(context);
    if (ret) {
        goto ERR;
    }

    mc_av_codec_startup_params_t startup_params;
    startup_params.video_enc_startup_params.receive_frame_number = 0;
    ret = hb_mm_mc_start(context, &startup_params);
    if (ret) {
        goto ERR;
    }

    ret = hb_mm_mc_pause(context);
    if (ret) {
        goto ERR;
    }

    do {
        set_message(ctx);
        if (!noMoreInput) {
            media_codec_buffer_t inputBuffer;
            memset(&inputBuffer, 0x00, sizeof(media_codec_buffer_t));
            ret = hb_mm_mc_dequeue_input_buffer(context, &inputBuffer, 100);
            if (!ret) {
                curTime = osal_gettime();
                if ((curTime - lastTime)/1000 < (uint32_t)ctx->duration) {
                    ret = fread(inputBuffer.vframe_buf.vir_ptr[0], 1,
                        inputBuffer.vframe_buf.size, inFile);
                    if (ret <= 0) {
                        if(fseek(inFile, 0, SEEK_SET)) {
                            printf("Failed to rewind input file\n");
                        } else {
                            ret = fread(inputBuffer.vframe_buf.vir_ptr[0], 1,
                                inputBuffer.vframe_buf.size, inFile);
                            if (ret <= 0) {
                                printf("Failed to read input file\n");
                            }
                        }
                    }
                } else {
                    printf("Time up(%d)\n",ctx->duration);
                    ret = 0;
                }
                if (!ret) {
                    printf("There is no more input data!\n");
                    inputBuffer.vframe_buf.frame_end = TRUE;
                    noMoreInput = 1;
                }
                ret = hb_mm_mc_queue_input_buffer(context, &inputBuffer, 100);
                if (ret) {
                    printf("Queue input buffer fail.\n");
                    break;
                }
            } else {
                if (ret != (int32_t)HB_MEDIA_ERR_WAIT_TIMEOUT) {
                    printf("Dequeue input buffer fail.\n");
                    break;
                }
            }
        }

        if (!lastStream) {
            media_codec_buffer_t outputBuffer;
            media_codec_output_buffer_info_t info;
            memset(&outputBuffer, 0x00, sizeof(media_codec_buffer_t));
            memset(&info, 0x00, sizeof(media_codec_output_buffer_info_t));
            ret = hb_mm_mc_dequeue_output_buffer(context, &outputBuffer, &info, 3000);
            if (!ret && outFile) {
                fwrite(outputBuffer.vstream_buf.vir_ptr, outputBuffer.vstream_buf.size, 1, outFile);

                ret = hb_mm_mc_queue_output_buffer(context, &outputBuffer, 100);
                if (ret) {
                    printf("Queue output buffer fail.\n");
                    break;
                }
                if (outputBuffer.vstream_buf.stream_end) {
                    printf("There is no more output data!\n");
                    lastStream = 1;
                    break;
                }
            } else {
                if (ret != (int32_t)HB_MEDIA_ERR_WAIT_TIMEOUT) {
                    printf("Dequeue output buffer fail.\n");
                    break;
                }
            }
        }
        if (needFlush) {
            ret = hb_mm_mc_flush(context);
            needFlush = 0;
            if (ret) {
                break;
            }
        }
    }while(TRUE);

    hb_mm_mc_stop(context);

    hb_mm_mc_release(context);
    context = NULL;

ERR:
    hb_mm_mc_get_state(context, &state);
    if (context && state != MEDIA_CODEC_STATE_UNINITIALIZED) {
        hb_mm_mc_stop(context);
        hb_mm_mc_release(context);
    }

    if (inFile)
        fclose(inFile);

    if (outFile)
        fclose(outFile);
}

int main(int argc, char *argv[])
{
    hb_s32 ret = 0;
    char outputFileName[MAX_FILE_PATH] = "./tmp.yuv";
    char inputFileName[MAX_FILE_PATH] = "./output.stream";
    mc_video_codec_enc_params_t *params;
    media_codec_context_t context;

    memset(&context, 0x00, sizeof(media_codec_context_t));
    context.codec_id = MEDIA_CODEC_ID_H265;
    context.encoder = TRUE;
    params = &context.video_enc_params;
    params->width = 640;
    params->height = 480;
    params->pix_fmt = MC_PIXEL_FORMAT_YUV420P;
    params->frame_buf_count = 5;
    params->external_frame_buf = FALSE;
    params->bitstream_buf_count = 5;
    params->rc_params.mode = MC_AV_RC_MODE_H265CBR;
    ret = hb_mm_mc_get_rate_control_config(&context, &params->rc_params);
    if (ret) {
        return -1;
    }
    params->rc_params.h265_cbr_params.bit_rate = 5000;
    params->rc_params.h265_cbr_params.frame_rate = 30;
    params->rc_params.h265_cbr_params.intra_period = 30;
    params->gop_params.decoding_refresh_type = 2;
    params->gop_params.gop_preset_idx = 2;
    params->rot_degree = MC_CCW_0;
    params->mir_direction = MC_DIRECTION_NONE;
    params->frame_cropping_flag = FALSE;

    MediaCodecTestContext ctx;
    memset(&ctx, 0x00, sizeof(ctx));
    ctx.context = &context;
    ctx.inputFileName = inputFileName;
    ctx.outputFileName = outputFileName;
    ctx.duration = 5;
    do_sync_encoding(&ctx);
}

hb_mm_mc_set_longterm_ref_mode

【函数声明】

hb_s32 hb_mm_mc_set_longterm_ref_mode(media_codec_context_t *context, const mc_video_longterm_ref_mode_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_video_longterm_ref_mode_t *params：长期参考帧模式参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置长期参考帧模式的参数，该参数为动态参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_get_intra_refresh_config

【函数声明】

hb_s32 hb_mm_mc_get_intra_refresh_config(media_codec_context_t *context, mc_video_intra_refresh_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_video_intra_refresh_params_t *params：帧内刷新参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取帧内刷新参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_set_intra_refresh_config

【函数声明】

hb_s32 hb_mm_mc_set_intra_refresh_config(media_codec_context_t *context, const mc_video_intra_refresh_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_video_intra_refresh_params_t *params：帧内刷新参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置帧内刷新模式参数，该参数为静态参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_get_rate_control_config

【函数声明】

hb_s32 hb_mm_mc_get_rate_control_config(media_codec_context_t *context, mc_rate_control_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_rate_control_params_t *params：码率控制参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取码率控制参数，该参数为动态参数，适用于 H264/H265/MJPEG。

【示例代码】

hb_mm_mc_set_rate_control_config

【函数声明】

hb_s32 hb_mm_mc_set_rate_control_config(media_codec_context_t *context, const mc_rate_control_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_rate_control_params_t *params：码率控制参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置码率控制参数，该参数为动态参数，适用于 H264/H265/MJPEG。

【示例代码】

hb_mm_mc_get_deblk_filter_config

【函数声明】

hb_s32 hb_mm_mc_get_deblk_filter_config(media_codec_context_t *context, mc_video_deblk_filter_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_video_deblk_filter_params_t * params：去块滤波参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取去块滤波参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_set_deblk_filter_config

【函数声明】

hb_s32 hb_mm_mc_set_deblk_filter_config(media_codec_context_t *context, const mc_video_deblk_filter_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_video_deblk_filter_params_t *params：去块滤波参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置去块滤波参数，该参数为动态参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_get_sao_config

【函数声明】

hb_s32 hb_mm_mc_get_sao_config(media_codec_context_t *context, mc_h265_sao_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_h265_sao_params_t *params：SAO 参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 SAO 参数，适用于 H265。

【示例代码】

hb_mm_mc_set_sao_config

【函数声明】

hb_s32 hb_mm_mc_set_sao_config(media_codec_context_t *context, const mc_h265_sao_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_h265_sao_params_t *params：SAO 参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置 SAO 参数，该参数为静态参数，适用于 H265。

【示例代码】

hb_mm_mc_get_entropy_config

【函数声明】

hb_s32 hb_mm_mc_get_entropy_config(media_codec_context_t *context, mc_h264_entropy_params_t *params);

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] mc_h264_entropy_params_t *params：entropy 参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 entropy 参数，适用于 H264。

【示例代码】

hb_mm_mc_set_entropy_config

【函数声明】

extern hb_s32 hb_mm_mc_set_entropy_config(media_codec_context_t *context, const mc_h264_entropy_params_t *params);

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_h264_entropy_params_t *params：entropy 数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置 entropy 参数，适用于 H264。

【示例代码】

hb_mm_mc_get_vui_timing_config

【函数声明】

hb_s32 hb_mm_mc_get_vui_timing_config(media_codec_context_t *context, mc_video_vui_timing_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_video_vui_timing_params_t *params：VUI Timing 参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 VUI Timing 参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_set_vui_timing_config

【函数声明】

hb_s32 hb_mm_mc_set_vui_timing_config(media_codec_context_t *context, const mc_video_vui_timing_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_video_vui_timing_params_t *params：VUI Timing 参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置 VUI Timing 参数，该参数为静态参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_get_slice_config

【函数声明】

hb_s32 hb_mm_mc_get_slice_config(media_codec_context_t *context, mc_video_slice_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_video_slice_params_t *params：slice 编码参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 slice 编码参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_set_slice_config

【函数声明】

hb_s32 hb_mm_mc_set_slice_config(media_codec_context_t *context, const mc_video_slice_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_video_slice_params_t *params：slice 编码参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置 slice 编码参数，该参数为动态参数，适用于 H264/H265。限制每帧 slice 个数小于等于1500。

【示例代码】

hb_mm_mc_insert_user_data

【函数声明】

hb_s32 hb_mm_mc_insert_user_data(media_codec_context_t * context, hb_u8 *data, hb_u32 length)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] hb_u8 *data：用户数据
[IN] hb_u32 length：用户数据长度

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

在编码流中插入用户数据，该参数为动态参数，适用于 H264/H265/MJPG/JPG。

【示例代码】

hb_mm_mc_request_idr_frame

【函数声明】

hb_s32 hb_mm_mc_request_idr_frame(media_codec_context_t *context)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例

【功能描述】

请求 IDR 帧，该接口可动态设置，适用于 H264/H265。

【示例代码】

hb_mm_mc_skip_pic

【函数声明】

hb_s32 hb_mm_mc_skip_pic(media_codec_context_t *context，hb_s32 src_idx)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] hb_s32 src_idx：source buffer 索引值

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

使能指定的图像的 skip 模式编码，该接口可动态设置，适用于 H264/H265。

【示例代码】

hb_mm_mc_get_smart_bg_enc_config

【函数声明】

extern hb_s32 hb_mm_mc_get_smart_bg_enc_config(media_codec_context_t *context, mc_video_smart_bg_enc_params_t *params);

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_video_smart_bg_enc_params_t *params：智能背景编码模式参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取智能背景编码参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_set_smart_bg_enc_config

【函数声明】

hb_s32 hb_mm_mc_set_smart_bg_enc_config(media_codec_context_t *context, const mc_video_smart_bg_enc_params_t *params);

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_video_smart_bg_enc_params_t *params：智能背景编码模式参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置智能背景编码参数，该参数为动态参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_get_pred_unit_config

【函数声明】

hb_s32 hb_mm_mc_get_pred_unit_config(media_codec_context_t *context, mc_video_pred_unit_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_video_pred_unit_params_t *params：预测单元参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取预测单元参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_set_pred_unit_config

【函数声明】

hb_s32 hb_mm_mc_set_pred_unit_config(media_codec_context_t *context, const mc_video_pred_unit_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_video_pred_unit_params_t *params：预测单元参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置预测单元参数，该参数为动态参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_get_transform_config

【函数声明】

hb_s32 hb_mm_mc_get_transform_config(media_codec_context_t *context, mc_video_transform_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_video_transform_params_t *params：Transform 参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 Transform 参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_set_transform_config

【函数声明】

hb_s32 hb_mm_mc_set_transform_config(media_codec_context_t *context, const mc_video_transform_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_video_transform_params_t *params： Transform 参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置 Transform 参数，该参数为动态参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_get_roi_config

【函数声明】

hb_s32 hb_mm_mc_get_roi_config(media_codec_context_t *context, mc_video_roi_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_video_roi_params_t *params：ROI 编码参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 ROI 编码参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_set_roi_config

【函数声明】

hb_s32 hb_mm_mc_set_roi_config(media_codec_context_t *context, const mc_video_roi_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_video_roi_params_t *params：ROI 编码参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置 ROI 编码参数，该参数为动态参数，适用于 H264/H265。

【示例代码】

hb_mm_mc_get_mode_decision_config

【函数声明】

hb_s32 hb_mm_mc_get_mode_decision_config(media_codec_context_t *context, mc_video_mode_decision_params_t *params);

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_video_mode_decision_params_t *params：模式决策参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 mode decision 参数，适用于 H265。

【示例代码】

hb_mm_mc_set_mode_decision_config

【函数声明】

hb_s32 hb_mm_mc_set_mode_decision_config(media_codec_context_t *context, const mc_video_mode_decision_params_t *params);

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_video_mode_decision_params_t *params：模式决策参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置模式决策参数，该参数为动态参数，适用于 H265。

【示例代码】

hb_mm_mc_get_user_data

【函数声明】

hb_s32 hb_mm_mc_get_user_data(media_codec_context_t *context, mc_user_data_buffer_t *params , hb_s32 timeout)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_user_data_buffer_t *params：用户数据
[IN] timeout：超时时间

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取解码流中的用户数据，适用于 H264/H265。

【示例代码】

#include "hb_media_codec.h"
#include "hb_media_error.h"
static int check_and_init_test(MediaCodecTestContext *ctx) {
    int32_t ret = 0;
    char *inputFileName, *outputFileName, *inputMd5FileName;
    EXPECT_NE(ctx, nullptr);
    EXPECT_NE(ctx->context, nullptr);
    if (ctx == NULL || ctx->context == NULL) {
        return -1;
    }
    inputFileName = ctx->inputFileName;
    outputFileName = ctx->outputFileName;
    inputMd5FileName = ctx->inputMd5FileName;
    printf("%s[%d:%d] Thread work in %s mode\n", TAG, getpid(), gettid(),
    ctx->workMode == THREAD_WORK_MODE_SYNC ? "sync" :
        (ctx->workMode == THREAD_WORK_MODE_ASYNC ? "async" : "poll"));
    printf("%s[%d:%d] InputFileName = %s\n", TAG, getpid(), gettid(), inputFileName);
    printf("%s[%d:%d] OutputFileName = %s\n", TAG, getpid(), gettid(), outputFileName);
    printf("%s[%d:%d] InputMd5File = %s\n", TAG, getpid(), gettid(), inputMd5FileName);
    EXPECT_NE(inputFileName, nullptr);
    EXPECT_NE(outputFileName, nullptr);
    if (inputFileName == NULL || outputFileName == NULL) {
        return -1;
    }
    ctx->inFile = fopen(inputFileName, "rb");
    EXPECT_NE(ctx->inFile, nullptr);
    ctx->outFile = fopen(outputFileName, "wb+");
    EXPECT_NE(ctx->outFile, nullptr);
    if (ctx->inFile == NULL || ctx->outFile == NULL) {
        return -1;
    }
    if (ctx->md5Test == TRUE) {
        if (inputMd5FileName) {
            ctx->inMd5File = fopen(inputMd5FileName, "rb");
        }
        EXPECT_NE(ctx->inMd5File, nullptr);
        if (ctx->inMd5File == NULL) {
            return -1;
        }
    }
    // allocate ion buffers
    ctx->ionFd = ion_open();
    EXPECT_GT(ctx->ionFd, 0);
    if (ctx->ionFd <= 0) {
        return -1;
    }
    if (ctx->context->encoder == TRUE) {
        printf("%s[%d:%d] Thread use %s buffer mode, %d rc mode\n", TAG, getpid(), gettid(),
        ctx->context->video_enc_params.external_frame_buf ?
        "external" : "internal",
        ctx->context->video_enc_params.rc_params.mode);
        if (ctx->context->video_enc_params.external_frame_buf) {
            ctx->exFb = (ExternalFrameBuffer *) malloc(
            ctx->context->video_enc_params.frame_buf_count * sizeof(ExternalFrameBuffer));
            EXPECT_NE(ctx->exFb, nullptr);
            if (ctx->exFb == NULL) {
                return -1;
            }
            for (Uint32 i=0; i<ctx->context->video_enc_params.frame_buf_count; i++) {
                ctx->exFb[i].buf.size = ctx->context->video_enc_params.width
                * ctx->context->video_enc_params.height * 3/2; // only for yuv420;
                ret = allocate_ion_mem(ctx->ionFd, &ctx->exFb[i].buf);
                EXPECT_EQ(ret, 0);
                if (ret != 0) {
                    return ret;
                }
                ctx->exFb[i].valid = 1;
                ctx->exFb[i].src_idx = i;
            }
        }
    } else {
        printf("%s[%d:%d] Thread use %s buffer mode, %d feed mode.\n", TAG, getpid(), gettid(),
        ctx->context->video_dec_params.external_bitstream_buf ?
        "external" : "internal",
        ctx->context->video_dec_params.feed_mode);
        if (ctx->context->video_dec_params.external_bitstream_buf) {
            ctx->exBs = (ExternalStreamBuffer *) malloc(
            ctx->context->video_dec_params.bitstream_buf_count * sizeof(ExternalStreamBuffer));
            EXPECT_NE(ctx->exBs, nullptr);
            if (ctx->exBs == NULL) {
                return -1;
            }
            for (Uint32 i=0; i<ctx->context->video_dec_params.bitstream_buf_count; i++) {
                ctx->exBs[i].buf.size = ctx->context->video_dec_params.bitstream_buf_size;
                ret = allocate_ion_mem(ctx->ionFd, &ctx->exBs[i].buf);
                EXPECT_EQ(ret, 0);
                if (ret != 0) {
                    return ret;
                }
                ctx->exBs[i].valid = 1;
                ctx->exBs[i].src_idx = i;
            }
        }
    }
// open decode files
    if (ctx->context->encoder != TRUE) {
    if (ctx->context->video_dec_params.feed_mode == MC_FEEDING_MODE_FRAME_SIZE) {
        ret = avformat_open_input(&ctx->avContext, ctx->inputFileName, 0, 0);
        EXPECT_GE(ret, 0);
        if (ret < 0) {
            return ret;
        }
        ret = avformat_find_stream_info(ctx->avContext, 0);
        EXPECT_GE(ret, 0);
        if (ret < 0) {
            return ret;
        }
        ctx->videoIndex = av_find_best_stream(ctx->avContext, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
        EXPECT_GE(ctx->videoIndex, 0);
        if (ctx->videoIndex < 0) {
            return -1;
        }
        av_init_packet(&ctx->avpacket);
    } else {
        if (ctx->feedingSize == 0) {
            uint32_t KB = 1024;
            int32_t probability10;
            srand((uint32_t)time(NULL));
            ctx->feedingSize = rand() % MAX_FEEDING_SIZE;
            probability10 = (ctx->feedingSize % 100) < 10;
            if (ctx->feedingSize < KB) {
                if (probability10 == FALSE)
                    ctx->feedingSize *= 100;
                }
            }
            printf("%s[%d:%d] Feeding size = %d\n", TAG,
            getpid(), gettid(), ctx->feedingSize);
        }
        ctx->firstPacket = 1;
    }
    return 0;
}
static int check_and_release_test(MediaCodecTestContext *ctx) {
    int32_t ret = 0;
    int md5Match, wholeFileSize = 0;
    uint8_t *md5Buffer = NULL;
    EXPECT_NE(ctx, nullptr);
    EXPECT_NE(ctx->context, nullptr);
    EXPECT_NE(ctx->inFile, nullptr);
    EXPECT_NE(ctx->outFile, nullptr);
    if (ctx == NULL || ctx->context == NULL || ctx->inFile == NULL ||
        ctx->outFile == NULL) {
        return -1;
    }
    if (ctx->context->encoder != TRUE) {
        if (ctx->context->video_dec_params.feed_mode == MC_FEEDING_MODE_FRAME_SIZE) {
            if (ctx->avContext) {
                avformat_close_input(&ctx->avContext);
            }
        }
    }
    if (ctx->context->encoder == TRUE) {
        if (ctx->context->video_enc_params.external_frame_buf) {
            if (ctx->exFb) {
                for (Uint32 i=0; i<ctx->context->video_enc_params.frame_buf_count; i++) {
                    ret = release_ion_mem(ctx->ionFd, &ctx->exFb[i].buf);
                    EXPECT_EQ(ret, 0);
                }
                free(ctx->exFb);
            }
        }
    } else {
        if (ctx->context->video_dec_params.external_bitstream_buf) {
            if (ctx->exBs) {
                for (Uint32 i=0; i<ctx->context->video_dec_params.bitstream_buf_count; i++) {
                    ret = release_ion_mem(ctx->ionFd, &ctx->exBs[i].buf);
                    EXPECT_EQ(ret, 0);
                }
                free(ctx->exBs);
            }
        }
    }
    if (ctx->ionFd)
        ion_close(ctx->ionFd);
    if (ctx->md5Test && ctx->inMd5File) {
        fseek(ctx->outFile, 0, SEEK_END);
        wholeFileSize = ftell(ctx->outFile);
        fseek(ctx->outFile, 0, SEEK_SET);
        md5Buffer = (uint8_t *)malloc(wholeFileSize);
        EXPECT_NE(md5Buffer, nullptr);
        if (md5Buffer == NULL) {
            return -1;
        }
        fread(md5Buffer, wholeFileSize, 1, ctx->outFile);
        md5Match = compare_md5_value(MD5_SIZE, ctx->inMd5File,
        md5Buffer, wholeFileSize);
        free(md5Buffer);
        fclose(ctx->inMd5File);
        EXPECT_EQ(md5Match, 1);
        if (md5Match != 1) {
            return -1;
        }
    }
    if (ctx->outFile)
        fclose(ctx->outFile);
    if (ctx->inFile)
        fclose(ctx->inFile);
    return 0;
}
static void on_vlc_buffer_message(hb_ptr userdata, hb_s32 * vlc_buf) {
    MediaCodecTestContext *ctx = (MediaCodecTestContext *)userdata;
    ASSERT_NE(vlc_buf, nullptr);
    ASSERT_NE(ctx, nullptr);
    ASSERT_GE(ctx->vlc_buf_size, 0);
    if (ctx->testLog) {
        printf("%s %s VLC Buffer size = %d; Reset to %d.\n", TAG, __FUNCTION__,
        *vlc_buf, ctx->vlc_buf_size);
    }
    *vlc_buf = ctx->vlc_buf_size;
}
static int read_input_streams(MediaCodecTestContext *ctx,
    media_codec_buffer_t *inputBuffer) {
    Uint64 curTime = 0;
    int ret = 0, ret2 = 0;
    Uint32 bufIdx = 0, srcIdx = 0;
    Int32 doRead = TRUE, doRewind = FALSE;
    uint8_t *seqHeader = NULL;
    int seqHeaderSize = 0;
    void *bufPtr = NULL;
    int avalBufSize = 0;
    EXPECT_NE(ctx, nullptr);
    EXPECT_NE(ctx->context, nullptr);
    EXPECT_NE(ctx->inFile, nullptr);
    EXPECT_NE(ctx->outFile, nullptr);
    EXPECT_NE(inputBuffer, nullptr);
    if (ctx == NULL || ctx->context == NULL || ctx->inFile == NULL ||
        ctx->outFile == NULL || inputBuffer == NULL) {
        printf("%s[%d:%d] Invalid parameters(%s).\n",
        TAG, getpid(), gettid(), __FUNCTION__);
        return -1;
    }
    if (ctx->stabilityTest || ctx->pfTest) {
        doRewind = TRUE;
        curTime = osal_gettime();
        if ((curTime - ctx->testStartTime)/1000 < (uint32_t)ctx->duration) {
            doRead = TRUE;
        } else {
            printf("%s[%d:%d] Time up(%d)\n",
            TAG, getpid(), gettid(), ctx->duration);
            doRead = FALSE;
            ret = 0;
        }
    }
    if (ctx->context->video_dec_params.external_bitstream_buf) {
        // release input buffer and take it as the new input buffer
        for (bufIdx = 0;
            bufIdx < ctx->context->video_dec_params.bitstream_buf_count;
            bufIdx++) {
            if (ctx->exBs[bufIdx].valid &&
                ctx->exBs[bufIdx].src_idx == inputBuffer->vstream_buf.src_idx) {
                srcIdx = inputBuffer->vstream_buf.src_idx;
                break;
            }
        }
        EXPECT_NE(bufIdx, ctx->context->video_dec_params.bitstream_buf_count);
        if (bufIdx == ctx->context->video_dec_params.bitstream_buf_count) {
            return -1;
        }
        bufPtr = (void *)ctx->exBs[srcIdx].buf.virt_addr;
        if (ctx->context->video_dec_params.feed_mode ==
            MC_FEEDING_MODE_FRAME_SIZE) {
            avalBufSize = ctx->exBs[srcIdx].buf.size;
        } else {
            avalBufSize = (ctx->exBs[srcIdx].buf.size < (int)ctx->feedingSize) ?
            ctx->exBs[srcIdx].buf.size : ctx->feedingSize;
        }
        inputBuffer->vstream_buf.fd = ctx->exBs[srcIdx].buf.fd;
        inputBuffer->vstream_buf.phy_ptr =
        ctx->exBs[srcIdx].buf.phys_addr;
        inputBuffer->vstream_buf.vir_ptr =
        (hb_u8 *)ctx->exBs[srcIdx].buf.virt_addr;
    } else {
        bufPtr = (void *)inputBuffer->vstream_buf.vir_ptr;
        if (ctx->context->video_dec_params.feed_mode ==
            MC_FEEDING_MODE_FRAME_SIZE) {
            avalBufSize = inputBuffer->vstream_buf.size;
        } else {
            avalBufSize = (inputBuffer->vstream_buf.size < ctx->feedingSize) ?
            inputBuffer->vstream_buf.size : ctx->feedingSize;
        }
    }
    if (doRead == FALSE) {
        return ret;
    }
    // MC_FEEDING_MODE_FRAME_SIZE mode
    if (ctx->context->video_dec_params.feed_mode == MC_FEEDING_MODE_FRAME_SIZE) {
        do {
            if (ctx->avpacket.size == 0) {
                ret = av_read_frame(ctx->avContext, &ctx->avpacket);
                if (ret < 0 && doRewind == FALSE) {
                    printf("%s[%d:%d] Failed to read input file (error=0x%x)\n",
                        TAG, getpid(), gettid(), ret);
                }
                if (ret < 0 && doRewind == TRUE) {
                    avformat_close_input(&ctx->avContext);
                    ret2 = avformat_open_input(&ctx->avContext, ctx->inputFileName, 0, 0);
                    EXPECT_GE(ret2, 0);
                    if (ret2 < 0) {
                        ret = ret2;
                        break;
                    }
                    /*ret = avformat_find_stream_info(ctx->avContext, 0);
                    EXPECT_GE(ret, 0);
                    if (ret < 0) {
                        break;
                    }
                    ctx->videoIndex = av_find_best_stream(ctx->avContext, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
                    EXPECT_GE(ctx->videoIndex, 0);
                    if (ctx->videoIndex < 0) {
                        ret = -1;
                        break;
                    }*/
                    av_init_packet(&ctx->avpacket);
                }
            } else {
                if (ctx->testLog) {
                    printf("%s[%d:%d] Reuse previous stream packet size %d\n",
                    TAG, getpid(), gettid(), ctx->avpacket.size);
                }
            }
        } while (ret < 0 && doRewind == TRUE);
        if (ret < 0) {
            if (ret == AVERROR_EOF || ctx->avContext->pb->eof_reached == TRUE) {
                printf("%s[%d:%d] End of file!\n", TAG, getpid(), gettid());
                ret = 0;
            } else {
                printf("%s[%d:%d] Failed to av_read_frame error(0x%08x)\n",
                TAG, getpid(), gettid(), ret);
            }
            return ret;
        }
        if (ctx->testLog) {
            printf("%s[%d:%d] Read packet size %d\n",
                TAG, getpid(), gettid(), ctx->avpacket.size);
        }
        seqHeaderSize = 0;
        if (ctx->firstPacket) {
            AVCodecParameters* codec;
            int retSize = 0;
            codec = ctx->avContext->streams[ctx->videoIndex]->codecpar;
            seqHeader = (uint8_t*)malloc(codec->extradata_size + 1024);
            if (seqHeader == NULL) {
                printf("%s[%d:%d] Failed to mallock seqHeader\n",
                TAG, getpid(), gettid());
                ret = -1;
                return ret;
            }
            memset((void*)seqHeader, 0x00, codec->extradata_size + 1024);
            seqHeaderSize = build_dec_seq_header(seqHeader,
            ctx->context->codec_id,
            ctx->avContext->streams[ctx->videoIndex], &retSize);
            if (seqHeaderSize < 0) {
                printf("%s[%d:%d] Failed to build seqHeader\n",
                TAG, getpid(), gettid());
                ret = -1;
                return ret;
            }
            ctx->firstPacket = 0;
        }
        if ((ctx->avpacket.size <= avalBufSize)
            && (seqHeaderSize <= avalBufSize)) {
            int bufSize = 0;
            if (seqHeaderSize) {
                memcpy(bufPtr, seqHeader, seqHeaderSize);
                bufSize = seqHeaderSize;
                /*memcpy((char *)bufPtr+bufSize,ctx->avpacket.data, ctx->avpacket.size);
                bufSize += ctx->avpacket.size;
                av_packet_unref(&ctx->avpacket);
                ctx->avpacket.size = 0;*/
            } else {
                memcpy(bufPtr,ctx->avpacket.data, ctx->avpacket.size);
                bufSize = ctx->avpacket.size;
                av_packet_unref(&ctx->avpacket);
                ctx->avpacket.size = 0;
            }
            inputBuffer->vstream_buf.size = bufSize;
        } else {
            printf("%s[%d:%d] The stream buffer is too "
            "small!\n", TAG, getpid(), gettid());
            return -1;
        }
        if (seqHeader) {
            free(seqHeader);
            seqHeader = NULL;
        }
        return 1;
    }
    // MC_FEEDING_MODE_STREAM_SIZE mode
    do {
        ret = fread(bufPtr, 1, avalBufSize, ctx->inFile);
        if (ret <= 0 && doRewind == FALSE) {
            printf("%s[%d:%d] Failed to read input file (error=0x%x)\n",
                TAG, getpid(), gettid(), ret);
        }
        if (ret <= 0 && doRewind == TRUE) {
            if(fseek(ctx->inFile, 0, SEEK_SET)) {
                printf("%s Failed to rewind input file (pid=%d, tid=%d)\n",
                    TAG, getpid(), gettid());
                break;
            }
        }
    } while (ret == 0 && doRewind == TRUE);
    inputBuffer->vstream_buf.size = ret > 0 ? ret : 0;
    return ret;
}
static int write_output_frames(MediaCodecTestContext *ctx,
    media_codec_buffer_t *outputBuffer) {
    int32_t ret = 0;
    EXPECT_NE(ctx, nullptr);
    EXPECT_NE(ctx->context, nullptr);
    EXPECT_NE(ctx->inFile, nullptr);
    EXPECT_NE(ctx->outFile, nullptr);
    EXPECT_NE(outputBuffer, nullptr);
    if (ctx == NULL || ctx->context == NULL || ctx->inFile == NULL ||
        ctx->outFile == NULL || outputBuffer == NULL) {
        printf("%s[%d:%d] Invalid parameters(%s).\n",
        TAG, getpid(), gettid(), __FUNCTION__);
        return -1;
    }
    if (!ctx->stabilityTest && !ctx->pfTest) {
        fwrite(outputBuffer->vframe_buf.vir_ptr[0], outputBuffer->vframe_buf.size,
            1, ctx->outFile);
    }
    return ret;
}
static int do_decode_params_checking(MediaCodecTestContext *ctx,
    media_codec_buffer_t *outputBuffer) {
    media_codec_context_t *context;
    int32_t ret = 0;
    EXPECT_NE(ctx, nullptr);
    EXPECT_NE(ctx->context, nullptr);
    if (ctx == NULL || ctx->context == NULL || ctx->inFile == NULL ||
        ctx->outFile == NULL || outputBuffer == NULL) {
        printf("%s[%d:%d] Invalid parameters(%s).\n",
        TAG, getpid(), gettid(), __FUNCTION__);
        return -1;
    }
    context = ctx->context;
    if (ctx->enable_get_userdata) {
        mc_user_data_buffer_t userdata = {0};
        ret = hb_mm_mc_get_user_data(context, &userdata, 0);
        if (!ret) {
            printf("%s[%d:%d] Get userdata %d:\n", TAG, getpid(), gettid(), userdata.size);
            for (uint32_t i = 0; i < userdata.size; i++) {
                if (i < 16) {
                    printf("%s[%d:%d] userdata[i]:%x\n", TAG, getpid(), gettid(), userdata.virt_addr[i]);
                } else {
                    printf("%s[%d:%d] userdata[i]:%c\n", TAG, getpid(), gettid(), userdata.virt_addr[i]);
                }
            }
            ret = hb_mm_mc_release_user_data(context, &userdata);
        } else {
            ret = 0;
        }
    }
    return ret;
}
static void do_sync_decoding(void *arg) {
    int ret = 0;
    int step = 0;
    MediaCodecTestContext *ctx = (MediaCodecTestContext *)arg;
    media_codec_context_t *context;
    media_codec_callback_t callback;
    media_codec_buffer_t inputBuffer;
    media_codec_buffer_t outputBuffer;
    media_codec_output_buffer_info_t info;
    int32_t decStartTime = 0, decFinishTime = 0;
    ctx->workMode = THREAD_WORK_MODE_SYNC;
    ASSERT_EQ(check_and_init_test(ctx), 0);
    context = ctx->context;
    //get current time
    ctx->testStartTime = osal_gettime();
    if (ctx->testLog) {
        printf("%s[%d:%d] Step %d initialize (outFile=%s, FileFd=%p)\n",
            TAG, getpid(), gettid(), step++, ctx->outputFileName, ctx->outFile);
    }
    ret = hb_mm_mc_initialize(context);
    ASSERT_EQ(ret, (int32_t)0);
    callback.on_vlc_buffer_message = on_vlc_buffer_message;
    if (ctx->vlc_buf_size > 0) {
        ret = hb_mm_mc_set_vlc_buffer_listener(context, &callback, ctx);
        ASSERT_EQ(ret, (int32_t)0);
    }
    if (ctx->testLog) {
        printf("%s[%d:%d] Step %d configure\n", TAG, getpid(), gettid(), step++);
    }
    ret = hb_mm_mc_configure(context);
    EXPECT_EQ(ret, (int32_t)0);
    if (ctx->testLog) {
        printf("%s[%d:%d] Step %d start\n", TAG, getpid(), gettid(), step++);
    }
    mc_av_codec_startup_params_t startup_params;
    memset(&startup_params, 0x00, sizeof(mc_av_codec_startup_params_t));
    ret = hb_mm_mc_start(context, &startup_params);
    EXPECT_EQ(ret, (int32_t)0);
    do {
        if (!ctx->lastStream) {
            if (ctx->testLog) {
                printf("%s[%d:%d] Step %d dequeue input\n", TAG, getpid(), gettid(), step++);
            }
            // process input buffers
            ret = hb_mm_mc_dequeue_input_buffer(context, &inputBuffer, 3000);
            //EXPECT_EQ(ret, (int32_t)0);
            if (!ret) {
                if (ctx->testLog) {
                    printf("%s[%d:%d] input buffer viraddr %p phy addr %x, size = %d\n",
                    TAG, getpid(), gettid(), inputBuffer.vstream_buf.vir_ptr,
                    inputBuffer.vstream_buf.phy_ptr,
                    inputBuffer.vstream_buf.size);
                }
                if (ctx->testLog) {
                    printf("%s[%d:%d] Step %d feed input (pid=%d, tid=%d)\n", TAG, getpid(), gettid(), step++);
                }
                ret = read_input_streams(ctx, &inputBuffer);
                if (ret <= 0) {
                    printf("%s[%d:%d] There is no more input data(ret=%d)!\n",
                    TAG, getpid(), gettid(), ret);
                    inputBuffer.vstream_buf.stream_end = TRUE;
                    inputBuffer.vstream_buf.size = 0;
                    ctx->lastStream = 1;
                }
                //EXPECT_EQ(ret, (int32_t)TRUE);
                if (ctx->testLog) {
                    printf("%s[%d:%d] Step %d queue input(size=%d)\n",
                    TAG, getpid(), gettid(), step++, inputBuffer.vstream_buf.size);
                }
                ret = hb_mm_mc_queue_input_buffer(context, &inputBuffer, 100);
                EXPECT_EQ(ret, (int32_t)0);
                if (ret != 0) {
                    break;
                }
                if (ctx->delaytest) {
                    decStartTime = osal_gettime();
                }
            } else {
                if (ret != (int32_t)HB_MEDIA_ERR_WAIT_TIMEOUT) {
                    EXPECT_EQ(ret, (int32_t)0);
                    char info[256];
                    hb_mm_strerror(ret, info, 256);
                    printf("%s[%d:%d] dequeue input buffer fail.(%s)\n", TAG, getpid(), gettid(), info);
                    break;
                }
            }
        }
        if (!ctx->lastFrame) {
            if (ctx->testLog) {
            printf("%s[%d:%d] Step %d dequeue output\n", TAG, getpid(), gettid(), step++);
            }
            // process output buffers
            memset(&outputBuffer, 0x00, sizeof(media_codec_buffer_t));
            memset(&info, 0x00, sizeof(media_codec_output_buffer_info_t));
            ret = hb_mm_mc_dequeue_output_buffer(context, &outputBuffer, &info, 100);
            //EXPECT_EQ(ret, (int32_t)0);
            if (!ret) {
                if (ctx->testLog) {
                    printf("%s[%d:%d] output bufferviraddr %p phy addr %x, size = %d, outFile = %p\n",
                    TAG, getpid(), gettid(), outputBuffer.vframe_buf.vir_ptr[0],
                    outputBuffer.vframe_buf.phy_ptr[0],
                    outputBuffer.vframe_buf.size, ctx->outFile);
                }
                if (ctx->testLog) {
                    printf("%s[%d:%d] Step %d write output file\n", TAG, getpid(), gettid(), step++);
                }
                if (ctx->delaytest) {
                    decFinishTime = osal_gettime();
                    if ((decFinishTime - decStartTime) >= ctx->delaytime) {
                        printf("%s[%d:%d] Decoding time is %d, more than %dms\n",
                        TAG, getpid(), gettid(), (decFinishTime - decStartTime), ctx->delaytime);
                        ASSERT_LE((decFinishTime - decStartTime), ctx->delaytime);
                    }
                }
                ASSERT_EQ(write_output_frames(ctx, &outputBuffer), 0);
                if (ctx->testLog) {
                    printf("%s[%d:%d] Step %d queue output\n", TAG, getpid(), gettid(), step++);
                }
                ASSERT_EQ(do_decode_params_checking(ctx, &outputBuffer), 0);
                ret = hb_mm_mc_queue_output_buffer(context, &outputBuffer, 100);
                EXPECT_EQ(ret, (int32_t)0);
                if (outputBuffer.vframe_buf.frame_end) {
                    printf("%s[%d:%d] There is no more output data!\n", TAG, getpid(), gettid());
                    ctx->lastFrame = 1;
                    break;
                }
                if (ret) {
                    break;
                }
            } else {
                char info[256];
                hb_mm_strerror(ret, info, 256);
                printf("%s[%d:%d] dequeue output buffer fail.(%s)\n", TAG, getpid(), gettid(), info);
                if (ret != (int32_t)HB_MEDIA_ERR_WAIT_TIMEOUT) {
                    EXPECT_EQ(ret, (int32_t)0);
                    break;
                }
                if (ctx->stabilityTest && ctx->lastStream ==1) {
                    break;
                }
            }
        }
    }while(TRUE);
    ret = hb_mm_mc_stop(context);
    EXPECT_EQ(ret, (int32_t)0);
    ret = hb_mm_mc_release(context);
    EXPECT_EQ(ret, (int32_t)0);
    ASSERT_EQ(check_and_release_test(ctx), 0);
}
int main(int argc, char *argv[])
{
    char outputFileName[MAX_FILE_PATH] = "input.h265";
    char inputFileName[MAX_FILE_PATH] = "output.yuv";
    mTestWidth = 640;
    mTestHeight = 480;
    mTestPixFmt = MC_PIXEL_FORMAT_YUV420P;
    mTestFeedMode = MC_FEEDING_MODE_FRAME_SIZE;
    mTestCodec = TEST_CODEC_ID_H265;
    mc_video_codec_dec_params_t *params;
    media_codec_context_t *context = (media_codec_context_t *)malloc(sizeof(media_codec_context_t ));
    ASSERT_NE(context, nullptr);
    memset(context, 0x00, sizeof(media_codec_context_t));
    context->codec_id = get_codec_id(mTestCodec);
    context->encoder = FALSE;
    params = &context->video_dec_params;
    params->feed_mode = mTestFeedMode;
    params->pix_fmt = mTestPixFmt;
    params->bitstream_buf_size = mTestWidth * mTestHeight * 3 / 2;
    params->bitstream_buf_count = 6;
    params->frame_buf_count = 8;
    if (context->codec_id == MEDIA_CODEC_ID_H265) {
        params->h265_dec_config.bandwidth_Opt = TRUE;
        params->h265_dec_config.reorder_enable = TRUE;
        params->h265_dec_config.skip_mode = 0;
        params->h265_dec_config.cra_as_bla = FALSE;
        params->h265_dec_config.dec_temporal_id_mode = 0;
        params->h265_dec_config.target_dec_temporal_id_plus1 = 0;
    }
    MediaCodecTestContext ctx;
    memset(&ctx, 0x00, sizeof(ctx));
    ctx.context = context;
    ctx.inputFileName = inputFileName;
    ctx.outputFileName = outputFileName;
    char inputMd5FileName[MAX_FILE_PATH];
    if (ctx.md5Test) {
        char inputMd5Suffix[MAX_FILE_PATH] = ".md5";
        snprintf(dedicatedSuffix, MAX_FILE_PATH, "%s", "dec");
        snprintf(inputMd5FileName, MAX_FILE_PATH, "%s%s_%s_%s%s",
        dedicatedInputPrefix, mGlobalPixFmtName[mTestPixFmt],
        dedicatedSuffix, mGlobalCodecName[mTestCodec], inputMd5Suffix);
        ctx.inputMd5FileName = inputMd5FileName;
    }
    do_sync_decoding(&ctx);
    if (context != NULL) {
        free(context);
    }
}

hb_mm_mc_release_user_data

【函数声明】

hb_s32 hb_mm_mc_release_user_data(media_codec_context_t * context, const mc_user_data_buffer_t * params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_user_data_buffer_t * params：用户数据

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

释放解码流中的用户数据，适用于 H264/H265。

【示例代码】

参考 hb_mm_mc_get_user_data

hb_mm_mc_get_mjpeg_config

【函数声明】

hb_s32 hb_mm_mc_get_mjpeg_config(media_codec_context_t *context, mc_mjpeg_enc_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_mjpeg_enc_params_t *params：MJPEG 编码参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 MJPEG 编码参数，适用于 MJPEG。

【示例代码】

#include "hb_media_codec.h"
#include "hb_media_error.h"
int main(int argc, char *argv[])
{
    int ret = 0;
    char outputFileName[MAX_FILE_PATH];
    char inputFileName[MAX_FILE_PATH];
    mTestCodec = TEST_CODEC_ID_MJPEG;
    mTestPixFmt = MC_PIXEL_FORMAT_NV12;
    char dedicatedSuffix[MAX_FILE_PATH] = "_test";
    char inputSuffix[MAX_FILE_PATH] = ".yuv";
    char outputSuffixJpeg[MAX_FILE_PATH] = ".jpg";
    char outputSuffixMjpg[MAX_FILE_PATH] = ".mjpg";
    snprintf(inputFileName, MAX_FILE_PATH, "%s%s%s",
        mInputSpecPrefix, mTest12Bit ? mGlobal12BPixFmtName[mTestPixFmt]
        : mGlobalPixFmtName[mTestPixFmt], inputSuffix);
    snprintf(outputFileName, MAX_FILE_PATH, "%s%s%s%s",
        mOutputSpecPrefix, mTest12Bit ? mGlobal12BPixFmtName[mTestPixFmt]
        : mGlobalPixFmtName[mTestPixFmt], dedicatedSuffix,
    mTestCodec == TEST_CODEC_ID_JPEG ? outputSuffixJpeg : outputSuffixMjpg);
    mc_video_codec_enc_params_t *params;
    media_codec_context_t *context = (media_codec_context_t *)malloc(sizeof(media_codec_context_t ));
    ASSERT_NE(context, nullptr);
    memset(context, 0x00, sizeof(media_codec_context_t));
    context->codec_id = mTestCodec == TEST_CODEC_ID_JPEG ?
        MEDIA_CODEC_ID_JPEG : MEDIA_CODEC_ID_MJPEG;
    context->encoder = TRUE;
    params = &context->video_enc_params;
    params->width = mTestWidth;
    params->height = mTestHeight;
    params->pix_fmt = mTestPixFmt;
    params->frame_buf_count = 5;
    params->bitstream_buf_count = 5;
    params->rot_degree = MC_CCW_0;
    params->mir_direction = MC_DIRECTION_NONE;
    params->frame_cropping_flag = FALSE;
    params->external_frame_buf = FALSE;
    if (context->codec_id == MEDIA_CODEC_ID_MJPEG) {
        params->rc_params.mode = MC_AV_RC_MODE_MJPEGFIXQP;
        ret = hb_mm_mc_get_rate_control_config(context, &params->rc_params);
        ASSERT_EQ(ret, (int32_t)0);
        params->mjpeg_enc_config.restart_interval = mTestWidth/16;
        params->mjpeg_enc_config.extended_sequential = mTest12Bit;
    } else {
        params->jpeg_enc_config.restart_interval = mTestWidth/16;
        params->jpeg_enc_config.extended_sequential = mTest12Bit;
    }
    mc_mjpeg_enc_params_t mjpeg_params;
    memset(&mjpeg_params, 0x00, sizeof(mjpeg_params));
    ret = hb_mm_mc_get_mjpeg_config(context, &mjpeg_params);
    ASSERT_EQ(ret, (int32_t)0);
    ret = hb_mm_mc_initialize(context);
    ASSERT_EQ(ret, (int32_t)0);
    ret = hb_mm_mc_set_mjpeg_config(context, &mjpeg_params);
    ASSERT_EQ(ret, (int32_t)0);
    ret = hb_mm_mc_stop(context);
    ASSERT_EQ(ret, (int32_t)0);
    ret = hb_mm_mc_release(context);
    ASSERT_EQ(ret, (int32_t)0);
    if (context != NULL) {
        free(context);
    }
}

hb_mm_mc_set_mjpeg_config

【函数声明】

hb_s32 hb_mm_mc_set_mjpeg_config(media_codec_context_t *context, const mc_mjpeg_enc_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_mjpeg_enc_params_t *params：MJPEG 编码参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置 MJPEG 编码参数，该参数为动态参数，适用于 MJPEG。

【示例代码】

参考 hb_mm_mc_get_mjpeg_config

hb_mm_mc_get_jpeg_config

【函数声明】

hb_s32 hb_mm_mc_get_jpeg_config(media_codec_context_t *context, mc_jpeg_enc_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_jpeg_enc_params_t *params：JPEG 编码参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 JPEG 编码参数，适用于 JPEG。

【示例代码】

#include "hb_media_codec.h"
#include "hb_media_error.h"
int main(int argc, char *argv[])
{
    int ret = 0;
    char outputFileName[MAX_FILE_PATH];
    char inputFileName[MAX_FILE_PATH];
    mTestCodec = TEST_CODEC_ID_JPEG;
    mTestPixFmt = MC_PIXEL_FORMAT_NV12;
    char dedicatedSuffix[MAX_FILE_PATH] = "_test";
    char inputSuffix[MAX_FILE_PATH] = ".yuv";
    char outputSuffixJpeg[MAX_FILE_PATH] = ".jpg";
    char outputSuffixMjpg[MAX_FILE_PATH] = ".mjpg";
    snprintf(inputFileName, MAX_FILE_PATH, "%s%s%s",
        mInputSpecPrefix, mTest12Bit ? mGlobal12BPixFmtName[mTestPixFmt]
        : mGlobalPixFmtName[mTestPixFmt], inputSuffix);
    snprintf(outputFileName, MAX_FILE_PATH, "%s%s%s%s",
        mOutputSpecPrefix, mTest12Bit ? mGlobal12BPixFmtName[mTestPixFmt]
        : mGlobalPixFmtName[mTestPixFmt], dedicatedSuffix,
        mTestCodec == TEST_CODEC_ID_JPEG ? outputSuffixJpeg : outputSuffixMjpg);
    mc_video_codec_enc_params_t *params;
    media_codec_context_t *context = (media_codec_context_t *)malloc(sizeof(media_codec_context_t ));
    ASSERT_NE(context, nullptr);
    memset(context, 0x00, sizeof(media_codec_context_t));
    context->codec_id = mTestCodec == TEST_CODEC_ID_JPEG ?
    MEDIA_CODEC_ID_JPEG : MEDIA_CODEC_ID_MJPEG;
    context->encoder = TRUE;
    params = &context->video_enc_params;
    params->width = mTestWidth;
    params->height = mTestHeight;
    params->pix_fmt = mTestPixFmt;
    params->frame_buf_count = 5;
    params->bitstream_buf_count = 5;
    params->rot_degree = MC_CCW_0;
    params->mir_direction = MC_DIRECTION_NONE;
    params->frame_cropping_flag = FALSE;
    params->external_frame_buf = FALSE;
    if (context->codec_id == MEDIA_CODEC_ID_MJPEG) {
        params->rc_params.mode = MC_AV_RC_MODE_MJPEGFIXQP;
        ret = hb_mm_mc_get_rate_control_config(context, &params->rc_params);
        ASSERT_EQ(ret, (int32_t)0);
        params->mjpeg_enc_config.restart_interval = mTestWidth/16;
        params->mjpeg_enc_config.extended_sequential = mTest12Bit;
    } else {
        params->jpeg_enc_config.restart_interval = mTestWidth/16;
        params->jpeg_enc_config.extended_sequential = mTest12Bit;
    }
    mc_jpeg_enc_params_t jpeg_params;
    memset(&jpeg_params, 0x00, sizeof(jpeg_params));
    ret = hb_mm_mc_get_jpeg_config(context, &jpeg_params);
    ASSERT_EQ(ret, (int32_t)0);
    ret = hb_mm_mc_initialize(context);
    ASSERT_EQ(ret, (int32_t)0);
    jpeg_params.quality_factor = 30;
    jpeg_params.restart_interval = (((params->width+15)>>4) *
        ((params->height+15)>>4) * 2) + 1;
    jpeg_params.crop_en = FALSE;
    ret = hb_mm_mc_set_jpeg_config(context, &jpeg_params);
    ASSERT_EQ(ret, (int32_t)HB_MEDIA_ERR_INVALID_PARAMS);
    jpeg_params.restart_interval = 70;
    ret = hb_mm_mc_set_jpeg_config(context, &jpeg_params);
    ASSERT_EQ(ret, (int32_t)0);
    ret = hb_mm_mc_stop(context);
    ASSERT_EQ(ret, (int32_t)0);
    ret = hb_mm_mc_release(context);
    ASSERT_EQ(ret, (int32_t)0);
    if (context != NULL) {
        free(context);
    }
}

hb_mm_mc_set_jpeg_config

【函数声明】

hb_s32 hb_mm_mc_set_jpeg_config(media_codec_context_t *context, const mc_jpeg_enc_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_jpeg_enc_params_t *params：JPEG 编码参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置 JPEG 编码参数，该参数为动态参数，适用于 JPEG。

【示例代码】

参考 hb_mm_mc_get_jpeg_config

hb_mm_mc_get_fd

【函数声明】

hb_s32 hb_mm_mc_get_fd(media_codec_context_t * context, hb_s32 *fd)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] hb_s32 *fd：设备节点 fd

【返回值】

0：操作成功
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取设备节点 fd，可用于 select 操作，监听编解码结果。

【示例代码】

#include "hb_media_codec.h"
#include "hb_media_error.h"

typedef struct MediaCodecTestContext {
    media_codec_context_t *context;
    char *inputFileName;
    char *outputFileName;
    int abnormal;
    int32_t duration; // s
} MediaCodecTestContext;

Uint64 osal_gettime(void)
{
    struct timespec tp;

    clock_gettime(CLOCK_MONOTONIC, &tp);

    return ((Uint64)tp.tv_sec*1000 + tp.tv_nsec/1000000);
}

static void do_poll_encoding_select(void *arg) {
    hb_s32 ret = 0;
    int pollFd = -1;
    FILE *outFile;
    int lastStream = 0;
    fd_set readFds;
    MediaCodecTestContext *ctx = (MediaCodecTestContext *)arg;
    media_codec_context_t *context = ctx->context;
    char *outputFileName = ctx->outputFileName;
    mc_inter_status_t status;

    outFile = fopen(outputFileName, "wb");
    if (!outFile) {
        goto ERR;
    }

    ret = hb_mm_mc_get_fd(context, &pollFd);
    if (ret) {
        goto ERR;
    }

    do {
        FD_ZERO(&readFds);
        FD_SET(pollFd, &readFds);
        ret = select(pollFd+1, &readFds, NULL, NULL, NULL);
        if (ret < 0) {
            printf("Failed to select fd = %d.(err %s)\n", pollFd, strerror(errno));
            ctx->abnormal = TRUE;
            break;
        } else if (ret == 0) {
            printf("Time out to select fd = %d.\n", pollFd);
            ctx->abnormal = TRUE;
            break;
        } else {
            if (FD_ISSET(pollFd, &readFds)) {
                ASSERT_EQ(hb_mm_mc_get_status(context, &status), (int32_t)0);
                if (ctx->testLog) {
                    printf("%s[%d:%d] output count %d input count %d\n", TAG, getpid(), gettid(),
                    status.cur_output_buf_cnt, status.cur_input_buf_cnt);
                }
                media_codec_buffer_t outputBuffer;
                media_codec_output_buffer_info_t info;
                memset(&outputBuffer, 0x00, sizeof(media_codec_buffer_t));
                memset(&info, 0x00, sizeof(media_codec_output_buffer_info_t));
                ret = hb_mm_mc_dequeue_output_buffer(context, &outputBuffer, &info, 100);
                if (!ret && outFile) {
                    fwrite(outputBuffer.vstream_buf.vir_ptr, outputBuffer.vstream_buf.size, 1, outFile);
                    ret = hb_mm_mc_queue_output_buffer(context, &outputBuffer, 100);

                    if (outputBuffer.vstream_buf.stream_end) {
                        printf("%There is no more output data!\n");
                        lastStream = 1;
                        break;
                    }
                    if (ret) {
                        ctx->abnormal = TRUE;
                        break;
                    }
                } else {
                    if (ret != (int32_t)HB_MEDIA_ERR_WAIT_TIMEOUT) {
                        printf("Dequeue output buffer fail.\n");
                        break;
                    }
                }
            }
        }
    } while (!lastStream && !ctx->abnormal);

ERR:
    if (pollFd) {
        hb_mm_mc_close_fd(context, pollFd)
    }
    if (outFile)
        fclose(outFile);
}

static void do_poll_encoding(void *arg) {
    pthread_t thread_id;
    void* retVal;
    hb_s32 ret = 0;
    FILE *inFile;
    int noMoreInput = 0;
    MediaCodecTestContext *ctx = (MediaCodecTestContext *)arg;
    media_codec_context_t *context = ctx->context;

    char *inputFileName = ctx->inputFileName;
    char *outputFileName = ctx->outputFileName;
    media_codec_state_t state = MEDIA_CODEC_STATE_NONE;
    inFile = fopen(inputFileName, "rb");
    if (!inFile) {
        goto ERR;
    }

    ret = hb_mm_mc_initialize(context);
    if (ret) {
        goto ERR;
    }

    ret = hb_mm_mc_configure(context);
    if (ret) {
        goto ERR;
    }

    mc_av_codec_startup_params_t startup_params;
    startup_params.video_enc_startup_params.receive_frame_number = 0;
    ret = hb_mm_mc_start(context, &startup_params);
    if (ret) {
        goto ERR;
    }

    pthread_create(&thread_id, NULL, (void* (*)(void*))do_poll_encoding_select, ctx);

    do {
        media_codec_buffer_t inputBuffer;
        memset(&inputBuffer, 0x00, sizeof(media_codec_buffer_t));
        ret = hb_mm_mc_dequeue_input_buffer(context, &inputBuffer, 100);
        if (!ret) {
            ret = fread(inputBuffer.vframe_buf.vir_ptr[0], 1,
                inputBuffer.vframe_buf.size, inFile);
            if (!ret) {
                printf("There is no more input data!\n");
                inputBuffer.vframe_buf.frame_end = TRUE;
                noMoreInput = 1;
            }
            ret = hb_mm_mc_queue_input_buffer(context, &inputBuffer, 100);
            if (ret) {
                printf("Queue input buffer fail.\n");
                break;
            }
        } else {
            if (ret != (int32_t)HB_MEDIA_ERR_WAIT_TIMEOUT) {
                printf("Dequeue input buffer fail.\n");
                break;
            }
        }
    }while(!noMoreInput && !ctx->abnormal);

    pthread_join(thread_id, &retVal);

    hb_mm_mc_stop(context);

    hb_mm_mc_release(context);
    context = NULL;

ERR:
    hb_mm_mc_get_state(context, &state);
    if (context && state != MEDIA_CODEC_STATE_UNINITIALIZED) {
        hb_mm_mc_stop(context);
        hb_mm_mc_release(context);
    }

    if (inFile)
        fclose(inFile);
}

int main(int argc, char *argv[])
{
    hb_s32 ret = 0;
    char outputFileName[MAX_FILE_PATH] = "./tmp.yuv";
    char inputFileName[MAX_FILE_PATH] = "./output.stream";
    mc_video_codec_enc_params_t *params;
    media_codec_context_t context;

    memset(&context, 0x00, sizeof(media_codec_context_t));
    context.codec_id = MEDIA_CODEC_ID_H265;
    context.encoder = TRUE;
    params = &context.video_enc_params;
    params->width = 640;
    params->height = 480;
    params->pix_fmt = MC_PIXEL_FORMAT_YUV420P;
    params->frame_buf_count = 5;
    params->external_frame_buf = FALSE;
    params->bitstream_buf_count = 5;
    params->rc_params.mode = MC_AV_RC_MODE_H265CBR;
    ret = hb_mm_mc_get_rate_control_config(&context, &params->rc_params);
    if (ret) {
        return -1;
    }
    params->rc_params.h265_cbr_params.bit_rate = 5000;
    params->rc_params.h265_cbr_params.frame_rate = 30;
    params->rc_params.h265_cbr_params.intra_period = 30;
    params->gop_params.decoding_refresh_type = 2;
    params->gop_params.gop_preset_idx = 2;
    params->rot_degree = MC_CCW_0;
    params->mir_direction = MC_DIRECTION_NONE;
    params->frame_cropping_flag = FALSE;

    MediaCodecTestContext ctx;
    memset(&ctx, 0x00, sizeof(ctx));
    ctx.context = &context;
    ctx.inputFileName = inputFileName;
    ctx.outputFileName = outputFileName;
    ctx.duration = 5;
    do_poll_encoding(&ctx);
}

hb_mm_mc_close_fd

【函数声明】

hb_s32 hb_mm_mc_close_fd(media_codec_context_t * context, hb_s32 fd)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] hb_s32 fd：设备节点 fd

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

关闭设备节点。

【示例代码】

参考 hb_mm_mc_get_fd

hb_mm_mc_set_camera

【函数声明】

hb_s32 hb_mm_mc_set_camera(media_codec_context_t *context, hb_s32 pipeline, hb_s32 channel_port_id)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] hb_s32 pipeline：pipeline
[IN] hb_s32 channel_port_id：通道端口号

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置 VIO 的 camera 信息，该参数为静态参数，适用于 H264/H265。

【示例代码】

#include "hb_media_codec.h"
#include "hb_media_error.h"
typedef struct _media_codec_context {
    media_codec_id_t codec_id;
    hb_bool encoder;
    hb_s32 instance_index;
    union {
        mc_video_codec_enc_params_t video_enc_params;
        mc_video_codec_dec_params_t video_dec_params;
        mc_audio_codec_enc_params_t audio_enc_params;
        mc_audio_codec_dec_params_t audio_dec_params;
    };
} media_codec_context_t;
void MediaCodecAPITest::init_params_H265() {
    memset(&context, 0x00, sizeof(media_codec_context_t));
    context.codec_id = MEDIA_CODEC_ID_H265;
    context.encoder = TRUE;
    params = &context.video_enc_params;
    params->width = mGlobalWidth;
    params->height = mGlobalHeight;
    params->pix_fmt = mGlobalPixFmt;
    params->frame_buf_count = 5;
    params->external_frame_buf = FALSE;
    params->bitstream_buf_count = 5;
    params->rc_params.mode = MC_AV_RC_MODE_H265CBR;
    EXPECT_EQ(hb_mm_mc_get_rate_control_config(&context, &params->rc_params), (int32_t)0);
    params->rc_params.h265_cbr_params.bit_rate = 5000;
    params->rc_params.h265_cbr_params.frame_rate = 30;
    params->rc_params.h265_cbr_params.intra_period = 6;
    params->gop_params.decoding_refresh_type = 2;
    params->gop_params.gop_preset_idx = 2;
    params->rot_degree = MC_CCW_0;
    params->mir_direction = MC_DIRECTION_NONE;
    params->frame_cropping_flag = FALSE;
}
int main(int argc, char *argv[])
{
    init_params_H265();
    EXPECT_EQ(hb_mm_mc_initialize(&context), (int32_t)0);
    EXPECT_EQ(hb_mm_mc_set_camera(&context, 1, 1), (int32_t)0);
    EXPECT_EQ(hb_mm_mc_release(&context), (int32_t)0);
}

hb_mm_mc_get_vui_config

【函数声明】

hb_s32 hb_mm_mc_get_vui_config(media_codec_context_t *context, mc_video_vui_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] mc_video_vui_ params_t *params：VUI 参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 VUI 参数。

【其他说明】

目前 video 编码时设置头信息中的默认 color range 为 full range 模式，如果设置 limit range 需要显式调用 hb_mm_mc_set_vui_config 接口。

【示例代码】

#include "hb_media_codec.h"
#include "hb_media_error.h"
typedef enum ENC_CONFIG_MESSAGE {
    ENC_CONFIG_NONE = (0 << 0),
    ENC_CONFIG_LONGTERM_REF = (1 << 0),
    ENC_CONFIG_INTRA_REFRESH = (1 << 1),
    ENC_CONFIG_RATE_CONTROL = (1 << 2),
    ENC_CONFIG_DEBLK_FILTER = (1 << 3),
    ENC_CONFIG_SAO = (1 << 4),
    ENC_CONFIG_ENTROPY = (1 << 5),
    ENC_CONFIG_VUI_TIMING = (1 << 6),
    ENC_CONFIG_SLICE = (1 << 7),
    ENC_CONFIG_REQUEST_IDR = (1 << 8),
    ENC_CONFIG_SKIP_PIC = (1 << 9),
    ENC_CONFIG_SMART_BG = (1 << 10),
    ENC_CONFIG_MONOCHROMA = (1 << 11),
    ENC_CONFIG_PRED_UNIT = (1 << 12),
    ENC_CONFIG_TRANSFORM = (1 << 13),
    ENC_CONFIG_ROI = (1 << 14),
    ENC_CONFIG_MODE_DECISION = (1 << 15),
    ENC_CONFIG_USER_DATA = (1 << 16),
    ENC_CONFIG_MJPEG = (1 << 17),
    ENC_CONFIG_JPEG = (1 << 18),
    ENC_CONFIG_CAMERA = (1 << 19),
    ENC_CONFIG_INSERT_USERDATA = (1 << 20),
    ENC_CONFIG_VUI = (1 << 21),
    ENC_CONFIG_3DNR = (1 << 22),
    ENC_CONFIG_REQUEST_IDR_HEADER = (1 << 23),
    ENC_CONFIG_ENABLE_IDR = (1 << 24),
    ENC_CONFIG_TOTAL = (1 << 25),
} ENC_CONFIG_MESSAGE;
typedef struct MediaCodecTestContext {
    media_codec_context_t *context;
    char *inputFileName;
    char *outputFileName;
    int32_t duration; // s
    ENC_CONFIG_MESSAGE message;
    mc_video_longterm_ref_mode_t ref_mode;
    mc_rate_control_params_t rc_params;
    mc_video_intra_refresh_params_t intra_refr;
    mc_video_deblk_filter_params_t deblk_filter;
    mc_h265_sao_params_t sao;
    mc_h264_entropy_params_t entropy;
    mc_video_vui_params_t vui;
    mc_video_vui_timing_params_t vui_timing;
    mc_video_slice_params_t slice;
    mc_video_3dnr_enc_params_t noise_reduction;
    mc_video_smart_bg_enc_params_t smart_bg;
    mc_video_pred_unit_params_t pred_unit;
    mc_video_transform_params_t transform;
    mc_video_roi_params_t roi;
    mc_video_mode_decision_params_t mode_decision;
} MediaCodecTestContext;
Uint64 osal_gettime(void)
{
    struct timespec tp;
    clock_gettime(CLOCK_MONOTONIC, &tp);
    return ((Uint64)tp.tv_sec*1000 + tp.tv_nsec/1000000);
}
uint8_t uuid[] =
"dc45e9bd-e6d948b7-962cd820-d923eeef+HorizonAI";
static void set_message(MediaCodecTestContext *ctx) {
    int ret = 0;
    media_codec_context_t *context = ctx->context;
    if (ctx->message & ENC_CONFIG_VUI) {
        hb_mm_mc_get_vui_config(context, &ctx->vui);
        ret = hb_mm_mc_set_vui_config(context, &ctx->vui);
    }
}
static void do_sync_encoding(void *arg) {
    hb_s32 ret = 0;
    FILE *inFile;
    FILE *outFile;
    int noMoreInput = 0;
    int lastStream = 0;
    Uint64 lastTime = 0;
    Uint64 curTime = 0;
    int needFlush = 1;
    MediaCodecTestContext *ctx = (MediaCodecTestContext *)arg;
    media_codec_context_t *context = ctx->context;
    char *inputFileName = ctx->inputFileName;
    char *outputFileName = ctx->outputFileName;
    media_codec_state_t state = MEDIA_CODEC_STATE_NONE;
    inFile = fopen(inputFileName, "rb");
    if (!inFile) {
        goto ERR;
    }
    outFile = fopen(outputFileName, "wb");
    if (!outFile) {
        goto ERR;
    }
    //get current time
    lastTime = osal_gettime();
    ret = hb_mm_mc_initialize(context);
    if (ret) {
        goto ERR;
    }
    ret = hb_mm_mc_configure(context);
    if (ret) {
        goto ERR;
    }
    mc_av_codec_startup_params_t startup_params;
    startup_params.video_enc_startup_params.receive_frame_number = 0;
    ret = hb_mm_mc_start(context, &startup_params);
    if (ret) {
        goto ERR;
    }
    ret = hb_mm_mc_pause(context);
    if (ret) {
        goto ERR;
    }
    do {
    set_message(ctx);
    if (!noMoreInput) {
        media_codec_buffer_t inputBuffer;
        memset(&inputBuffer, 0x00, sizeof(media_codec_buffer_t));
        ret = hb_mm_mc_dequeue_input_buffer(context, &inputBuffer, 100);
        if (!ret) {
            curTime = osal_gettime();
            if ((curTime - lastTime)/1000 < (uint32_t)ctx->duration) {
                ret = fread(inputBuffer.vframe_buf.vir_ptr[0], 1,
                inputBuffer.vframe_buf.size, inFile);
                if (ret <= 0) {
                    if(fseek(inFile, 0, SEEK_SET)) {
                        printf("Failed to rewind input filen");
                    } else {
                        ret = fread(inputBuffer.vframe_buf.vir_ptr[0], 1,
                        inputBuffer.vframe_buf.size, inFile);
                        if (ret <= 0) {
                            printf("Failed to read input filen");
                        }
                    }
                }
            } else {
                printf("Time up(%d)n",ctx->duration);
                ret = 0;
            }
            if (!ret) {
                printf("There is no more input data!n");
                inputBuffer.vframe_buf.frame_end = TRUE;
                noMoreInput = 1;
            }
            ret = hb_mm_mc_queue_input_buffer(context, &inputBuffer, 100);
            if (ret) {
                printf("Queue input buffer fail.n");
                break;
            }
        } else {
            if (ret != (int32_t)HB_MEDIA_ERR_WAIT_TIMEOUT) {
                printf("Dequeue input buffer fail.n");
                break;
            }
        }
    }
    if (!lastStream) {
        media_codec_buffer_t outputBuffer;
        media_codec_output_buffer_info_t info;
        memset(&outputBuffer, 0x00, sizeof(media_codec_buffer_t));
        memset(&info, 0x00, sizeof(media_codec_output_buffer_info_t));
        ret = hb_mm_mc_dequeue_output_buffer(context, &outputBuffer, &info,
        3000);
        if (!ret && outFile) {
            fwrite(outputBuffer.vstream_buf.vir_ptr,
                outputBuffer.vstream_buf.size, 1, outFile);
            ret = hb_mm_mc_queue_output_buffer(context, &outputBuffer, 100);
            if (ret) {
                printf("Queue output buffer fail.n");
                break;
            }
            if (outputBuffer.vstream_buf.stream_end) {
                printf("There is no more output data!n");
                lastStream = 1;
                break;
            }
        } else {
            if (ret != (int32_t)HB_MEDIA_ERR_WAIT_TIMEOUT) {
                printf("Dequeue output buffer fail.n");
                break;
            }
        }
    }
    if (needFlush) {
        ret = hb_mm_mc_flush(context);
        needFlush = 0;
        if (ret) {
            break;
        }
    }
}while(TRUE);
hb_mm_mc_stop(context);
hb_mm_mc_release(context);
context = NULL;
ERR:
hb_mm_mc_get_state(context, &state);
if (context && state!=
    MEDIA_CODEC_STATE_UNINITIALIZED) {
    hb_mm_mc_stop(context);
    hb_mm_mc_release(context);
}
if (inFile)
    fclose(inFile);
if (outFile)
    fclose(outFile);
}
int main(int argc, char *argv[])
{
    hb_s32 ret = 0;
    char outputFileName[MAX_FILE_PATH] = "./tmp.yuv";
    char inputFileName[MAX_FILE_PATH] = "./output.stream";
    mc_video_codec_enc_params_t *params;
    media_codec_context_t context;
    memset(&context, 0x00, sizeof(media_codec_context_t));
    context.codec_id = MEDIA_CODEC_ID_H265;
    context.encoder = TRUE;
    params = &context.video_enc_params;
    params->width = 640;
    params->height = 480;
    params->pix_fmt = MC_PIXEL_FORMAT_YUV420P;
    params->frame_buf_count = 5;
    params->external_frame_buf = FALSE;
    params->bitstream_buf_count = 5;
    params->rc_params.mode = MC_AV_RC_MODE_H265CBR;
    ret = hb_mm_mc_get_rate_control_config(&context, &params->rc_params);
    if (ret) {
        return -1;
    }
    params->rc_params.h265_cbr_params.bit_rate = 5000;
    params->rc_params.h265_cbr_params.frame_rate = 30;
    params->rc_params.h265_cbr_params.intra_period = 30;
    params->gop_params.decoding_refresh_type = 2;
    params->gop_params.gop_preset_idx = 2;
    params->rot_degree = MC_CCW_0;
    params->mir_direction = MC_DIRECTION_NONE;
    params->frame_cropping_flag = FALSE;
    MediaCodecTestContext ctx;
    memset(&ctx, 0x00, sizeof(ctx));
    ctx.context = &context;
    ctx.inputFileName = inputFileName;
    ctx.outputFileName = outputFileName;
    mc_video_vui_params_t *vui = &ctx.vui;
    ret = hb_mm_mc_get_vui_config(context, vui);
    if (ret != 0) {
        return -1;
    }
    vui->h265_vui.video_signal_type_present_flag = 1;
    vui->h265_vui.video_format = 0;
    vui->h265_vui.video_full_range_flag = 0;
    ctx.message = ENC_CONFIG_VUI;
    do_sync_encoding(&ctx);
}

hb_mm_mc_set_vui_config

【函数声明】

hb_s32 hb_mm_mc_set_vui_config(media_codec_context_t *context, const mc_video_vui_params_t *params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_video_vui_params_t *params：VUI 参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置 VUI 参数，该参数为静态参数。

【示例代码】

参考 hb_mm_mc_get_vui_config

hb_mm_mc_get_3dnr_enc_config

【函数声明】

hb_s32 hb_mm_mc_get_3dnr_enc_config(media_codec_context_t *context, mc_video_3dnr_enc_params_t *params);

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] mc_video_3dnr_enc_params_t *params：3DNR 参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取3DNR 参数，该参数为动态参数，适用于 H265.

【示例代码】

#include "hb_media_codec.h"
#include "hb_media_error.h"
typedef enum ENC_CONFIG_MESSAGE {
    ENC_CONFIG_NONE = (0 << 0),
    ENC_CONFIG_LONGTERM_REF = (1 << 0),
    ENC_CONFIG_INTRA_REFRESH = (1 << 1),
    ENC_CONFIG_RATE_CONTROL = (1 << 2),
    ENC_CONFIG_DEBLK_FILTER = (1 << 3),
    ENC_CONFIG_SAO = (1 << 4),
    ENC_CONFIG_ENTROPY = (1 << 5),
    ENC_CONFIG_VUI_TIMING = (1 << 6),
    ENC_CONFIG_SLICE = (1 << 7),
    ENC_CONFIG_REQUEST_IDR = (1 << 8),
    ENC_CONFIG_SKIP_PIC = (1 << 9),
    ENC_CONFIG_SMART_BG = (1 << 10),
    ENC_CONFIG_MONOCHROMA = (1 << 11),
    ENC_CONFIG_PRED_UNIT = (1 << 12),
    ENC_CONFIG_TRANSFORM = (1 << 13),
    ENC_CONFIG_ROI = (1 << 14),
    ENC_CONFIG_MODE_DECISION = (1 << 15),
    ENC_CONFIG_USER_DATA = (1 << 16),
    ENC_CONFIG_MJPEG = (1 << 17),
    ENC_CONFIG_JPEG = (1 << 18),
    ENC_CONFIG_CAMERA = (1 << 19),
    ENC_CONFIG_INSERT_USERDATA = (1 << 20),
    ENC_CONFIG_VUI = (1 << 21),
    ENC_CONFIG_3DNR = (1 << 22),
    ENC_CONFIG_REQUEST_IDR_HEADER = (1 << 23),
    ENC_CONFIG_ENABLE_IDR = (1 << 24),
    ENC_CONFIG_TOTAL = (1 << 25),
} ENC_CONFIG_MESSAGE;
typedef struct MediaCodecTestContext {
    media_codec_context_t *context;
    char *inputFileName;
    char *outputFileName;
    int32_t duration; // s
    ENC_CONFIG_MESSAGE message;
    mc_video_longterm_ref_mode_t ref_mode;
    mc_rate_control_params_t rc_params;
    mc_video_intra_refresh_params_t intra_refr;
    mc_video_deblk_filter_params_t deblk_filter;
    mc_h265_sao_params_t sao;
    mc_h264_entropy_params_t entropy;
    mc_video_vui_params_t vui;
    mc_video_vui_timing_params_t vui_timing;
    mc_video_slice_params_t slice;
    mc_video_3dnr_enc_params_t noise_reduction;
    mc_video_smart_bg_enc_params_t smart_bg;
    mc_video_pred_unit_params_t pred_unit;
    mc_video_transform_params_t transform;
    mc_video_roi_params_t roi;
    mc_video_mode_decision_params_t mode_decision;
} MediaCodecTestContext;
Uint64 osal_gettime(void)
{
    struct timespec tp;
    clock_gettime(CLOCK_MONOTONIC, &tp);
    return ((Uint64)tp.tv_sec*1000 + tp.tv_nsec/1000000);
}
uint8_t uuid[] =
"dc45e9bd-e6d948b7-962cd820-d923eeef+HorizonAI";
static void set_message(MediaCodecTestContext *ctx) {
    int ret = 0;
    media_codec_context_t *context = ctx->context;
    if (ctx->message & ENC_CONFIG_VUI) {
        hb_mm_mc_get_vui_config(context, &ctx->vui);
        ret = hb_mm_mc_set_vui_config(context, &ctx->vui);
    }
}
static void do_sync_encoding(void *arg) {
    hb_s32 ret = 0;
    FILE *inFile;
    FILE *outFile;
    int noMoreInput = 0;
    int lastStream = 0;
    Uint64 lastTime = 0;
    Uint64 curTime = 0;
    int needFlush = 1;
    MediaCodecTestContext *ctx = (MediaCodecTestContext *)arg;
    media_codec_context_t *context = ctx->context;
    char *inputFileName = ctx->inputFileName;
    char *outputFileName = ctx->outputFileName;
    media_codec_state_t state = MEDIA_CODEC_STATE_NONE;
    inFile = fopen(inputFileName, "rb");
    if (!inFile) {
        goto ERR;
    }
    outFile = fopen(outputFileName, "wb");
    if (!outFile) {
        goto ERR;
    }
    //get current time
    lastTime = osal_gettime();
    ret = hb_mm_mc_initialize(context);
    if (ret) {
        goto ERR;
    }
    ret = hb_mm_mc_configure(context);
    if (ret) {
        goto ERR;
    }
    mc_av_codec_startup_params_t startup_params;
    startup_params.video_enc_startup_params.receive_frame_number = 0;
    ret = hb_mm_mc_start(context, &startup_params);
    if (ret) {
        goto ERR;
    }
    ret = hb_mm_mc_pause(context);
    if (ret) {
        goto ERR;
    }
    do {
    set_message(ctx);
    if (!noMoreInput) {
        media_codec_buffer_t inputBuffer;
        memset(&inputBuffer, 0x00, sizeof(media_codec_buffer_t));
        ret = hb_mm_mc_dequeue_input_buffer(context, &inputBuffer, 100);
        if (!ret) {
            curTime = osal_gettime();
            if ((curTime - lastTime)/1000 < (uint32_t)ctx->duration) {
                ret = fread(inputBuffer.vframe_buf.vir_ptr[0], 1,
                inputBuffer.vframe_buf.size, inFile);
                if (ret <= 0) {
                    if(fseek(inFile, 0, SEEK_SET)) {
                        printf("Failed to rewind input filen");
                    } else {
                        ret = fread(inputBuffer.vframe_buf.vir_ptr[0], 1,
                        inputBuffer.vframe_buf.size, inFile);
                        if (ret <= 0) {
                            printf("Failed to read input filen");
                        }
                    }
                }
            } else {
                printf("Time up(%d)n",ctx->duration);
                ret = 0;
            }
            if (!ret) {
                printf("There is no more input data!n");
                inputBuffer.vframe_buf.frame_end = TRUE;
                noMoreInput = 1;
            }
            ret = hb_mm_mc_queue_input_buffer(context, &inputBuffer, 100);
            if (ret) {
                printf("Queue input buffer fail.n");
                break;
            }
        } else {
            if (ret != (int32_t)HB_MEDIA_ERR_WAIT_TIMEOUT) {
                printf("Dequeue input buffer fail.n");
                break;
            }
        }
    }
    if (!lastStream) {
        media_codec_buffer_t outputBuffer;
        media_codec_output_buffer_info_t info;
        memset(&outputBuffer, 0x00, sizeof(media_codec_buffer_t));
        memset(&info, 0x00, sizeof(media_codec_output_buffer_info_t));
        ret = hb_mm_mc_dequeue_output_buffer(context, &outputBuffer, &info,
        3000);
        if (!ret && outFile) {
            fwrite(outputBuffer.vstream_buf.vir_ptr,
                outputBuffer.vstream_buf.size, 1, outFile);
            ret = hb_mm_mc_queue_output_buffer(context, &outputBuffer, 100);
            if (ret) {
                printf("Queue output buffer fail.n");
                break;
            }
            if (outputBuffer.vstream_buf.stream_end) {
                printf("There is no more output data!n");
                lastStream = 1;
                break;
            }
        } else {
            if (ret != (int32_t)HB_MEDIA_ERR_WAIT_TIMEOUT) {
                printf("Dequeue output buffer fail.n");
                break;
            }
        }
    }
    if (needFlush) {
        ret = hb_mm_mc_flush(context);
        needFlush = 0;
        if (ret) {
            break;
        }
    }
}while(TRUE);
hb_mm_mc_stop(context);
hb_mm_mc_release(context);
context = NULL;
ERR:
hb_mm_mc_get_state(context, &state);
if (context && state!=
    MEDIA_CODEC_STATE_UNINITIALIZED) {
    hb_mm_mc_stop(context);
    hb_mm_mc_release(context);
}
if (inFile)
    fclose(inFile);
if (outFile)
    fclose(outFile);
}
int main(int argc, char *argv[])
{
    hb_s32 ret = 0;
    char outputFileName[MAX_FILE_PATH] = "./tmp.yuv";
    char inputFileName[MAX_FILE_PATH] = "./output.stream";
    mc_video_codec_enc_params_t *params;
    media_codec_context_t context;
    memset(&context, 0x00, sizeof(media_codec_context_t));
    context.codec_id = MEDIA_CODEC_ID_H265;
    context.encoder = TRUE;
    params = &context.video_enc_params;
    params->width = 640;
    params->height = 480;
    params->pix_fmt = MC_PIXEL_FORMAT_YUV420P;
    params->frame_buf_count = 5;
    params->external_frame_buf = FALSE;
    params->bitstream_buf_count = 5;
    params->rc_params.mode = MC_AV_RC_MODE_H265CBR;
    ret = hb_mm_mc_get_rate_control_config(&context, &params->rc_params);
    if (ret) {
        return -1;
    }
    params->rc_params.h265_cbr_params.bit_rate = 5000;
    params->rc_params.h265_cbr_params.frame_rate = 30;
    params->rc_params.h265_cbr_params.intra_period = 30;
    params->gop_params.decoding_refresh_type = 2;
    params->gop_params.gop_preset_idx = 2;
    params->rot_degree = MC_CCW_0;
    params->mir_direction = MC_DIRECTION_NONE;
    params->frame_cropping_flag = FALSE;
    MediaCodecTestContext ctx;
    memset(&ctx, 0x00, sizeof(ctx));
    ctx.context = &context;
    ctx.inputFileName = inputFileName;
    ctx.outputFileName = outputFileName;
    mc_video_3dnr_enc_params_t *noise_rd = &ctx.noise_reduction;
    ret = hb_mm_mc_get_3dnr_enc_config(context, noise_rd);
    noise_rd->nr_y_enable = 0;
    noise_rd->nr_cb_enable = 0;
    noise_rd->nr_cr_enable = 0;
    noise_rd->nr_est_enable = 0;
    ctx.message = ENC_CONFIG_3DNR;
    do_sync_encoding(&ctx);
}

hb_mm_mc_set_3dnr_enc_config

【函数声明】

hb_s32 hb_mm_mc_set_3dnr_enc_config(media_codec_context_t *context, const mc_video_3dnr_enc_params_t *params);

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] const mc_video_3dnr_enc_params_t *params：3DNR 参数

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

设置3DNR 参数，该参数为动态参数，适用于 H265。

【示例代码】

参考 hb_mm_mc_get_3dnr_enc_config

hb_mm_mc_request_idr_header

【函数声明】

hb_s32 hb_mm_mc_request_idr_header(media_codec_context_t *context, hb_u32 force_header)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] hb_u32 force_header：

0 : No froced header(VPS/SPS/PPS)

1 : Forced header before IDR frame

2 : Forced header before I frame for H264 or forced header before CRA and IDR frame for H265

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

请求帧头 IDR 帧头信息，适用于 H264/H265。

【示例代码】

hb_mm_mc_enable_idr_frame

【函数声明】

hb_s32 hb_mm_mc_enable_idr_frame(media_codec_context_t *context, hb_bool enable)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] hb_bool enable：0：不使能；1：使能；

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

使能 IDR 帧，适用于 H264/H265。

【示例代码】

hb_mm_mc_register_audio_encoder

【函数声明】

hb_s32 hb_mm_mc_register_audio_encoder(hb_s32 *handle, mc_audio_encode_param_t *encoder)

【参数描述】

[IN] hb_s32 *handle：编码器句柄
[IN] mc_audio_encode_param_t *encoder：audio 编码器描述符；

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

【示例代码】

#include "hb_media_codec.h"
#include "hb_media_error.h"
#include "include/aac.h"
int main(int argc, char *argv[])
{
    mc_audio_codec_enc_params_t *params;
    media_codec_context_t context;
    memset(&context, 0x00, sizeof(media_codec_context_t));
    context.codec_id = MEDIA_CODEC_ID_AAC;
    context.encoder = TRUE;
    params = &context.audio_enc_params;
    params->bit_rate = 128000;
    params->frame_buf_count = 5;
    params->packet_count = 5;
    params->sample_fmt = MC_AV_SAMPLE_FMT_S16;
    params->sample_rate = MC_AV_SAMPLE_RATE_16000;
    params->channel_layout = MC_AV_CHANNEL_LAYOUT_STEREO;
    params->channels = 2;
    mc_aac_enc_config_t config;
    config.profile = MC_AAC_PROFILE_LOW;
    config.type = MC_AAC_DATA_TYPE_ADTS;
    params->enc_config = &config;
    int ret;
    int handle;
    mc_audio_encode_param_t encoder;
    encoder.ff_type = MEDIA_CODEC_ID_AAC;
    snprintf(encoder.ff_codec_name, sizeof(encoder.ff_codec_name), "aacenc");
    encoder.ff_audio_open_encoder = ff_audio_aac_open_encoder;
    encoder.ff_audio_encode_frame = ff_audio_aac_encode_frm;
    encoder.ff_audio_close_encoder = ff_audio_aac_close_encoder;
    ret = hb_mm_mc_register_audio_encoder(&handle, &encoder);
    printf("handle = %d\n", handle);
    ASSERT_EQ(ret, 0);
    ret = hb_mm_mc_unregister_audio_encoder(handle);
    ASSERT_EQ(ret, 0);
}

hb_mm_mc_unregister_audio_encoder

【函数声明】

hb_s32 hb_mm_mc_unregister_audio_encoder(hb_s32 handle)

【参数描述】

[IN] hb_s32 *handle：编码器句柄

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

注销 audio 编码器，适用于 Audio。

【示例代码】

参考 hb_mm_mc_register_audio_encoder

hb_mm_mc_register_audio_decoder

【函数声明】

hb_s32 hb_mm_mc_register_audio_decoder(hb_s32 *handle, mc_audio_decode_param_t *decoder)

【参数描述】

[IN] hb_s32 *handle：解码器句柄
[IN] mc_audio_decode_param_t *decoder：audio 解码器描述符；

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

【示例代码】

#include "hb_media_codec.h"
#include "hb_media_error.h"
#include "include/aac.h"
int main(int argc, char *argv[])
{
    mc_audio_codec_dec_params_t *params;
    media_codec_context_t context;
    memset(&context, 0x00, sizeof(media_codec_context_t));
    context.codec_id = MEDIA_CODEC_ID_AAC;
    context.encoder = FALSE;
    params = &context.audio_dec_params;
    params->feed_mode = MC_FEEDING_MODE_FRAME_SIZE;
    params->packet_buf_size = 1024;
    params->packet_count = 5;
    params->frame_cache_size = 5;
    params->frame_buf_count = 5;
    mc_aac_dec_config_t config;
    config.sample_rate = MC_AV_SAMPLE_RATE_8000;
    config.channels = 1;
    config.sample_fmt = MC_AV_SAMPLE_FMT_S16;
    params->dec_config = &config;
    mc_audio_decode_param_t decoder;
    decoder.ff_type = MEDIA_CODEC_ID_AAC;
    snprintf(decoder.ff_codec_name, sizeof(decoder.ff_codec_name), "aacdec");
    decoder.ff_audio_open_decoder = ff_audio_aac_open_decoder;
    decoder.ff_audio_decode_frame = ff_audio_aac_decode_frm;
    decoder.ff_audio_close_decoder = ff_audio_aac_close_decoder;
    ret = hb_mm_mc_register_audio_decoder(&handle, &decoder);
    ASSERT_EQ(ret, 0);
    ret = hb_mm_mc_unregister_audio_decoder(handle);
    ASSERT_EQ(ret, 0);
}

hb_mm_mc_unregister_audio_decoder

【函数声明】

hb_s32 hb_mm_mc_unregister_audio_decoder(hb_s32 handle)

【参数描述】

[IN] hb_s32 *handle：解码器句柄；

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

注销 audio 解码器，适用于 Audio。

【示例代码】

参考 hb_mm_mc_register_audio_decoder

hb_mm_mc_get_explicit_header_config

【函数声明】

hb_s32 hb_mm_mc_get_explicit_header_config (media_codec_context_t *context, hb_s32 *status)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] hb_s32 *status：使能/不使能头信息和 IDR 帧编码成一帧

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取头信息和 IDR 帧是否编码成一帧的配置，0：IDR 和头信息独立，1：IDR 和头信息合成一帧，适用于 H264/H265。

【示例代码】

hb_mm_mc_set_explicit_header_config

【函数声明】

hb_s32 hb_mm_mc_set_explicit_header_config (media_codec_context_t *context, hb_s32 status)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[IN] hb_s32 status：使能/不使能头信息和 IDR 帧编码成一帧

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_OPERATION_NOT_ALLOWED：操作不允许
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

使能/不使能头信息和 I 帧编码成一帧，该参数为静态参数，0：IDR 和头信息独立，1：IDR 和头信息合成一帧，适用于 H264/H265。

【示例代码】

hb_mm_mc_get_roi_avg_qp

【函数声明】

hb_s32 hb_mm_mc_get_roi_avg_qp(media_codec_context_t * context, hb_u32 * params)

【参数描述】

[IN] media_codec_context_t *context：指定 codec 类型的 context
[OUT] hb_u32 *params：ROI 平均 QP

【返回值】

0：操作成功
HB_MEDIA_ERR_UNKNOWN：未知错误
HB_MEDIA_ERR_INVALID_INSTANCE：无效实例
HB_MEDIA_ERR_INVALID_PARAMS：无效参数

【功能描述】

获取 ROI 平均 QP 值，0：代表该值由用户设定得 QPMAP 决定，适用于 H264/H265。

【示例代码】