package/mpp
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2025-10-07 18:11:02 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

1. update cmakelist in hal part

Browse Source 
2. update some functions

git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@262 6e48237b-75ef-9749-8fc9-41990f28c85a
This commit is contained in:
DingWei
2015-09-10 00:45:26 +00:00
parent 7de8ec2794
commit f13afd665c
5 changed files with 254 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

258
mpp/codec/dec/h264/h264d_api.c
View File

@@ -18,8 +18,9 @@
#include "mpp_packet.h"
#include "mpp_packet_impl.h"
#include "mpp_mem.h"
#include "h264d_api.h"
#include "h264d_log.h"
#include "h264d_api.h"
#include "h264d_global.h"
#include "h264d_parse.h"
@@ -30,7 +31,7 @@
static MPP_RET free_input_ctx(H264dInputCtx_t *p_Inp)
{
INP_CHECK(!p_Inp);
INP_CHECK(!p_Inp);
FunctionIn(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
(void)p_Inp;
@@ -41,7 +42,7 @@ __RETURN:
}
static MPP_RET init_input_ctx(H264dInputCtx_t *p_Inp, MppParserInitCfg *init)
{
INP_CHECK(!p_Inp && !init);
INP_CHECK(!p_Inp && !init);
FunctionIn(p_Inp->p_Dec->logctx.parr[RUN_PARSE]);
p_Inp->init = *init;
@@ -54,193 +55,182 @@ __RETURN:
static MPP_RET free_cur_ctx(H264dCurCtx_t *p_Cur)
{
RK_U32 i = 0;
INP_CHECK(!p_Cur);
RK_U32 i = 0;
INP_CHECK(!p_Cur);
FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
if (p_Cur)
{
//rkv_h264d_recycle_slice(p_Cur->slice);
for (i = 0; i < 2; i++)
{
mpp_free(p_Cur->listP[i]);
mpp_free(p_Cur->listB[i]);
}
mpp_free(p_Cur->strm.buf);
}
if (p_Cur) {
//rkv_h264d_recycle_slice(p_Cur->slice);
for (i = 0; i < 2; i++) {
mpp_free(p_Cur->listP[i]);
mpp_free(p_Cur->listB[i]);
}
mpp_free(p_Cur->strm.buf);
}
FunctionOut(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return MPP_OK;
}
static MPP_RET init_cur_ctx(H264dCurCtx_t *p_Cur)
{
RK_U32 i = 0;
INP_CHECK(!p_Cur);
RK_U32 i = 0;
INP_CHECK(!p_Cur);
FunctionIn(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
MEM_CHECK(p_Cur->strm.buf = mpp_malloc_size(RK_U8, NALU_BUF_MAX_SIZE));
p_Cur->strm.max_size = NALU_BUF_MAX_SIZE;
p_Cur->strm.prefixdata[0] = 0xff;
p_Cur->strm.prefixdata[1] = 0xff;
p_Cur->strm.prefixdata[2] = 0xff;
for (i = 0; i < 2; i++)
{
MEM_CHECK(p_Cur->listP[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE*sizeof(H264_StorePic_t*))); // +1 for reordering
MEM_CHECK(p_Cur->listB[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE*sizeof(H264_StorePic_t*))); // +1 for reordering
}
MEM_CHECK(p_Cur->strm.buf = mpp_malloc_size(RK_U8, NALU_BUF_MAX_SIZE));
p_Cur->strm.max_size = NALU_BUF_MAX_SIZE;
p_Cur->strm.prefixdata[0] = 0xff;
p_Cur->strm.prefixdata[1] = 0xff;
p_Cur->strm.prefixdata[2] = 0xff;
for (i = 0; i < 2; i++) {
MEM_CHECK(p_Cur->listP[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE * sizeof(H264_StorePic_t*))); // +1 for reordering
MEM_CHECK(p_Cur->listB[i] = mpp_malloc_size(H264_StorePic_t*, MAX_LIST_SIZE * sizeof(H264_StorePic_t*))); // +1 for reordering
}
FunctionOut(p_Cur->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return MPP_OK;
__FAILED:
free_cur_ctx(p_Cur);
free_cur_ctx(p_Cur);
return MPP_NOK;
return MPP_NOK;
}
static MPP_RET free_vid_ctx(H264dVideoCtx_t *p_Vid)
{
RK_U32 i = 0;
INP_CHECK(!p_Vid);
RK_U32 i = 0;
INP_CHECK(!p_Vid);
FunctionIn(p_Vid->p_Dec->logctx.parr[RUN_PARSE]);
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++)
{
mpp_free(p_Vid->p_Dpb_layer[i]);
}
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
mpp_free(p_Vid->p_Dpb_layer[i]);
}
FunctionOut(p_Vid->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return MPP_OK;
}
static MPP_RET init_vid_ctx(H264dVideoCtx_t *p_Vid)
{
RK_U32 i = 0;
INP_CHECK(!p_Vid);
RK_U32 i = 0;
INP_CHECK(!p_Vid);
FunctionIn(p_Vid->p_Dec->logctx.parr[RUN_PARSE]);
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++)
{
MEM_CHECK(p_Vid->p_Dpb_layer[i] = mpp_calloc(H264_DpbBuf_t, 1));
p_Vid->p_Dpb_layer[i]->layer_id = i;
p_Vid->p_Dpb_layer[i]->p_Vid = p_Vid;
p_Vid->p_Dpb_layer[i]->init_done = 0;
}
//!< init video pars
for (i = 0; i < MAXSPS; i++)
{
p_Vid->spsSet[i].seq_parameter_set_id = -1;
p_Vid->subspsSet[i].sps.seq_parameter_set_id = -1;
}
for (i = 0; i < MAXPPS; i++)
{
p_Vid->ppsSet[i].pic_parameter_set_id = -1;
p_Vid->ppsSet[i].seq_parameter_set_id = -1;
}
//!< init active_sps
p_Vid->active_sps = NULL;
p_Vid->active_subsps = NULL;
p_Vid->active_sps_id[0] = -1;
p_Vid->active_sps_id[1] = -1;
//!< init subspsSet
for (i = 0; i < MAXSPS; i++)
{
p_Vid->subspsSet[i].sps.seq_parameter_set_id = -1;
p_Vid->subspsSet[i].num_views_minus1 = -1;
p_Vid->subspsSet[i].num_level_values_signalled_minus1 = -1;
}
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++) {
MEM_CHECK(p_Vid->p_Dpb_layer[i] = mpp_calloc(H264_DpbBuf_t, 1));
p_Vid->p_Dpb_layer[i]->layer_id = i;
p_Vid->p_Dpb_layer[i]->p_Vid = p_Vid;
p_Vid->p_Dpb_layer[i]->init_done = 0;
}
//!< init video pars
for (i = 0; i < MAXSPS; i++) {
p_Vid->spsSet[i].seq_parameter_set_id = -1;
p_Vid->subspsSet[i].sps.seq_parameter_set_id = -1;
}
for (i = 0; i < MAXPPS; i++) {
p_Vid->ppsSet[i].pic_parameter_set_id = -1;
p_Vid->ppsSet[i].seq_parameter_set_id = -1;
}
//!< init active_sps
p_Vid->active_sps = NULL;
p_Vid->active_subsps = NULL;
p_Vid->active_sps_id[0] = -1;
p_Vid->active_sps_id[1] = -1;
//!< init subspsSet
for (i = 0; i < MAXSPS; i++) {
p_Vid->subspsSet[i].sps.seq_parameter_set_id = -1;
p_Vid->subspsSet[i].num_views_minus1 = -1;
p_Vid->subspsSet[i].num_level_values_signalled_minus1 = -1;
}
FunctionOut(p_Vid->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return MPP_OK;
__FAILED:
free_vid_ctx(p_Vid);
free_vid_ctx(p_Vid);
return MPP_NOK;
return MPP_NOK;
}
static MPP_RET free_dxva_ctx(H264dDxvaCtx_t *p_dxva)
{
INP_CHECK(!p_dxva);
FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
{
INP_CHECK(!p_dxva);
FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
mpp_free(p_dxva->slice_short);
mpp_free(p_dxva->slice_long);
mpp_free(p_dxva->bitstream);
mpp_free(p_dxva->syn.buf);
mpp_free(p_dxva->slice_short);
mpp_free(p_dxva->slice_long);
mpp_free(p_dxva->bitstream);
mpp_free(p_dxva->syn.buf);
FunctionOut(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
FunctionOut(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return MPP_OK;
return MPP_OK;
}
static MPP_RET init_dxva_ctx(H264dDxvaCtx_t *p_dxva)
{
INP_CHECK(!p_dxva);
FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
INP_CHECK(!p_dxva);
FunctionIn(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
p_dxva->max_slice_size = MAX_SLICE_SIZE;
MEM_CHECK(p_dxva->slice_short = mpp_calloc(DXVA_Slice_H264_Short, p_dxva->max_slice_size));
MEM_CHECK(p_dxva->slice_long = mpp_calloc(DXVA_Slice_H264_Long, p_dxva->max_slice_size));
p_dxva->max_strm_size = FRAME_BUF_MAX_SIZE;
MEM_CHECK(p_dxva->bitstream = mpp_malloc(RK_U8,p_dxva->max_strm_size));
MEM_CHECK(p_dxva->syn.buf = mpp_calloc(DXVA2_DecodeBufferDesc, SYNTAX_BUF_SIZE));
p_dxva->max_slice_size = MAX_SLICE_SIZE;
MEM_CHECK(p_dxva->slice_short = mpp_calloc(DXVA_Slice_H264_Short, p_dxva->max_slice_size));
MEM_CHECK(p_dxva->slice_long = mpp_calloc(DXVA_Slice_H264_Long, p_dxva->max_slice_size));
p_dxva->max_strm_size = FRAME_BUF_MAX_SIZE;
MEM_CHECK(p_dxva->bitstream = mpp_malloc(RK_U8, p_dxva->max_strm_size));
MEM_CHECK(p_dxva->syn.buf = mpp_calloc(DXVA2_DecodeBufferDesc, SYNTAX_BUF_SIZE));
FunctionOut(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
FunctionOut(p_dxva->p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return MPP_OK;
return MPP_OK;
__FAILED:
return MPP_NOK;
return MPP_NOK;
}
static MPP_RET free_dec_ctx(H264_DecCtx_t *p_Dec)
{
RK_U32 i = 0;
INP_CHECK(!p_Dec);
RK_U32 i = 0;
INP_CHECK(!p_Dec);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
for (i = 0; i < MAX_TASK_SIZE; i++)
{
free_dxva_ctx(&p_Dec->dxva_ctx[i]);
}
mpp_free(p_Dec->mem);
for (i = 0; i < MAX_TASK_SIZE; i++) {
free_dxva_ctx(&p_Dec->dxva_ctx[i]);
}
mpp_free(p_Dec->mem);
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return MPP_OK;
}
static MPP_RET init_dec_ctx(H264_DecCtx_t *p_Dec)
{
RK_U32 i = 0;
INP_CHECK(p_Dec);
{
RK_U32 i = 0;
INP_CHECK(!p_Dec);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
MEM_CHECK(p_Dec->mem = mpp_calloc(H264_DecMem_t, 1));
MEM_CHECK(p_Dec->mem = mpp_calloc(H264_DecMem_t, 1));
p_Dec->dpb_mark = p_Dec->mem->dpb_mark; //!< for write out, MAX_DPB_SIZE
p_Dec->dpb_info = p_Dec->mem->dpb_info; //!< 16
p_Dec->refpic_info_p = p_Dec->mem->refpic_info_p; //!< 32
p_Dec->refpic_info[0] = p_Dec->mem->refpic_info[0]; //!< [2][32]
p_Dec->refpic_info[1] = p_Dec->mem->refpic_info[1]; //!< [2][32]
p_Dec->dxva_ctx = p_Dec->mem->dxva_ctx; //!< MAX_TASK_SIZE
p_Dec->dpb_mark = p_Dec->mem->dpb_mark; //!< for write out, MAX_DPB_SIZE
p_Dec->dpb_info = p_Dec->mem->dpb_info; //!< 16
p_Dec->refpic_info_p = p_Dec->mem->refpic_info_p; //!< 32
p_Dec->refpic_info[0] = p_Dec->mem->refpic_info[0]; //!< [2][32]
p_Dec->refpic_info[1] = p_Dec->mem->refpic_info[1]; //!< [2][32]
p_Dec->dxva_ctx = p_Dec->mem->dxva_ctx; //!< MAX_TASK_SIZE
for (i = 0; i < MAX_TASK_SIZE; i++)
{
p_Dec->dxva_ctx[i].p_Dec = p_Dec;
FUN_CHECK(init_dxva_ctx(&p_Dec->dxva_ctx[i]));
}
//!< init Dpb_memory Mark
for (i = 0; i < MAX_DPB_SIZE; i++)
{
p_Dec->dpb_mark[i].index = i;
}
//!< set Dec support decoder method
p_Dec->spt_decode_mtds = MPP_DEC_BY_FRAME | MPP_DEC_BY_SLICE;
p_Dec->next_state = SliceSTATE_ResetSlice;
p_Dec->nalu_ret = NALU_NULL;
p_Dec->first_frame_flag = 1;
for (i = 0; i < MAX_TASK_SIZE; i++) {
p_Dec->dxva_ctx[i].p_Dec = p_Dec;
FUN_CHECK(init_dxva_ctx(&p_Dec->dxva_ctx[i]));
}
//!< init Dpb_memory Mark
for (i = 0; i < MAX_DPB_SIZE; i++) {
p_Dec->dpb_mark[i].index = i;
}
//!< set Dec support decoder method
p_Dec->spt_decode_mtds = MPP_DEC_BY_FRAME | MPP_DEC_BY_SLICE;
p_Dec->next_state = SliceSTATE_ResetSlice;
p_Dec->nalu_ret = NALU_NULL;
p_Dec->first_frame_flag = 1;
__RETURN:
return MPP_OK;
__FAILED:
free_dec_ctx(p_Dec);
free_dec_ctx(p_Dec);
return MPP_NOK;
return MPP_NOK;
}
@@ -299,7 +289,7 @@ MPP_RET h264d_deinit(void *decoder)
{
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
INP_CHECK(decoder);
INP_CHECK(!decoder);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
free_input_ctx(p_Dec->p_Inp);
@@ -323,7 +313,7 @@ __RETURN:
*/
MPP_RET h264d_reset(void *decoder)
{
INP_CHECK(decoder);
INP_CHECK(decoder);
(void)decoder;
__RETURN:
@@ -338,7 +328,7 @@ __RETURN:
*/
MPP_RET h264d_flush(void *decoder)
{
INP_CHECK(decoder);
INP_CHECK(decoder);
(void)decoder;
__RETURN:
@@ -372,10 +362,10 @@ MPP_RET h264d_control(void *decoder, RK_S32 cmd_type, void *param)
*/
MPP_RET h264d_parse(void *decoder, MppPacket in_pkt, HalDecTask *in_task)
{
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
MppPacketImpl *pkt = (MppPacketImpl *)in_pkt;
INP_CHECK(!decoder && !in_pkt && !in_task);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
H264_DecCtx_t *p_Dec = (H264_DecCtx_t *)decoder;
MppPacketImpl *pkt = (MppPacketImpl *)in_pkt;
INP_CHECK(!decoder && !in_pkt && !in_task);
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
@@ -383,17 +373,17 @@ MPP_RET h264d_parse(void *decoder, MppPacket in_pkt, HalDecTask *in_task)
pkt->size = (pkt->size >= 500) ? (pkt->size - 500) : 0;
pkt->size = (pkt->size >= 500) ? (pkt->size - 500) : 0;
in_task->valid = pkt->size ? 0 : 1;
in_task->valid = pkt->size ? 0 : 1;
FunctionIn(p_Dec->logctx.parr[RUN_PARSE]);
FunctionOut(p_Dec->logctx.parr[RUN_PARSE]);
__RETURN:
return MPP_OK;
return MPP_OK;
}
/*!

30
mpp/codec/dec/h264/h264d_bitread.c
View File

@@ -16,6 +16,7 @@
*/
#include <string.h>
#include <stdlib.h>
#include "mpp_err.h"
#include "h264d_bitread.h"
@@ -70,9 +71,7 @@ MPP_RET read_bits(BitReadCtx_t *bitctx, RK_S32 num_bits, RK_S32 *out)
*out |= (bitctx->curr_byte_ << (bits_left - bitctx->num_remaining_bits_in_curr_byte_));
bits_left -= bitctx->num_remaining_bits_in_curr_byte_;
if (ret = update_currbyte(bitctx)) {
return MPP_NOK;
}
FUN_CHECK(ret = update_currbyte(bitctx));
}
*out |= (bitctx->curr_byte_ >> (bitctx->num_remaining_bits_in_curr_byte_ - bits_left));
@@ -81,6 +80,8 @@ MPP_RET read_bits(BitReadCtx_t *bitctx, RK_S32 num_bits, RK_S32 *out)
bitctx->used_bits += num_bits;
return MPP_OK;
__FAILED:
return ret;
}
/*!
***********************************************************************
@@ -106,26 +107,22 @@ MPP_RET read_ue(BitReadCtx_t *bitctx, RK_U32 *val)
RK_S32 rest;
// Count the number of contiguous zero bits.
do {
if (read_bits(bitctx, 1, &bit)) {
return ret = MPP_NOK;
}
FUN_CHECK(ret = read_bits(bitctx, 1, &bit));
num_bits++;
} while (bit == 0);
if (num_bits > 31) {
return ret = MPP_NOK;
}
VAL_CHECK(num_bits < 32);
// Calculate exp-Golomb code value of size num_bits.
*val = (1 << num_bits) - 1;
if (num_bits > 0) {
if (read_bits(bitctx, num_bits, &rest)) {
return ret = MPP_NOK;
}
FUN_CHECK(ret = read_bits(bitctx, num_bits, &rest));
*val += rest;
}
return ret = MPP_OK;
return MPP_OK;
__FAILED:
return ret;
}
/*!
***********************************************************************
@@ -137,9 +134,8 @@ MPP_RET read_se(BitReadCtx_t *bitctx, RK_S32 *val)
{
MPP_RET ret = MPP_NOK;
RK_U32 ue;
if (ret = read_ue(bitctx, &ue)) {
return ret = MPP_NOK;
}
FUN_CHECK(ret = read_ue(bitctx, &ue));
if (ue % 2 == 0) { // odd
*val = -(RK_S32)(ue >> 1);
} else {
@@ -147,6 +143,8 @@ MPP_RET read_se(BitReadCtx_t *bitctx, RK_S32 *val)
}
return MPP_OK;
__FAILED:
return ret;
}
/*!

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

@@ -21,6 +21,8 @@
#include <stdio.h>
#include "rk_type.h"
#include "rk_mpi.h"
#include "h264d_log.h"
#include "h264d_bitread.h"
#include "h264d_syntax.h"
@@ -789,21 +791,20 @@ typedef struct h264_old_slice_par_t {
#define FRAME_BUF_MAX_SIZE 64//512*1024
#define FRAME_BUF_ADD_SIZE 32//512
#define SYNTAX_BUF_SIZE 5
typedef struct h264d_dxva_ctx_t
{
RK_U8 cfgBitstrmRaw;
struct _DXVA_PicParams_H264_MVC pp;
struct _DXVA_Qmatrix_H264 qm;
RK_U32 max_slice_size;
RK_U32 slice_count;
struct _DXVA_Slice_H264_Short *slice_short; //!< MAX_SLICES
struct _DXVA_Slice_H264_Long *slice_long; //!< MAX_SLICES
RK_U8 *bitstream;
RK_U32 max_strm_size;
RK_U32 strm_offset;
struct h264d_syntax_t syn;
struct h264_dec_ctx_t *p_Dec;
}H264dDxvaCtx_t;
typedef struct h264d_dxva_ctx_t {
RK_U8 cfgBitstrmRaw;
struct _DXVA_PicParams_H264_MVC pp;
struct _DXVA_Qmatrix_H264 qm;
RK_U32 max_slice_size;
RK_U32 slice_count;
struct _DXVA_Slice_H264_Short *slice_short; //!< MAX_SLICES
struct _DXVA_Slice_H264_Long *slice_long; //!< MAX_SLICES
RK_U8 *bitstream;
RK_U32 max_strm_size;
RK_U32 strm_offset;
struct h264d_syntax_t syn;
struct h264_dec_ctx_t *p_Dec;
} H264dDxvaCtx_t;
//!< input parameter
@@ -911,24 +912,23 @@ typedef struct h264d_video_ctx_t {
} H264dVideoCtx_t;
typedef struct h264d_mem_t
{
struct h264_dpb_mark_t dpb_mark[MAX_DPB_SIZE]; //!< for write out, MAX_DPB_SIZE
struct h264_dpb_info_t dpb_info[DPB_INFO_SIZE]; //!< 16
struct h264_refpic_info_t refpic_info_p[REFPIC_INFO_SIZE]; //!< 32
struct h264_refpic_info_t refpic_info[2][REFPIC_INFO_SIZE]; //!< [2][32]
struct h264d_dxva_ctx_t dxva_ctx[MAX_TASK_SIZE];
}H264_DecMem_t;
typedef struct h264d_mem_t {
struct h264_dpb_mark_t dpb_mark[MAX_DPB_SIZE]; //!< for write out, MAX_DPB_SIZE
struct h264_dpb_info_t dpb_info[DPB_INFO_SIZE]; //!< 16
struct h264_refpic_info_t refpic_info_p[REFPIC_INFO_SIZE]; //!< 32
struct h264_refpic_info_t refpic_info[2][REFPIC_INFO_SIZE]; //!< [2][32]
struct h264d_dxva_ctx_t dxva_ctx[MAX_TASK_SIZE];
} H264_DecMem_t;
//!< decoder video parameter
typedef struct h264_dec_ctx_t {
struct h264d_mem_t *mem;
struct h264_dpb_mark_t *dpb_mark; //!< for write out, MAX_DPB_SIZE
struct h264_dpb_info_t *dpb_info; //!< 16
struct h264_refpic_info_t *refpic_info_p; //!< 32
struct h264_refpic_info_t *refpic_info[2]; //!< [2][32]
struct h264d_dxva_ctx_t *dxva_ctx;
struct h264d_mem_t *mem;
struct h264_dpb_mark_t *dpb_mark; //!< for write out, MAX_DPB_SIZE
struct h264_dpb_info_t *dpb_info; //!< 16
struct h264_refpic_info_t *refpic_info_p; //!< 32
struct h264_refpic_info_t *refpic_info[2]; //!< [2][32]
struct h264d_dxva_ctx_t *dxva_ctx;
struct h264d_input_ctx_t *p_Inp;
struct h264d_cur_ctx_t *p_Cur; //!< current parameters, use in read nalu
struct h264d_video_ctx_t *p_Vid; //!< parameters for video decoder

166
mpp/codec/dec/h264/h264d_parse.h
View File

@@ -1,90 +1,88 @@
/*
*
* 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 __H264D_PARSE_H__
#define __H264D_PARSE_H__
#include "rk_type.h"
#include "mpp_err.h"
typedef enum
{
NALU_NULL = 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.
*/
//StreamError,
//HaveNoStream,
//NaluNotSupport,
//ReadNaluError,
//NALU_ERROR,
//NALU_OK,
//StartofNalu,
//EndofStream,
//ReallocBufError,
//MidOfNalu,
//EndOfNalu,
//StartOfPicture,
//StartOfSlice,
//SkipNALU,
//NALU_SPS,
//NALU_SubSPS,
//NALU_PPS,
//NALU_SEI,
NALU_MAX,
}NALU_STATUS;
#ifndef __H264D_PARSE_H__
#define __H264D_PARSE_H__
#include "rk_type.h"
#include "mpp_err.h"
typedef enum Rkv_slice_state_t
{
SliceSTATE_NULL = 0,
SliceSTATE_IDLE,
typedef enum {
NALU_NULL = 0,
//SliceSTATE_GetLastSlice,
SliceSTATE_ResetSlice,
//SliceSTATE_ReadNalu,
//SliceSTATE_ParseNalu,
//SliceSTATE_DecodeOneSlice,
//SliceSTATE_InitPicture,
//SliceSTATE_GetOuterDpbMemory,
////SliceSTATE_InitSlice,
//SliceSTATE_GetSliceData,
//SliceSTATE_RegisterOneSlice,
//SliceSTATE_RegisterOneFrame,
//SliceSTATE_ExitPicture,
//SliceSTATE_ErrorMaster,
//StreamError,
//HaveNoStream,
//NaluNotSupport,
//ReadNaluError,
//NALU_ERROR,
//NALU_OK,
//StartofNalu,
//EndofStream,
//ReallocBufError,
//MidOfNalu,
//EndOfNalu,
//StartOfPicture,
//StartOfSlice,
//SkipNALU,
//NALU_SPS,
//NALU_SubSPS,
//NALU_PPS,
//NALU_SEI,
//SliceSTATE_Return,
SliceSTATE_MAX,
NALU_MAX,
} NALU_STATUS;
}RKV_SLICE_STATUS;
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
}
#endif
#endif /* __H264D_PARSE_H__ */
typedef enum Rkv_slice_state_t {
SliceSTATE_NULL = 0,
SliceSTATE_IDLE,
//SliceSTATE_GetLastSlice,
SliceSTATE_ResetSlice,
//SliceSTATE_ReadNalu,
//SliceSTATE_ParseNalu,
//SliceSTATE_DecodeOneSlice,
//SliceSTATE_InitPicture,
//SliceSTATE_GetOuterDpbMemory,
////SliceSTATE_InitSlice,
//SliceSTATE_GetSliceData,
//SliceSTATE_RegisterOneSlice,
//SliceSTATE_RegisterOneFrame,
//SliceSTATE_ExitPicture,
//SliceSTATE_ErrorMaster,
//SliceSTATE_Return,
SliceSTATE_MAX,
} RKV_SLICE_STATUS;
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
}
#endif
#endif /* __H264D_PARSE_H__ */

5
mpp/hal/rkdec/h264d/CMakeLists.txt
View File

@@ -23,5 +23,8 @@ add_library(hal_h264d STATIC
${HAL_H264D_HDR}
${HAL_H264D_SRC}
)
target_link_libraries(hal_h264d
mpp
)
set_target_properties(hal_h264d PROPERTIES FOLDER "mpp/hal")