/*
|
*
|
* 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 "mpp_mem.h"
|
#include "mpp_packet_impl.h"
|
#include "hal_dec_task.h"
|
|
#include "avsd_api.h"
|
#include "avsd_parse.h"
|
|
|
static MPP_RET add_nalu_header(AvsdCtx_t *p_dec, RK_U32 header)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
|
AvsdStreamBuf_t *p_buf = p_dec->p_header;
|
RK_U32 add_size = sizeof(AvsdNalu_t);
|
|
if ((p_buf->len + add_size) > p_buf->size) {
|
mpp_err_f("buffer is larger than %d", p_buf->size);
|
goto __FAILED;
|
}
|
p_dec->nal = (AvsdNalu_t *)&p_buf->pbuf[p_buf->len];
|
p_dec->nal->eof = 0;
|
p_dec->nal->header = header;
|
p_dec->nal->pdata = NULL;
|
p_dec->nal->length = 0;
|
p_dec->nal->start_pos = 4;
|
p_buf->len += add_size;
|
|
return ret = MPP_OK;
|
__FAILED:
|
return ret;
|
}
|
|
static MPP_RET store_cur_nalu(AvsdCtx_t *p_dec, RK_U8 *p_start, RK_U32 nalu_len)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
AvsdStreamBuf_t *p_buf = NULL;
|
AvsdNalu_t *p_nalu = p_dec->nal;
|
|
if (p_nalu->header >= SLICE_MIN_START_CODE
|
&& p_nalu->header <= SLICE_MAX_START_CODE) {
|
p_buf = p_dec->p_stream;
|
} else {
|
p_buf = p_dec->p_header;
|
}
|
if ((p_buf->len + nalu_len) > p_buf->size) {
|
mpp_err_f("buffer is larger than %d", p_buf->size);
|
goto __FAILED;
|
}
|
p_nalu->length += nalu_len;
|
p_nalu->pdata = &p_buf->pbuf[p_buf->len];
|
memcpy(p_nalu->pdata, p_start, nalu_len);
|
p_buf->len += nalu_len;
|
|
return ret = MPP_OK;
|
__FAILED:
|
return ret;
|
}
|
|
static MPP_RET get_sequence_header(BitReadCtx_t *bitctx, AvsdSeqHeader_t *vsh)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
RK_U32 val_temp = 0;
|
|
READ_BITS(bitctx, 8, &vsh->profile_id);
|
//!< check profile_id
|
if (vsh->profile_id != 0x20 && vsh->profile_id != 0x48) {
|
ret = MPP_NOK;
|
mpp_err_f("profile_id 0x%02x is not supported.\n", vsh->profile_id);
|
goto __FAILED;
|
}
|
READ_BITS(bitctx, 8, &vsh->level_id);
|
if (vsh->level_id > 0x42) {
|
ret = MPP_NOK;
|
mpp_err_f("level_id 0x%02x is not supported.\n", vsh->level_id);
|
goto __FAILED;
|
}
|
READ_ONEBIT(bitctx, &vsh->progressive_sequence);
|
READ_BITS(bitctx, 14, &vsh->horizontal_size);
|
READ_BITS(bitctx, 14, &vsh->vertical_size);
|
READ_BITS(bitctx, 2, &vsh->chroma_format);
|
READ_BITS(bitctx, 3, &vsh->sample_precision);
|
READ_BITS(bitctx, 4, &vsh->aspect_ratio);
|
READ_BITS(bitctx, 4, &vsh->frame_rate_code);
|
READ_BITS(bitctx, 18, &val_temp); //!< bit_rate_high_18
|
vsh->bit_rate = val_temp << 12;
|
SKIP_BITS(bitctx, 1);
|
READ_BITS(bitctx, 12, &val_temp); //!< bit_rate_low_12
|
vsh->bit_rate += val_temp;
|
READ_ONEBIT(bitctx, &vsh->low_delay);
|
SKIP_BITS(bitctx, 1);
|
READ_BITS(bitctx, 18, &vsh->bbv_buffer_size);
|
READ_BITS(bitctx, 3, &val_temp); //!< reserve 3bits 000
|
if (val_temp) {
|
AVSD_DBG(AVSD_DBG_WARNNING, "reserver bits error.\n");
|
}
|
return ret = MPP_OK;
|
__BITREAD_ERR:
|
return ret = bitctx->ret;
|
__FAILED:
|
return ret;
|
}
|
|
static MPP_RET gen_weight_quant_param(AvsdPicHeader_t *ph)
|
{
|
RK_U32 i = 0;
|
RK_U32 *wqp = (RK_U32 *)ph->weighting_quant_param;
|
|
RK_U32 weighting_quant_param_default[] = { 128, 98, 106, 116, 116, 128 };
|
RK_U32 weighting_quant_param_base1[] = { 135, 143, 143, 160, 160, 213 };
|
RK_U32 weighting_quant_param_base2[] = { 128, 98, 106, 116, 116, 128 };
|
|
if (ph->weighting_quant_flag == 0) {
|
//!< needn't generate this param
|
for (i = 0; i < 6; i++) {
|
wqp[i] = 128;
|
}
|
return MPP_OK;
|
}
|
|
if (ph->weighting_quant_param_index == 0x0) {
|
for (i = 0; i < 6; i++) {
|
wqp[i] = weighting_quant_param_default[i];
|
}
|
} else if (ph->weighting_quant_param_index == 0x1) {
|
for (i = 0; i < 6; i++) {
|
wqp[i] = weighting_quant_param_base1[i] +
|
ph->weighting_quant_param_delta1[i];
|
}
|
} else if (ph->weighting_quant_param_index == 0x2) {
|
for (i = 0; i < 6; i++) {
|
wqp[i] = weighting_quant_param_base2[i] +
|
ph->weighting_quant_param_delta2[i];
|
}
|
} else {
|
//!< shouldn't happen
|
AVSD_DBG(AVSD_DBG_WARNNING, "Something went wrong.\n");
|
for (i = 0; i < 6; i++) {
|
wqp[i] = 128;
|
}
|
}
|
|
return MPP_OK;
|
}
|
|
static MPP_RET get_extend_header(BitReadCtx_t *bitctx, AvsdSeqHeader_t *vsh, AvsdPicHeader_t *ph)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
RK_U32 i = 0;
|
|
READ_ONEBIT(bitctx, &ph->loop_filter_disable);
|
if (!ph->loop_filter_disable) {
|
READ_ONEBIT(bitctx, &ph->loop_filter_parameter_flag);
|
if (ph->loop_filter_parameter_flag) {
|
READ_SE(bitctx, &ph->alpha_c_offset);
|
READ_SE(bitctx, &ph->beta_offset);
|
}
|
}
|
ph->chroma_quant_param_delta_cb = 0;
|
ph->chroma_quant_param_delta_cr = 0;
|
for (i = 0; i < 6; i++) {
|
ph->weighting_quant_param_delta1[i] = 0;
|
ph->weighting_quant_param_delta2[i] = 0;
|
}
|
if (vsh->profile_id == 0x48) {
|
READ_ONEBIT(bitctx, &ph->weighting_quant_flag);
|
if (ph->weighting_quant_flag) {
|
SKIP_BITS(bitctx, 1);
|
READ_ONEBIT(bitctx, &ph->chroma_quant_param_disable);
|
if (!ph->chroma_quant_param_disable) {
|
READ_SE(bitctx, &ph->chroma_quant_param_delta_cb);
|
READ_SE(bitctx, &ph->chroma_quant_param_delta_cr);
|
}
|
READ_BITS(bitctx, 2, &ph->weighting_quant_param_index);
|
READ_BITS(bitctx, 2, &ph->weighting_quant_model);
|
if (ph->weighting_quant_param_index == 1) {
|
for (i = 0; i < 6; i++) {
|
READ_SE(bitctx, &ph->weighting_quant_param_delta1[i]);
|
}
|
} else if (ph->weighting_quant_param_index == 2) {
|
for (i = 0; i < 6; i++) {
|
READ_SE(bitctx, &ph->weighting_quant_param_delta2[i]);
|
}
|
}
|
}
|
gen_weight_quant_param(ph); //!< generate wqP[m][6]
|
|
READ_ONEBIT(bitctx, &ph->aec_enable);
|
}
|
|
return ret = MPP_OK;
|
__BITREAD_ERR:
|
return ret = bitctx->ret;
|
}
|
|
static MPP_RET get_seq_dispay_ext_header(BitReadCtx_t *bitctx, AvsdSeqExtHeader_t *ext)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
RK_U32 val_temp = 0;
|
|
READ_BITS(bitctx, 3, &ext->video_format);
|
READ_ONEBIT(bitctx, &ext->sample_range);
|
READ_ONEBIT(bitctx, &ext->color_description);
|
|
if (ext->color_description) {
|
READ_BITS(bitctx, 8, &ext->color_primaries);
|
READ_BITS(bitctx, 8, &ext->transfer_characteristics);
|
READ_BITS(bitctx, 8, &ext->matrix_coefficients);
|
}
|
READ_BITS(bitctx, 14, &ext->display_horizontalSize);
|
SKIP_BITS(bitctx, 1); //!< marker bit
|
READ_BITS(bitctx, 14, &ext->display_verticalSize);
|
|
READ_BITS(bitctx, 2, &val_temp); //!< reserve 2 bits
|
if (val_temp) {
|
AVSD_DBG(AVSD_DBG_WARNNING, "reserve bits not equal to zeros.\n");
|
}
|
return ret = MPP_OK;
|
__BITREAD_ERR:
|
return ret = bitctx->ret;
|
}
|
static MPP_RET get_extension_header(BitReadCtx_t *bitctx, AvsdSeqExtHeader_t *ext)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
RK_U32 val_temp = 0;
|
|
READ_BITS(bitctx, 4, &val_temp); //!< extension_start_code
|
switch (val_temp) {
|
case SEQUENCE_DISPLAY_EXTENTION:
|
FUN_CHECK(ret = get_seq_dispay_ext_header(bitctx, ext));
|
break;
|
|
default:
|
break;
|
}
|
|
return ret = MPP_OK;
|
__BITREAD_ERR:
|
return ret = bitctx->ret;
|
__FAILED:
|
return ret;
|
}
|
|
static MPP_RET get_i_picture_header(BitReadCtx_t *bitctx, AvsdSeqHeader_t *vsh, AvsdPicHeader_t *ph)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
RK_U32 val_temp = 0;
|
ph->picture_coding_type = I_PICTURE;
|
|
READ_BITS(bitctx, 16, &ph->bbv_delay);
|
if (vsh->profile_id == 0x48) {
|
SKIP_BITS(bitctx, 1);
|
READ_BITS(bitctx, 7, &ph->bbv_delay_extension);
|
}
|
READ_ONEBIT(bitctx, &ph->time_code_flag);
|
if (ph->time_code_flag) {
|
READ_BITS(bitctx, 24, &ph->time_code);
|
}
|
SKIP_BITS(bitctx, 1);
|
READ_BITS(bitctx, 8, &ph->picture_distance);
|
if (vsh->low_delay) {
|
READ_UE(bitctx, &ph->bbv_check_times);
|
}
|
READ_ONEBIT(bitctx, &ph->progressive_frame);
|
if (!ph->progressive_frame) {
|
READ_ONEBIT(bitctx, &ph->picture_structure);
|
} else {
|
ph->picture_structure = 1; //!< frame picture
|
}
|
READ_ONEBIT(bitctx, &ph->top_field_first);
|
READ_ONEBIT(bitctx, &ph->repeat_first_field);
|
READ_ONEBIT(bitctx, &ph->fixed_picture_qp);
|
READ_BITS(bitctx, 6, &ph->picture_qp);
|
if (!ph->progressive_frame && !ph->picture_structure) {
|
READ_ONEBIT(bitctx, &ph->skip_mode_flag);
|
} else {
|
ph->skip_mode_flag = 0;
|
}
|
READ_BITS(bitctx, 4, &val_temp); //!< reserve 4 bits
|
if (val_temp) {
|
AVSD_DBG(AVSD_DBG_WARNNING, "reserve bits not equal to zeros.\n");
|
}
|
ph->no_forward_reference_flag = 0;
|
ph->pb_field_enhanced_flag = 0;
|
ph->weighting_quant_flag = 0;
|
ph->aec_enable = 0;
|
|
FUN_CHECK(ret = get_extend_header(bitctx, vsh, ph));
|
|
return ret = MPP_OK;
|
__BITREAD_ERR:
|
return ret = bitctx->ret;
|
__FAILED:
|
return ret;
|
}
|
|
static MPP_RET get_pb_picture_header(BitReadCtx_t *bitctx, AvsdSeqHeader_t *vsh, AvsdPicHeader_t *ph)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
RK_U32 val_temp = 0;
|
|
READ_BITS(bitctx, 16, &ph->bbv_delay);
|
if (vsh->profile_id == 0x48) {
|
SKIP_BITS(bitctx, 1);
|
READ_BITS(bitctx, 7, &ph->bbv_delay_extension);
|
}
|
READ_BITS(bitctx, 2, &ph->picture_coding_type);
|
READ_BITS(bitctx, 8, &ph->picture_distance);
|
if (vsh->low_delay) {
|
READ_UE(bitctx, &ph->bbv_check_times);
|
}
|
READ_ONEBIT(bitctx, &ph->progressive_frame);
|
|
if (!ph->progressive_frame) {
|
READ_ONEBIT(bitctx, &ph->picture_structure);
|
if (!ph->picture_structure) {
|
READ_ONEBIT(bitctx, &ph->advanced_pred_mode_disable);
|
}
|
} else {
|
ph->picture_structure = 1; //!< frame picture
|
}
|
READ_ONEBIT(bitctx, &ph->top_field_first);
|
READ_ONEBIT(bitctx, &ph->repeat_first_field);
|
READ_ONEBIT(bitctx, &ph->fixed_picture_qp);
|
READ_BITS(bitctx, 6, &ph->picture_qp);
|
if (!(ph->picture_coding_type == B_PICTURE && ph->picture_structure == P_PICTURE)) {
|
READ_ONEBIT(bitctx, &ph->picture_reference_flag);
|
}
|
READ_ONEBIT(bitctx, &ph->no_forward_reference_flag);
|
READ_ONEBIT(bitctx, &ph->pb_field_enhanced_flag);
|
if (vsh->profile_id != 0x48) {
|
ph->no_forward_reference_flag = 0;
|
ph->pb_field_enhanced_flag = 0;
|
}
|
ph->weighting_quant_flag = 0;
|
ph->aec_enable = 0;
|
|
READ_BITS(bitctx, 2, &val_temp); //!< reserve bits
|
if (val_temp) {
|
AVSD_DBG(AVSD_DBG_WARNNING, "reserve bits not equal to zeros.\n");
|
}
|
READ_ONEBIT(bitctx, &ph->skip_mode_flag);
|
|
FUN_CHECK(ret = get_extend_header(bitctx, vsh, ph));
|
|
return ret = MPP_OK;
|
__BITREAD_ERR:
|
return ret = bitctx->ret;
|
__FAILED:
|
return ret;
|
}
|
|
static void reset_one_save(AvsdFrame_t *p)
|
{
|
if (p) {
|
memset(p, 0, sizeof(AvsdFrame_t));
|
p->slot_idx = -1;
|
}
|
}
|
|
static AvsdFrame_t *get_one_save(AvsdCtx_t *p_dec, HalDecTask *task)
|
{
|
RK_U32 i = 0;
|
AvsdFrame_t *p_cur = NULL;
|
|
for (i = 0; i < MPP_ARRAY_ELEMS(p_dec->mem->save); i++) {
|
if (!p_dec->mem->save[i].valid) {
|
p_dec->mem->save[i].valid = 1;
|
p_cur = &p_dec->mem->save[i];
|
break;
|
}
|
}
|
if (!p_cur) {
|
AVSD_DBG(AVSD_DBG_WARNNING, "error, mem_save dpb has not get.\n");
|
goto __FAILED;
|
}
|
(void)task;
|
return p_cur;
|
__FAILED:
|
reset_one_save(p_cur);
|
|
return NULL;
|
}
|
|
static MPP_RET set_frame_unref(AvsdCtx_t *pdec, AvsdFrame_t *p)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
|
if (p && p->slot_idx >= 0) {
|
mpp_buf_slot_clr_flag(pdec->frame_slots, p->slot_idx, SLOT_CODEC_USE);
|
memset(p, 0, sizeof(AvsdFrame_t));
|
p->slot_idx = -1;
|
}
|
|
return ret = MPP_OK;
|
}
|
|
|
static MPP_RET set_frame_output(AvsdCtx_t *p_dec, AvsdFrame_t *p)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
|
if (p && p->slot_idx >= 0 && !p->had_display) {
|
mpp_buf_slot_set_flag(p_dec->frame_slots, p->slot_idx, SLOT_QUEUE_USE);
|
mpp_buf_slot_enqueue(p_dec->frame_slots, p->slot_idx, QUEUE_DISPLAY);
|
p->had_display = 1;
|
}
|
|
return ret = MPP_OK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* reset decoder parameters
|
***********************************************************************
|
*/
|
MPP_RET avsd_reset_parameters(AvsdCtx_t *p_dec)
|
{
|
RK_U32 i = 0;
|
|
set_frame_output(p_dec, p_dec->dpb[1]);
|
set_frame_output(p_dec, p_dec->dpb[0]);
|
set_frame_output(p_dec, p_dec->cur);
|
set_frame_unref(p_dec, p_dec->dpb[1]);
|
set_frame_unref(p_dec, p_dec->dpb[0]);
|
set_frame_unref(p_dec, p_dec->cur);
|
|
p_dec->cur = NULL;
|
p_dec->dpb[0] = NULL;
|
p_dec->dpb[1] = NULL;
|
p_dec->has_get_eos = 0;
|
|
for (i = 0; i < MPP_ARRAY_ELEMS(p_dec->mem->save); i++) {
|
memset(&p_dec->mem->save[i], 0, sizeof(AvsdFrame_t));
|
p_dec->mem->save[i].slot_idx = -1;
|
}
|
|
return MPP_OK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* set refer
|
***********************************************************************
|
*/
|
MPP_RET avsd_set_dpb(AvsdCtx_t *p_dec, HalDecTask *task)
|
{
|
MppFrame mframe = NULL;
|
RK_S32 slot_idx = -1;
|
AvsdFrame_t *p_cur = p_dec->cur;
|
|
//!< set current dpb for decode
|
mpp_buf_slot_get_unused(p_dec->frame_slots, &slot_idx);
|
if (slot_idx < 0) {
|
AVSD_DBG(AVSD_DBG_WARNNING, "error, buf_slot has not get.\n");
|
goto __FAILED;
|
}
|
//!< init current frame data
|
p_cur->slot_idx = slot_idx;
|
p_cur->pic_type = p_dec->ph.picture_coding_type;
|
p_cur->width = p_dec->vsh.horizontal_size;
|
p_cur->height = p_dec->vsh.vertical_size;
|
p_cur->hor_stride = MPP_ALIGN(p_dec->vsh.horizontal_size, 16);
|
p_cur->ver_stride = MPP_ALIGN(p_dec->vsh.vertical_size, 16);
|
p_cur->pts = mpp_packet_get_pts(task->input_packet);
|
p_cur->dts = mpp_packet_get_dts(task->input_packet);
|
//!< set frame info
|
mpp_frame_init(&mframe);
|
mpp_frame_set_fmt(mframe, MPP_FMT_YUV420SP);
|
mpp_frame_set_hor_stride(mframe, p_cur->hor_stride); // before crop
|
mpp_frame_set_ver_stride(mframe, p_cur->ver_stride);
|
mpp_frame_set_width(mframe, p_cur->width); // after crop
|
mpp_frame_set_height(mframe, p_cur->height);
|
mpp_frame_set_pts(mframe, p_cur->pts);
|
mpp_frame_set_dts(mframe, p_cur->dts);
|
if (p_dec->ph.picture_structure) { //!< data combine 2 field
|
p_cur->frame_mode = MPP_FRAME_FLAG_PAIRED_FIELD;
|
if (p_dec->ph.top_field_first) {
|
p_cur->frame_mode |= MPP_FRAME_FLAG_TOP_FIRST;
|
} else {
|
p_cur->frame_mode |= MPP_FRAME_FLAG_BOT_FIRST;
|
}
|
} else { //!< frame picture
|
p_cur->frame_mode = MPP_FRAME_FLAG_FRAME;
|
}
|
mpp_frame_set_mode(mframe, p_cur->frame_mode);
|
mpp_buf_slot_set_prop(p_dec->frame_slots, slot_idx, SLOT_FRAME, mframe);
|
mpp_frame_deinit(&mframe);
|
|
mpp_buf_slot_set_flag(p_dec->frame_slots, p_cur->slot_idx, SLOT_CODEC_USE);
|
mpp_buf_slot_set_flag(p_dec->frame_slots, p_cur->slot_idx, SLOT_HAL_OUTPUT);
|
|
//!< set task
|
task->output = p_dec->cur->slot_idx;
|
//!< set task refers
|
if (p_dec->dpb[0] && p_dec->dpb[0]->slot_idx >= 0 &&
|
(p_dec->dpb[0]->slot_idx != p_dec->cur->slot_idx)) {
|
mpp_buf_slot_set_flag(p_dec->frame_slots, p_dec->dpb[0]->slot_idx, SLOT_HAL_INPUT);
|
if (p_dec->ph.picture_coding_type == B_PICTURE) {
|
task->refer[1] = p_dec->dpb[0]->slot_idx;
|
} else {
|
task->refer[0] = p_dec->dpb[0]->slot_idx;
|
}
|
}
|
if (p_dec->dpb[1] && p_dec->dpb[1]->slot_idx >= 0 &&
|
(p_dec->dpb[1]->slot_idx != p_dec->cur->slot_idx)) {
|
mpp_buf_slot_set_flag(p_dec->frame_slots, p_dec->dpb[1]->slot_idx, SLOT_HAL_INPUT);
|
if (p_dec->ph.picture_coding_type == B_PICTURE) {
|
task->refer[0] = p_dec->dpb[1]->slot_idx;
|
} else {
|
task->refer[1] = p_dec->dpb[1]->slot_idx;
|
}
|
}
|
|
//!< set ref flag and mark error
|
if (p_dec->ph.picture_coding_type == I_PICTURE) {
|
task->flags.used_for_ref = 1;
|
task->flags.ref_err = 0;
|
} else if (p_dec->ph.picture_coding_type == P_PICTURE) {
|
task->flags.used_for_ref = 1;
|
if (task->refer[0] >= 0) {
|
mpp_buf_slot_get_prop(p_dec->frame_slots, task->refer[0], SLOT_FRAME_PTR, &mframe);
|
if (mframe)
|
task->flags.ref_err |= mpp_frame_get_errinfo(mframe);
|
}
|
} else if (p_dec->ph.picture_coding_type == B_PICTURE) {
|
task->flags.used_for_ref = 0;
|
if (task->refer[0] >= 0) {
|
mpp_buf_slot_get_prop(p_dec->frame_slots, task->refer[0], SLOT_FRAME_PTR, &mframe);
|
if (mframe)
|
task->flags.ref_err |= mpp_frame_get_errinfo(mframe);
|
}
|
if (task->refer[1] >= 0) {
|
mpp_buf_slot_get_prop(p_dec->frame_slots, task->refer[1], SLOT_FRAME_PTR, &mframe);
|
if (mframe)
|
task->flags.ref_err |= mpp_frame_get_errinfo(mframe);
|
}
|
}
|
|
return MPP_OK;
|
__FAILED:
|
return MPP_NOK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* commit buffer to hal
|
***********************************************************************
|
*/
|
MPP_RET avsd_commit_syntaxs(AvsdSyntax_t *syn, HalDecTask *task)
|
{
|
task->syntax.number = 1;
|
task->syntax.data = syn;
|
|
return MPP_OK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* commit buffer to hal
|
***********************************************************************
|
*/
|
MPP_RET avsd_update_dpb(AvsdCtx_t *p_dec)
|
{
|
if (p_dec->ph.picture_coding_type != B_PICTURE) {
|
set_frame_output(p_dec, p_dec->dpb[0]);
|
set_frame_unref(p_dec, p_dec->dpb[1]);
|
p_dec->dpb[1] = p_dec->dpb[0];
|
p_dec->dpb[0] = p_dec->cur;
|
p_dec->cur = NULL;
|
} else {
|
set_frame_output(p_dec, p_dec->cur);
|
set_frame_unref(p_dec, p_dec->cur);
|
p_dec->cur = NULL;
|
}
|
|
return MPP_OK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* fill parameters
|
***********************************************************************
|
*/
|
MPP_RET avsd_fill_parameters(AvsdCtx_t *p_dec, AvsdSyntax_t *syn)
|
{
|
RK_S32 i = 0;
|
PicParams_Avsd *pp = &syn->pp;
|
|
//!< sequence header
|
pp->profileId = p_dec->vsh.profile_id;
|
pp->levelId = p_dec->vsh.level_id;
|
pp->progressiveSequence = p_dec->vsh.progressive_sequence;
|
pp->horizontalSize = p_dec->vsh.horizontal_size;
|
pp->verticalSize = p_dec->vsh.vertical_size;
|
pp->chromaFormat = p_dec->vsh.chroma_format;
|
pp->aspectRatio = p_dec->vsh.aspect_ratio;
|
pp->frameRateCode = p_dec->vsh.frame_rate_code;
|
pp->bitRateValue = p_dec->vsh.bit_rate;
|
pp->lowDelay = p_dec->vsh.low_delay;
|
pp->bbvBufferSize = p_dec->vsh.bbv_buffer_size;
|
|
//!< sequence display extension header
|
pp->videoFormat = p_dec->ext.video_format;
|
pp->sampleRange = p_dec->ext.sample_range;
|
pp->colorDescription = p_dec->ext.color_description;
|
pp->colorPrimaries = p_dec->ext.color_primaries;
|
pp->transferCharacteristics = p_dec->ext.transfer_characteristics;
|
pp->matrixCoefficients = p_dec->ext.matrix_coefficients;
|
pp->displayHorizontalSize = p_dec->ext.display_horizontalSize;
|
pp->displayVerticalSize = p_dec->ext.display_verticalSize;
|
|
//!< picture header
|
pp->picCodingType = p_dec->ph.picture_coding_type;
|
pp->bbvDelay = p_dec->ph.bbv_delay;
|
pp->bbvDelayExtension = p_dec->ph.bbv_delay_extension;
|
pp->timeCodeFlag = p_dec->ph.time_code_flag;
|
pp->timeCode = p_dec->ph.time_code;
|
|
pp->pictureDistance = p_dec->ph.picture_distance;
|
pp->progressiveFrame = p_dec->ph.progressive_frame;
|
pp->pictureStructure = p_dec->ph.picture_structure;
|
pp->advancedPredModeDisable = p_dec->ph.advanced_pred_mode_disable;
|
pp->topFieldFirst = p_dec->ph.top_field_first;
|
pp->repeatFirstField = p_dec->ph.repeat_first_field;
|
pp->fixedPictureQp = p_dec->ph.fixed_picture_qp;
|
pp->pictureQp = p_dec->ph.picture_qp;
|
pp->pictureReferenceFlag = p_dec->ph.picture_reference_flag;
|
pp->skipModeFlag = p_dec->ph.skip_mode_flag;
|
pp->loopFilterDisable = p_dec->ph.loop_filter_disable;
|
pp->alphaOffset = p_dec->ph.alpha_c_offset;
|
pp->betaOffset = p_dec->ph.beta_offset;
|
|
//!< weighting quant, AVS Plus stuff
|
pp->weightingQuantFlag = p_dec->ph.weighting_quant_flag;
|
pp->chromaQuantParamDisable = p_dec->ph.chroma_quant_param_disable;
|
pp->chromaQuantParamDeltaCb = p_dec->ph.chroma_quant_param_delta_cb;
|
pp->chromaQuantParamDeltaCr = p_dec->ph.chroma_quant_param_delta_cr;
|
pp->weightingQuantParamIndex = p_dec->ph.weighting_quant_param_index;
|
pp->weightingQuantModel = p_dec->ph.weighting_quant_model;
|
for (i = 0; i < 6; i++) {
|
pp->weightingQuantParamDelta1[i] = p_dec->ph.weighting_quant_param_delta1[i];
|
pp->weightingQuantParamDelta2[i] = p_dec->ph.weighting_quant_param_delta2[i];
|
pp->weightingQuantParam[i] = p_dec->ph.weighting_quant_param[i];
|
}
|
//!< advance entropy coding
|
pp->aecEnable = p_dec->ph.aec_enable;
|
|
//!< picture enhance
|
pp->noForwardReferenceFlag = p_dec->ph.no_forward_reference_flag;
|
pp->pbFieldEnhancedFlag = p_dec->ph.pb_field_enhanced_flag;
|
|
return MPP_OK;
|
}
|
/*!
|
***********************************************************************
|
* \brief
|
* prepare function for parser
|
***********************************************************************
|
*/
|
MPP_RET avsd_parse_prepare(AvsdCtx_t *p_dec, MppPacket *pkt, HalDecTask *task)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
RK_U8 *p_curdata = NULL;
|
RK_U8 *p_start = NULL; //!< store nalu start
|
RK_U32 nalu_len = 0;
|
RK_U8 got_frame_flag = 0;
|
RK_U8 got_nalu_flag = 0;
|
RK_U32 pkt_length = 0;
|
|
RK_U32 prefix = 0xFFFFFFFF;
|
|
AVSD_PARSE_TRACE("In.");
|
//!< check input
|
if (mpp_packet_get_length(pkt) < 4) {
|
AVSD_DBG(AVSD_DBG_WARNNING, "input have no stream.");
|
mpp_packet_set_length(pkt, 0);
|
goto __RETURN;
|
}
|
|
pkt_length = (RK_U32)mpp_packet_get_length(pkt);
|
p_curdata = p_start = (RK_U8 *)mpp_packet_get_pos(pkt);
|
|
while (pkt_length > 0) {
|
//!< found next nalu start code
|
if ((prefix & 0xFFFFFF00) == 0x00000100) {
|
if (got_nalu_flag) {
|
nalu_len = (RK_U32)(p_curdata - p_start) - 4;
|
FUN_CHECK(ret = store_cur_nalu(p_dec, p_start, nalu_len));
|
}
|
FUN_CHECK(ret = add_nalu_header(p_dec, prefix));
|
p_start = p_curdata - 4;
|
got_nalu_flag = 1;
|
}
|
//!< found next picture start code
|
if (prefix == I_PICUTRE_START_CODE || prefix == PB_PICUTRE_START_CODE) {
|
task->valid = 1;
|
if (got_frame_flag) {
|
p_dec->nal->eof = 1;
|
pkt_length += 4;
|
break;
|
}
|
got_frame_flag = 1;
|
}
|
|
prefix = (prefix << 8) | (*p_curdata);
|
p_curdata++;
|
pkt_length--;
|
}
|
//!< reach the packet end
|
if (!pkt_length) {
|
nalu_len = (RK_U32)(p_curdata - p_start);
|
FUN_CHECK(ret = store_cur_nalu(p_dec, p_start, nalu_len));
|
if (task->valid) {
|
FUN_CHECK(ret = add_nalu_header(p_dec, 0));
|
p_dec->nal->eof = 1;
|
}
|
}
|
//!< reset position
|
pkt_length = (RK_U32)mpp_packet_get_length(pkt) - pkt_length;
|
mpp_packet_set_pos(pkt, (RK_U8 *)mpp_packet_get_pos(pkt) + pkt_length);
|
|
__RETURN:
|
AVSD_PARSE_TRACE("Out.");
|
|
return ret = MPP_OK;
|
__FAILED:
|
return ret;
|
}
|
/*!
|
***********************************************************************
|
* \brief
|
* parse stream which ha function for parser
|
***********************************************************************
|
*/
|
MPP_RET avsd_parse_stream(AvsdCtx_t *p_dec, HalDecTask *task)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
|
RK_U8 pic_type = 0;
|
AvsdNalu_t *p_nalu = (AvsdNalu_t *)p_dec->p_header->pbuf;
|
|
task->valid = 0;
|
while (!p_nalu->eof) {
|
RK_U32 startcode = p_nalu->header;
|
|
if (startcode >= SLICE_MIN_START_CODE && startcode <= SLICE_MAX_START_CODE) {
|
p_nalu++;
|
} else {
|
memset(&p_dec->bitctx, 0, sizeof(BitReadCtx_t));
|
mpp_set_bitread_ctx(&p_dec->bitctx, p_nalu->pdata + p_nalu->start_pos, p_nalu->length);
|
p_nalu = (AvsdNalu_t *)(p_nalu->pdata + p_nalu->length);
|
}
|
|
if (startcode != VIDEO_SEQUENCE_START_CODE && !p_dec->got_vsh) {
|
// when has not got sequence header, then do nothing
|
continue;
|
}
|
switch (startcode) {
|
case VIDEO_SEQUENCE_START_CODE:
|
ret = get_sequence_header(&p_dec->bitctx, &p_dec->vsh);
|
if (ret == MPP_OK) {
|
p_dec->got_vsh = 1;
|
}
|
break;
|
case VIDEO_SEQUENCE_END_CODE:
|
break;
|
case USER_DATA_CODE:
|
break;
|
case VIDEO_EDIT_CODE:
|
p_dec->vec_flag = 0;
|
break;
|
case I_PICUTRE_START_CODE:
|
if (!p_dec->got_keyframe) {
|
avsd_reset_parameters(p_dec);
|
p_dec->got_keyframe = 1;
|
}
|
ret = get_i_picture_header(&p_dec->bitctx, &p_dec->vsh, &p_dec->ph);
|
if (ret == MPP_OK) {
|
p_dec->cur = get_one_save(p_dec, task);
|
}
|
p_dec->cur->pic_type = pic_type = I_PICTURE;
|
p_dec->vec_flag++;
|
break;
|
case EXTENSION_START_CODE:
|
ret = get_extension_header(&p_dec->bitctx, &p_dec->ext);
|
break;
|
case PB_PICUTRE_START_CODE:
|
if (!p_dec->got_keyframe) {
|
avsd_reset_parameters(p_dec);
|
break;
|
}
|
ret = get_pb_picture_header(&p_dec->bitctx, &p_dec->vsh, &p_dec->ph);
|
if (ret == MPP_OK) {
|
p_dec->cur = get_one_save(p_dec, task);
|
}
|
p_dec->cur->pic_type = pic_type = p_dec->ph.picture_coding_type;
|
p_dec->vec_flag += (p_dec->vec_flag == 1 && pic_type == P_PICTURE);
|
break;
|
default:
|
if (!p_dec->cur
|
|| (pic_type == P_PICTURE && !p_dec->dpb[0])
|
|| (pic_type == B_PICTURE && !p_dec->dpb[0])
|
|| (pic_type == B_PICTURE && !p_dec->dpb[1] && !p_dec->vsh.low_delay)
|
|| (pic_type == P_PICTURE && p_dec->vec_flag < 1)
|
|| (pic_type == B_PICTURE && p_dec->vec_flag < 2)) {
|
mpp_err_f("missing refer frame.\n");
|
ret = MPP_NOK;
|
goto __FAILED;
|
}
|
if (startcode >= SLICE_MIN_START_CODE
|
&& startcode <= SLICE_MAX_START_CODE) {
|
task->valid = 1;
|
}
|
|
break;
|
}
|
}
|
|
return ret = MPP_OK;
|
__FAILED:
|
reset_one_save(p_dec->cur);
|
|
return ret;
|
}
|
