/*
|
*
|
* 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_api"
|
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
|
#include "mpp_env.h"
|
#include "mpp_mem.h"
|
#include "mpp_debug.h"
|
#include "mpp_packet_impl.h"
|
|
#include "avsd_syntax.h"
|
#include "avsd_api.h"
|
#include "avsd_parse.h"
|
#include "mpp_dec_cb_param.h"
|
|
RK_U32 avsd_parse_debug = 0;
|
|
|
/*!
|
***********************************************************************
|
* \brief
|
* free all buffer
|
***********************************************************************
|
*/
|
MPP_RET avsd_deinit(void *decoder)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
AvsdCtx_t *p_dec = (AvsdCtx_t *)decoder;
|
|
INP_CHECK(ret, !decoder);
|
AVSD_PARSE_TRACE("In.");
|
|
mpp_packet_deinit(&p_dec->task_pkt);
|
MPP_FREE(p_dec->p_stream->pbuf);
|
MPP_FREE(p_dec->p_header->pbuf);
|
MPP_FREE(p_dec->mem);
|
|
__RETURN:
|
(void)decoder;
|
AVSD_PARSE_TRACE("Out.");
|
return ret = MPP_OK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* alloc all buffer
|
***********************************************************************
|
*/
|
|
MPP_RET avsd_init(void *decoder, ParserCfg *init)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
RK_S32 i = 0;
|
AvsdCtx_t *p_dec = (AvsdCtx_t *)decoder;
|
|
AVSD_PARSE_TRACE("In.");
|
INP_CHECK(ret, !p_dec);
|
|
memset(p_dec, 0, sizeof(AvsdCtx_t));
|
mpp_env_get_u32("avsd_debug", &avsd_parse_debug, 0);
|
//!< restore init parameters
|
p_dec->init = *init;
|
p_dec->frame_slots = init->frame_slots;
|
p_dec->packet_slots = init->packet_slots;
|
//!< decoder parameters
|
mpp_buf_slot_setup(p_dec->frame_slots, 5);
|
p_dec->mem = mpp_calloc(AvsdMemory_t, 1);
|
MEM_CHECK(ret, p_dec->mem);
|
p_dec->p_header = &p_dec->mem->headerbuf;
|
p_dec->p_header->size = MAX_HEADER_SIZE;
|
p_dec->p_header->pbuf = mpp_malloc(RK_U8, p_dec->p_header->size);
|
MEM_CHECK(ret, p_dec->p_header->pbuf);
|
|
p_dec->syn = &p_dec->mem->syntax;
|
p_dec->p_stream = &p_dec->mem->streambuf;
|
p_dec->p_stream->size = MAX_STREAM_SIZE;
|
p_dec->p_stream->pbuf = mpp_malloc(RK_U8, p_dec->p_stream->size);
|
MEM_CHECK(ret, p_dec->p_stream->pbuf);
|
mpp_packet_init(&p_dec->task_pkt, p_dec->p_stream->pbuf, p_dec->p_stream->size);
|
|
mpp_packet_set_length(p_dec->task_pkt, 0);
|
MEM_CHECK(ret, p_dec->task_pkt);
|
for (i = 0; i < 3; i++) {
|
memset(&p_dec->mem->save[i], 0, sizeof(AvsdFrame_t));
|
p_dec->mem->save[i].slot_idx = -1;
|
}
|
__RETURN:
|
AVSD_PARSE_TRACE("Out.");
|
return ret = MPP_OK;
|
__FAILED:
|
avsd_deinit(decoder);
|
|
return ret;
|
}
|
/*!
|
***********************************************************************
|
* \brief
|
* reset
|
***********************************************************************
|
*/
|
MPP_RET avsd_reset(void *decoder)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
AvsdCtx_t *p_dec = (AvsdCtx_t *)decoder;
|
|
AVSD_PARSE_TRACE("In.");
|
|
avsd_reset_parameters(p_dec);
|
p_dec->got_keyframe = 0;
|
p_dec->vec_flag = 0;
|
|
AVSD_PARSE_TRACE("Out.");
|
(void)p_dec;
|
(void)decoder;
|
return ret = MPP_OK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* flush
|
***********************************************************************
|
*/
|
MPP_RET avsd_flush(void *decoder)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
AvsdCtx_t *p_dec = (AvsdCtx_t *)decoder;
|
AVSD_PARSE_TRACE("In.");
|
|
avsd_reset_parameters(p_dec);
|
p_dec->got_keyframe = 0;
|
p_dec->vec_flag = 0;
|
|
AVSD_PARSE_TRACE("Out.");
|
(void)p_dec;
|
(void)decoder;
|
return ret = MPP_OK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* control/perform
|
***********************************************************************
|
*/
|
MPP_RET avsd_control(void *decoder, MpiCmd cmd_type, void *param)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
|
AVSD_PARSE_TRACE("In.");
|
|
|
(void)decoder;
|
(void)cmd_type;
|
(void)param;
|
AVSD_PARSE_TRACE("Out.");
|
return ret = MPP_OK;
|
}
|
|
|
/*!
|
***********************************************************************
|
* \brief
|
* prepare
|
***********************************************************************
|
*/
|
MPP_RET avsd_prepare(void *decoder, MppPacket pkt, HalDecTask *task)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
AvsdCtx_t *p_dec = (AvsdCtx_t *)decoder;
|
|
AVSD_PARSE_TRACE("In.");
|
INP_CHECK(ret, !decoder && !pkt && !task);
|
|
if (p_dec->has_get_eos
|
|| (mpp_packet_get_flag(pkt) & MPP_PACKET_FLAG_EXTRA_DATA)) {
|
mpp_packet_set_length(pkt, 0);
|
goto __RETURN;
|
}
|
AVSD_DBG(AVSD_DBG_INPUT, "[pkt_in_timeUs] in_pts=%lld, pkt_eos=%d, len=%d, pkt_no=%d\n",
|
mpp_packet_get_pts(pkt), (RK_U32)mpp_packet_get_eos(pkt), (RK_U32)mpp_packet_get_length(pkt), (RK_U32)p_dec->pkt_no);
|
p_dec->pkt_no++;
|
|
if (mpp_packet_get_eos(pkt)) {
|
if (mpp_packet_get_length(pkt) < 4) {
|
avsd_flush(decoder);
|
}
|
p_dec->has_get_eos = 1;
|
}
|
if (mpp_packet_get_length(pkt) > MAX_STREAM_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;
|
}
|
|
task->valid = 0;
|
do {
|
(ret = avsd_parse_prepare(p_dec, pkt, task));
|
|
} while (mpp_packet_get_length(pkt) && !task->valid);
|
|
if (task->valid) {
|
//!< bit stream
|
RK_U32 align_len = MPP_ALIGN(p_dec->p_stream->len + 32, 16);
|
|
mpp_assert(p_dec->p_stream->size > align_len);
|
memset(p_dec->p_stream->pbuf + p_dec->p_stream->len,
|
0, align_len - p_dec->p_stream->len);
|
|
p_dec->syn->bitstream_size = align_len;
|
p_dec->syn->bitstream = p_dec->p_stream->pbuf;
|
|
mpp_packet_set_data(p_dec->task_pkt, p_dec->syn->bitstream);
|
mpp_packet_set_length(p_dec->task_pkt, p_dec->syn->bitstream_size);
|
mpp_packet_set_size(p_dec->task_pkt, p_dec->p_stream->size);
|
|
mpp_packet_set_pts(p_dec->task_pkt, mpp_packet_get_pts(pkt));
|
mpp_packet_set_dts(p_dec->task_pkt, mpp_packet_get_dts(pkt));
|
task->input_packet = p_dec->task_pkt;
|
|
p_dec->p_stream->len = 0;
|
p_dec->p_header->len = 0;
|
} else {
|
task->input_packet = NULL;
|
}
|
|
__RETURN:
|
(void)decoder;
|
(void)pkt;
|
(void)task;
|
AVSD_PARSE_TRACE("Out.");
|
return ret = MPP_OK;
|
__FAILED:
|
return ret;
|
}
|
|
|
/*!
|
***********************************************************************
|
* \brief
|
* parser
|
***********************************************************************
|
*/
|
MPP_RET avsd_parse(void *decoder, HalDecTask *task)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
AvsdCtx_t *p_dec = (AvsdCtx_t *)decoder;
|
AVSD_PARSE_TRACE("In.");
|
|
task->valid = 0;
|
memset(task->refer, -1, sizeof(task->refer));
|
|
avsd_parse_stream(p_dec, task);
|
if (task->valid) {
|
avsd_fill_parameters(p_dec, p_dec->syn);
|
avsd_set_dpb(p_dec, task);
|
|
avsd_commit_syntaxs(p_dec->syn, task);
|
avsd_update_dpb(p_dec);
|
}
|
|
AVSD_PARSE_TRACE("Out.");
|
|
return ret = MPP_OK;
|
}
|
/*!
|
***********************************************************************
|
* \brief
|
* callback
|
***********************************************************************
|
*/
|
MPP_RET avsd_callback(void *decoder, void *info)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
AvsdCtx_t *p_dec = (AvsdCtx_t *)decoder;
|
DecCbHalDone *ctx = (DecCbHalDone *)info;
|
|
AVSD_PARSE_TRACE("In.");
|
{
|
MppFrame mframe = NULL;
|
HalDecTask *task_dec = (HalDecTask *)ctx->task;
|
AVSD_DBG(AVSD_DBG_CALLBACK, "reg[1]=%08x, ref=%d, dpberr=%d, harderr-%d\n",
|
ctx->regs[1], task_dec->flags.used_for_ref, task_dec->flags.ref_err, ctx->hard_err);
|
|
mpp_buf_slot_get_prop(p_dec->frame_slots, task_dec->output, SLOT_FRAME_PTR, &mframe);
|
if (mframe) {
|
if (ctx->hard_err || task_dec->flags.ref_err) {
|
if (task_dec->flags.used_for_ref) {
|
mpp_frame_set_errinfo(mframe, MPP_FRAME_FLAG_PAIRED_FIELD);
|
} else {
|
mpp_frame_set_discard(mframe, MPP_FRAME_FLAG_PAIRED_FIELD);
|
}
|
}
|
}
|
}
|
AVSD_PARSE_TRACE("Out.");
|
(void)p_dec;
|
(void)ctx;
|
return ret = MPP_OK;
|
}
|
/*!
|
***********************************************************************
|
* \brief
|
* api struct interface
|
***********************************************************************
|
*/
|
const ParserApi api_avsd_parser = {
|
.name = "avsd_parse",
|
.coding = MPP_VIDEO_CodingAVSPLUS,
|
.ctx_size = sizeof(AvsdCtx_t),
|
.flag = 0,
|
.init = avsd_init,
|
.deinit = avsd_deinit,
|
.prepare = avsd_prepare,
|
.parse = avsd_parse,
|
.reset = avsd_reset,
|
.flush = avsd_flush,
|
.control = avsd_control,
|
.callback = avsd_callback,
|
};
|
