package/mpp
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2025-10-04 16:52:40 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[h264]: encoder and decoder share common definition

Browse Source 
[h264e]: separate init and config into two functions and add mpp encoder config check function

git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@1145 6e48237b-75ef-9749-8fc9-41990f28c85a
This commit is contained in:
ChenHengming
2016-08-03 06:20:01 +00:00
parent 64f28f24b2
commit 560213eef9
21 changed files with 421 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
inc/rk_mpi.h
View File

@@ -129,6 +129,10 @@ typedef void* MppParam;
* and decoder will try to decode the
*/
typedef struct MppEncConfig_t {
/* encoder config also need to know size of itself */
RK_U32 size;
RK_U32 version;
/*
* input source data format
*/

2
mpp/codec/dec/h264/h264d_dpb.c
View File

@@ -117,7 +117,7 @@ static RK_S32 getDpbSize(H264dVideoCtx_t *p_Vid, H264_SPS_t *active_sps)
}
size /= pic_size;
if (p_Vid->active_mvc_sps_flag &&
(p_Vid->profile_idc == MVC_HIGH || p_Vid->profile_idc == STEREO_HIGH)) {
(p_Vid->profile_idc == H264_PROFILE_MVC_HIGH || p_Vid->profile_idc == H264_PROFILE_STEREO_HIGH)) {
num_views = p_Vid->active_subsps->num_views_minus1 + 1;
size = MPP_MIN(2 * size, MPP_MAX(1, RoundLog2(num_views)) * 16) / num_views;
} else {

50
mpp/codec/dec/h264/h264d_global.h
View File

@@ -26,9 +26,6 @@
#include "h264d_log.h"
#include "h264d_syntax.h"
//!< define
#define MAXSPS 32
#define MAXPPS 256
#define START_PREFIX_3BYTE 3
#define MAX_NUM_DPB_LAYERS 2
#define MAX_LIST_SIZE 33 //!< for init list reorder
@@ -44,51 +41,6 @@
#define NALU_BUF_MAX_SIZE (10*1024*1024)
#define SODB_BUF_MAX_SIZE (10*1024*1024)
//!< AVC Profile IDC definitions
typedef enum {
FREXT_CAVLC444 = 44, //!< YUV 4:4:4/14 "CAVLC 4:4:4"
BASELINE = 66, //!< YUV 4:2:0/8 "Baseline"
H264_MAIN = 77, //!< YUV 4:2:0/8 "Main"
EXTENDED = 88, //!< YUV 4:2:0/8 "Extended"
FREXT_HP = 100, //!< YUV 4:2:0/8 "High"
FREXT_Hi10P = 110, //!< YUV 4:2:0/10 "High 10"
FREXT_Hi422 = 122, //!< YUV 4:2:2/10 "High 4:2:2"
FREXT_Hi444 = 244, //!< YUV 4:4:4/14 "High 4:4:4"
MVC_HIGH = 118, //!< YUV 4:2:0/8 "Multiview High"
STEREO_HIGH = 128 //!< YUV 4:2:0/8 "Stereo High"
} ProfileIDC;
//!< values for nalu_type
typedef enum {
NALU_TYPE_NULL = 0,
NALU_TYPE_SLICE = 1,
NALU_TYPE_DPA = 2,
NALU_TYPE_DPB = 3,
NALU_TYPE_DPC = 4,
NALU_TYPE_IDR = 5,
NALU_TYPE_SEI = 6,
NALU_TYPE_SPS = 7,
NALU_TYPE_PPS = 8,
NALU_TYPE_AUD = 9, // Access Unit Delimiter
NALU_TYPE_EOSEQ = 10, // end of sequence
NALU_TYPE_EOSTREAM = 11, // end of stream
NALU_TYPE_FILL = 12,
NALU_TYPE_SPSEXT = 13,
NALU_TYPE_PREFIX = 14, // prefix
NALU_TYPE_SUB_SPS = 15,
NALU_TYPE_SLICE_AUX = 19,
NALU_TYPE_SLC_EXT = 20, // slice extensive
NALU_TYPE_VDRD = 24 // View and Dependency Representation Delimiter NAL Unit
} Nalu_type;
//!< values for nal_ref_idc
typedef enum {
NALU_PRIORITY_HIGHEST = 3,
NALU_PRIORITY_HIGH = 2,
NALU_PRIORITY_LOW = 1,
NALU_PRIORITY_DISPOSABLE = 0
} NalRefIdc_type;
//!< PPS parameters
#define MAXnum_slice_groups_minus1 8
enum {
@@ -110,6 +62,7 @@ typedef enum {
FRAME = 0x3,
STRUCT_MAX,
} PictureStructure; //!< New enum for field processing
typedef enum {
PIC_ERR_NULL = 0,
PIC_ERR_TOP = 0x1,
@@ -126,6 +79,7 @@ typedef enum {
FIELD_ORDER_SAME,
FIELD_ORDER_MAX
} FieldOrder;
//!< Field Coding Types
typedef enum {
FRAME_CODING = 0,

2
mpp/codec/dec/h264/h264d_init.c
View File

@@ -548,7 +548,7 @@ static MPP_RET alloc_decpic(H264_SLICE_t *currSlice)
dec_pic->inter_view_flag = currSlice->inter_view_flag;
dec_pic->anchor_pic_flag = currSlice->anchor_pic_flag;
if (dec_pic->layer_id == 1) {
if ((p_Vid->profile_idc == MVC_HIGH) || (p_Vid->profile_idc == STEREO_HIGH)) {
if ((p_Vid->profile_idc == H264_PROFILE_MVC_HIGH) || (p_Vid->profile_idc == H264_PROFILE_STEREO_HIGH)) {
FUN_CHECK(ret = init_mvc_picture(currSlice));
}
}

2
mpp/codec/dec/h264/h264d_scalist.c
View File

@@ -161,7 +161,7 @@ static void set_pps_scanlist_matrix(H264_SPS_t *sps, H264_PPS_t *pps, H264dVideo
//extern "C"
RK_U32 is_prext_profile(RK_U32 profile_idc)
{
return (profile_idc >= FREXT_HP || profile_idc == FREXT_CAVLC444) ? 1 : 0;
return (profile_idc >= H264_PROFILE_HIGH || profile_idc == H264_PROFILE_FREXT_CAVLC444) ? 1 : 0;
}
/*!

20
mpp/codec/dec/h264/h264d_sps.c
View File

@@ -23,6 +23,7 @@
#include "vpu_api.h"
#include "h264_syntax.h"
#include "h264d_log.h"
#include "h264d_sps.h"
#include "h264d_scalist.h"
@@ -154,11 +155,16 @@ static MPP_RET parser_sps(BitReadCtx_t *p_bitctx, H264_SPS_t *cur_sps, H264_DecC
cur_sps->delta_pic_order_always_zero_flag = 0;
LogInfo(p_bitctx->ctx, "----------------------------- SPS begin --------------------------------");
READ_BITS(p_bitctx, 8, &cur_sps->profile_idc, "profile_idc");
VAL_CHECK (ret, (cur_sps->profile_idc == BASELINE) || (cur_sps->profile_idc == H264_MAIN)
|| (cur_sps->profile_idc == EXTENDED) || (cur_sps->profile_idc == FREXT_HP)
|| (cur_sps->profile_idc == FREXT_Hi10P) || (cur_sps->profile_idc == FREXT_Hi422)
|| (cur_sps->profile_idc == FREXT_Hi444) || (cur_sps->profile_idc == FREXT_CAVLC444)
|| (cur_sps->profile_idc == MVC_HIGH) || (cur_sps->profile_idc == STEREO_HIGH)
VAL_CHECK (ret, (cur_sps->profile_idc == H264_PROFILE_BASELINE)
|| (cur_sps->profile_idc == H264_PROFILE_MAIN)
|| (cur_sps->profile_idc == H264_PROFILE_EXTENDED)
|| (cur_sps->profile_idc == H264_PROFILE_HIGH)
|| (cur_sps->profile_idc == H264_PROFILE_HIGH10)
|| (cur_sps->profile_idc == H264_PROFILE_HIGH422)
|| (cur_sps->profile_idc == H264_PROFILE_HIGH444)
|| (cur_sps->profile_idc == H264_PROFILE_FREXT_CAVLC444)
|| (cur_sps->profile_idc == H264_PROFILE_MVC_HIGH)
|| (cur_sps->profile_idc == H264_PROFILE_STEREO_HIGH)
);
READ_ONEBIT(p_bitctx, &cur_sps->constrained_set0_flag, "constrained_set0_flag");
READ_ONEBIT(p_bitctx, &cur_sps->constrained_set1_flag, "constrained_set1_flag");
@@ -326,8 +332,8 @@ static MPP_RET parser_subsps_ext(BitReadCtx_t *p_bitctx, H264_subSPS_t *cur_subs
{
MPP_RET ret = MPP_ERR_UNKNOW;
if ((cur_subsps->sps.profile_idc == MVC_HIGH)
|| (cur_subsps->sps.profile_idc == STEREO_HIGH)) {
if ((cur_subsps->sps.profile_idc == H264_PROFILE_MVC_HIGH)
|| (cur_subsps->sps.profile_idc == H264_PROFILE_STEREO_HIGH)) {
READ_ONEBIT(p_bitctx, &cur_subsps->bit_equal_to_one, "bit_equal_to_one");
ASSERT(cur_subsps->bit_equal_to_one == 1);
FUN_CHECK(ret = sps_mvc_extension(p_bitctx, cur_subsps));

19
mpp/codec/enc/h264/include/H264Init.h
View File

@@ -17,27 +17,12 @@
#ifndef __H264_INIT_H__
#define __H264_INIT_H__
/*------------------------------------------------------------------------------
1. Include headers
------------------------------------------------------------------------------*/
#include "h264encapi.h"
#include "H264Instance.h"
/*------------------------------------------------------------------------------
2. External compiler flags
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
3. Module defines
------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
4. Function prototypes
------------------------------------------------------------------------------*/
bool_e H264CheckCfg(const H264EncConfig * pEncCfg);
i32 H264GetAllowedWidth(i32 width, H264EncPictureFormat inputType);
H264EncRet H264Init(const H264EncConfig * pEncCfg, h264Instance_s * pinst);
H264EncRet H264Init(h264Instance_s * pinst);
H264EncRet H264Cfg(const H264EncConfig * pEncCfg, h264Instance_s * pinst);
#endif

8
mpp/codec/enc/h264/include/H264Instance.h
View File

@@ -82,12 +82,6 @@ typedef struct {
u32 streamSize; /* Size of output stream in bytes */
} H264EncOut;
/* Encoder configure parameter */
typedef struct {
RK_U32 intraPicRate; // set I frame interval, and is 30 default
} H264EncCfg;
typedef struct {
u32 encStatus;
RK_U32 lumWidthSrc; // TODO need to think again modify by lance 2016.06.15
@@ -112,7 +106,7 @@ typedef struct {
// then determine next frame to which type to be encoded
H264EncIn encIn; // put input struct into instance, todo modify by lance 2016.05.31
H264EncOut encOut; // put input struct into instance, todo modify by lance 2016.05.31
H264EncCfg h264EncCfg;
RK_U32 intraPicRate; // set I frame interval, and is 30 default
} h264Instance_s;
#define H264E_DBG_FUNCTION (0x00000001)

4
mpp/codec/enc/h264/include/encasiccontroller.h
View File

@@ -181,7 +181,6 @@ typedef struct {
} regValues_s;
typedef struct {
const void *ewl;
regValues_s regs;
} asicData_s;
@@ -190,9 +189,6 @@ typedef struct {
------------------------------------------------------------------------------*/
i32 EncAsicControllerInit(asicData_s * asic);
i32 EncAsicMemAlloc_V2(asicData_s * asic, u32 width, u32 height,
u32 encodingType);
/* Functions for controlling ASIC */
void EncAsicFrameStart(void * inst,/* const void *ewl,*/ regValues_s * val, h264e_syntax *syntax_data); // mask by lance 2016.05.12
#endif

34
mpp/codec/enc/h264/include/h264encapi.h
View File

@@ -17,6 +17,7 @@
#ifndef __H264ENCAPI_H__
#define __H264ENCAPI_H__
#include "h264_syntax.h"
#include "basetype.h"
#include "h264e_syntax.h"
@@ -27,16 +28,8 @@ extern "C"
#include "H264Instance.h"
/*------------------------------------------------------------------------------
1. Type definition for encoder instance
------------------------------------------------------------------------------*/
typedef const void *H264EncInst;
/*------------------------------------------------------------------------------
2. Enumerations for API parameters
------------------------------------------------------------------------------*/
/* Function return values */
typedef enum {
H264ENC_OK = 0,
@@ -67,23 +60,6 @@ typedef enum {
H264ENC_NAL_UNIT_STREAM = 1 /* Plain NAL units without startcode */
} H264EncStreamType;
/* Level for initialization */
typedef enum {
H264ENC_LEVEL_1 = 10,
H264ENC_LEVEL_1_b = 99,
H264ENC_LEVEL_1_1 = 11,
H264ENC_LEVEL_1_2 = 12,
H264ENC_LEVEL_1_3 = 13,
H264ENC_LEVEL_2 = 20,
H264ENC_LEVEL_2_1 = 21,
H264ENC_LEVEL_2_2 = 22,
H264ENC_LEVEL_3 = 30,
H264ENC_LEVEL_3_1 = 31,
H264ENC_LEVEL_3_2 = 32,
H264ENC_LEVEL_4_0 = 40,
H264ENC_LEVEL_4_1 = 41
} H264EncLevel;
/* Picture YUV type for initialization */
typedef enum {
H264ENC_YUV420_PLANAR = 0, /* YYYY... UUUU... VVVV */
@@ -133,8 +109,8 @@ typedef struct {
H264EncStreamType streamType; /* Byte stream / Plain NAL units */
/* Stream Profile will be automatically decided,
* CABAC -> main/high, 8x8-transform -> high */
h264e_profile profile;
H264EncLevel level;
H264Profile profile;
H264Level level;
u32 width; /* Encoded picture width in pixels, multiple of 4 */
u32 height; /* Encoded picture height in pixels, multiple of 2 */
u32 frameRateNum; /* The stream time scale, [1..65535] */
@@ -271,11 +247,11 @@ typedef struct {
------------------------------------------------------------------------------*/
/* Initialization & release */
H264EncRet H264EncInit(const H264EncConfig * pEncConfig,
h264Instance_s * instAddr);
H264EncRet H264EncInit(h264Instance_s *instAddr);
H264EncRet H264EncRelease(H264EncInst inst);
/* Encoder configuration before stream generation */
H264EncRet H264EncCfg(H264EncInst inst, const H264EncConfig * pEncConfig);
H264EncRet H264EncSetCodingCtrl(H264EncInst inst, const H264EncCodingCtrl *
pCodingParams);
H264EncRet H264EncGetCodingCtrl(H264EncInst inst, H264EncCodingCtrl *

21
mpp/codec/enc/h264/src/H264EncApi.c
View File

@@ -58,14 +58,14 @@ static i32 VSCheckSize(u32 inputWidth, u32 inputHeight, u32 stabilizedWidth,
Argument : pEncCfg - initialization parameters
instAddr - where to save the created instance
------------------------------------------------------------------------------*/
H264EncRet H264EncInit(const H264EncConfig * pEncCfg, h264Instance_s * instAddr)
H264EncRet H264EncInit(h264Instance_s *instAddr)
{
H264EncRet ret;
h264Instance_s *pEncInst = instAddr;
h264e_dbg_func("enter\n");
ret = H264Init(pEncCfg, pEncInst);
ret = H264Init(pEncInst);
if (ret != H264ENC_OK) {
mpp_err("H264EncInit: ERROR Initialization failed");
return ret;
@@ -109,6 +109,23 @@ H264EncRet H264EncRelease(H264EncInst inst)
return H264ENC_OK;
}
H264EncRet H264EncCfg(H264EncInst inst, const H264EncConfig * pEncConfig)
{
H264EncRet ret;
h264Instance_s *pEncInst = (h264Instance_s *) inst;
h264e_dbg_func("enter\n");
ret = H264Cfg(pEncConfig, pEncInst);
if (ret != H264ENC_OK) {
mpp_err("H264EncCfg: ERROR Config failed");
return ret;
}
h264e_dbg_func("leave\n");
return H264ENC_OK;
}
/*------------------------------------------------------------------------------
Function name : H264EncSetCodingCtrl

91
mpp/codec/enc/h264/src/H264Init.c
View File

@@ -63,7 +63,7 @@ static bool_e CheckParameter(const h264Instance_s * inst);
H264ENC_INVALID_ARGUMENT
------------------------------------------------------------------------------*/
H264EncRet H264Init(const H264EncConfig * pEncCfg, h264Instance_s * pinst)
H264EncRet H264Init(h264Instance_s * pinst)
{
h264Instance_s *inst = pinst;
@@ -74,68 +74,13 @@ H264EncRet H264Init(const H264EncConfig * pEncCfg, h264Instance_s * pinst)
H264PicParameterSetInit(&inst->picParameterSet);
H264SliceInit(&inst->slice);
/* Set parameters depending on user config */
if (SetParameter(inst, pEncCfg) != ENCHW_OK) {
mpp_err("SetParameter error\n");
ret = H264ENC_INVALID_ARGUMENT;
goto err;
}
/* Check and init the rest of parameters */
if (CheckParameter(inst) != ENCHW_OK) {
mpp_err("CheckParameter error\n");
ret = H264ENC_INVALID_ARGUMENT;
goto err;
}
if (H264InitRc(&inst->rateControl) != ENCHW_OK) {
mpp_err("H264InitRc error\n");
return H264ENC_INVALID_ARGUMENT;
}
/* Initialize ASIC */
inst->asic.ewl = NULL;//ewl;
(void) EncAsicControllerInit(&inst->asic);
/* Allocate internal SW/HW shared memories */
if (EncAsicMemAlloc_V2(&inst->asic,
(u32) inst->preProcess.lumWidth,
(u32) inst->preProcess.lumHeight,
ASIC_H264) != ENCHW_OK) {
ret = H264ENC_EWL_MEMORY_ERROR;
goto err;
}
/* init VUI */
{
const h264VirtualBuffer_s *vb = &inst->rateControl.virtualBuffer;
H264SpsSetVuiTimigInfo(&inst->seqParameterSet,
vb->timeScale, vb->unitsInTic);
}
if (inst->seqParameterSet.levelIdc >= 31)
inst->asic.regs.h264Inter4x4Disabled = 1;
else
inst->asic.regs.h264Inter4x4Disabled = 0;
/* When resolution larger than 720p = 3600 macroblocks
* there is not enough time to do 1/4 pixel ME */
if (inst->mbPerFrame > 3600)
inst->asic.regs.disableQuarterPixelMv = 1;
else
inst->asic.regs.disableQuarterPixelMv = 0;
EncAsicControllerInit(&inst->asic);
inst->asic.regs.codingType = ASIC_H264;
inst->asic.regs.skipPenalty = 1;
return ret;
err:
/*if(inst != NULL)
free(inst);*/
/*if(ewl != NULL)
(void) EWLRelease(ewl);*/
return ret;
}
/*------------------------------------------------------------------------------
@@ -202,15 +147,17 @@ bool_e SetParameter(h264Instance_s * inst, const H264EncConfig * pEncCfg)
}
/* Level 1b is indicated with levelIdc == 11 and constraintSet3 */
if (pEncCfg->level == H264ENC_LEVEL_1_b) {
if (pEncCfg->level == H264_LEVEL_1_b) {
inst->seqParameterSet.levelIdc = 11;
inst->seqParameterSet.constraintSet3 = ENCHW_YES;
}
/* Get the index for the table of level maximum values */
tmp = H264GetLevelIndex(inst->seqParameterSet.levelIdc);
if (tmp == INVALID_LEVEL)
if (tmp == INVALID_LEVEL) {
mpp_err("H264GetLevelIndex failed\n");
return ENCHW_NOK;
}
inst->seqParameterSet.levelIdx = tmp;
@@ -342,18 +289,42 @@ H264EncRet H264Cfg(const H264EncConfig * pEncCfg, h264Instance_s * pinst)
/* Set parameters depending on user config */
if (SetParameter(inst, pEncCfg) != ENCHW_OK) {
ret = H264ENC_INVALID_ARGUMENT;
mpp_err_f("SetParameter failed\n");
return ret;
}
/* Check and init the rest of parameters */
if (CheckParameter(inst) != ENCHW_OK) {
ret = H264ENC_INVALID_ARGUMENT;
mpp_err_f("CheckParameter failed\n");
return ret;
}
if (H264InitRc(&inst->rateControl) != ENCHW_OK) {
mpp_err_f("H264InitRc failed\n");
return H264ENC_INVALID_ARGUMENT;
}
/* init VUI */
{
const h264VirtualBuffer_s *vb = &inst->rateControl.virtualBuffer;
H264SpsSetVuiTimigInfo(&inst->seqParameterSet,
vb->timeScale, vb->unitsInTic);
}
if (inst->seqParameterSet.levelIdc >= 31)
inst->asic.regs.h264Inter4x4Disabled = 1;
else
inst->asic.regs.h264Inter4x4Disabled = 0;
/* When resolution larger than 720p = 3600 macroblocks
* there is not enough time to do 1/4 pixel ME */
if (inst->mbPerFrame > 3600)
inst->asic.regs.disableQuarterPixelMv = 1;
else
inst->asic.regs.disableQuarterPixelMv = 0;
return ret;
}

90
mpp/codec/enc/h264/src/encasiccontroller_v2.c
View File

@@ -1,90 +0,0 @@
/*
* Copyright 2015 Rockchip Electronics Co. LTD
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*------------------------------------------------------------------------------
Include headers
------------------------------------------------------------------------------*/
#include "encpreprocess.h"
#include "encasiccontroller.h"
#include "enccommon.h"
#include "ewl.h"
#include "mpp_log.h"
/*------------------------------------------------------------------------------
External compiler flags
------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
Module defines
------------------------------------------------------------------------------*/
/* Mask fields */
#define mask_2b (u32)0x00000003
#define mask_3b (u32)0x00000007
#define mask_4b (u32)0x0000000F
#define mask_5b (u32)0x0000001F
#define mask_6b (u32)0x0000003F
#define mask_11b (u32)0x000007FF
#define mask_14b (u32)0x00003FFF
#define mask_16b (u32)0x0000FFFF
#define HSWREG(n) ((n)*4)
/*------------------------------------------------------------------------------
Local function prototypes
------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------
EncAsicMemAlloc_V2
Allocate HW/SW shared memory
Input:
asic asicData structure
width width of encoded image, multiple of four
height height of encoded image
type ASIC_MPEG4 / ASIC_H263 / ASIC_JPEG
Output:
asic base addresses point to allocated memory areas
Return:
ENCHW_OK Success.
ENCHW_NOK Error: memory allocation failed, no memories allocated
and EWL instance released
------------------------------------------------------------------------------*/
i32 EncAsicMemAlloc_V2(asicData_s * asic, u32 width, u32 height,
u32 encodingType)
{
regValues_s *regs;
ASSERT(asic != NULL);
ASSERT(width != 0);
ASSERT(height != 0);
ASSERT((height % 2) == 0);
ASSERT((width % 4) == 0);
regs = &asic->regs;
regs->codingType = encodingType;
width = (width + 15) / 16;
height = (height + 15) / 16;
return ENCHW_OK;
}

188
mpp/codec/enc/h264/src/h264e_api.c
View File

@@ -17,6 +17,7 @@
#define MODULE_TAG "H264E_API"
#include "mpp_log.h"
#include "mpp_common.h"
#include "H264Instance.h"
#include "h264e_api.h"
@@ -34,9 +35,16 @@ FILE *fp_syntax_in = NULL;
MPP_RET h264e_init(void *ctx, ControllerCfg *ctrlCfg)
{
(void)ctx;
h264Instance_s * pEncInst = (h264Instance_s*)ctx;
MPP_RET ret = (MPP_RET)H264EncInit(pEncInst);
if (ret) {
mpp_err_f("H264EncInit() failed ret %d", ret);
}
(void)ctrlCfg;
return MPP_OK;
return ret;
}
MPP_RET h264e_deinit(void *ctx)
@@ -75,7 +83,6 @@ MPP_RET h264e_encode(void *ctx, /*HalEncTask **/void *task)
h264Instance_s *pEncInst = (h264Instance_s *)ctx; // add by lance 2016.05.31
H264EncIn *encIn = &(pEncInst->encIn); // TODO modify by lance 2016.05.19
H264EncOut *encOut = &(pEncInst->encOut); // TODO modify by lance 2016.05.19
const H264EncCfg *encCfgParam = &(pEncInst->h264EncCfg);
RK_U32 srcLumaWidth = pEncInst->lumWidthSrc;
RK_U32 srcLumaHeight = pEncInst->lumHeightSrc;
@@ -118,8 +125,8 @@ MPP_RET h264e_encode(void *ctx, /*HalEncTask **/void *task)
//encIn.busLumaStab = mpp_buffer_get_fd(pictureStabMem)/*pictureStabMem.phy_addr*/;
/* Select frame type */
if (encCfgParam->intraPicRate != 0 &&
(pEncInst->intraPeriodCnt >= encCfgParam->intraPicRate)) {
if (pEncInst->intraPicRate != 0 &&
(pEncInst->intraPeriodCnt >= pEncInst->intraPicRate)) {
encIn->codingType = H264ENC_INTRA_FRAME;
} else {
encIn->codingType = H264ENC_PREDICTED_FRAME;
@@ -150,31 +157,135 @@ MPP_RET h264e_flush(void *ctx)
return MPP_OK;
}
static const H264Profile h264e_supported_profile[] =
{
H264_PROFILE_BASELINE,
H264_PROFILE_MAIN,
H264_PROFILE_HIGH,
};
static const H264Level h264e_supported_level[] =
{
H264_LEVEL_1,
H264_LEVEL_1_b,
H264_LEVEL_1_1,
H264_LEVEL_1_2,
H264_LEVEL_1_3,
H264_LEVEL_2,
H264_LEVEL_2_1,
H264_LEVEL_2_2,
H264_LEVEL_3,
H264_LEVEL_3_1,
H264_LEVEL_3_2,
H264_LEVEL_4_0,
H264_LEVEL_4_1,
H264_LEVEL_4_2,
};
static MPP_RET h264e_check_mpp_cfg(MppEncConfig *mpp_cfg)
{
MPP_RET ret = MPP_NOK;
RK_U32 i, count;
count = MPP_ARRAY_ELEMS(h264e_supported_profile);
for (i = 0; i < count; i++) {
if (h264e_supported_profile[i] == (H264Profile)mpp_cfg->profile) {
break;
}
}
if (i >= count) {
mpp_log_f("invalid profile %d set to default baseline\n", mpp_cfg->profile);
mpp_cfg->profile = H264_PROFILE_BASELINE;
}
count = MPP_ARRAY_ELEMS(h264e_supported_level);
for (i = 0; i < count; i++) {
if (h264e_supported_level[i] == (H264Level)mpp_cfg->level) {
break;
}
}
if (i >= count) {
mpp_log_f("invalid level %d set to default 4.0\n", mpp_cfg->level);
mpp_cfg->level = H264_LEVEL_3;
}
if (mpp_cfg->fps_in <= 0) {
mpp_log_f("invalid input fps %d will be set to default 30\n", mpp_cfg->fps_in);
mpp_cfg->fps_in = 30;
}
if (mpp_cfg->fps_out <= 0) {
mpp_log_f("invalid output fps %d will be set to fps_in 30\n", mpp_cfg->fps_out, mpp_cfg->fps_in);
mpp_cfg->fps_out = mpp_cfg->fps_in;
}
if (mpp_cfg->gop <= 0) {
mpp_log_f("invalid gop %d will be set to fps_out 30\n", mpp_cfg->gop, mpp_cfg->fps_out);
mpp_cfg->gop = mpp_cfg->fps_out;
}
if (mpp_cfg->rc_mode < 0 || mpp_cfg->rc_mode > 2) {
mpp_err_f("invalid rc_mode %d\n", mpp_cfg->rc_mode);
return ret;
}
if (mpp_cfg->qp <= 0 || mpp_cfg->qp > 51) {
mpp_log_f("invalid qp %d set to default 26\n", mpp_cfg->qp);
mpp_cfg->qp = 26;
}
if (mpp_cfg->bps <= 0) {
mpp_err_f("invalid bit rate %d\n", mpp_cfg->bps);
return ret;
}
if (mpp_cfg->width <= 0 || mpp_cfg->height <= 0) {
mpp_err_f("invalid width %d height %d\n", mpp_cfg->width, mpp_cfg->height);
return ret;
}
if (mpp_cfg->hor_stride <= 0) {
mpp_err_f("invalid hor_stride %d will be set to %d\n", mpp_cfg->hor_stride, MPP_ALIGN(mpp_cfg->width, 16));
mpp_cfg->hor_stride = MPP_ALIGN(mpp_cfg->width, 16);
}
if (mpp_cfg->ver_stride <= 0) {
mpp_err_f("invalid ver_stride %d will be set to %d\n", mpp_cfg->ver_stride, MPP_ALIGN(mpp_cfg->height, 16));
mpp_cfg->ver_stride = MPP_ALIGN(mpp_cfg->height, 16);
}
return MPP_OK;
}
MPP_RET h264e_config(void *ctx, RK_S32 cmd, void *param)
{
MPP_RET ret = MPP_NOK;
h264Instance_s *pEncInst = (h264Instance_s *)ctx; // add by lance 2016.05.31
h264e_control_debug_enter();
switch (cmd) {
case CHK_ENC_CFG : {
ret = h264e_check_mpp_cfg((MppEncConfig *)param);
} break;
case SET_ENC_CFG : {
const H264EncConfig *encCfg = (const H264EncConfig *)param;
H264EncInst encoderOpen = (H264EncInst)ctx;
H264EncInst encoder = (H264EncInst)ctx;
H264EncCodingCtrl oriCodingCfg;
H264EncPreProcessingCfg oriPreProcCfg;
H264EncRet ret = MPP_OK;
h264e_control_debug_enter();
if ((ret = H264EncInit(encCfg, pEncInst)) != H264ENC_OK) {
mpp_err("H264EncInit() failed, ret %d.", ret);
return -1;
}
ret = H264EncCfg(encoder, encCfg);
/* Encoder setup: coding control */
if ((ret = H264EncGetCodingCtrl(encoderOpen, &oriCodingCfg)) != H264ENC_OK) {
ret = H264EncGetCodingCtrl(encoder, &oriCodingCfg);
if (ret) {
mpp_err("H264EncGetCodingCtrl() failed, ret %d.", ret);
h264e_deinit((void*)encoderOpen);
return -1;
h264e_deinit((void*)encoder);
break;
} else {
// will be replaced modify by lance 2016.05.20
// ------------
@@ -186,18 +297,20 @@ MPP_RET h264e_config(void *ctx, RK_S32 cmd, void *param)
oriCodingCfg.transform8x8Mode = 0;
oriCodingCfg.videoFullRange = 0;
oriCodingCfg.seiMessages = 0;
if ((ret = H264EncSetCodingCtrl(encoderOpen, &oriCodingCfg)) != H264ENC_OK) {
ret = H264EncSetCodingCtrl(encoder, &oriCodingCfg);
if (ret) {
mpp_err("H264EncSetCodingCtrl() failed, ret %d.", ret);
h264e_deinit((void*)encoderOpen);
return -1;
h264e_deinit((void*)encoder);
break;
}
}
/* PreP setup */
if ((ret = H264EncGetPreProcessing(encoderOpen, &oriPreProcCfg)) != H264ENC_OK) {
ret = H264EncGetPreProcessing(encoder, &oriPreProcCfg);
if (ret) {
mpp_err("H264EncGetPreProcessing() failed, ret %d.\n", ret);
h264e_deinit((void*)encoderOpen);
return -1;
h264e_deinit((void*)encoder);
break;
} else {
h264e_control_log("Get PreP: input %4dx%d : offset %4dx%d : format %d : rotation %d "
": stab %d : cc %d\n",
@@ -208,8 +321,8 @@ MPP_RET h264e_config(void *ctx, RK_S32 cmd, void *param)
// will be replaced modify by lance 2016.05.20
oriPreProcCfg.inputType = H264ENC_YUV420_SEMIPLANAR;//H264ENC_YUV420_PLANAR;
oriPreProcCfg.rotation = H264ENC_ROTATE_0;
oriPreProcCfg.origWidth = encCfg->width/*352*/;
oriPreProcCfg.origHeight = encCfg->height/*288*/;
oriPreProcCfg.origWidth = encCfg->width;
oriPreProcCfg.origHeight = encCfg->height;
oriPreProcCfg.xOffset = 0;
oriPreProcCfg.yOffset = 0;
oriPreProcCfg.videoStabilization = 0;
@@ -222,10 +335,11 @@ MPP_RET h264e_config(void *ctx, RK_S32 cmd, void *param)
oriPreProcCfg.colorConversion.coeffF = 38000;
}
if ((ret = H264EncSetPreProcessing(encoderOpen, &oriPreProcCfg)) != H264ENC_OK) {
ret = H264EncSetPreProcessing(encoder, &oriPreProcCfg);
if (ret) {
mpp_err("H264EncSetPreProcessing() failed.", ret);
h264e_deinit((void*)encoderOpen);
return -1;
h264e_deinit((void*)encoder);
break;
}
}
@@ -237,24 +351,20 @@ MPP_RET h264e_config(void *ctx, RK_S32 cmd, void *param)
mpp_err("open fp_syntax_in failed!");
}
#endif
h264e_control_debug_leave();
} break;
case SET_ENC_RC_CFG : {
const H264EncRateCtrl *encCfg = (const H264EncRateCtrl *)param;
H264EncInst encoder = (H264EncInst)ctx;
H264EncRateCtrl oriRcCfg;
H264EncRet ret = MPP_OK;
mpp_assert(pEncInst);
pEncInst->h264EncCfg.intraPicRate = encCfg->intraPicRate;
pEncInst->intraPicRate = encCfg->intraPicRate;
pEncInst->intraPeriodCnt = encCfg->intraPicRate;
/* Encoder setup: rate control */
if ((ret = H264EncGetRateCtrl(encoder, &oriRcCfg)) != H264ENC_OK) {
ret = H264EncGetRateCtrl(encoder, &oriRcCfg);
if (ret) {
mpp_err("H264EncGetRateCtrl() failed, ret %d.", ret);
return -1;
} else {
h264e_control_log("Get rate control: qp %2d [%2d, %2d] bps %8d\n",
oriRcCfg.qpHdr, oriRcCfg.qpMin, oriRcCfg.qpMax, oriRcCfg.bitPerSecond);
@@ -292,9 +402,9 @@ MPP_RET h264e_config(void *ctx, RK_S32 cmd, void *param)
oriRcCfg.pictureRc, oriRcCfg.mbRc, oriRcCfg.pictureSkip, oriRcCfg.hrd,
oriRcCfg.hrdCpbSize, oriRcCfg.gopLen);
if ((ret = H264EncSetRateCtrl(encoder, &oriRcCfg)) != H264ENC_OK) {
ret = H264EncSetRateCtrl(encoder, &oriRcCfg);
if (ret) {
mpp_err("H264EncSetRateCtrl() failed, ret %d.", ret);
return -1;
}
}
} break;
@@ -305,7 +415,9 @@ MPP_RET h264e_config(void *ctx, RK_S32 cmd, void *param)
mpp_err("No correspond cmd found, and can not config!");
break;
}
return MPP_OK;
h264e_control_debug_leave();
return ret;
}
MPP_RET h264e_callback(void *ctx, void *feedback)
@@ -430,7 +542,7 @@ MPP_RET h264e_callback(void *ctx, void *feedback)
const ControlApi api_h264e_controller = {
"h264e_control",
MPP_VIDEO_CodingAVC,
sizeof(h264Instance_s),//sizeof(H264eContext), // TODO modify by lance 2016.05.20
sizeof(h264Instance_s),
0,
h264e_init,
h264e_deinit,

1
mpp/codec/inc/encoder_codec_api.h
View File

@@ -26,6 +26,7 @@
// config cmd
typedef enum EncCfgCmd_t {
CHK_ENC_CFG,
SET_ENC_CFG,
SET_ENC_RC_CFG,
GET_OUTPUT_STREAM_SIZE,

54
mpp/codec/mpp_enc.cpp
View File

@@ -337,12 +337,13 @@ MPP_RET mpp_enc_init(MppEnc **enc, MppCodingType coding)
break;
}
p->coding = coding;
p->controller = controller;
p->hal = hal;
p->tasks = hal_cfg.tasks;
p->coding = coding;
p->controller = controller;
p->hal = hal;
p->tasks = hal_cfg.tasks;
p->frame_slots = frame_slots;
p->packet_slots = packet_slots;
p->mpp_cfg.size = sizeof(p->mpp_cfg);
*enc = p;
return MPP_OK;
} while (0);
@@ -404,35 +405,33 @@ MPP_RET mpp_enc_control(MppEnc *enc, MpiCmd cmd, void *param)
return MPP_ERR_NULL_PTR;
}
// TODO
MppEncConfig *mpp_cfg = (MppEncConfig*)param;
H264EncConfig *enc_cfg = &(enc->enc_cfg);
MPP_RET ret = MPP_NOK;
H264EncRateCtrl *enc_rc_cfg = &(enc->enc_rc_cfg);
switch (cmd) {
case MPP_ENC_SET_CFG : {
MppEncConfig *mpp_cfg = &enc->mpp_cfg;
H264EncConfig *enc_cfg = &enc->enc_cfg;
//H264ENC_NAL_UNIT_STREAM; // decide whether stream start with start code,e.g."00 00 00 01"
enc->mpp_cfg = *mpp_cfg;
enc->mpp_cfg = *((MppEncConfig *)param);
/* before set config to controller check it first */
ret = controller_config(enc->controller, CHK_ENC_CFG, (void *)&enc->mpp_cfg);
if (ret)
break;
enc_cfg->streamType = H264ENC_BYTE_STREAM;
enc_cfg->frameRateDenom = 1;
if (mpp_cfg->profile)
enc_cfg->profile = (h264e_profile)mpp_cfg->profile;
else
enc_cfg->profile = H264_PROFILE_BASELINE;
if (mpp_cfg->level)
enc_cfg->level = (H264EncLevel)mpp_cfg->level;
else
enc_cfg->level = H264ENC_LEVEL_4_0;
enc_cfg->profile = (H264Profile)mpp_cfg->profile;
enc_cfg->level = (H264Level)mpp_cfg->level;
if (mpp_cfg->width && mpp_cfg->height) {
enc_cfg->width = mpp_cfg->width;
enc_cfg->width = mpp_cfg->width;
enc_cfg->height = mpp_cfg->height;
} else
mpp_err("width %d height %d is not available\n", mpp_cfg->width, mpp_cfg->height);
if (mpp_cfg->fps_in)
enc_cfg->frameRateNum = mpp_cfg->fps_in;
else
enc_cfg->frameRateNum = 30;
enc_cfg->frameRateNum = mpp_cfg->fps_in;
if (mpp_cfg->cabac_en)
enc_cfg->enable_cabac = mpp_cfg->cabac_en;
else
@@ -443,7 +442,7 @@ MPP_RET mpp_enc_control(MppEnc *enc, MpiCmd cmd, void *param)
enc_cfg->pic_init_qp = mpp_cfg->qp;
enc_cfg->second_chroma_qp_index_offset = 2;
enc_cfg->pps_id = 0;
enc_cfg->input_image_format = H264ENC_YUV420_SEMIPLANAR;
enc_cfg->input_image_format = (H264EncPictureFormat)mpp_cfg->format;
controller_config(enc->controller, SET_ENC_CFG, (void *)enc_cfg);
@@ -487,19 +486,24 @@ MPP_RET mpp_enc_control(MppEnc *enc, MpiCmd cmd, void *param)
mpp_extra_info_generate(enc);
mpp_hal_control(enc->hal, MPP_ENC_SET_EXTRA_INFO, (void*)(&(enc->extra_info_cfg)));
ret = mpp_hal_control(enc->hal, MPP_ENC_SET_EXTRA_INFO, (void*)(&(enc->extra_info_cfg)));
} break;
case MPP_ENC_GET_CFG : {
MppEncConfig *mpp_cfg = (MppEncConfig *)param;
mpp_assert(mpp_cfg->size == sizeof(enc->mpp_cfg));
*mpp_cfg = enc->mpp_cfg;
ret = MPP_OK;
} break;
case MPP_ENC_GET_EXTRA_INFO : {
mpp_hal_control(enc->hal, cmd, param);
ret = mpp_hal_control(enc->hal, cmd, param);
} break;
default : {
} break;
}
return MPP_OK;
return ret;
}

94
mpp/common/h264_syntax.h Normal file
View File

@@ -0,0 +1,94 @@
/*
*
* Copyright 2015 Rockchip Electronics Co. LTD
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __H264_SYNTAX_H__
#define __H264_SYNTAX_H__
/* H.264/AVC-specific definition */
//!< define
#define MAXSPS 32
#define MAXPPS 256
//!< AVC Profile IDC definitions
typedef enum h264e_profile_t {
H264_PROFILE_FREXT_CAVLC444 = 44, //!< YUV 4:4:4/14 "CAVLC 4:4:4"
H264_PROFILE_BASELINE = 66, //!< YUV 4:2:0/8 "Baseline"
H264_PROFILE_MAIN = 77, //!< YUV 4:2:0/8 "Main"
H264_PROFILE_EXTENDED = 88, //!< YUV 4:2:0/8 "Extended"
H264_PROFILE_HIGH = 100, //!< YUV 4:2:0/8 "High"
H264_PROFILE_HIGH10 = 110, //!< YUV 4:2:0/10 "High 10"
H264_PROFILE_HIGH422 = 122, //!< YUV 4:2:2/10 "High 4:2:2"
H264_PROFILE_HIGH444 = 244, //!< YUV 4:4:4/14 "High 4:4:4"
H264_PROFILE_MVC_HIGH = 118, //!< YUV 4:2:0/8 "Multiview High"
H264_PROFILE_STEREO_HIGH = 128 //!< YUV 4:2:0/8 "Stereo High"
} H264Profile;
//!< AVC Level IDC definitions
typedef enum {
H264_LEVEL_1 = 10,
H264_LEVEL_1_b = 99,
H264_LEVEL_1_1 = 11,
H264_LEVEL_1_2 = 12,
H264_LEVEL_1_3 = 13,
H264_LEVEL_2 = 20,
H264_LEVEL_2_1 = 21,
H264_LEVEL_2_2 = 22,
H264_LEVEL_3 = 30,
H264_LEVEL_3_1 = 31,
H264_LEVEL_3_2 = 32,
H264_LEVEL_4_0 = 40,
H264_LEVEL_4_1 = 41,
H264_LEVEL_4_2 = 42,
H264_LEVEL_5_0 = 50,
H264_LEVEL_5_1 = 51,
} H264Level;
//!< values for nalu_type
typedef enum {
NALU_TYPE_NULL = 0,
NALU_TYPE_SLICE = 1,
NALU_TYPE_DPA = 2,
NALU_TYPE_DPB = 3,
NALU_TYPE_DPC = 4,
NALU_TYPE_IDR = 5,
NALU_TYPE_SEI = 6,
NALU_TYPE_SPS = 7,
NALU_TYPE_PPS = 8,
NALU_TYPE_AUD = 9, // Access Unit Delimiter
NALU_TYPE_EOSEQ = 10, // end of sequence
NALU_TYPE_EOSTREAM = 11, // end of stream
NALU_TYPE_FILL = 12,
NALU_TYPE_SPSEXT = 13,
NALU_TYPE_PREFIX = 14, // prefix
NALU_TYPE_SUB_SPS = 15,
NALU_TYPE_SLICE_AUX = 19,
NALU_TYPE_SLC_EXT = 20, // slice extensive
NALU_TYPE_VDRD = 24 // View and Dependency Representation Delimiter NAL Unit
} Nalu_type;
//!< values for nal_ref_idc
typedef enum {
NALU_PRIORITY_HIGHEST = 3,
NALU_PRIORITY_HIGH = 2,
NALU_PRIORITY_LOW = 1,
NALU_PRIORITY_DISPOSABLE = 0
} NalRefIdc_type;
#endif /*__H264_SYNTAX_H__*/

1
mpp/common/h264d_syntax.h
View File

@@ -19,6 +19,7 @@
#ifndef __H264D_SYNTAX_H__
#define __H264D_SYNTAX_H__
#include "h264_syntax.h"
#include "dxva_syntax.h"
/* H.264/AVC-specific structures */

10
mpp/common/h264e_syntax.h
View File

@@ -1,19 +1,11 @@
#ifndef __H264E_SYNTAX_H__
#define __H264E_SYNTAX_H__
#include "rk_type.h"
#define H264_BIT_DEPTH 8
#define H264_QP_BD_OFFSET (6*(H264_BIT_DEPTH-8))
typedef enum h264e_profile_t {
H264_PROFILE_BASELINE = 66,
H264_PROFILE_MAIN = 77,
H264_PROFILE_HIGH = 100,
H264_PROFILE_HIGH10 = 110,
H264_PROFILE_HIGH422 = 122,
H264_PROFILE_HIGH444_PREDICTIVE = 244,
} h264e_profile;
typedef struct h264e_osd_pos_t {
RK_U32 lt_pos_x : 8;
RK_U32 lt_pos_y : 8;

40
mpp/hal/rkenc/h264e/hal_h264e_rkv.c
View File

@@ -15,11 +15,15 @@
*/
#define MODULE_TAG "hal_h264e_rk"
#include <string.h>
#include <math.h>
#include "vpu.h"
#include "mpp_common.h"
#include "mpp_mem.h"
#include "h264_syntax.h"
#include "hal_h264e.h"
#include "hal_h264e_rkv.h"
@@ -344,7 +348,7 @@ static MPP_RET hal_h264e_rkv_open_dump_files(void *dump_files)
if (!files->fp_mpp_extra_ino_cfg) {
mpp_err("%s open error", full_path);
return MPP_ERR_OPEN_FILE;
}
}
}
return MPP_OK;
}
@@ -551,7 +555,7 @@ static void hal_h264e_rkv_dump_mpp_extra_info_cfg(h264e_hal_context *ctx, h264e_
FILE *fp = dump_files->fp_mpp_extra_ino_cfg;
if(fp) {
/* common cfg */
fprintf(fp, "%-16d %s\n", cfg->pic_luma_width, "pic_luma_width");
fprintf(fp, "%-16d %s\n", cfg->pic_luma_height, "pic_luma_height");
@@ -563,14 +567,14 @@ static void hal_h264e_rkv_dump_mpp_extra_info_cfg(h264e_hal_context *ctx, h264e_
/* additional cfg only for rkv */
fprintf(fp, "%-16d %s\n", cfg->input_image_format, "input_image_format");
fprintf(fp, "%-16d %s\n", cfg->profile_idc, "profile_idc");
fprintf(fp, "%-16d %s\n", cfg->profile_idc, "profile_idc");
fprintf(fp, "%-16d %s\n", cfg->level_idc, "level_idc"); //TODO: may be removed later, get from sps/pps instead
fprintf(fp, "%-16d %s\n", cfg->keyframe_max_interval, "keyframe_max_interval");
fprintf(fp, "%-16d %s\n", cfg->second_chroma_qp_index_offset, "second_chroma_qp_index_offset");
fprintf(fp, "%-16d %s\n", cfg->pps_id, "pps_id"); //TODO: may be removed later, get from sps/pps instead
fprintf(fp, "\n");
fflush(fp);
fflush(fp);
}
}
@@ -578,12 +582,12 @@ static void hal_h264e_rkv_dump_mpp_reg_out(h264e_hal_context *ctx)
{
RK_U32 k = 0;
h264e_hal_rkv_dump_files *dump_files = (h264e_hal_rkv_dump_files *)ctx->dump_files;
FILE *fp = dump_files->fp_mpp_reg_out;
h264e_rkv_ioctl_output *reg_out = (h264e_rkv_ioctl_output *)ctx->ioctl_output;
FILE *fp = dump_files->fp_mpp_reg_out;
h264e_rkv_ioctl_output *reg_out = (h264e_rkv_ioctl_output *)ctx->ioctl_output;
RK_U32 *p_reg = (RK_U32 *)reg_out + sizeof(reg_out->frame_num)/4;
if (fp) {
if (fp) {
fprintf(fp, "%d frames out\n", reg_out->frame_num);
for(k= 0; k<ctx->num_frames_to_send; k++) {
for(k= 0; k<ctx->num_frames_to_send; k++) {
fprintf(fp, "#FRAME %d:\n", (ctx->frame_cnt-1) - (ctx->num_frames_to_send-1-k));
for (k=0; k<12; k++) {
fprintf(fp, "reg[%03d/%03x]: %08x\n", k, k * 4, p_reg[k]);
@@ -600,7 +604,7 @@ static void hal_h264e_rkv_dump_mpp_reg_out(h264e_hal_context *ctx)
static void hal_h264e_rkv_dump_mpp_feedback(h264e_hal_context *ctx)
{
h264e_hal_rkv_dump_files *dump_files = (h264e_hal_rkv_dump_files *)ctx->dump_files;
FILE *fp = dump_files->fp_mpp_feedback;
FILE *fp = dump_files->fp_mpp_feedback;
if (fp) {
h264e_feedback *fb = &ctx->feedback;
(void)fb;
@@ -628,7 +632,7 @@ static void hal_h264e_rkv_dump_mpp_strm_out_header(h264e_hal_context *ctx, MppPa
void hal_h264e_rkv_dump_mpp_strm_out(h264e_hal_context *ctx, MppBuffer *hw_buf)
{
h264e_hal_rkv_dump_files *dump_files = (h264e_hal_rkv_dump_files *)ctx->dump_files;
FILE *fp = dump_files->fp_mpp_strm_out;
FILE *fp = dump_files->fp_mpp_strm_out;
if (fp) {
RK_U32 k = 0;
RK_U32 strm_size = 0;
@@ -1561,7 +1565,7 @@ MPP_RET hal_h264e_rkv_set_sps(h264e_hal_sps *sps, h264e_hal_param *par, h264e_co
/* only for backup, excluded in read SPS */
sps->keyframe_max_interval = cfg->keyframe_max_interval;
return MPP_OK;
}
@@ -2384,7 +2388,7 @@ MPP_RET hal_h264e_rkv_deinit(void *hal)
hal_h264e_rkv_reference_deinit(ctx->dpb_ctx);
MPP_FREE(ctx->dpb_ctx);
}
if(ctx->dump_files) {
hal_h264e_rkv_close_dump_files(ctx->dump_files);
MPP_FREE(ctx->dump_files);
@@ -2432,7 +2436,7 @@ MPP_RET hal_h264e_rkv_set_ioctl_extra_info(h264e_rkv_ioctl_extra_info *extra_inf
static MPP_RET hal_h264e_rkv_validate_syntax(h264e_syntax *syn)
{
h264e_hal_debug_enter();
/* validate */
H264E_HAL_VALIDATE_GT(syn->output_strm_limit_size, "output_strm_limit_size", 0);
@@ -2441,7 +2445,7 @@ static MPP_RET hal_h264e_rkv_validate_syntax(h264e_syntax *syn)
syn->input_cb_addr = syn->input_luma_addr;
syn->input_cr_addr = syn->input_luma_addr;
}
h264e_hal_debug_leave();
return MPP_OK;
}
@@ -2508,7 +2512,7 @@ MPP_RET hal_h264e_rkv_gen_regs(void *hal, HalTaskInfo *task)
h264e_hal_log_detail("generate regs when frame_cnt_gen_ready/(num_frames_to_send-1): %d/%d",
ctx->frame_cnt_gen_ready, ctx->num_frames_to_send - 1);
memset(regs, 0, sizeof(h264e_rkv_reg_set));
regs->swreg01.rkvenc_ver = 0x1;
@@ -3164,7 +3168,7 @@ MPP_RET hal_h264e_rkv_control(void *hal, RK_S32 cmd_type, void *param)
break;
}
case MPP_ENC_GET_EXTRA_INFO: {
RK_S32 k = 0;
RK_S32 k = 0;
size_t offset = 0;
MppPacket pkt = ctx->packeted_param;
MppPacket *pkt_out = (MppPacket *)param;
@@ -3177,7 +3181,7 @@ MPP_RET hal_h264e_rkv_control(void *hal, RK_S32 cmd_type, void *param)
}
mpp_packet_set_length(pkt, offset);
*pkt_out = pkt;
hal_h264e_rkv_dump_mpp_strm_out_header(ctx, pkt);
break;
}

45
mpp/legacy/vpu_api_legacy.cpp
View File

@@ -803,10 +803,51 @@ RK_S32 VpuApiLegacy::control(VpuCodecContext *ctx, VPU_API_CMD cmd, void *param)
MpiCmd mpicmd = MPI_CMD_BUTT;
switch (cmd) {
case VPU_API_ENC_SETCFG : {
mpicmd = MPP_ENC_SET_CFG;
/* input EncParameter_t need to be transform to MppEncConfig */
EncParameter_t *cfg = (EncParameter_t *)param;
MppEncConfig mpp_cfg;
mpp_cfg.size = sizeof(mpp_cfg);
mpp_cfg.version = 0;
mpp_cfg.width = cfg->width;
mpp_cfg.height = cfg->height;
mpp_cfg.hor_stride = MPP_ALIGN(cfg->width, 16);
mpp_cfg.ver_stride = MPP_ALIGN(cfg->height, 16);
mpp_cfg.format = (RK_S32)enc_in_fmt;
mpp_cfg.rc_mode = cfg->rc_mode;
mpp_cfg.skip_cnt = 0;
mpp_cfg.bps = cfg->bitRate;
mpp_cfg.fps_in = cfg->framerate;
mpp_cfg.fps_out = cfg->framerateout;
mpp_cfg.qp = cfg->qp;
mpp_cfg.gop = cfg->intraPicRate;
mpp_cfg.profile = cfg->profileIdc;
mpp_cfg.level = cfg->levelIdc;
mpp_cfg.cabac_en = cfg->enableCabac;
return mpi->control(mpp_ctx, MPP_ENC_SET_CFG, (MppParam)&mpp_cfg);
} break;
case VPU_API_ENC_GETCFG : {
mpicmd = MPP_ENC_GET_CFG;
/* input EncParameter_t need to be transform to MppEncConfig */
EncParameter_t *cfg = (EncParameter_t *)param;
MppEncConfig mpp_cfg;
MPP_RET ret = mpi->control(mpp_ctx, MPP_ENC_GET_CFG, (MppParam)&mpp_cfg);
cfg->width = mpp_cfg.width;
cfg->height = mpp_cfg.height;
cfg->rc_mode = mpp_cfg.rc_mode;
cfg->bitRate = mpp_cfg.bps;
cfg->framerate = mpp_cfg.fps_in;
cfg->framerateout = mpp_cfg.fps_out;
cfg->qp = mpp_cfg.qp;
cfg->intraPicRate = mpp_cfg.gop;
cfg->profileIdc = mpp_cfg.profile;
cfg->levelIdc = mpp_cfg.level;
cfg->enableCabac = mpp_cfg.cabac_en;
cfg->cabacInitIdc = 0;
return ret;
} break;
case VPU_API_ENC_SETFORMAT : {
enc_in_fmt = *((EncInputPictureType *)param);