/*
|
* 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 "m2vd_parser"
|
|
#include <string.h>
|
|
#include "mpp_env.h"
|
#include "mpp_debug.h"
|
#include "mpp_packet_impl.h"
|
|
#include "m2vd_parser.h"
|
#include "m2vd_codec.h"
|
|
#define VPU_BITSTREAM_START_CODE (0x42564b52) /* RKVB, rockchip video bitstream */
|
|
RK_U32 m2vd_debug = 0x0;
|
|
static RK_U8 scanOrder[2][64] = {
|
{ /* zig-zag */
|
0, 1, 8, 16, 9, 2, 3, 10,
|
17, 24, 32, 25, 18, 11, 4, 5,
|
12, 19, 26, 33, 40, 48, 41, 34,
|
27, 20, 13, 6, 7, 14, 21, 28,
|
35, 42, 49, 56, 57, 50, 43, 36,
|
29, 22, 15, 23, 30, 37, 44, 51,
|
58, 59, 52, 45, 38, 31, 39, 46,
|
53, 60, 61, 54, 47, 55, 62, 63
|
},
|
|
{ /* Alternate */
|
0, 8, 16, 24, 1, 9, 2, 10,
|
17, 25, 32, 40, 48, 56, 57, 49,
|
41, 33, 26, 18, 3, 11, 4, 12,
|
19, 27, 34, 42, 50, 58, 35, 43,
|
51, 59, 20, 28, 5, 13, 6, 14,
|
21, 29, 36, 44, 52, 60, 37, 45,
|
53, 61, 22, 30, 7, 15, 23, 31,
|
38, 46, 54, 62, 39, 47, 55, 63
|
}
|
};
|
|
static RK_U8 intraDefaultQMatrix[64] = {
|
8, 16, 19, 22, 26, 27, 29, 34,
|
16, 16, 22, 24, 27, 29, 34, 37,
|
19, 22, 26, 27, 29, 34, 34, 38,
|
22, 22, 26, 27, 29, 34, 37, 40,
|
22, 26, 27, 29, 32, 35, 40, 48,
|
26, 27, 29, 32, 35, 40, 48, 58,
|
26, 27, 29, 34, 38, 46, 56, 69,
|
27, 29, 35, 38, 46, 56, 69, 83
|
};
|
|
static int frame_period_Table[16] = {
|
1,
|
11142,
|
10667,
|
10240,
|
8542,
|
8533,
|
5120,
|
4271,
|
4267,
|
1,
|
1,
|
1,
|
1,
|
1,
|
1,
|
1
|
};
|
|
static const MppFrameRational mpeg2_aspect[16] = {
|
{0, 1},
|
{1, 1},
|
{4, 3},
|
{16, 9},
|
{221, 100},
|
{0, 1},
|
{0, 1},
|
{0, 1},
|
{0, 1},
|
{0, 1},
|
{0, 1},
|
{0, 1},
|
{0, 1},
|
{0, 1},
|
{0, 1},
|
{0, 1},
|
};
|
|
static inline RK_S32 m2vd_get_readbits(BitReadCtx_t *bx)
|
{
|
return bx->used_bits;
|
}
|
|
static inline RK_S32 m2vd_get_leftbits(BitReadCtx_t *bx)
|
{
|
return (bx->bytes_left_ * 8 + bx->num_remaining_bits_in_curr_byte_);
|
}
|
|
static RK_S32 m2vd_read_bits(BitReadCtx_t *bx, RK_U32 bits)
|
{
|
RK_S32 ret = 0;
|
if (bits < 32)
|
mpp_read_bits(bx, bits, &ret);
|
else
|
mpp_read_longbits(bx, bits, (RK_U32 *)&ret);
|
return ret;
|
}
|
|
static RK_S32 m2vd_show_bits(BitReadCtx_t *bx, RK_U32 bits)
|
{
|
RK_S32 ret = 0;
|
mpp_show_bits(bx, bits, &ret);
|
return ret;
|
}
|
|
static MPP_RET m2vd_parser_init_ctx(M2VDParserContext *ctx, ParserCfg *cfg)
|
{
|
MPP_RET ret = MPP_OK;
|
RK_S32 i = 0;
|
m2vd_dbg_func("FUN_I");
|
|
M2VD_CHK_I(ctx);
|
memset(ctx, 0, sizeof(*ctx));
|
|
ctx->dxva_ctx = mpp_calloc(M2VDDxvaParam, 1);
|
ctx->bitread_ctx = mpp_calloc(BitReadCtx_t, 1);
|
|
ctx->packet_slots = cfg->packet_slots;
|
ctx->frame_slots = cfg->frame_slots;
|
|
mpp_buf_slot_setup(ctx->frame_slots, 16);
|
|
ctx->initFlag = 0;
|
|
/* copy from mpeg2decoder::mpeg2decoder */
|
memset(&ctx->Framehead, 0, 3 * sizeof(M2VDFrameHead));
|
|
ctx->frame_ref0 = &ctx->Framehead[0];
|
ctx->frame_ref1 = &ctx->Framehead[1];
|
ctx->frame_cur = &ctx->Framehead[2];
|
for (i = 0; i < 3; i++) {
|
mpp_frame_init(&ctx->Framehead[i].f);
|
if (!ctx->Framehead[i].f) {
|
mpp_err("Failed to allocate frame buffer %d\n", i);
|
return MPP_ERR_NOMEM;
|
}
|
ctx->Framehead[i].picCodingType = 0xffffffff;
|
ctx->Framehead[i].slot_index = 0xff;
|
}
|
#if M2VD_SKIP_ERROR_FRAME_EN
|
ctx->mHwDecStatus = MPP_OK;
|
#endif
|
ctx->resetFlag = 0;
|
ctx->flush_dpb_eos = 0;
|
ctx->pic_head.pre_temporal_reference = 0;
|
ctx->pic_head.pre_picture_coding_type = 0;
|
ctx->pic_head.picture_coding_type = 0;
|
|
/* copy form mpeg2decoder::decoder_init */
|
//----------------------------------------------------
|
ctx->bitstream_sw_buf = mpp_calloc(RK_U8, M2VD_BUF_SIZE_BITMEM);
|
mpp_packet_init(&ctx->input_packet, ctx->bitstream_sw_buf, M2VD_BUF_SIZE_BITMEM);
|
|
ctx->qp_tab_sw_buf = mpp_calloc(RK_U8, M2VD_BUF_SIZE_QPTAB);
|
ctx->seq_head.pIntra_table = ctx->qp_tab_sw_buf;
|
ctx->seq_head.pInter_table = ctx->seq_head.pIntra_table + 64;
|
|
ctx->MPEG2_Flag = 0;
|
ctx->seq_ext_head.progressive_sequence = 1;
|
ctx->pic_code_ext_head.progressive_frame = 1;
|
ctx->pic_code_ext_head.picture_structure = M2VD_PIC_STRUCT_FRAME;
|
ctx->pic_head.pre_picture_coding_type = M2VD_CODING_TYPE_D;
|
ctx->top_first_cnt = 0;
|
ctx->bottom_first_cnt = 0;
|
ctx->pic_code_ext_head.frame_pred_frame_dct = 1;
|
ctx->seq_ext_head.chroma_format = 1;
|
ctx->seq_disp_ext_head.matrix_coefficients = 5;
|
ctx->PreGetFrameTime = 0;
|
ctx->maxFrame_inGOP = 0;
|
ctx->preframe_period = 0;
|
ctx->mHeaderDecFlag = 0;
|
ctx->mExtraHeaderDecFlag = 0;
|
ctx->max_stream_size = M2VD_BUF_SIZE_BITMEM;
|
ctx->ref_frame_cnt = 0;
|
ctx->need_split = cfg->cfg->base.split_parse;
|
ctx->left_length = 0;
|
ctx->vop_header_found = 0;
|
|
if (M2VD_DBG_DUMP_REG & m2vd_debug) {
|
RK_S32 k = 0;
|
for (k = 0; k < M2VD_DBG_FILE_NUM; k++)
|
ctx->fp_dbg_file[k] = NULL;
|
|
ctx->fp_dbg_file[0] = fopen("/sdcard/m2vd_dbg_stream.txt", "wb");
|
if (!ctx->fp_dbg_file[0])
|
mpp_log("open file failed: %s", "/sdcard/m2vd_dbg_stream.txt");
|
|
ctx->fp_dbg_yuv = fopen("/sdcard/m2vd_dbg_yuv_out.txt", "wb");
|
if (!ctx->fp_dbg_yuv)
|
mpp_log("open file failed: %s", "/sdcard/m2vd_dbg_yuv_out.txt");
|
} else {
|
RK_S32 k = 0;
|
for (k = 0; k < M2VD_DBG_FILE_NUM; k++)
|
ctx->fp_dbg_file[k] = NULL;
|
}
|
|
|
m2vd_dbg_func("FUN_O");
|
__FAILED:
|
|
return ret;
|
}
|
|
MPP_RET m2vd_parser_init(void *ctx, ParserCfg *parser_cfg)
|
{
|
MPP_RET ret = MPP_OK;
|
M2VDContext *c = (M2VDContext *)ctx;
|
M2VDParserContext *p = (M2VDParserContext *)c->parse_ctx;
|
m2vd_dbg_func("FUN_I");
|
if (p == NULL) {
|
M2VD_CHK_M(p = (M2VDParserContext*)mpp_calloc(M2VDParserContext, 1));
|
c->parse_ctx = p;
|
}
|
|
M2VD_CHK_F(m2vd_parser_init_ctx(p, parser_cfg));
|
|
mpp_env_get_u32("m2vd_debug", &m2vd_debug, 0);
|
|
m2vd_dbg_func("FUN_O");
|
__FAILED:
|
return ret;
|
}
|
|
MPP_RET m2vd_parser_deinit(void *ctx)
|
{
|
RK_U32 k = 0;
|
MPP_RET ret = MPP_OK;
|
M2VDContext *c = (M2VDContext *)ctx;
|
M2VDParserContext *p = (M2VDParserContext *)c->parse_ctx;
|
|
m2vd_dbg_func("FUN_I");
|
|
for (k = 0; k < M2VD_DBG_FILE_NUM; k++) {
|
M2VD_FCLOSE(p->fp_dbg_file[k]);
|
}
|
M2VD_FCLOSE(p->fp_dbg_yuv);
|
|
if (p->bitstream_sw_buf) {
|
mpp_free(p->bitstream_sw_buf);
|
p->bitstream_sw_buf = NULL;
|
}
|
if (p->qp_tab_sw_buf) {
|
mpp_free(p->qp_tab_sw_buf);
|
p->qp_tab_sw_buf = NULL;
|
}
|
|
if (p->input_packet) {
|
mpp_packet_deinit(&p->input_packet);
|
}
|
|
if (p->dxva_ctx) {
|
mpp_free(p->dxva_ctx);
|
p->dxva_ctx = NULL;
|
}
|
if (p->bitread_ctx) {
|
mpp_free(p->bitread_ctx);
|
p->bitread_ctx = NULL;
|
}
|
|
for (k = 0; k < 3; k++) {
|
mpp_frame_deinit(&p->Framehead[k].f);
|
}
|
|
if (p) {
|
mpp_free(p);
|
}
|
|
m2vd_dbg_func("FUN_O");
|
return ret;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* reset
|
***********************************************************************
|
*/
|
MPP_RET m2vd_parser_reset(void *ctx)
|
{
|
MPP_RET ret = MPP_OK;
|
M2VDContext *c = (M2VDContext *)ctx;
|
M2VDParserContext *p = (M2VDParserContext *)c->parse_ctx;
|
m2vd_dbg_func("FUN_I");
|
if (p->frame_cur->slot_index != 0xff)
|
mpp_buf_slot_clr_flag(p->frame_slots, p->frame_cur->slot_index,
|
SLOT_CODEC_USE);
|
|
if (p->frame_ref0->slot_index != 0xff) {
|
if (p->frame_ref0->flags) {
|
mpp_buf_slot_set_flag(p->frame_slots, p->frame_ref0->slot_index,
|
SLOT_QUEUE_USE);
|
mpp_buf_slot_enqueue(p->frame_slots, p->frame_ref0->slot_index,
|
QUEUE_DISPLAY);
|
p->frame_ref0->flags = 0;
|
}
|
mpp_buf_slot_clr_flag(p->frame_slots, p->frame_ref0->slot_index,
|
SLOT_CODEC_USE);
|
}
|
|
if (p->frame_ref1->slot_index != 0xff)
|
mpp_buf_slot_clr_flag(p->frame_slots, p->frame_ref1->slot_index,
|
SLOT_CODEC_USE);
|
|
if (p->input_packet) {
|
mpp_packet_clr_eos(p->input_packet);
|
}
|
|
p->frame_cur->slot_index = 0xff;
|
p->frame_ref0->slot_index = 0xff;
|
p->frame_ref1->slot_index = 0xff;
|
p->ref_frame_cnt = 0;
|
p->resetFlag = 1;
|
p->eos = 0;
|
p->left_length = 0;
|
p->vop_header_found = 0;
|
m2vd_dbg_func("FUN_O");
|
return ret;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* flush
|
***********************************************************************
|
*/
|
MPP_RET m2vd_parser_flush(void *ctx)
|
{
|
MPP_RET ret = MPP_OK;
|
M2VDContext *c = (M2VDContext *)ctx;
|
M2VDParserContext *p = (M2VDParserContext *)c->parse_ctx;
|
m2vd_dbg_func("FUN_I");
|
|
if ((p->frame_ref0->slot_index != 0xff) && p->frame_ref0->flags) {
|
mpp_buf_slot_set_flag(p->frame_slots, p->frame_ref0->slot_index,
|
SLOT_QUEUE_USE);
|
mpp_buf_slot_enqueue(p->frame_slots, p->frame_ref0->slot_index,
|
QUEUE_DISPLAY);
|
p->frame_ref0->flags = 0;
|
}
|
|
m2vd_dbg_func("FUN_O");
|
return ret;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* control/perform
|
***********************************************************************
|
*/
|
MPP_RET m2vd_parser_control(void *ctx, MpiCmd cmd_type, void *param)
|
{
|
MPP_RET ret = MPP_OK;
|
m2vd_dbg_func("FUN_I");
|
(void)ctx;
|
(void)cmd_type;
|
(void)param;
|
m2vd_dbg_func("FUN_O");
|
return ret;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* prepare
|
***********************************************************************
|
*/
|
MPP_RET mpp_m2vd_parser_split(M2VDParserContext *ctx, MppPacket dst, MppPacket src)
|
{
|
MPP_RET ret = MPP_NOK;
|
M2VDParserContext *p = ctx;
|
RK_U8 *src_buf = (RK_U8 *)mpp_packet_get_pos(src);
|
RK_U32 src_len = (RK_U32)mpp_packet_get_length(src);
|
RK_U32 src_eos = mpp_packet_get_eos(src);
|
RK_U8 *dst_buf = (RK_U8 *)mpp_packet_get_data(dst);
|
RK_U32 dst_len = (RK_U32)mpp_packet_get_length(dst);
|
RK_U32 src_pos = 0;
|
|
if (!p->vop_header_found) {
|
if ((dst_len < sizeof(p->state)) &&
|
((p->state & 0x00FFFFFF) == 0x000001)) {
|
dst_buf[0] = 0;
|
dst_buf[1] = 0;
|
dst_buf[2] = 1;
|
dst_len = 3;
|
}
|
|
while (src_pos < src_len) {
|
p->state = (p->state << 8) | src_buf[src_pos];
|
dst_buf[dst_len++] = src_buf[src_pos++];
|
|
/*
|
* 0x1b3 : sequence header
|
* 0x100 : frame header
|
* we see all 0x1b3 and 0x100 as boundary
|
*/
|
if (p->state == SEQUENCE_HEADER_CODE || p->state == PICTURE_START_CODE) {
|
p->pts = mpp_packet_get_pts(src);
|
p->vop_header_found = 1;
|
break;
|
}
|
}
|
}
|
|
if (p->vop_header_found) {
|
while (src_pos < src_len) {
|
p->state = (p->state << 8) | src_buf[src_pos];
|
dst_buf[dst_len++] = src_buf[src_pos++];
|
|
if (((p->state & 0x00FFFFFF) == 0x000001) && (src_pos < src_len) &&
|
(src_buf[src_pos] == (SEQUENCE_HEADER_CODE & 0xFF) ||
|
src_buf[src_pos] == (PICTURE_START_CODE & 0xFF))) {
|
dst_len -= 3;
|
p->vop_header_found = 0;
|
ret = MPP_OK;
|
break;
|
}
|
}
|
}
|
|
if (src_eos && src_pos >= src_len) {
|
mpp_packet_set_eos(dst);
|
ret = MPP_OK;
|
}
|
|
mpp_packet_set_length(dst, dst_len);
|
mpp_packet_set_pos(src, src_buf + src_pos);
|
|
return ret;
|
}
|
|
MPP_RET m2vd_parser_prepare(void *ctx, MppPacket pkt, HalDecTask *task)
|
{
|
M2VDContext *c = (M2VDContext *)ctx;
|
M2VDParserContext *p = (M2VDParserContext *)c->parse_ctx;
|
RK_U8 *pos = NULL;
|
size_t length = 0;
|
RK_U32 eos = 0;
|
|
if (ctx == NULL || pkt == NULL || task == NULL) {
|
mpp_err_f("found NULL input ctx %p pkt %p task %p\n", ctx, pkt, task);
|
return MPP_ERR_NULL_PTR;
|
}
|
|
pos = mpp_packet_get_pos(pkt);
|
length = mpp_packet_get_length(pkt);
|
eos = mpp_packet_get_eos(pkt);
|
|
if (eos && !length && !p->left_length) {
|
task->valid = 0;
|
task->flags.eos = 1;
|
m2vd_parser_flush(ctx);
|
return MPP_OK;
|
}
|
|
if (p->bitstream_sw_buf == NULL) {
|
mpp_err("failed to malloc task buffer for hardware with size %d\n", length);
|
return MPP_ERR_UNKNOW;
|
}
|
|
mpp_packet_set_length(p->input_packet, p->left_length);
|
|
size_t total_length = MPP_ALIGN(p->left_length + length, 16) + 64;
|
|
if (total_length > p->max_stream_size) {
|
RK_U8 *dst = NULL;
|
|
do {
|
p->max_stream_size <<= 1;
|
} while (total_length > p->max_stream_size);
|
|
dst = mpp_malloc_size(RK_U8, p->max_stream_size);
|
mpp_assert(dst);
|
|
if (p->left_length > 0) {
|
memcpy(dst, p->bitstream_sw_buf, p->left_length);
|
}
|
mpp_free(p->bitstream_sw_buf);
|
p->bitstream_sw_buf = dst;
|
|
mpp_packet_set_data(p->input_packet, p->bitstream_sw_buf);
|
mpp_packet_set_size(p->input_packet, p->max_stream_size);
|
}
|
|
if (!p->need_split) {
|
RK_U32 *val = (RK_U32 *)mpp_packet_get_pos(pkt);
|
/* if input data is rk format styl skip those 32 byte */
|
RK_S32 offset = (VPU_BITSTREAM_START_CODE == val[0]) ? 32 : 0;
|
memcpy(p->bitstream_sw_buf, pos + offset, length - offset);
|
|
mpp_packet_set_length(p->input_packet, length - offset);
|
mpp_packet_set_data(p->input_packet, p->bitstream_sw_buf);
|
mpp_packet_set_size(p->input_packet, p->max_stream_size);
|
|
if (mpp_packet_get_eos(pkt))
|
mpp_packet_set_eos(p->input_packet);
|
|
p->pts = mpp_packet_get_pts(pkt);
|
task->valid = 1;
|
mpp_packet_set_length(pkt, 0);
|
} else {
|
if (MPP_OK == mpp_m2vd_parser_split(p, p->input_packet, pkt)) {
|
p->left_length = 0;
|
task->valid = 1;
|
} else {
|
task->valid = 0;
|
p->left_length = mpp_packet_get_length(p->input_packet);
|
}
|
}
|
|
if (mpp_packet_get_flag(pkt) & MPP_PACKET_FLAG_EXTRA_DATA) {
|
mpp_packet_set_extra_data(p->input_packet);
|
}
|
|
p->eos = mpp_packet_get_eos(p->input_packet);
|
mpp_packet_set_pts(p->input_packet, p->pts);
|
task->input_packet = p->input_packet;
|
task->flags.eos = p->eos;
|
|
return MPP_OK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* parser
|
***********************************************************************
|
*/
|
|
static RK_U32 m2vd_search_header(BitReadCtx_t *bx)
|
{
|
mpp_align_get_bits(bx);
|
while (m2vd_show_bits(bx, 24) != 0x01) {
|
mpp_skip_bits(bx, 8);
|
if (m2vd_get_leftbits(bx) < 32) {
|
if (M2VD_DBG_SEC_HEADER & m2vd_debug) {
|
mpp_log("[m2v]: seach_header: str.leftbit()[%d] < 32", m2vd_get_leftbits(bx));
|
}
|
return NO_MORE_STREAM;
|
}
|
}
|
return m2vd_show_bits(bx, 32);
|
}
|
|
static int m2vd_decode_seq_ext_header(M2VDParserContext *ctx)
|
{
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
m2vd_dbg_func("FUN_I");
|
ctx->MPEG2_Flag = 1;
|
ctx->seq_ext_head.profile_and_level_indication = m2vd_read_bits(bx, 8);
|
ctx->seq_ext_head.progressive_sequence = m2vd_read_bits(bx, 1);
|
ctx->seq_ext_head.chroma_format = m2vd_read_bits(bx, 2);
|
if (ctx->seq_ext_head.chroma_format != 1)
|
return M2VD_DEC_UNSURPORT;
|
ctx->seq_ext_head.horizontal_size_extension = m2vd_read_bits(bx, 2);
|
ctx->seq_ext_head.vertical_size_extension = m2vd_read_bits(bx, 2);
|
ctx->seq_ext_head.bit_rate_extension = m2vd_read_bits(bx, 12);
|
mpp_skip_bits(bx, 1);
|
ctx->seq_ext_head.vbv_buffer_size_extension = m2vd_read_bits(bx, 8);
|
ctx->seq_ext_head.low_delay = m2vd_read_bits(bx, 1);
|
ctx->seq_ext_head.frame_rate_extension_n = m2vd_read_bits(bx, 2);
|
ctx->seq_ext_head.frame_rate_extension_d = m2vd_read_bits(bx, 5);
|
|
ctx->seq_head.bit_rate_value |= (ctx->seq_ext_head.bit_rate_extension << 18);
|
ctx->seq_head.vbv_buffer_size += (ctx->seq_ext_head.vbv_buffer_size_extension << 10);
|
|
m2vd_dbg_func("FUN_O");
|
return M2VD_DEC_OK;
|
}
|
|
static int m2vd_decode_seqdisp_ext_header(M2VDParserContext *ctx)
|
{
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
ctx->seq_disp_ext_head.video_format = m2vd_read_bits(bx, 3);
|
ctx->seq_disp_ext_head.color_description = m2vd_read_bits(bx, 1);
|
|
if (ctx->seq_disp_ext_head.color_description) {
|
ctx->seq_disp_ext_head.color_primaries = m2vd_read_bits(bx, 8);
|
ctx->seq_disp_ext_head.transfer_characteristics = m2vd_read_bits(bx, 8);
|
ctx->seq_disp_ext_head.matrix_coefficients = m2vd_read_bits(bx, 8);
|
}
|
|
m2vd_read_bits(bx, 14);
|
mpp_skip_bits(bx, 1);
|
m2vd_read_bits(bx, 14);
|
return M2VD_DEC_OK;
|
}
|
|
static int m2vd_decode_matrix_ext_header(M2VDParserContext *ctx)
|
{
|
RK_U32 load_intra_quantizer_matrix;
|
RK_U32 load_non_intra_quantizer_matrix;
|
RK_U32 load_chroma_intra_quantizer_matrix;
|
RK_U32 load_chroma_non_intra_quantizer_matrix;
|
RK_U32 i;
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
|
load_intra_quantizer_matrix = m2vd_read_bits(bx, 1);
|
if (load_intra_quantizer_matrix) {
|
for (i = 0; i < 64; i++)
|
ctx->seq_head.pIntra_table[scanOrder[0][i]] = (unsigned char)m2vd_read_bits(bx, 8);
|
|
}
|
load_non_intra_quantizer_matrix = m2vd_read_bits(bx, 1);
|
if (load_non_intra_quantizer_matrix) {
|
for (i = 0; i < 64; i++)
|
ctx->seq_head.pInter_table[scanOrder[0][i]] = (unsigned char)m2vd_read_bits(bx, 8);
|
}
|
load_chroma_intra_quantizer_matrix = m2vd_read_bits(bx, 1);
|
if (load_chroma_intra_quantizer_matrix) {
|
return M2VD_DEC_UNSURPORT;
|
}
|
load_chroma_non_intra_quantizer_matrix = m2vd_read_bits(bx, 1);
|
if (load_chroma_non_intra_quantizer_matrix) {
|
return M2VD_DEC_UNSURPORT;
|
}
|
return M2VD_DEC_OK;
|
}
|
|
static int m2vd_decode_scalable_ext_header(M2VDParserContext *ctx)
|
{
|
/* ISO/IEC 13818-2 section 6.2.2.5: sequence_scalable_extension() header */
|
int layer_id;
|
int lower_layer_prediction_horizontal_size;
|
int lower_layer_prediction_vertical_size;
|
int horizontal_subsampling_factor_m;
|
int horizontal_subsampling_factor_n;
|
int vertical_subsampling_factor_m;
|
int vertical_subsampling_factor_n;
|
int scalable_mode;
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
|
/* scalable_mode */
|
#define SC_NONE 0
|
#define SC_DP 1
|
#define SC_SPAT 2
|
#define SC_SNR 3
|
#define SC_TEMP 4
|
|
scalable_mode = m2vd_read_bits(bx, 2) + 1; /* add 1 to make SC_DP != SC_NONE */
|
|
layer_id = m2vd_read_bits(bx, 4);
|
|
if (scalable_mode == SC_SPAT) {
|
lower_layer_prediction_horizontal_size = m2vd_read_bits(bx, 14);
|
mpp_skip_bits(bx, 1);
|
lower_layer_prediction_vertical_size = m2vd_read_bits(bx, 14);
|
horizontal_subsampling_factor_m = m2vd_read_bits(bx, 5);
|
horizontal_subsampling_factor_n = m2vd_read_bits(bx, 5);
|
vertical_subsampling_factor_m = m2vd_read_bits(bx, 5);
|
vertical_subsampling_factor_n = m2vd_read_bits(bx, 5);
|
}
|
|
(void)layer_id;
|
(void)lower_layer_prediction_horizontal_size;
|
(void)lower_layer_prediction_vertical_size;
|
(void)horizontal_subsampling_factor_m;
|
(void)horizontal_subsampling_factor_n;
|
(void)vertical_subsampling_factor_m;
|
(void)vertical_subsampling_factor_n;
|
|
|
if (scalable_mode == SC_TEMP)
|
return M2VD_DEC_UNSURPORT;
|
else
|
return M2VD_DEC_OK;
|
}
|
|
static int m2vd_decode_picdisp_ext_header(M2VDParserContext *ctx)
|
{
|
int i;
|
int number_of_frame_center_offsets;
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
/* based on ISO/IEC 13818-2 section 6.3.12
|
(November 1994) Picture display extensions */
|
|
/* derive number_of_frame_center_offsets */
|
if (ctx->seq_ext_head.progressive_sequence) {
|
if (ctx->pic_code_ext_head.repeat_first_field) {
|
if (ctx->pic_code_ext_head.top_field_first)
|
number_of_frame_center_offsets = 3;
|
else
|
number_of_frame_center_offsets = 2;
|
} else {
|
number_of_frame_center_offsets = 1;
|
}
|
} else {
|
if (ctx->pic_code_ext_head.picture_structure != M2VD_PIC_STRUCT_FRAME) {
|
number_of_frame_center_offsets = 1;
|
} else {
|
if (ctx->pic_code_ext_head.repeat_first_field)
|
number_of_frame_center_offsets = 3;
|
else
|
number_of_frame_center_offsets = 2;
|
}
|
}
|
|
/* now parse */
|
for (i = 0; i < number_of_frame_center_offsets; i++) {
|
ctx->pic_disp_ext_head.frame_center_horizontal_offset[i] = m2vd_read_bits(bx, 16);
|
mpp_skip_bits(bx, 1);
|
|
ctx->pic_disp_ext_head.frame_center_vertical_offset[i] = m2vd_read_bits(bx, 16);
|
mpp_skip_bits(bx, 1);
|
}
|
return M2VD_DEC_OK;
|
}
|
|
static int m2vd_decode_spatial_ext_header(M2VDParserContext *ctx)
|
{
|
/* ISO/IEC 13818-2 section 6.2.3.5: picture_spatial_scalable_extension() header */
|
int lower_layer_temporal_reference;
|
int lower_layer_horizontal_offset;
|
int lower_layer_vertical_offset;
|
int spatial_temporal_weight_code_table_index;
|
int lower_layer_progressive_frame;
|
int lower_layer_deinterlaced_field_select;
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
|
lower_layer_temporal_reference = m2vd_read_bits(bx, 10);
|
mpp_skip_bits(bx, 1);
|
lower_layer_horizontal_offset = m2vd_read_bits(bx, 15);
|
if (lower_layer_horizontal_offset >= 16384)
|
lower_layer_horizontal_offset -= 32768;
|
mpp_skip_bits(bx, 1);
|
lower_layer_vertical_offset = m2vd_read_bits(bx, 15);
|
if (lower_layer_vertical_offset >= 16384)
|
lower_layer_vertical_offset -= 32768;
|
spatial_temporal_weight_code_table_index = m2vd_read_bits(bx, 2);
|
lower_layer_progressive_frame = m2vd_read_bits(bx, 1);
|
lower_layer_deinterlaced_field_select = m2vd_read_bits(bx, 1);
|
|
(void)lower_layer_temporal_reference;
|
(void)lower_layer_vertical_offset;
|
(void)spatial_temporal_weight_code_table_index;
|
(void)lower_layer_progressive_frame;
|
(void)lower_layer_deinterlaced_field_select;
|
|
return M2VD_DEC_OK;
|
}
|
|
static int m2vd_decode_pic_ext_header(M2VDParserContext *ctx)
|
{
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
ctx->pic_code_ext_head.f_code[0][0] = m2vd_read_bits(bx, 4);
|
ctx->pic_code_ext_head.f_code[0][1] = m2vd_read_bits(bx, 4);
|
ctx->pic_code_ext_head.f_code[1][0] = m2vd_read_bits(bx, 4);
|
ctx->pic_code_ext_head.f_code[1][1] = m2vd_read_bits(bx, 4);
|
if (ctx->MPEG2_Flag) {
|
ctx->pic_head.full_pel_forward_vector = ctx->pic_code_ext_head.f_code[0][0];
|
ctx->pic_head.forward_f_code = ctx->pic_code_ext_head.f_code[0][1];
|
ctx->pic_head.full_pel_backward_vector = ctx->pic_code_ext_head.f_code[1][0];
|
ctx->pic_head.backward_f_code = ctx->pic_code_ext_head.f_code[1][1];
|
}
|
|
ctx->pic_code_ext_head.intra_dc_precision = m2vd_read_bits(bx, 2);
|
ctx->pic_code_ext_head.picture_structure = m2vd_read_bits(bx, 2);
|
if (ctx->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_FRAME)
|
ctx->pic_code_ext_head.top_field_first = m2vd_read_bits(bx, 1);
|
else {
|
m2vd_read_bits(bx, 1);
|
if ((ctx->pic_head.pre_picture_coding_type != ctx->pic_head.picture_coding_type) &&
|
(ctx->pic_head.pre_picture_coding_type != M2VD_CODING_TYPE_I)) {
|
if (ctx->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_TOP_FIELD)
|
ctx->top_first_cnt++;
|
else
|
ctx->bottom_first_cnt++;
|
}
|
if (ctx->top_first_cnt >= ctx->bottom_first_cnt)
|
ctx->pic_code_ext_head.top_field_first = 1;
|
else
|
ctx->pic_code_ext_head.top_field_first = 0;
|
}
|
ctx->pic_code_ext_head.frame_pred_frame_dct = m2vd_read_bits(bx, 1);
|
ctx->pic_code_ext_head.concealment_motion_vectors = m2vd_read_bits(bx, 1);
|
ctx->pic_code_ext_head.q_scale_type = m2vd_read_bits(bx, 1);
|
ctx->pic_code_ext_head.intra_vlc_format = m2vd_read_bits(bx, 1);
|
ctx->pic_code_ext_head.alternate_scan = m2vd_read_bits(bx, 1);
|
ctx->pic_code_ext_head.repeat_first_field = m2vd_read_bits(bx, 1);
|
ctx->pic_code_ext_head.chroma_420_type = m2vd_read_bits(bx, 1);
|
ctx->pic_code_ext_head.progressive_frame = m2vd_read_bits(bx, 1);
|
ctx->pic_code_ext_head.composite_display_flag = m2vd_read_bits(bx, 1);
|
if (ctx->pic_code_ext_head.composite_display_flag) {
|
ctx->pic_code_ext_head.v_axis = m2vd_read_bits(bx, 1);
|
ctx->pic_code_ext_head.field_sequence = m2vd_read_bits(bx, 3);
|
ctx->pic_code_ext_head.sub_carrier = m2vd_read_bits(bx, 1);
|
ctx->pic_code_ext_head.burst_amplitude = m2vd_read_bits(bx, 7);
|
ctx->pic_code_ext_head.sub_carrier_phase = m2vd_read_bits(bx, 8);
|
}
|
return M2VD_DEC_OK;
|
}
|
|
static inline int m2vd_decode_temp_ext_header(void)
|
{
|
return M2VD_DEC_UNSURPORT;
|
}
|
|
static int m2vd_decode_copyright_ext_header(M2VDParserContext *ctx)
|
{
|
int copyright_flag;
|
int copyright_identifier;
|
int original_or_copy;
|
int copyright_number_1;
|
int copyright_number_2;
|
int copyright_number_3;
|
int reserved_data;
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
|
copyright_flag = m2vd_read_bits(bx, 1);
|
copyright_identifier = m2vd_read_bits(bx, 8);
|
original_or_copy = m2vd_read_bits(bx, 1);
|
|
/* reserved */
|
reserved_data = m2vd_read_bits(bx, 7);
|
|
mpp_skip_bits(bx, 1);
|
copyright_number_1 = m2vd_read_bits(bx, 20);
|
mpp_skip_bits(bx, 1);
|
copyright_number_2 = m2vd_read_bits(bx, 22);
|
mpp_skip_bits(bx, 1);
|
copyright_number_3 = m2vd_read_bits(bx, 22);
|
|
(void)copyright_flag;
|
(void)copyright_identifier;
|
(void)original_or_copy;
|
(void)copyright_number_1;
|
(void)copyright_number_2;
|
(void)copyright_number_3;
|
(void)reserved_data;
|
|
return M2VD_DEC_OK;
|
}
|
|
static int m2vd_decode_ext_header(M2VDParserContext *ctx)
|
{
|
RK_U32 code;
|
RK_U32 ext_ID;
|
int result;
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
|
code = m2vd_search_header(bx);
|
|
if (M2VD_DBG_SEC_HEADER & m2vd_debug) {
|
mpp_log("[m2v]: decoder_ext_header : seach_header return code: %#03x", code);
|
}
|
while (code == EXTENSION_START_CODE || code == USER_DATA_START_CODE) {
|
if (code == EXTENSION_START_CODE) {
|
mpp_skip_bits(bx, 32);
|
ext_ID = m2vd_read_bits(bx, 4);
|
if (M2VD_DBG_SEC_HEADER & m2vd_debug) {
|
mpp_log("[m2v]: decoder_ext_header : ext_ID: %d", ext_ID);
|
}
|
switch (ext_ID) {
|
case SEQUENCE_EXTENSION_ID:
|
result = m2vd_decode_seq_ext_header(ctx);
|
break;
|
case SEQUENCE_DISPLAY_EXTENSION_ID:
|
result = m2vd_decode_seqdisp_ext_header(ctx);
|
break;
|
case QUANT_MATRIX_EXTENSION_ID:
|
result = m2vd_decode_matrix_ext_header(ctx);
|
break;
|
case SEQUENCE_SCALABLE_EXTENSION_ID:
|
result = m2vd_decode_scalable_ext_header(ctx);
|
break;
|
case PICTURE_DISPLAY_EXTENSION_ID:
|
result = m2vd_decode_picdisp_ext_header(ctx);
|
break;
|
case PICTURE_CODING_EXTENSION_ID:
|
result = m2vd_decode_pic_ext_header(ctx);
|
break;
|
case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
|
result = m2vd_decode_spatial_ext_header(ctx);
|
break;
|
case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
|
result = m2vd_decode_temp_ext_header();
|
break;
|
case COPYRIGHT_EXTENSION_ID:
|
result = m2vd_decode_copyright_ext_header(ctx);
|
break;
|
case NO_MORE_STREAM:
|
break;
|
default:
|
break;
|
}
|
|
if (M2VD_DBG_SEC_HEADER & m2vd_debug) {
|
mpp_log("[m2v]: decoder_ext_header result: %d", result);
|
}
|
if (result)
|
return result;
|
} else {
|
mpp_skip_bits(bx, 32);
|
}
|
code = m2vd_search_header(bx);
|
}
|
|
return MPP_OK;
|
}
|
|
static int m2vd_decode_gop_header(M2VDParserContext *ctx)
|
{
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
|
ctx->gop_head.drop_flag = m2vd_read_bits(bx, 1);
|
ctx->gop_head.hour = m2vd_read_bits(bx, 5);
|
ctx->gop_head.minute = m2vd_read_bits(bx, 6);
|
|
mpp_skip_bits(bx, 1);
|
|
ctx->gop_head.sec = m2vd_read_bits(bx, 6);
|
ctx->gop_head.frame = m2vd_read_bits(bx, 6);
|
ctx->gop_head.closed_gop = m2vd_read_bits(bx, 1);
|
ctx->gop_head.broken_link = m2vd_read_bits(bx, 1);
|
|
return m2vd_decode_ext_header(ctx);
|
}
|
|
static int m2vd_decode_seq_header(M2VDParserContext *ctx)
|
{
|
RK_U32 i;
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
ctx->seq_head.decode_width = m2vd_read_bits(bx, 12);
|
ctx->seq_head.decode_height = m2vd_read_bits(bx, 12);
|
ctx->display_width = ctx->seq_head.decode_width;
|
ctx->display_height = ctx->seq_head.decode_height;
|
ctx->seq_head.aspect_ratio_information = m2vd_read_bits(bx, 4);
|
ctx->seq_head.frame_rate_code = m2vd_read_bits(bx, 4);
|
if (!ctx->frame_period)
|
ctx->frame_period = frame_period_Table[ctx->seq_head.frame_rate_code];
|
ctx->seq_head.bit_rate_value = m2vd_read_bits(bx, 18);
|
mpp_skip_bits(bx, 1);
|
ctx->seq_head.vbv_buffer_size = m2vd_read_bits(bx, 10);
|
ctx->seq_head.constrained_parameters_flag = m2vd_read_bits(bx, 1);
|
ctx->seq_head.load_intra_quantizer_matrix = m2vd_read_bits(bx, 1);
|
if (ctx->seq_head.load_intra_quantizer_matrix) {
|
for (i = 0; i < 64; i++)
|
ctx->seq_head.pIntra_table[scanOrder[0][i]] = (unsigned char)m2vd_read_bits(bx, 8);
|
} else {
|
for (i = 0; i < 64; i++)
|
ctx->seq_head.pIntra_table[i] = intraDefaultQMatrix[i];
|
}
|
|
ctx->seq_head.load_non_intra_quantizer_matrix = m2vd_read_bits(bx, 1);
|
if (ctx->seq_head.load_non_intra_quantizer_matrix) {
|
for (i = 0; i < 64; i++)
|
ctx->seq_head.pInter_table[scanOrder[0][i]] = (unsigned char)m2vd_read_bits(bx, 8);
|
|
} else {
|
for (i = 0; i < 64; i++)
|
ctx->seq_head.pInter_table[i] = 16;
|
|
}
|
|
|
return m2vd_decode_ext_header(ctx);
|
}
|
|
static int m2vd_extra_bit_information(M2VDParserContext *ctx)
|
{
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
while (m2vd_read_bits(bx, 1)) {
|
mpp_skip_bits(bx, 8);
|
}
|
return M2VD_DEC_OK;
|
}
|
|
static int m2vd_decode_pic_header(M2VDParserContext *ctx)
|
{
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
ctx->pic_head.temporal_reference = m2vd_read_bits(bx, 10);
|
ctx->pic_head.picture_coding_type = m2vd_read_bits(bx, 3);
|
ctx->pic_head.vbv_delay = m2vd_read_bits(bx, 16);
|
if (ctx->pic_head.temporal_reference > 50) {
|
ctx->pic_head.temporal_reference = ctx->pretemporal_reference;
|
}
|
//if ((maxFrame_inGOP < temporal_reference)&&(temporal_reference<60))
|
// maxFrame_inGOP = temporal_reference;
|
if (((RK_S32)ctx->maxFrame_inGOP < ctx->pic_head.temporal_reference) && (ctx->pic_head.temporal_reference < 60))
|
ctx->maxFrame_inGOP = ctx->pic_head.temporal_reference;
|
|
|
if (ctx->pic_head.picture_coding_type == M2VD_CODING_TYPE_P ||
|
ctx->pic_head.picture_coding_type == M2VD_CODING_TYPE_B) {
|
ctx->pic_head.full_pel_forward_vector = m2vd_read_bits(bx, 1);
|
ctx->pic_head.forward_f_code = m2vd_read_bits(bx, 3);
|
}
|
if (ctx->pic_head.picture_coding_type == M2VD_CODING_TYPE_B) {
|
ctx->pic_head.full_pel_backward_vector = m2vd_read_bits(bx, 1);
|
ctx->pic_head.backward_f_code = m2vd_read_bits(bx, 3);
|
}
|
|
m2vd_extra_bit_information(ctx);
|
|
return m2vd_decode_ext_header(ctx);
|
}
|
|
static MPP_RET m2vd_decode_head(M2VDParserContext *ctx)
|
{
|
RK_U32 code;
|
int ret = 0;
|
BitReadCtx_t *bx = ctx->bitread_ctx;
|
|
m2vd_dbg_func("FUN_I");
|
while (1) {
|
code = m2vd_search_header(bx);
|
if (M2VD_DBG_SEC_HEADER & m2vd_debug) {
|
mpp_log("[m2v]: decoder_header : seach_header return code: 0x%3x", code);
|
}
|
if (code == NO_MORE_STREAM)
|
return M2VD_DEC_FILE_END;
|
code = m2vd_read_bits(bx, 32);
|
|
switch (code) {
|
case SEQUENCE_HEADER_CODE:
|
ret = m2vd_decode_seq_header(ctx);
|
if (!ret) {
|
MppPacket pkt = ctx->input_packet;
|
if (mpp_packet_get_flag(pkt) & MPP_PACKET_FLAG_EXTRA_DATA) {
|
ctx->mExtraHeaderDecFlag = 1;
|
} else {
|
ctx->mHeaderDecFlag = 1;
|
}
|
}
|
break;
|
case GROUP_START_CODE:
|
ret = m2vd_decode_gop_header(ctx);
|
break;
|
case PICTURE_START_CODE:
|
ret = m2vd_decode_pic_header(ctx);
|
ret = M2VD_DEC_PICHEAD_OK;
|
break;
|
case SEQUENCE_END_CODE:
|
ret = M2VD_DEC_STREAM_END;
|
break;
|
default:
|
if (M2VD_DBG_SEC_HEADER & m2vd_debug) {
|
mpp_log("code=%x,leftbit=%d", code, m2vd_get_leftbits(bx));
|
}
|
break;
|
}
|
if (ret)
|
break;
|
}
|
m2vd_dbg_func("FUN_O");
|
|
return ret;
|
}
|
|
static MPP_RET m2vd_alloc_frame(M2VDParserContext *ctx)
|
{
|
RK_U64 pts = ctx->pts;
|
if (ctx->resetFlag && ctx->pic_head.picture_coding_type != M2VD_CODING_TYPE_I) {
|
mpp_log("[m2v]: resetFlag[%d] && picture_coding_type[%d] != I_TYPE", ctx->resetFlag, ctx->pic_head.picture_coding_type);
|
return MPP_NOK;
|
} else {
|
ctx->resetFlag = 0;
|
}
|
if ((ctx->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_FRAME ) ||
|
((ctx->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_TOP_FIELD) && ctx->pic_code_ext_head.top_field_first) ||
|
((ctx->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_BOTTOM_FIELD) && (!ctx->pic_code_ext_head.top_field_first)) ||
|
(ctx->frame_cur->slot_index == 0xff)) {
|
RK_S64 Time = 0;
|
if (ctx->PreGetFrameTime != pts) {
|
RK_S64 tmp_frame_period;
|
|
if (ctx->GroupFrameCnt) {
|
ctx->GroupFrameCnt = ctx->GroupFrameCnt + ctx->pic_head.temporal_reference;
|
} else if (ctx->pic_head.temporal_reference == (RK_S32)ctx->PreChangeTime_index)
|
ctx->GroupFrameCnt = ctx->max_temporal_reference + 1;
|
else if (ctx->pic_head.temporal_reference)
|
ctx->GroupFrameCnt = ctx->pic_head.temporal_reference - ctx->PreChangeTime_index;
|
else
|
ctx->GroupFrameCnt = ctx->max_temporal_reference - ctx->PreChangeTime_index + 1;
|
|
tmp_frame_period = pts - ctx->PreGetFrameTime;
|
|
if ((pts > ctx->PreGetFrameTime) && (ctx->pic_head.temporal_reference > (RK_S32)ctx->PreChangeTime_index)) {
|
RK_S32 theshold_frame_period = tmp_frame_period * 2 ;
|
RK_S32 last_frame_period = ctx->preframe_period ? ctx->preframe_period : ctx->frame_period;
|
RK_S32 predict_frame_period = (ctx->pic_head.temporal_reference - ctx->PreChangeTime_index) * last_frame_period / 256;
|
if (theshold_frame_period < predict_frame_period) {
|
pts = ctx->PreGetFrameTime + predict_frame_period;
|
tmp_frame_period = predict_frame_period;
|
}
|
}
|
|
if ((pts > ctx->PreGetFrameTime) && (ctx->GroupFrameCnt > 0)) {
|
tmp_frame_period = (tmp_frame_period * 256) / ctx->GroupFrameCnt;
|
if ((tmp_frame_period > 4200) && (tmp_frame_period < 11200) &&
|
(llabs(ctx->frame_period - tmp_frame_period) > 128)) {
|
if (llabs(ctx->preframe_period - tmp_frame_period) > 128)
|
ctx->preframe_period = tmp_frame_period;
|
else
|
ctx->frame_period = tmp_frame_period;
|
}
|
}
|
|
ctx->Group_start_Time = pts - (ctx->pic_head.temporal_reference * ctx->frame_period / 256);
|
if (ctx->Group_start_Time < 0)
|
ctx->Group_start_Time = 0;
|
ctx->PreGetFrameTime = pts;
|
ctx->PreChangeTime_index = ctx->pic_head.temporal_reference;
|
ctx->GroupFrameCnt = 0;
|
} else if ((RK_S32)ctx->pretemporal_reference > ctx->pic_head.temporal_reference + 5) {
|
ctx->Group_start_Time += ((ctx->max_temporal_reference + 1) * ctx->frame_period / 256);
|
ctx->GroupFrameCnt = ctx->max_temporal_reference - ctx->PreChangeTime_index + 1;
|
ctx->max_temporal_reference = 0;
|
}
|
if ((RK_S32)ctx->pretemporal_reference > ctx->pic_head.temporal_reference + 5)
|
ctx->max_temporal_reference = 0;
|
if (ctx->pic_head.temporal_reference > (RK_S32)ctx->max_temporal_reference)
|
ctx->max_temporal_reference = ctx->pic_head.temporal_reference;
|
ctx->pretemporal_reference = ctx->pic_head.temporal_reference;
|
/*if(picture_coding_type == I_TYPE)
|
{
|
if (Video_Bitsream.Slice_Time.low_part >= (RK_U32)(frame_period/128))
|
Group_start_Time = Video_Bitsream.Slice_Time.low_part - (RK_U32)(frame_period/128);
|
else
|
Group_start_Time = Video_Bitsream.Slice_Time.low_part;
|
}*/
|
Time = ctx->Group_start_Time;
|
Time += ((ctx->pic_head.temporal_reference * ctx->frame_period) / 256);
|
if (Time < 0) {
|
Time = 0;
|
}
|
//base.Current_frame->ShowTime = Time;//Video_Bitsream.Slice_Time.low_part;
|
//!< mark current slot error
|
if (ctx->pic_head.picture_coding_type != M2VD_CODING_TYPE_I
|
&& ctx->pic_head.pre_picture_coding_type == ctx->pic_head.picture_coding_type) {
|
if ((ctx->pic_head.temporal_reference - ctx->pic_head.pre_temporal_reference > 3)
|
|| (ctx->pic_head.temporal_reference - ctx->pic_head.pre_temporal_reference < -3)) {
|
mpp_frame_set_errinfo(ctx->frame_cur->f, 1);
|
} else {
|
mpp_frame_set_errinfo(ctx->frame_cur->f, 0);
|
}
|
}
|
ctx->pic_head.pre_temporal_reference = ctx->pic_head.temporal_reference;
|
ctx->pic_head.pre_picture_coding_type = ctx->pic_head.picture_coding_type;
|
ctx->frame_cur->picCodingType = ctx->pic_head.picture_coding_type;
|
ctx->seq_head.decode_height = (ctx->seq_head.decode_height + 15) & (~15);
|
ctx->seq_head.decode_width = (ctx->seq_head.decode_width + 15) & (~15);
|
|
if ((ctx->ref_frame_cnt < 2) && (ctx->frame_cur->picCodingType == M2VD_CODING_TYPE_B)) {
|
// not enough refs on B-type need cal pts and parser ctx but not need to decode
|
mpp_log("[m2v]: (ref_frame_cnt[%d] < 2) && (frame_cur->picCodingType[%d] == B_TYPE)", ctx->ref_frame_cnt, ctx->frame_cur->picCodingType);
|
return MPP_NOK;
|
}
|
if (ctx->frame_cur->slot_index == 0xff) {
|
RK_U32 frametype = 0;
|
mpp_frame_set_width(ctx->frame_cur->f, ctx->display_width);
|
mpp_frame_set_height(ctx->frame_cur->f, ctx->display_height);
|
mpp_frame_set_hor_stride(ctx->frame_cur->f, ctx->display_width);
|
mpp_frame_set_ver_stride(ctx->frame_cur->f, ctx->display_height);
|
mpp_frame_set_errinfo(ctx->frame_cur->f, 0);
|
mpp_frame_set_pts(ctx->frame_cur->f, Time);
|
ctx->frame_cur->flags = M2V_OUT_FLAG;
|
if (ctx->seq_ext_head.progressive_sequence) {
|
frametype = MPP_FRAME_FLAG_FRAME;
|
} else {
|
frametype = MPP_FRAME_FLAG_PAIRED_FIELD;
|
if (ctx->pic_code_ext_head.top_field_first)
|
frametype |= MPP_FRAME_FLAG_TOP_FIRST;
|
else
|
frametype |= MPP_FRAME_FLAG_BOT_FIRST;
|
}
|
mpp_frame_set_mode(ctx->frame_cur->f, frametype);
|
|
if (ctx->seq_head.aspect_ratio_information >= 0 && ctx->seq_head.aspect_ratio_information < 16)
|
mpp_frame_set_sar(ctx->frame_cur->f, mpeg2_aspect[ctx->seq_head.aspect_ratio_information]);
|
|
mpp_buf_slot_get_unused(ctx->frame_slots, &ctx->frame_cur->slot_index);
|
mpp_buf_slot_set_prop(ctx->frame_slots, ctx->frame_cur->slot_index, SLOT_FRAME, ctx->frame_cur->f);
|
mpp_buf_slot_set_flag(ctx->frame_slots, ctx->frame_cur->slot_index, SLOT_CODEC_USE);
|
mpp_buf_slot_set_flag(ctx->frame_slots, ctx->frame_cur->slot_index, SLOT_HAL_OUTPUT);
|
}
|
}
|
//alloc frame space
|
if ((ctx->ref_frame_cnt < 2) && (ctx->frame_cur->picCodingType == M2VD_CODING_TYPE_B)) {
|
mpp_log("[m2v]: (ref_frame_cnt[%d] < 2) && (frame_cur->picCodingType[%d] == B_TYPE)", ctx->ref_frame_cnt, ctx->frame_cur->picCodingType);
|
return MPP_NOK;
|
}
|
|
return MPP_OK;
|
}
|
|
static MPP_RET m2v_update_ref_frame(M2VDParserContext *p)
|
{
|
|
MPP_RET ret = MPP_OK;
|
m2vd_dbg_func("FUN_I");
|
//push frame
|
if ((p->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_FRAME) ||
|
((p->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_BOTTOM_FIELD) && p->pic_code_ext_head.top_field_first ) ||
|
((p->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_TOP_FIELD) && (!p->pic_code_ext_head.top_field_first))) {
|
|
if (p->frame_cur->picCodingType == M2VD_CODING_TYPE_B) {
|
mpp_buf_slot_set_flag(p->frame_slots, p->frame_cur->slot_index, SLOT_QUEUE_USE);
|
mpp_buf_slot_enqueue(p->frame_slots, p->frame_cur->slot_index, QUEUE_DISPLAY);
|
mpp_buf_slot_clr_flag(p->frame_slots, p->frame_cur->slot_index, SLOT_CODEC_USE);
|
p->frame_cur->slot_index = 0xFF;
|
} else if (p->frame_cur->picCodingType != 0xffffffff) {
|
M2VDFrameHead *tmpHD = NULL;
|
p->ref_frame_cnt++;
|
if (p->frame_ref0->slot_index < 0x7f) {
|
if (p->frame_ref0->flags) {
|
mpp_buf_slot_set_flag(p->frame_slots, p->frame_ref0->slot_index, SLOT_QUEUE_USE);
|
mpp_buf_slot_enqueue(p->frame_slots, p->frame_ref0->slot_index, QUEUE_DISPLAY);
|
p->frame_ref0->flags = 0;
|
}
|
}
|
if (p->frame_ref1->slot_index < 0x7f) {
|
mpp_buf_slot_clr_flag(p->frame_slots, p->frame_ref1->slot_index, SLOT_CODEC_USE);
|
p->frame_ref1->slot_index = 0xff;
|
}
|
tmpHD = p->frame_ref1;
|
p->frame_ref1 = p->frame_ref0;
|
p->frame_ref0 = p->frame_cur;
|
p->frame_cur = tmpHD;
|
}
|
}
|
return ret;
|
}
|
|
static MPP_RET m2vd_convert_to_dxva(M2VDParserContext *p)
|
{
|
MPP_RET ret = MPP_OK;
|
m2vd_dbg_func("FUN_I");
|
M2VDDxvaParam *dst = p->dxva_ctx;
|
M2VDFrameHead *pfw = p->frame_ref1;
|
M2VDFrameHead *pbw = p->frame_ref0;
|
BitReadCtx_t *bx = p->bitread_ctx;
|
RK_U32 i = 0;
|
RK_U32 error_info = 0;
|
|
RK_S32 readbits = m2vd_get_readbits(bx);
|
|
dst->seq.decode_width = p->seq_head.decode_width;
|
dst->seq.decode_height = p->seq_head.decode_height;
|
dst->seq.aspect_ratio_information = p->seq_head.aspect_ratio_information;
|
dst->seq.frame_rate_code = p->seq_head.frame_rate_code;
|
dst->seq.bit_rate_value = p->seq_head.bit_rate_value;
|
dst->seq.vbv_buffer_size = p->seq_head.vbv_buffer_size;
|
dst->seq.constrained_parameters_flag = p->seq_head.constrained_parameters_flag;
|
dst->seq.load_intra_quantizer_matrix = p->seq_head.load_intra_quantizer_matrix;
|
dst->seq.load_non_intra_quantizer_matrix = p->seq_head.load_non_intra_quantizer_matrix;
|
|
dst->seq_ext.profile_and_level_indication = p->seq_ext_head.profile_and_level_indication;
|
dst->seq_ext.progressive_sequence = p->seq_ext_head.progressive_sequence;
|
dst->seq_ext.chroma_format = p->seq_ext_head.chroma_format;
|
dst->seq_ext.low_delay = p->seq_ext_head.low_delay;
|
dst->seq_ext.frame_rate_extension_n = p->seq_ext_head.frame_rate_extension_n;
|
dst->seq_ext.frame_rate_extension_d = p->seq_ext_head.frame_rate_extension_d;
|
|
|
dst->gop.drop_flag = p->gop_head.drop_flag;
|
dst->gop.hour = p->gop_head.hour;
|
dst->gop.minute = p->gop_head.minute;
|
dst->gop.sec = p->gop_head.sec;
|
dst->gop.frame = p->gop_head.frame;
|
dst->gop.closed_gop = p->gop_head.closed_gop;
|
dst->gop.broken_link = p->gop_head.broken_link;
|
|
|
dst->pic.temporal_reference = p->pic_head.temporal_reference;
|
dst->pic.picture_coding_type = p->pic_head.picture_coding_type;
|
dst->pic.pre_picture_coding_type = p->pic_head.pre_picture_coding_type;
|
dst->pic.vbv_delay = p->pic_head.vbv_delay;
|
dst->pic.full_pel_forward_vector = p->pic_head.full_pel_forward_vector;
|
dst->pic.forward_f_code = p->pic_head.forward_f_code;
|
dst->pic.full_pel_backward_vector = p->pic_head.full_pel_backward_vector;
|
dst->pic.backward_f_code = p->pic_head.backward_f_code;
|
dst->pic.pre_temporal_reference = p->pic_head.pre_temporal_reference;
|
|
dst->seq_disp_ext.video_format = p->seq_disp_ext_head.video_format;
|
dst->seq_disp_ext.color_description = p->seq_disp_ext_head.color_description;
|
dst->seq_disp_ext.color_primaries = p->seq_disp_ext_head.color_primaries;
|
dst->seq_disp_ext.transfer_characteristics = p->seq_disp_ext_head.transfer_characteristics;
|
dst->seq_disp_ext.matrix_coefficients = p->seq_disp_ext_head.matrix_coefficients;
|
|
memcpy(dst->pic_code_ext.f_code, p->pic_code_ext_head.f_code, 2 * 2 * sizeof(RK_S32));
|
dst->pic_code_ext.intra_dc_precision = p->pic_code_ext_head.intra_dc_precision;
|
dst->pic_code_ext.picture_structure = p->pic_code_ext_head.picture_structure;
|
dst->pic_code_ext.top_field_first = p->pic_code_ext_head.top_field_first;
|
dst->pic_code_ext.frame_pred_frame_dct = p->pic_code_ext_head.frame_pred_frame_dct;
|
dst->pic_code_ext.concealment_motion_vectors = p->pic_code_ext_head.concealment_motion_vectors;
|
dst->pic_code_ext.q_scale_type = p->pic_code_ext_head.q_scale_type;
|
dst->pic_code_ext.intra_vlc_format = p->pic_code_ext_head.intra_vlc_format;
|
dst->pic_code_ext.alternate_scan = p->pic_code_ext_head.alternate_scan;
|
dst->pic_code_ext.repeat_first_field = p->pic_code_ext_head.repeat_first_field;
|
dst->pic_code_ext.chroma_420_type = p->pic_code_ext_head.chroma_420_type;
|
dst->pic_code_ext.progressive_frame = p->pic_code_ext_head.progressive_frame;
|
dst->pic_code_ext.composite_display_flag = p->pic_code_ext_head.composite_display_flag;
|
dst->pic_code_ext.v_axis = p->pic_code_ext_head.v_axis;
|
dst->pic_code_ext.field_sequence = p->pic_code_ext_head.field_sequence;
|
dst->pic_code_ext.sub_carrier = p->pic_code_ext_head.sub_carrier;
|
dst->pic_code_ext.burst_amplitude = p->pic_code_ext_head.burst_amplitude;
|
dst->pic_code_ext.sub_carrier_phase = p->pic_code_ext_head.sub_carrier_phase;
|
|
memcpy(dst->pic_disp_ext.frame_center_horizontal_offset, p->pic_disp_ext_head.frame_center_horizontal_offset, 3 * sizeof(RK_S32));
|
memcpy(dst->pic_disp_ext.frame_center_vertical_offset, p->pic_disp_ext_head.frame_center_vertical_offset, 3 * sizeof(RK_S32));
|
|
dst->bitstream_length = p->frame_size - ((readbits >> 3) & (~7));
|
dst->bitstream_offset = ((readbits >> 3) & (~7));
|
dst->bitstream_start_bit = readbits & 0x3f;
|
dst->qp_tab = p->qp_tab_sw_buf;
|
dst->CurrPic.Index7Bits = p->frame_cur->slot_index;
|
p->cur_slot_index = p->frame_cur->slot_index;
|
|
if (p->frame_ref0->slot_index == 0xff) {
|
pbw = p->frame_cur;
|
}
|
if (p->frame_ref1->slot_index == 0xff) {
|
pfw = pbw;
|
}
|
|
for (i = 0; i < 4; i++) {
|
dst->frame_refs[i].bPicEntry = 0xff;
|
}
|
if (p->pic_head.picture_coding_type == M2VD_CODING_TYPE_B) {
|
MppFrame frame0 = NULL;
|
MppFrame frame1 = NULL;
|
dst->frame_refs[0].Index7Bits = pfw->slot_index;
|
dst->frame_refs[1].Index7Bits = pfw->slot_index;
|
dst->frame_refs[2].Index7Bits = pbw->slot_index;
|
dst->frame_refs[3].Index7Bits = pbw->slot_index;
|
mpp_buf_slot_get_prop(p->frame_slots, pfw->slot_index, SLOT_FRAME_PTR, &frame0);
|
mpp_buf_slot_get_prop(p->frame_slots, pbw->slot_index, SLOT_FRAME_PTR, &frame1);
|
error_info = mpp_frame_get_errinfo(frame0) | mpp_frame_get_errinfo(frame1);
|
} else {
|
MppFrame frame = NULL;
|
if ((p->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_FRAME) ||
|
((p->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_TOP_FIELD) && p->pic_code_ext_head.top_field_first) ||
|
((p->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_BOTTOM_FIELD) && (!p->pic_code_ext_head.top_field_first))) {
|
dst->frame_refs[0].Index7Bits = pbw->slot_index;
|
dst->frame_refs[1].Index7Bits = pbw->slot_index;
|
} else if (p->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_TOP_FIELD) {
|
dst->frame_refs[0].Index7Bits = pbw->slot_index;
|
dst->frame_refs[1].Index7Bits = p->frame_cur->slot_index;
|
} else if (p->pic_code_ext_head.picture_structure == M2VD_PIC_STRUCT_BOTTOM_FIELD) {
|
dst->frame_refs[0].Index7Bits = p->frame_cur->slot_index;
|
dst->frame_refs[1].Index7Bits = pbw->slot_index;
|
}
|
dst->frame_refs[2].Index7Bits = p->frame_cur->slot_index;
|
dst->frame_refs[3].Index7Bits = p->frame_cur->slot_index;
|
mpp_buf_slot_get_prop(p->frame_slots, pbw->slot_index, SLOT_FRAME_PTR, &frame);
|
error_info = mpp_frame_get_errinfo(frame);
|
}
|
if (p->frame_cur->picCodingType == M2VD_CODING_TYPE_I) {
|
error_info = 0;
|
}
|
dst->seq_ext_head_dec_flag = p->MPEG2_Flag;
|
{
|
MppFrame frame = NULL;
|
mpp_buf_slot_get_prop(p->frame_slots, p->cur_slot_index, SLOT_FRAME_PTR, &frame);
|
mpp_frame_set_errinfo(frame, error_info);
|
}
|
m2vd_dbg_func("FUN_O");
|
return ret;
|
}
|
|
MPP_RET m2vd_parser_parse(void *ctx, HalDecTask *in_task)
|
{
|
MPP_RET ret = MPP_OK;
|
int rev = 0;
|
M2VDContext *c = (M2VDContext *)ctx;
|
M2VDParserContext *p = (M2VDParserContext *)c->parse_ctx;
|
m2vd_dbg_func("FUN_I");
|
|
M2VD_CHK_I(in_task->valid);
|
|
in_task->valid = 0;
|
|
p->flush_dpb_eos = 0;
|
|
p->frame_size = (RK_U32)mpp_packet_get_length(in_task->input_packet);
|
|
mpp_set_bitread_ctx(p->bitread_ctx, p->bitstream_sw_buf, p->frame_size);
|
|
rev = m2vd_decode_head(p);
|
|
if (!p->mHeaderDecFlag) {
|
if (p->mExtraHeaderDecFlag &&
|
p->pic_head.picture_coding_type == M2VD_CODING_TYPE_I) {
|
p->mHeaderDecFlag = 1;
|
if (M2VD_DBG_SEC_HEADER & m2vd_debug)
|
mpp_log("[m2v]: use extra data sequence header");
|
} else {
|
if (M2VD_DBG_SEC_HEADER & m2vd_debug)
|
mpp_log("[m2v]: !mHeaderDecFlag");
|
goto __FAILED;
|
}
|
}
|
|
p->mb_width = (p->seq_head.decode_width + 15) >> 4;
|
p->mb_height = (p->seq_head.decode_height + 15) >> 4;
|
|
if (rev < M2VD_DEC_OK) {
|
if (M2VD_DBG_SEC_HEADER & m2vd_debug) {
|
mpp_log("decoder_header error rev %d", rev);
|
}
|
goto __FAILED;
|
}
|
|
if (rev == M2VD_DEC_PICHEAD_OK) {
|
if (MPP_OK != m2vd_alloc_frame(p)) {
|
mpp_err("m2vd_alloc_frame not OK");
|
goto __FAILED;
|
}
|
m2vd_convert_to_dxva(p);
|
in_task->syntax.data = (void *)p->dxva_ctx;
|
in_task->syntax.number = sizeof(M2VDDxvaParam);
|
in_task->output = p->frame_cur->slot_index;
|
p->pic_head.pre_picture_coding_type = p->pic_head.picture_coding_type;
|
|
if (p->frame_ref0->slot_index < 0x7f &&
|
(p->frame_ref0->slot_index != p->frame_cur->slot_index)) {
|
mpp_buf_slot_set_flag(p->frame_slots, p->frame_ref0->slot_index, SLOT_HAL_INPUT);
|
in_task->refer[0] = p->frame_ref0->slot_index;
|
}
|
|
if (p->frame_ref1->slot_index < 0x7f && (p->frame_ref1->slot_index != p->frame_cur->slot_index)) {
|
mpp_buf_slot_set_flag(p->frame_slots, p->frame_ref1->slot_index, SLOT_HAL_INPUT);
|
in_task->refer[1] = p->frame_ref1->slot_index;
|
}
|
|
MppFrame frame = NULL;
|
mpp_buf_slot_get_prop(p->frame_slots, p->cur_slot_index, SLOT_FRAME_PTR, &frame);
|
mpp_frame_set_poc(frame, p->pic_head.temporal_reference);
|
|
if (p->dxva_ctx->seq_disp_ext.color_description) {
|
mpp_frame_set_color_primaries(frame, p->dxva_ctx->seq_disp_ext.color_primaries);
|
mpp_frame_set_color_trc(frame, p->dxva_ctx->seq_disp_ext.transfer_characteristics);
|
mpp_frame_set_colorspace(frame, p->dxva_ctx->seq_disp_ext.matrix_coefficients);
|
} else {
|
mpp_frame_set_color_primaries(frame, MPP_FRAME_PRI_UNSPECIFIED);
|
mpp_frame_set_color_trc(frame, MPP_FRAME_TRC_UNSPECIFIED);
|
mpp_frame_set_colorspace(frame, MPP_FRAME_SPC_UNSPECIFIED);
|
}
|
|
in_task->valid = 1;
|
m2v_update_ref_frame(p);
|
}
|
|
__FAILED:
|
if (p->eos) {
|
m2vd_parser_flush(ctx);
|
}
|
|
m2vd_dbg_func("FUN_O");
|
|
return ret;
|
}
|
|
MPP_RET m2vd_parser_callback(void *ctx, void *errinfo)
|
{
|
MPP_RET ret = MPP_OK;
|
M2VDContext *c = (M2VDContext *)ctx;
|
M2VDParserContext *p = (M2VDParserContext *)c->parse_ctx;
|
MppFrame frame = NULL;
|
(void)errinfo;
|
|
m2vd_dbg_func("FUN_I");
|
mpp_buf_slot_get_prop(p->frame_slots, p->cur_slot_index, SLOT_FRAME_PTR, &frame);
|
mpp_frame_set_errinfo(frame, 1);
|
m2vd_dbg_func("FUN_O");
|
|
return ret;
|
}
|
