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

[avsd]

Browse Source 
1. change avs_impl CMakeLists.txt
2. add libavs.a && libavs.so, which used in avsd_api.c
3. update avsd_api.c && avsd_parse.c which interface of between libavs.a and mpp_dec 

git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@678 6e48237b-75ef-9749-8fc9-41990f28c85a
This commit is contained in:
DingWei
2016-05-03 13:32:09 +00:00
parent 506ffb1e31
commit 01b4727ba4
11 changed files with 968 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
mpp/codec/CMakeLists.txt
View File

@@ -15,25 +15,14 @@ add_subdirectory(dec)
add_subdirectory(enc) add_subdirectory(enc)
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/dec/avs_impl/")
add_subdirectory(dec/avs_impl) target_link_libraries(mpp_codec
target_link_libraries(mpp_codec codec_h264d
codec_h264d codec_vp9d
codec_vp9d codec_h265d
codec_h265d codec_avsd
codec_avsd codec_dummy_enc
codec_avsd_impl codec_dummy_dec
codec_dummy_enc mpp)
codec_dummy_dec
mpp)
else()
target_link_libraries(mpp_codec
codec_h264d
codec_vp9d
codec_h265d
codec_avsd
codec_dummy_enc
codec_dummy_dec
mpp)
endif()

15
mpp/codec/dec/avs/CMakeLists.txt
View File

@@ -11,12 +11,13 @@ set(AVSD_COMMON
# avs decoder header # avs decoder header
set(AVSD_HDR set(AVSD_HDR
avsd_parse.h
) )
# avs decoder sourse # avs decoder sourse
set(AVSD_SRC set(AVSD_SRC
avsd_api.c avsd_api.c
avsd_parse.c
) )
add_library(codec_avsd STATIC add_library(codec_avsd STATIC
@@ -26,6 +27,18 @@ add_library(codec_avsd STATIC
${AVSD_SRC} ${AVSD_SRC}
) )
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/avs_impl/")
add_subdirectory(avs_impl)
target_link_libraries(codec_avsd codec_avsd_impl)
else()
set(LIBAVS "${CMAKE_CURRENT_SOURCE_DIR}/libavs.a")
add_library(codec_avsd_impl STATIC IMPORTED)
set_target_properties(codec_avsd_impl PROPERTIES IMPORTED_LOCATION ${LIBAVS})
target_link_libraries(codec_avsd codec_avsd_impl)
endif()
target_link_libraries(codec_avsd mpp) target_link_libraries(codec_avsd mpp)
set_target_properties(codec_avsd PROPERTIES FOLDER "mpp/codec") set_target_properties(codec_avsd PROPERTIES FOLDER "mpp/codec")

386
mpp/codec/dec/avs/avsd_api.c
View File

@@ -21,17 +21,217 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "mpp_packet.h"
#include "mpp_packet_impl.h"
#include "mpp_mem.h" #include "mpp_mem.h"
#include "mpp_log.h" #include "mpp_log.h"
#include "mpp_env.h" #include "mpp_env.h"
#include "mpp_packet.h"
#include "mpp_packet_impl.h"
#include "mpp_buffer_impl.h"
#include "avsd_api.h" #include "avsd_api.h"
#include "avsd_parse.h"
RK_U32 avsd_parse_debug = 0; RK_U32 avsd_parse_debug = 0;
static MPP_RET free_input_ctx(AvsdInputCtx_t *p_inp)
{
MPP_RET ret = MPP_ERR_UNKNOW;
INP_CHECK(ret, !p_inp);
AVSD_PARSE_TRACE("In.");
MPP_FCLOSE(p_inp->fp_log);
__RETURN:
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
}
static MPP_RET init_input_ctx(AvsdInputCtx_t *p_inp, ParserCfg *init)
{
MPP_RET ret = MPP_ERR_UNKNOW;
INP_CHECK(ret, !p_inp && !init);
AVSD_PARSE_TRACE("In.");
p_inp->init = *init;
#if defined(_WIN32)
if ((p_inp->fp_log = fopen("F:/avs_log/avs_runlog.txt", "wb")) == 0) {
mpp_log("Wanning, open file, %s(%d)", __FUNCTION__, __LINE__);
}
#endif
__RETURN:
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
}
static MPP_RET free_cur_ctx(AvsdCurCtx_t *p_cur)
{
MPP_RET ret = MPP_ERR_UNKNOW;
INP_CHECK(ret, !p_cur);
AVSD_PARSE_TRACE("In.");
__RETURN:
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
}
static MPP_RET init_cur_ctx(AvsdCurCtx_t *p_cur)
{
MPP_RET ret = MPP_ERR_UNKNOW;
AvsdCurStream_t *p_strm = NULL;
INP_CHECK(ret, !p_cur);
AVSD_PARSE_TRACE("In.");
p_strm = &p_cur->m_strm;
p_strm->prefixdata = 0xffffffff;
__RETURN:
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
}
static MPP_RET free_vid_ctx(AvsdVideoCtx_t *p_vid)
{
MPP_RET ret = MPP_ERR_UNKNOW;
INP_CHECK(ret, !p_vid);
AVSD_PARSE_TRACE("In.");
__RETURN:
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
}
static MPP_RET init_vid_ctx(AvsdVideoCtx_t *p_vid)
{
MPP_RET ret = MPP_ERR_UNKNOW;
INP_CHECK(ret, !p_vid);
AVSD_PARSE_TRACE("In.");
__RETURN:
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
}
static MPP_RET free_bitstream(AvsdBitstream_t *p)
{
MPP_RET ret = MPP_ERR_UNKNOW;
INP_CHECK(ret, !p);
AVSD_PARSE_TRACE("In.");
MPP_FREE(p->pbuf);
__RETURN:
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
}
static MPP_RET init_bitstream(AvsdBitstream_t *p)
{
MPP_RET ret = MPP_ERR_UNKNOW;
INP_CHECK(ret, !p);
AVSD_PARSE_TRACE("In.");
p->size = MAX_BITSTREAM_SIZE;
p->pbuf = mpp_malloc(RK_U8, MAX_BITSTREAM_SIZE);
MEM_CHECK(ret, p->pbuf);
__RETURN:
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
__FAILED:
return ret;
}
static MPP_RET free_dec_ctx(Avs_DecCtx_t *p_dec)
{
MPP_RET ret = MPP_ERR_UNKNOW;
INP_CHECK(ret, NULL == p_dec);
AVSD_PARSE_TRACE("In.");
lib_avsd_free(p_dec->libdec);
mpp_packet_deinit(&p_dec->task_pkt);
free_bitstream(p_dec->bitstream);
MPP_FREE(p_dec->mem);
__RETURN:
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
}
static MPP_RET init_dec_ctx(Avs_DecCtx_t *p_dec)
{
MPP_RET ret = MPP_ERR_UNKNOW;
INP_CHECK(ret, !p_dec);
AVSD_PARSE_TRACE("In.");
mpp_buf_slot_setup(p_dec->frame_slots, 4);
p_dec->mem = mpp_calloc(AvsdMemory_t, 1);
MEM_CHECK(ret, p_dec->mem);
p_dec->bitstream = &p_dec->mem->bitstream;
FUN_CHECK(ret = init_bitstream(p_dec->bitstream));
//!< malloc mpp packet
mpp_packet_init(&p_dec->task_pkt, p_dec->bitstream->pbuf, p_dec->bitstream->size);
mpp_packet_set_length(p_dec->task_pkt, 0);
MEM_CHECK(ret, p_dec->task_pkt);
//!< malloc libavsd.so
p_dec->libdec = lib_avsd_malloc(p_dec);
MEM_CHECK(ret, p_dec->libdec);
__RETURN:
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
__FAILED:
free_dec_ctx(p_dec);
return ret;
}
/*!
***********************************************************************
* \brief
* free all buffer
***********************************************************************
*/
MPP_RET avsd_deinit(void *decoder)
{
MPP_RET ret = MPP_ERR_UNKNOW;
Avs_DecCtx_t *p_dec = (Avs_DecCtx_t *)decoder;
INP_CHECK(ret, !decoder);
AVSD_PARSE_TRACE("In.");
avsd_flush(decoder);
free_input_ctx(p_dec->p_inp);
MPP_FREE(p_dec->p_inp);
free_cur_ctx(p_dec->p_cur);
MPP_FREE(p_dec->p_cur);
free_vid_ctx(p_dec->p_vid);
MPP_FREE(p_dec->p_vid);
free_dec_ctx(p_dec);
__RETURN:
(void)decoder;
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
}
/*! /*!
*********************************************************************** ***********************************************************************
* \brief * \brief
@@ -39,48 +239,64 @@ RK_U32 avsd_parse_debug = 0;
*********************************************************************** ***********************************************************************
*/ */
MPP_RET avsd_init(void *ctx, ParserCfg *init) MPP_RET avsd_init(void *decoder, ParserCfg *init)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
Avs_DecCtx_t *p_dec = (Avs_DecCtx_t *)decoder;
mpp_env_get_u32("avsd_debug", &avsd_parse_debug, 0); AVSD_PARSE_TRACE("In.");
INP_CHECK(ret, !p_dec);
memset(p_dec, 0, sizeof(Avs_DecCtx_t));
// init logctx
mpp_env_get_u32("avsd_debug", &avsd_parse_debug, 0);
//!< get init frame_slots and packet_slots
p_dec->frame_slots = init->frame_slots;
p_dec->packet_slots = init->packet_slots;
//!< malloc decoder buffer
p_dec->p_inp = mpp_calloc(AvsdInputCtx_t, 1);
p_dec->p_cur = mpp_calloc(AvsdCurCtx_t, 1);
p_dec->p_vid = mpp_calloc(AvsdVideoCtx_t, 1);
MEM_CHECK(ret, p_dec->p_inp && p_dec->p_cur && p_dec->p_vid);
AVSD_PARSE_TRACE("In."); p_dec->p_inp->p_dec = p_dec;
p_dec->p_inp->p_cur = p_dec->p_cur;
p_dec->p_inp->p_vid = p_dec->p_vid;
FUN_CHECK(ret = init_input_ctx(p_dec->p_inp, init));
p_dec->p_cur->p_dec = p_dec;
p_dec->p_cur->p_inp = p_dec->p_inp;
p_dec->p_cur->p_vid = p_dec->p_vid;
FUN_CHECK(ret = init_cur_ctx(p_dec->p_cur));
p_dec->p_vid->p_dec = p_dec;
p_dec->p_vid->p_inp = p_dec->p_inp;
p_dec->p_vid->p_cur = p_dec->p_cur;
FUN_CHECK(ret = init_vid_ctx(p_dec->p_vid));
FUN_CHECK(ret = init_dec_ctx(p_dec));
__RETURN:
(void)decoder;
(void)init;
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
__FAILED:
avsd_deinit(decoder);
(void)ctx; return ret;
(void)init;
return ret = MPP_OK;
} }
/*!
***********************************************************************
* \brief
* free all buffer
***********************************************************************
*/
MPP_RET avsd_deinit(void *ctx)
{
MPP_RET ret = MPP_ERR_UNKNOW;
AVSD_PARSE_TRACE("In.");
(void)ctx;
return ret = MPP_OK;
}
/*! /*!
*********************************************************************** ***********************************************************************
* \brief * \brief
* reset * reset
*********************************************************************** ***********************************************************************
*/ */
MPP_RET avsd_reset(void *ctx) MPP_RET avsd_reset(void *decoder)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
Avs_DecCtx_t *p_dec = (Avs_DecCtx_t *)decoder;
AVSD_PARSE_TRACE("In."); AVSD_PARSE_TRACE("In.");
lib_reset(p_dec->libdec);
(void)ctx; AVSD_PARSE_TRACE("Out.");
(void)decoder;
return ret = MPP_OK; return ret = MPP_OK;
} }
@@ -90,13 +306,16 @@ MPP_RET avsd_reset(void *ctx)
* flush * flush
*********************************************************************** ***********************************************************************
*/ */
MPP_RET avsd_flush(void *ctx) MPP_RET avsd_flush(void *decoder)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
Avs_DecCtx_t *p_dec = (Avs_DecCtx_t *)decoder;
AVSD_PARSE_TRACE("In."); AVSD_PARSE_TRACE("In.");
(void)ctx; lib_flush(p_dec->libdec);
AVSD_PARSE_TRACE("Out.");
(void)decoder;
return ret = MPP_OK; return ret = MPP_OK;
} }
@@ -106,16 +325,17 @@ MPP_RET avsd_flush(void *ctx)
* control/perform * control/perform
*********************************************************************** ***********************************************************************
*/ */
MPP_RET avsd_control(void *ctx, RK_S32 cmd_type, void *param) MPP_RET avsd_control(void *decoder, RK_S32 cmd_type, void *param)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
AVSD_PARSE_TRACE("In."); AVSD_PARSE_TRACE("In.");
(void)ctx;
(void)decoder;
(void)cmd_type; (void)cmd_type;
(void)param; (void)param;
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK; return ret = MPP_OK;
} }
@@ -126,19 +346,53 @@ MPP_RET avsd_control(void *ctx, RK_S32 cmd_type, void *param)
* prepare * prepare
*********************************************************************** ***********************************************************************
*/ */
MPP_RET avsd_prepare(void *ctx, MppPacket pkt, HalDecTask *task) MPP_RET avsd_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
AvsdInputCtx_t *p_inp = NULL;
Avs_DecCtx_t *p_dec = (Avs_DecCtx_t *)decoder;
AVSD_PARSE_TRACE("In."); AVSD_PARSE_TRACE("In.");
INP_CHECK(ret, !decoder && !pkt && !task);
p_inp = p_dec->p_inp;
if (p_inp->has_get_eos) {
mpp_packet_set_length(pkt, 0);
goto __RETURN;
}
p_inp->in_pkt = pkt;
p_inp->in_task = task;
mpp_packet_set_length(pkt, 0); if (mpp_packet_get_eos(pkt)) {
if (mpp_packet_get_length(pkt) < 4) {
avsd_flush(decoder);
}
p_inp->has_get_eos = 1;
}
AVSD_DBG(AVSD_DBG_INPUT, "[pkt_in_timeUs] in_pts=%lld, pkt_eos=%d, len=%d, pkt_no=%d",
mpp_packet_get_pts(pkt), mpp_packet_get_eos(pkt), mpp_packet_get_length(pkt), p_inp->pkt_no++);
if (mpp_packet_get_length(pkt) > MAX_STREM_IN_SIZE) {
AVSD_DBG(AVSD_DBG_ERROR, "[pkt_in_timeUs] input error, stream too large");
mpp_packet_set_length(pkt, 0);
ret = MPP_NOK;
goto __FAILED;
}
p_inp->in_pts = mpp_packet_get_pts(pkt);
p_inp->in_dts = mpp_packet_get_dts(pkt);
(void)ctx; memset(task, 0, sizeof(HalDecTask));
(void)pkt; do {
(void)task; (ret = avsd_parse_prepare(p_inp, p_dec->p_cur));
return ret = MPP_OK;
} while (mpp_packet_get_length(pkt) && !task->valid);
__RETURN:
(void)decoder;
(void)pkt;
(void)task;
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
__FAILED:
return ret;
} }
@@ -148,14 +402,30 @@ MPP_RET avsd_prepare(void *ctx, MppPacket pkt, HalDecTask *task)
* parser * parser
*********************************************************************** ***********************************************************************
*/ */
MPP_RET avsd_parse(void *ctx, HalDecTask *in_task) MPP_RET avsd_parse(void *decoder, HalDecTask *task)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
Avs_DecCtx_t *p_dec = (Avs_DecCtx_t *)decoder;
AVSD_PARSE_TRACE("In."); AVSD_PARSE_TRACE("In.");
(void)ctx; task->valid = 0;
(void)in_task; memset(task->refer, -1, sizeof(task->refer));
lib_parse_one_frame(p_dec->libdec, task);
if (task->flags.eos) {
avsd_flush(decoder);
goto __RETURN;
}
task->valid = 1; // register valid flag
if (task->valid) {
lib_init_one_frame(p_dec->libdec, task);
}
__RETURN:
(void)decoder;
(void)task;
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK; return ret = MPP_OK;
} }
@@ -167,14 +437,27 @@ MPP_RET avsd_parse(void *ctx, HalDecTask *in_task)
*/ */
MPP_RET avsd_callback(void *decoder, void *info) MPP_RET avsd_callback(void *decoder, void *info)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
HalTaskInfo *task = (HalTaskInfo *)info;
Avs_DecCtx_t *p_dec = (Avs_DecCtx_t *)decoder;
AVSD_PARSE_TRACE("In.");
AVSD_PARSE_TRACE("In."); AVSD_PARSE_TRACE("[avsd_parse_decode] frame_dec_no=%d", p_dec->dec_no++);
lib_decode_one_frame(p_dec->libdec, &task->dec);
{
MppBuffer mbuffer = NULL;
mpp_buf_slot_get_prop(p_dec->frame_slots, task->dec.output, SLOT_BUFFER, &mbuffer);
if (mbuffer) {
RK_U8 *p = (RK_U8 *)mpp_buffer_get_ptr(mbuffer);
nv12_copy_buffer(p_dec->libdec, p);
}
}
(void)task;
(void)decoder;
(void)info;
AVSD_PARSE_TRACE("Out.");
(void)decoder; return ret = MPP_OK;
(void)info;
return ret = MPP_OK;
} }
/*! /*!
@@ -183,11 +466,10 @@ MPP_RET avsd_callback(void *decoder, void *info)
* api struct interface * api struct interface
*********************************************************************** ***********************************************************************
*/ */
const ParserApi api_avsd_parser = { const ParserApi api_avsd_parser = {
"avsd_parse", "avsd_parse",
MPP_VIDEO_CodingAVS, MPP_VIDEO_CodingAVS,
200,//sizeof(AvsCodecContext), sizeof(Avs_DecCtx_t),
0, 0,
avsd_init, avsd_init,
avsd_deinit, avsd_deinit,

214
mpp/codec/dec/avs/avsd_parse.c Normal file
View File

@@ -0,0 +1,214 @@
/*
*
* 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.
*/
#define MODULE_TAG "avsd_parse"
#include <string.h>
#include <stdlib.h>
#include "vpu_api.h"
#include "mpp_mem.h"
#include "mpp_log.h"
#include "mpp_packet.h"
#include "mpp_packet_impl.h"
#include "hal_task.h"
#include "avsd_api.h"
#include "avsd_parse.h"
#if 0
#define START_PREFIX_3BYTE (3)
static void reset_curstream(AvsdCurStream_t *p_strm)
{
p_strm->p_start = NULL;
p_strm->len = 0;
p_strm->got_frame_flag = 0;
p_strm->got_nalu_flag = 0;
}
static MPP_RET add_nalu_header(AvsdCurCtx_t *p_cur)
{
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U32 add_size = sizeof(AvsdNalu_t);
AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream;
if ((p_bitstream->offset + add_size) > p_bitstream->size) {
AVSD_DBG(AVSD_DBG_ERROR, "error, head_offset is larger than %d", p_bitstream->size);
goto __FAILED;
}
p_cur->cur_nalu = (AvsdNalu_t *)&p_bitstream->pbuf[p_bitstream->offset];
p_cur->cur_nalu->eof = 1;
p_cur->cur_nalu->header = 0;
p_cur->cur_nalu->pdata = NULL;
p_cur->cur_nalu->length = 0;
p_cur->cur_nalu->start_pos = 0;
p_bitstream->offset += add_size;
(void)p_cur;
return ret = MPP_OK;
__FAILED:
return ret;
}
static MPP_RET store_cur_nalu(AvsdCurCtx_t *p_cur, AvsdCurStream_t *p_strm)
{
MPP_RET ret = MPP_ERR_UNKNOW;
AvsdNalu_t *p_nalu = p_cur->cur_nalu;
AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream;
//!< fill bitstream buffer
RK_U32 add_size = p_strm->len;
if ((p_bitstream->offset + add_size) > p_bitstream->size) {
AVSD_DBG(AVSD_DBG_ERROR, "error, head_offset is larger than %d", p_bitstream->size);
goto __FAILED;
}
p_nalu->length += p_strm->len;
p_nalu->pdata = &p_bitstream->pbuf[p_bitstream->offset];
memcpy(p_nalu->pdata, p_strm->p_start, p_strm->len);
p_bitstream->offset += add_size;
return ret = MPP_OK;
__FAILED:
return ret;
}
/*!
***********************************************************************
* \brief
* prepare function for parser
***********************************************************************
*/
MPP_RET avsd_parse_prepare(AvsdInputCtx_t *p_inp, AvsdCurCtx_t *p_cur)
{
MPP_RET ret = MPP_ERR_UNKNOW;
RK_U8 *p_curdata = NULL;
HalDecTask *in_task = p_inp->in_task;
MppPacket *in_pkt = p_inp->in_pkt;
MppPacketImpl *pkt_impl = (MppPacketImpl *)p_inp->in_pkt;
AvsdCurStream_t *p_strm = &p_cur->m_strm;
AvsdBitstream_t *p_bitstream = p_cur->p_dec->bitstream;
AVSD_PARSE_TRACE("In.");
//!< check input
if (!mpp_packet_get_length(in_pkt)) {
AVSD_DBG(AVSD_DBG_WARNNING, "input have no stream.");
goto __RETURN;
}
in_task->valid = 0;
in_task->flags.eos = 0;
//!< check eos
if (mpp_packet_get_eos(in_pkt)) {
FUN_CHECK(ret = add_nalu_header(p_cur));
in_task->valid = 1;
in_task->flags.eos = 1;
AVSD_DBG(AVSD_DBG_LOG, "end of stream.");
goto __RETURN;
}
p_strm->p_start = p_curdata = (RK_U8 *)mpp_packet_get_pos(p_inp->in_pkt);
while (pkt_impl->length > 0) {
//!< found next picture start code
if (((*p_curdata) == I_PICTURE_START_CODE)
|| ((*p_curdata) == PB_PICTURE_START_CODE)) {
if (p_strm->got_frame_flag) {
FUN_CHECK(ret = add_nalu_header(p_cur));
in_task->valid = 1;
pkt_impl->length += START_PREFIX_3BYTE;
p_bitstream->len = p_bitstream->offset;
//!< reset value
p_bitstream->offset = 0;
reset_curstream(p_strm);
break;
}
p_strm->got_frame_flag = 1;
}
//!< found next nalu start code
p_strm->prefixdata = (p_strm->prefixdata << 8) | (*p_curdata);
if ((p_strm->prefixdata & 0xFFFFFF00) == 0x00000100) {
if (p_strm->got_nalu_flag) {
p_strm->len = (RK_U32)(p_curdata - p_strm->p_start) - START_PREFIX_3BYTE;
FUN_CHECK(ret = store_cur_nalu(p_cur, p_strm));
FPRINT(p_cur->p_inp->fp_log, "g_nalu_no=%d, length=%d, header=0x%02x \n", g_nalu_no++, p_cur->cur_nalu->length, p_cur->cur_nalu->header);
}
FUN_CHECK(ret = add_nalu_header(p_cur));
p_cur->cur_nalu->header = (*p_curdata);
p_cur->cur_nalu->eof = 0;
p_cur->cur_nalu->start_pos = START_PREFIX_3BYTE;
p_strm->p_start = p_curdata - START_PREFIX_3BYTE;
p_strm->got_nalu_flag = 1;
}
p_curdata++;
pkt_impl->length--;
}
if (!pkt_impl->length) {
p_strm->len = (RK_U32)(p_curdata - p_strm->p_start) - 1;
FUN_CHECK(ret = store_cur_nalu(p_cur, p_strm));
}
__RETURN:
AVSD_PARSE_TRACE("Out.");
return ret = MPP_OK;
__FAILED:
return ret;
}
#else
MPP_RET avsd_parse_prepare(AvsdInputCtx_t *p_inp, AvsdCurCtx_t *p_cur)
{
RK_S32 ret_val = 0;
MPP_RET ret = MPP_ERR_UNKNOW;
Avs_DecCtx_t *p_dec = p_inp->p_dec;
HalDecTask *in_task = p_inp->in_task;
AvsdBitstream_t *pb = p_dec->bitstream;
AVSD_PARSE_TRACE("In.");
in_task->input_packet = p_dec->task_pkt;
ret_val = lib_prepare_one_frame(p_dec->libdec, p_inp->in_pkt, in_task);
if (ret_val < 0) {
goto __FAILED;
}
if (in_task->valid) {
mpp_packet_set_pos(in_task->input_packet, pb->pbuf);
mpp_packet_set_length(in_task->input_packet, 0);
}
AVSD_PARSE_TRACE("Out.");
(void)p_cur;
return ret = MPP_OK;
__FAILED:
mpp_packet_set_pos(p_dec->task_pkt, pb->pbuf);
mpp_packet_set_length(p_dec->task_pkt, 0);
return ret;
}
#endif

171
mpp/codec/dec/avs/avsd_parse.h Normal file
View File

@@ -0,0 +1,171 @@
/*
* Copyright 2010 Rockchip Electronics S.LSI 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 __AVSD_PARSE_H__
#define __AVSD_PARSE_H__
#include "rk_type.h"
#include "parser_api.h"
#include "mpp_err.h"
#include "mpp_packet.h"
#include "mpp_buf_slot.h"
#include "hal_task.h"
#define MAX_STREM_IN_SIZE (2*1024*1024)
#define MAX_BITSTREAM_SIZE (2*1024*1024)
//!< NALU type
#define SLICE_START_CODE_MIN 0x00
#define SLICE_START_CODE_MAX 0xAF
#define I_PICTURE_START_CODE 0xB3
#define PB_PICTURE_START_CODE 0xB6
#define USER_DATA_START_CODE 0xB2
#define SEQUENCE_HEADER_CODE 0xB0
#define EXTENSION_START_CODE 0xB5
#define SEQUENCE_END_CODE 0xB1 //!< no in ffmpeg
#define VIDEO_EDIT_CODE 0xB7 //!< no in ffmpeg
#define FPRINT(fp, ...) do{ if (fp) { fprintf(fp, ## __VA_ARGS__); fflush(fp);} }while(0)
//!< input parameter
typedef struct avsd_input_ctx_t {
FILE *fp_log;
ParserCfg init;
MppPacket in_pkt;
HalDecTask *in_task;
RK_S64 in_pts;
RK_S64 in_dts;
RK_U8 has_get_eos;
RK_U64 pkt_no;
struct avsd_cur_ctx_t *p_cur;
struct avsd_video_ctx_t *p_vid;
struct avs_dec_ctx_t *p_dec;
} AvsdInputCtx_t;
//!< current stream
typedef struct avsd_cur_strm_t {
RK_U8 *p_start; //!< store read nalu data
RK_U32 len;
RK_U32 prefixdata;
RK_U8 got_frame_flag;
RK_U8 got_nalu_flag;
} AvsdCurStream_t;
typedef struct avsd_nalu_t
{
RK_U8 header;
RK_U8 *pdata;
RK_U32 size;
RK_U32 length;
RK_U8 start_pos;
RK_U8 eof; //!< end of frame stream
}AvsdNalu_t;
//!< current parameters
typedef struct avsd_cur_ctx_t {
struct avsd_cur_strm_t m_strm;
struct avsd_nalu_t *cur_nalu; //!< current nalu
struct avsd_input_ctx_t *p_inp;
struct avsd_video_ctx_t *p_vid;
struct avs_dec_ctx_t *p_dec;
} AvsdCurCtx_t;
//!< decoder parameters
typedef struct avsd_video_ctx_t {
struct img_par *img;
struct avsd_input_ctx_t *p_inp;
struct avsd_cur_ctx_t *p_cur;
struct avs_dec_ctx_t *p_dec;
}AvsdVideoCtx_t;
typedef struct avsd_bitstream_t {
RK_U8 *pbuf;
RK_U32 size;
RK_U32 len;
RK_U32 offset; //!< start from the offset byte
}AvsdBitstream_t;
typedef struct avsd_memory_t {
struct avsd_bitstream_t bitstream;
} AvsdMemory_t;
//!< decoder parameters
typedef struct avs_dec_ctx_t {
MppBufSlots frame_slots;
MppBufSlots packet_slots;
MppPacket task_pkt;
struct avsd_memory_t *mem; //!< resotre slice data to decoder
struct avsd_bitstream_t *bitstream;
struct avsd_input_ctx_t *p_inp;
struct avsd_cur_ctx_t *p_cur;
struct avsd_video_ctx_t *p_vid;
//!< use in libavs.so
void *libdec;
RK_U32 dec_no;
//mpp_list
} Avs_DecCtx_t;
#ifdef __cplusplus
extern "C" {
#endif
MPP_RET avsd_parse_prepare(AvsdInputCtx_t *p_inp, AvsdCurCtx_t *p_cur);
//!< used in libavs.so
MPP_RET lib_avsd_free(void *decoder);
void *lib_avsd_malloc(void *decoder);
RK_S32 lib_prepare_one_frame(void *decoder, MppPacket pkt, HalDecTask *task);
RK_S32 lib_parse_one_frame(void *decoder, HalDecTask *task);
RK_S32 lib_init_one_frame(void *decoder, HalDecTask *task);
RK_S32 lib_decode_one_frame(void *decoder, HalDecTask *task);
RK_S32 lib_flush(void *decoder);
RK_S32 lib_reset(void *decoder);
RK_S32 nv12_copy_buffer(void *p_dec, RK_U8 *des);
#ifdef __cplusplus
}
#endif
#endif /*__AVSD_PARSE_H__*/

BIN
mpp/codec/dec/avs/libavs.a Normal file
View File

Binary file not shown.

BIN
mpp/codec/dec/avs/libavs.so Normal file
View File

Binary file not shown.

52
mpp/codec/inc/avsd_api.h
View File

@@ -20,7 +20,17 @@
#include "parser_api.h" #include "parser_api.h"
#define AVSD_DBG_TRACE (0x00000001) #define AVSD_DBG_ERROR (0x00000001)
#define AVSD_DBG_ASSERT (0x00000002)
#define AVSD_DBG_WARNNING (0x00000004)
#define AVSD_DBG_TRACE (0x00000008)
#define AVSD_DBG_INPUT (0x00000010) //!< input packet
#define AVSD_DBG_CALLBACK (0x00008000)
extern RK_U32 avsd_parse_debug; extern RK_U32 avsd_parse_debug;
@@ -32,6 +42,46 @@ do {\
} while (0) } while (0)
#define AVSD_DBG(level, fmt, ...)\
do {\
if (level & avsd_parse_debug)\
{ mpp_log(fmt, ## __VA_ARGS__); }\
} while (0)
#ifdef INP_CHECK
#undef INP_CHECK
#endif
//!< input check
#define INP_CHECK(ret, val, ...)\
do{\
if ((val)) {\
ret = MPP_ERR_INIT; \
AVSD_DBG(AVSD_DBG_WARNNING, "input empty(%d).\n", __LINE__); \
goto __RETURN; \
}} while (0)
#ifdef MEM_CHECK
#undef MEM_CHECK
#endif
//!< memory malloc check
#define MEM_CHECK(ret, val, ...)\
do{\
if(!(val)) {\
ret = MPP_ERR_MALLOC;\
AVSD_DBG(AVSD_DBG_ERROR, "malloc buffer error(%d).\n", __LINE__); \
goto __FAILED; \
}} while (0)
#ifdef FUN_CHECK
#undef FUN_CHECK
#endif
//!< function return check
#define FUN_CHECK(val)\
do{\
if ((val) < 0) {\
AVSD_DBG(AVSD_DBG_WARNNING, "Function error(%d).\n", __LINE__); \
goto __FAILED; \
}} while (0)
#ifdef __cplusplus #ifdef __cplusplus

54
mpp/hal/inc/hal_avsd_api.h
View File

@@ -25,18 +25,54 @@
#define AVSD_HAL_DBG_TRACE (0x00000001) #define AVSD_HAL_DBG_ERROR (0x00000001)
#define AVSD_HAL_DBG_ASSERT (0x00000002)
#define AVSD_HAL_DBG_WARNNING (0x00000004)
#define AVSD_HAL_DBG_TRACE (0x00000008)
extern RK_U32 avsd_hal_debug; extern RK_U32 avsd_hal_debug;
#define AVSD_HAL_DBG(level, fmt, ...)\
do {\
if (level & avsd_hal_debug)\
{ mpp_log(fmt, ## __VA_ARGS__); }\
} while (0)
#define AVSD_HAL_TRACE(fmt, ...)\ #define AVSD_HAL_TRACE(fmt, ...)\
do {\ do {\
if (AVSD_HAL_DBG_TRACE & avsd_hal_debug)\ if (AVSD_HAL_DBG_TRACE & avsd_hal_debug)\
{ mpp_log_f(fmt, ## __VA_ARGS__); }\ { mpp_log_f(fmt, ## __VA_ARGS__); }\
} while (0) } while (0)
#ifdef INP_CHECK
#undef INP_CHECK
#endif
//!< input check
#define INP_CHECK(ret, val, ...)\
do{\
if ((val)) { \
ret = MPP_ERR_INIT; \
AVSD_HAL_DBG(AVSD_HAL_DBG_WARNNING, "input empty(%d).\n", __LINE__); \
goto __RETURN; \
}} while (0)
typedef struct avsd_hal_ctx_t {
MppBufSlots frame_slots;
MppBufSlots packet_slots;
IOInterruptCB init_cb;
} AvsdHalCtx_t;
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@@ -44,14 +80,14 @@ extern "C" {
extern const MppHalApi hal_api_avsd; extern const MppHalApi hal_api_avsd;
MPP_RET hal_avsd_init (void *hal, MppHalCfg *cfg); MPP_RET hal_avsd_init (void *decoder, MppHalCfg *cfg);
MPP_RET hal_avsd_deinit (void *hal); MPP_RET hal_avsd_deinit (void *decoder);
MPP_RET hal_avsd_gen_regs(void *hal, HalTaskInfo *task); MPP_RET hal_avsd_gen_regs(void *decoder, HalTaskInfo *task);
MPP_RET hal_avsd_start (void *hal, HalTaskInfo *task); MPP_RET hal_avsd_start (void *decoder, HalTaskInfo *task);
MPP_RET hal_avsd_wait (void *hal, HalTaskInfo *task); MPP_RET hal_avsd_wait (void *decoder, HalTaskInfo *task);
MPP_RET hal_avsd_reset (void *hal); MPP_RET hal_avsd_reset (void *decoder);
MPP_RET hal_avsd_flush (void *hal); MPP_RET hal_avsd_flush (void *decoder);
MPP_RET hal_avsd_control (void *hal, RK_S32 cmd_type, void *param); MPP_RET hal_avsd_control (void *decoder, RK_S32 cmd_type, void *param);
#ifdef __cplusplus #ifdef __cplusplus
} }

100
mpp/hal/rkdec/avsd/hal_avsd_api.c
View File

@@ -28,13 +28,27 @@
#include "mpp_err.h" #include "mpp_err.h"
#include "mpp_mem.h" #include "mpp_mem.h"
#include "mpp_env.h" #include "mpp_env.h"
#include "mpp_common.h"
#include "hal_avsd_api.h" #include "hal_avsd_api.h"
RK_U32 avsd_hal_debug = 0; RK_U32 avsd_hal_debug = 0;
static RK_U32 avsd_ver_align(RK_U32 val)
{
return MPP_ALIGN(val, 16);
}
static RK_U32 avsd_hor_align(RK_U32 val)
{
return MPP_ALIGN(val, 16);
}
static RK_U32 avsd_len_align(RK_U32 val)
{
return (2 * MPP_ALIGN(val, 16));
}
/*! /*!
*********************************************************************** ***********************************************************************
* \brief * \brief
@@ -42,15 +56,31 @@ RK_U32 avsd_hal_debug = 0;
*********************************************************************** ***********************************************************************
*/ */
//extern "C" //extern "C"
MPP_RET hal_avsd_init(void *hal, MppHalCfg *cfg) MPP_RET hal_avsd_init(void *decoder, MppHalCfg *cfg)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
AvsdHalCtx_t *p_hal = NULL;
mpp_env_get_u32("avsd_debug", &avsd_hal_debug, 0);
AVSD_HAL_TRACE("In."); AVSD_HAL_TRACE("In.");
INP_CHECK(ret, NULL == decoder);
(void)hal; mpp_env_get_u32("avsd_debug", &avsd_hal_debug, 0);
p_hal = (AvsdHalCtx_t *)decoder;
memset(p_hal, 0, sizeof(AvsdHalCtx_t));
p_hal->frame_slots = cfg->frame_slots;
p_hal->packet_slots = cfg->packet_slots;
//!< callback function to parser module
p_hal->init_cb = cfg->hal_int_cb;
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_HOR_ALIGN, avsd_hor_align);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_VER_ALIGN, avsd_ver_align);
mpp_slots_set_prop(p_hal->frame_slots, SLOTS_LEN_ALIGN, avsd_len_align);
__RETURN:
AVSD_HAL_TRACE("Out.");
(void)decoder;
(void)cfg; (void)cfg;
return ret = MPP_OK; return ret = MPP_OK;
} }
@@ -61,13 +91,14 @@ MPP_RET hal_avsd_init(void *hal, MppHalCfg *cfg)
*********************************************************************** ***********************************************************************
*/ */
//extern "C" //extern "C"
MPP_RET hal_avsd_deinit(void *hal) MPP_RET hal_avsd_deinit(void *decoder)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
AVSD_HAL_TRACE("In."); AVSD_HAL_TRACE("In.");
(void)hal; AVSD_HAL_TRACE("Out.");
(void)decoder;
return ret = MPP_OK; return ret = MPP_OK;
} }
/*! /*!
@@ -77,12 +108,26 @@ MPP_RET hal_avsd_deinit(void *hal)
*********************************************************************** ***********************************************************************
*/ */
//extern "C" //extern "C"
MPP_RET hal_avsd_gen_regs(void *hal, HalTaskInfo *task) MPP_RET hal_avsd_gen_regs(void *decoder, HalTaskInfo *task)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
AvsdHalCtx_t *p_hal = NULL;
AVSD_HAL_TRACE("In."); AVSD_HAL_TRACE("In.");
(void)hal; INP_CHECK(ret, NULL == decoder);
p_hal = (AvsdHalCtx_t *)decoder;
if (p_hal->init_cb.callBack) {
p_hal->init_cb.callBack(p_hal->init_cb.opaque, task);
}
__RETURN:
AVSD_HAL_TRACE("Out.");
(void)decoder;
(void)task; (void)task;
return ret = MPP_OK; return ret = MPP_OK;
} }
@@ -93,13 +138,16 @@ MPP_RET hal_avsd_gen_regs(void *hal, HalTaskInfo *task)
*********************************************************************** ***********************************************************************
*/ */
//extern "C" //extern "C"
MPP_RET hal_avsd_start(void *hal, HalTaskInfo *task) MPP_RET hal_avsd_start(void *decoder, HalTaskInfo *task)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
AVSD_HAL_TRACE("In."); AVSD_HAL_TRACE("In.");
INP_CHECK(ret, NULL == decoder);
(void)hal; __RETURN:
AVSD_HAL_TRACE("Out.");
(void)decoder;
(void)task; (void)task;
return ret = MPP_OK; return ret = MPP_OK;
} }
@@ -110,13 +158,23 @@ MPP_RET hal_avsd_start(void *hal, HalTaskInfo *task)
*********************************************************************** ***********************************************************************
*/ */
//extern "C" //extern "C"
MPP_RET hal_avsd_wait(void *hal, HalTaskInfo *task) MPP_RET hal_avsd_wait(void *decoder, HalTaskInfo *task)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
//AvsdHalCtx_t *p_hal = NULL;
AVSD_HAL_TRACE("In."); AVSD_HAL_TRACE("In.");
(void)hal; INP_CHECK(ret, NULL == decoder);
//p_hal = (AvsdHalCtx_t *)decoder;
//if (p_hal->init_cb.callBack) {
// p_hal->init_cb.callBack(p_hal->init_cb.opaque, task);
//}
__RETURN:
AVSD_HAL_TRACE("Out.");
(void)decoder;
(void)task; (void)task;
return ret = MPP_OK; return ret = MPP_OK;
} }
@@ -127,13 +185,13 @@ MPP_RET hal_avsd_wait(void *hal, HalTaskInfo *task)
*********************************************************************** ***********************************************************************
*/ */
//extern "C" //extern "C"
MPP_RET hal_avsd_reset(void *hal) MPP_RET hal_avsd_reset(void *decoder)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
AVSD_HAL_TRACE("In."); AVSD_HAL_TRACE("In.");
(void)hal; (void)decoder;
return ret = MPP_OK; return ret = MPP_OK;
} }
/*! /*!
@@ -143,13 +201,13 @@ MPP_RET hal_avsd_reset(void *hal)
*********************************************************************** ***********************************************************************
*/ */
//extern "C" //extern "C"
MPP_RET hal_avsd_flush(void *hal) MPP_RET hal_avsd_flush(void *decoder)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
AVSD_HAL_TRACE("In."); AVSD_HAL_TRACE("In.");
(void)hal; (void)decoder;
return ret = MPP_OK; return ret = MPP_OK;
} }
/*! /*!
@@ -159,13 +217,13 @@ MPP_RET hal_avsd_flush(void *hal)
*********************************************************************** ***********************************************************************
*/ */
//extern "C" //extern "C"
MPP_RET hal_avsd_control(void *hal, RK_S32 cmd_type, void *param) MPP_RET hal_avsd_control(void *decoder, RK_S32 cmd_type, void *param)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
AVSD_HAL_TRACE("In."); AVSD_HAL_TRACE("In.");
(void)hal; (void)decoder;
(void)cmd_type; (void)cmd_type;
(void)param; (void)param;
@@ -177,7 +235,7 @@ const MppHalApi hal_api_avsd = {
"avsd_rkdec", "avsd_rkdec",
MPP_CTX_DEC, MPP_CTX_DEC,
MPP_VIDEO_CodingAVS, MPP_VIDEO_CodingAVS,
200,//sizeof(AvsdHalCtx_t), sizeof(AvsdHalCtx_t),
0, 0,
hal_avsd_init, hal_avsd_init,
hal_avsd_deinit, hal_avsd_deinit,

117
mpp/test/avsd_test.c
View File

@@ -37,19 +37,10 @@
#include "hal_task.h" #include "hal_task.h"
#include "avsd_api.h" #include "avsd_api.h"
#include "avsd_parse.h"
#include "hal_avsd_api.h" #include "hal_avsd_api.h"
#ifdef AVS_TEST
int main(int argc, char **argv)
{
return avsd_test_main(argc, argv);
}
#else
#define AVSD_TEST_ERROR (0x00000001) #define AVSD_TEST_ERROR (0x00000001)
#define AVSD_TEST_ASSERT (0x00000002) #define AVSD_TEST_ASSERT (0x00000002)
#define AVSD_TEST_WARNNING (0x00000004) #define AVSD_TEST_WARNNING (0x00000004)
@@ -65,36 +56,20 @@ if (level & rkv_avsd_test_debug)\
} while (0) } while (0)
#define INP_CHECK(ret, val, ...)\ typedef struct ParserImpl_t {
do{\ ParserCfg cfg;
if ((val)) {\
ret = MPP_ERR_INIT; \
AVSD_TEST_LOG(AVSD_TEST_WARNNING, "input empty(%d).\n", __LINE__); \
goto __RETURN; \
}} while (0)
#define MEM_CHECK(ret, val, ...)\ const ParserApi *api;
do{\ void *ctx;
if (!(val)) {\ } ParserImpl;
ret = MPP_ERR_MALLOC; \
AVSD_TEST_LOG(AVSD_TEST_ERROR, "malloc buffer error(%d).\n", __LINE__); \
goto __FAILED; \
}} while (0)
#define FUN_CHECK(val)\
do{\
if ((val) < 0) {\
AVSD_TEST_LOG(AVSD_TEST_WARNNING, "Function error(%d).\n", __LINE__); \
goto __FAILED; \
}} while (0)
static RK_U32 rkv_avsd_test_debug = 0; static RK_U32 rkv_avsd_test_debug = 0;
typedef struct inp_par_t { typedef struct inp_par_t {
FILE *fp_in; FILE *fp_in;
FILE *fp_out; FILE *fp_out;
FILE *fp_read;
RK_U8 *pbuf; RK_U8 *pbuf;
RK_U32 bufsize; RK_U32 bufsize;
RK_U32 len; RK_U32 len;
@@ -119,20 +94,6 @@ typedef struct avsd_test_ctx_t {
MppBufferGroup mStreamGroup; MppBufferGroup mStreamGroup;
} AvsdTestCtx_t; } AvsdTestCtx_t;
static MPP_RET decoder_deinit(AvsdTestCtx_t *pctx) static MPP_RET decoder_deinit(AvsdTestCtx_t *pctx)
{ {
MppDec *pApi = &pctx->m_api; MppDec *pApi = &pctx->m_api;
@@ -155,18 +116,23 @@ static MPP_RET decoder_deinit(AvsdTestCtx_t *pctx)
} }
if (pctx->m_dec_pkt_buf) { if (pctx->m_dec_pkt_buf) {
mpp_buffer_put(pctx->m_dec_pkt_buf); mpp_buffer_put(pctx->m_dec_pkt_buf);
pctx->m_dec_pkt_buf = NULL;
} }
if (pctx->m_dec_pic_buf) { if (pctx->m_dec_pic_buf) {
mpp_buffer_put(pctx->m_dec_pic_buf); mpp_buffer_put(pctx->m_dec_pic_buf);
pctx->m_dec_pic_buf = NULL;
} }
if (pctx->mFrameGroup != NULL) { if (pctx->mFrameGroup) {
mpp_err("mFrameGroup deInit"); mpp_err("mFrameGroup deInit");
mpp_buffer_group_put(pctx->mFrameGroup); mpp_buffer_group_put(pctx->mFrameGroup);
pctx->mFrameGroup = NULL;
} }
if (pctx->mStreamGroup != NULL) { if (pctx->mStreamGroup) {
mpp_err("mStreamGroup deInit"); mpp_err("mStreamGroup deInit");
mpp_buffer_group_put(pctx->mStreamGroup); mpp_buffer_group_put(pctx->mStreamGroup);
pctx->mStreamGroup = NULL;
} }
return MPP_OK; return MPP_OK;
} }
@@ -181,14 +147,14 @@ static MPP_RET decoder_init(AvsdTestCtx_t *pctx)
if (pctx->mFrameGroup == NULL) { if (pctx->mFrameGroup == NULL) {
ret = mpp_buffer_group_get_internal(&pctx->mFrameGroup, MPP_BUFFER_TYPE_NORMAL); ret = mpp_buffer_group_get_internal(&pctx->mFrameGroup, MPP_BUFFER_TYPE_NORMAL);
if (MPP_OK != ret) { if (MPP_OK != ret) {
mpp_err("h264d mpp_buffer_group_get failed\n"); mpp_err("avsd mpp_buffer_group_get failed\n");
goto __FAILED; goto __FAILED;
} }
} }
if (pctx->mStreamGroup == NULL) { if (pctx->mStreamGroup == NULL) {
ret = mpp_buffer_group_get_internal(&pctx->mStreamGroup, MPP_BUFFER_TYPE_NORMAL); ret = mpp_buffer_group_get_internal(&pctx->mStreamGroup, MPP_BUFFER_TYPE_NORMAL);
if (MPP_OK != ret) { if (MPP_OK != ret) {
mpp_err("h264d mpp_buffer_group_get failed\n"); mpp_err("avsd mpp_buffer_group_get failed\n");
goto __FAILED; goto __FAILED;
} }
} }
@@ -207,15 +173,19 @@ static MPP_RET decoder_init(AvsdTestCtx_t *pctx)
parser_cfg.packet_slots = pApi->packet_slots; parser_cfg.packet_slots = pApi->packet_slots;
parser_cfg.task_count = 2; parser_cfg.task_count = 2;
FUN_CHECK(ret = parser_init(&pApi->parser, &parser_cfg)); FUN_CHECK(ret = parser_init(&pApi->parser, &parser_cfg));
// init hal part // init hal part
memset(&hal_cfg, 0, sizeof(hal_cfg)); memset(&hal_cfg, 0, sizeof(hal_cfg));
hal_cfg.type = MPP_CTX_DEC; hal_cfg.type = MPP_CTX_DEC;
hal_cfg.coding = pApi->coding; hal_cfg.coding = pApi->coding;
hal_cfg.work_mode = HAL_MODE_LIBVPU; hal_cfg.work_mode = HAL_MODE_LIBVPU;
hal_cfg.device_id = HAL_VDPU; hal_cfg.device_id = HAL_RKVDEC;
hal_cfg.frame_slots = pApi->frame_slots; hal_cfg.frame_slots = pApi->frame_slots;
hal_cfg.packet_slots = pApi->packet_slots; hal_cfg.packet_slots = pApi->packet_slots;
hal_cfg.task_count = parser_cfg.task_count; hal_cfg.task_count = parser_cfg.task_count;
hal_cfg.hal_int_cb.opaque = ((ParserImpl *)(pApi->parser))->ctx;
hal_cfg.hal_int_cb.callBack = api_avsd_parser.callback;
//api_avsd_parser.callback(hal_cfg.hal_int_cb.opaque, NULL);
FUN_CHECK(ret = mpp_hal_init(&pApi->hal, &hal_cfg)); FUN_CHECK(ret = mpp_hal_init(&pApi->hal, &hal_cfg));
pApi->tasks = hal_cfg.tasks; pApi->tasks = hal_cfg.tasks;
@@ -260,9 +230,10 @@ static MPP_RET avsd_input_deinit(InputParams *inp)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
MPP_FREE(inp->pbuf);
MPP_FCLOSE(inp->fp_in); MPP_FCLOSE(inp->fp_in);
MPP_FCLOSE(inp->fp_out); MPP_FCLOSE(inp->fp_out);
MPP_FCLOSE(inp->fp_read);
return ret = MPP_OK; return ret = MPP_OK;
} }
@@ -315,8 +286,13 @@ static MPP_RET avsd_input_init(InputParams *inp, RK_S32 ac, char *av[])
goto __FAILED; goto __FAILED;
} }
} }
if ((inp->fp_read = fopen("F:/avs_log/avs_read.txt", "wb")) == 0) {
mpp_log("error, open file %s", "F:/avs_log/avs_read.txt");
goto __FAILED;
}
//!< malloc read buffer //!< malloc read buffer
inp->bufsize = 512; inp->bufsize = 30*1024;
MEM_CHECK(ret, inp->pbuf = mpp_malloc(RK_U8, inp->bufsize)); MEM_CHECK(ret, inp->pbuf = mpp_malloc(RK_U8, inp->bufsize));
AVSD_TEST_LOG(AVSD_TEST_TRACE, "------------------------------------------------------------"); AVSD_TEST_LOG(AVSD_TEST_TRACE, "------------------------------------------------------------");
@@ -340,6 +316,11 @@ static MPP_RET avsd_read_data(InputParams *inp)
inp->len = (RK_U32)fread(inp->pbuf, sizeof(RK_U8), inp->bufsize, inp->fp_in); inp->len = (RK_U32)fread(inp->pbuf, sizeof(RK_U8), inp->bufsize, inp->fp_in);
inp->is_eof = feof(inp->fp_in); inp->is_eof = feof(inp->fp_in);
if (inp->fp_read){
fwrite(inp->pbuf, inp->len, 1, inp->fp_read);
fflush(inp->fp_read);
}
return ret = MPP_OK; return ret = MPP_OK;
} }
@@ -400,10 +381,12 @@ static MPP_RET decoder_single_test(AvsdTestCtx_t *pctx)
//!< deinit packet //!< deinit packet
if (mpp_packet_get_length(pkt) == 0) { if (mpp_packet_get_length(pkt) == 0) {
if (mpp_packet_get_eos(pkt)) { if (mpp_packet_get_eos(pkt)) {
if (task->dec.valid) {
mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT);
mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT);
task->dec.valid = 0;
}
end_of_flag = 1; //!< end of stream end_of_flag = 1; //!< end of stream
task->dec.valid = 0;
mpp_buf_slot_clr_flag(pApi->packet_slots, task->dec.input, SLOT_HAL_INPUT);
mpp_buf_slot_clr_flag(pApi->frame_slots, task->dec.output, SLOT_HAL_OUTPUT);
} }
mpp_packet_deinit(&pkt); mpp_packet_deinit(&pkt);
pkt = NULL; pkt = NULL;
@@ -415,7 +398,7 @@ static MPP_RET decoder_single_test(AvsdTestCtx_t *pctx)
} }
mpp_buf_slot_get_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, &pctx->m_dec_pic_buf); mpp_buf_slot_get_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, &pctx->m_dec_pic_buf);
if (NULL == pctx->m_dec_pic_buf) { if (NULL == pctx->m_dec_pic_buf) {
RK_U32 size = (RK_U32)mpp_buf_slot_get_size(pApi->frame_slots); RK_U32 size = 1920 * 1088 * 3 / 2;// (RK_U32)mpp_buf_slot_get_size(pApi->frame_slots);
mpp_buffer_get(pctx->mFrameGroup, &pctx->m_dec_pic_buf, size); mpp_buffer_get(pctx->mFrameGroup, &pctx->m_dec_pic_buf, size);
if (pctx->m_dec_pic_buf) if (pctx->m_dec_pic_buf)
mpp_buf_slot_set_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, pctx->m_dec_pic_buf); mpp_buf_slot_set_prop(pApi->frame_slots, task->dec.output, SLOT_BUFFER, pctx->m_dec_pic_buf);
@@ -448,9 +431,9 @@ static MPP_RET decoder_single_test(AvsdTestCtx_t *pctx)
} }
} while (!end_of_flag); } while (!end_of_flag);
//!< flush dpb and send to display //!< flush dpb and send to display
FUN_CHECK(ret = mpp_dec_flush(pApi)); FUN_CHECK(ret = mpp_dec_flush(pApi));
avsd_flush_frames(pApi, inp->fp_out);
ret = MPP_OK; ret = MPP_OK;
__FAILED: __FAILED:
@@ -461,19 +444,20 @@ __FAILED:
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
MPP_RET ret = MPP_ERR_UNKNOW; MPP_RET ret = MPP_ERR_UNKNOW;
AvsdTestCtx_t *pctx = NULL; AvsdTestCtx_t m_decoder;
AvsdTestCtx_t *p_dec = &m_decoder;
#if defined(_MSC_VER) #if defined(_MSC_VER)
mpp_env_set_u32("rkv_avsd_test_debug", 0xFF); mpp_env_set_u32("rkv_avsd_test_debug", 0xFF);
#endif #endif
mpp_env_get_u32("rkv_avsd_test_debug", &rkv_avsd_test_debug, 0x0F); mpp_env_get_u32("rkv_avsd_test_debug", &rkv_avsd_test_debug, 0x0F);
MEM_CHECK(ret, pctx = mpp_calloc(AvsdTestCtx_t, 1)); memset(p_dec, 0, sizeof(AvsdTestCtx_t));
// read file // read file
FUN_CHECK(ret = avsd_input_init(&pctx->m_in, argc, argv)); FUN_CHECK(ret = avsd_input_init(&p_dec->m_in, argc, argv));
// init // init
decoder_init(pctx); decoder_init(p_dec);
// decode // decode
ret = decoder_single_test(pctx); ret = decoder_single_test(p_dec);
if (ret != MPP_OK) { if (ret != MPP_OK) {
AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] Single-thread test error."); AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] Single-thread test error.");
goto __FAILED; goto __FAILED;
@@ -481,12 +465,11 @@ int main(int argc, char **argv)
ret = MPP_OK; ret = MPP_OK;
__FAILED: __FAILED:
decoder_deinit(pctx); decoder_deinit(p_dec);
avsd_input_deinit(&pctx->m_in); avsd_input_deinit(&p_dec->m_in);
MPP_FREE(pctx);
AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] decoder_deinit over."); AVSD_TEST_LOG(AVSD_TEST_TRACE, "[AVSD_TEST] decoder_deinit over.");
return ret; return ret;
} }
#endif