/*
|
*
|
* 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 "dummy_dec_api"
|
|
#include <string.h>
|
|
#include "mpp_mem.h"
|
#include "mpp_debug.h"
|
#include "mpp_common.h"
|
|
#include "dummy_dec_api.h"
|
|
#define DUMMY_DEC_FRAME_WIDTH 1280
|
#define DUMMY_DEC_FRAME_HEIGHT 720
|
|
#define DUMMY_DEC_FRAME_NEW_WIDTH 1920
|
#define DUMMY_DEC_FRAME_NEW_HEIGHT 1088
|
|
#define DUMMY_DEC_FRAME_SIZE SZ_1M
|
#define DUMMY_DEC_FRAME_COUNT 16
|
#define DUMMY_DEC_REF_COUNT 2
|
|
typedef struct DummyDec_t {
|
MppBufSlots frame_slots;
|
MppBufSlots packet_slots;
|
RK_S32 task_count;
|
void *stream;
|
size_t stream_size;
|
MppPacket task_pkt;
|
|
RK_S64 task_pts;
|
RK_U32 task_eos;
|
|
RK_U32 slots_inited;
|
RK_U32 frame_count;
|
RK_S32 prev_index;
|
RK_S32 slot_index[DUMMY_DEC_REF_COUNT];
|
} DummyDec;
|
|
MPP_RET dummy_dec_init(void *dec, ParserCfg *cfg)
|
{
|
DummyDec *p;
|
RK_S32 i;
|
void *stream;
|
size_t stream_size = SZ_512K;
|
MppPacket task_pkt;
|
|
if (NULL == dec) {
|
mpp_err_f("found NULL intput dec %p cfg %p\n", dec, cfg);
|
return MPP_ERR_NULL_PTR;
|
}
|
|
stream = mpp_malloc_size(void, stream_size);
|
if (NULL == stream) {
|
mpp_err_f("failed to malloc stream buffer size %d\n", stream_size);
|
return MPP_ERR_MALLOC;
|
}
|
|
mpp_packet_init(&task_pkt, stream, stream_size);
|
if (NULL == task_pkt) {
|
mpp_err_f("failed to create mpp_packet for task\n");
|
return MPP_ERR_UNKNOW;
|
}
|
|
p = (DummyDec *)dec;
|
p->frame_slots = cfg->frame_slots;
|
p->packet_slots = cfg->packet_slots;
|
p->task_count = 2;
|
p->stream = stream;
|
p->stream_size = stream_size;
|
p->task_pkt = task_pkt;
|
for (i = 0; i < DUMMY_DEC_REF_COUNT; i++) {
|
p->slot_index[i] = -1;
|
}
|
return MPP_OK;
|
}
|
|
MPP_RET dummy_dec_deinit(void *dec)
|
{
|
DummyDec *p;
|
if (NULL == dec) {
|
mpp_err_f("found NULL intput\n");
|
return MPP_ERR_NULL_PTR;
|
}
|
|
p = (DummyDec *)dec;
|
if (p->task_pkt)
|
mpp_packet_deinit(&p->task_pkt);
|
if (p->stream)
|
mpp_free(p->stream);
|
return MPP_OK;
|
}
|
|
MPP_RET dummy_dec_reset(void *dec)
|
{
|
if (NULL == dec) {
|
mpp_err_f("found NULL intput\n");
|
return MPP_ERR_NULL_PTR;
|
}
|
return MPP_OK;
|
}
|
|
|
MPP_RET dummy_dec_flush(void *dec)
|
{
|
if (NULL == dec) {
|
mpp_err_f("found NULL intput\n");
|
return MPP_ERR_NULL_PTR;
|
}
|
return MPP_OK;
|
}
|
|
|
MPP_RET dummy_dec_control(void *dec, MpiCmd cmd_type, void *param)
|
{
|
if (NULL == dec) {
|
mpp_err_f("found NULL intput\n");
|
return MPP_ERR_NULL_PTR;
|
}
|
(void)cmd_type;
|
(void)param;
|
return MPP_OK;
|
}
|
|
MPP_RET dummy_dec_prepare(void *dec, MppPacket pkt, HalDecTask *task)
|
{
|
DummyDec *p;
|
RK_U8 *data;
|
size_t length;
|
|
if (NULL == dec) {
|
mpp_err_f("found NULL intput\n");
|
return MPP_ERR_NULL_PTR;
|
}
|
|
p = (DummyDec *)dec;
|
|
/*********************************************************************
|
* do packet prepare here
|
* including connet nals into a big buffer, setup packet for task copy
|
* pts/eos record
|
*********************************************************************/
|
p->task_pts = mpp_packet_get_pts(pkt);
|
p->task_eos = mpp_packet_get_eos(pkt);
|
|
// set pos to indicate that buffer is done
|
data = mpp_packet_get_data(pkt);
|
length = mpp_packet_get_length(pkt);
|
if (length > p->stream_size) {
|
p->stream = mpp_realloc(p->stream, RK_U8, length);
|
mpp_packet_set_data(p->task_pkt, p->stream);
|
p->stream_size = length;
|
}
|
if (p->stream) {
|
memcpy(p->stream, data, length);
|
mpp_packet_set_length(p->task_pkt, length);
|
} else {
|
mpp_err("failed to found task buffer for hardware\n");
|
return MPP_ERR_UNKNOW;
|
}
|
mpp_packet_set_pos(pkt, data + length);
|
|
/*
|
* this step will enable the task and goto parse stage
|
*/
|
task->input_packet = p->task_pkt;
|
task->flags.eos = p->task_eos;
|
task->valid = 1;
|
return MPP_OK;
|
}
|
MPP_RET dummy_dec_parse(void *dec, HalDecTask *task)
|
{
|
DummyDec *p;
|
RK_S32 output;
|
MppFrame frame = NULL;
|
RK_U32 frame_count;
|
MppBufSlots slots;
|
RK_S32 i;
|
RK_U32 width, height;
|
|
if (NULL == dec) {
|
mpp_err_f("found NULL intput\n");
|
return MPP_ERR_NULL_PTR;
|
}
|
p = (DummyDec *)dec;
|
|
slots = p->frame_slots;
|
frame_count = p->frame_count;
|
|
width = DUMMY_DEC_FRAME_WIDTH;
|
height = DUMMY_DEC_FRAME_HEIGHT;
|
|
mpp_frame_init(&frame);
|
|
if (!p->slots_inited) {
|
mpp_buf_slot_setup(slots, DUMMY_DEC_FRAME_COUNT);
|
p->slots_inited = 1;
|
} else if (frame_count >= 2) {
|
// do info change test
|
width = DUMMY_DEC_FRAME_NEW_WIDTH;
|
height = DUMMY_DEC_FRAME_NEW_HEIGHT;
|
}
|
|
mpp_frame_set_width(frame, width);
|
mpp_frame_set_height(frame, height);
|
mpp_frame_set_hor_stride(frame, MPP_ALIGN(width, 16));
|
mpp_frame_set_ver_stride(frame, MPP_ALIGN(height, 16));
|
|
/*
|
* set slots information
|
* 1. output index MUST be set
|
* 2. get unused index for output if needed
|
* 3. set output index as hal_input
|
* 4. set frame information to output index
|
* 5. if one frame can be display, it SHOULD be enqueued to display queue
|
*/
|
mpp_buf_slot_get_unused(slots, &output);
|
mpp_buf_slot_set_flag(slots, output, SLOT_HAL_OUTPUT);
|
task->output = output;
|
|
mpp_frame_set_pts(frame, p->task_pts);
|
mpp_buf_slot_set_prop(slots, output, SLOT_FRAME, frame);
|
mpp_frame_deinit(&frame);
|
mpp_assert(NULL == frame);
|
|
/*
|
* setup output task
|
* 1. valid flag MUST be set if need hardware to run once
|
* 2. set output slot index
|
* 3. set reference slot index
|
*/
|
memset(&task->refer, -1, sizeof(task->refer));
|
for (i = 0; i < DUMMY_DEC_REF_COUNT; i++) {
|
RK_S32 index = p->slot_index[i];
|
if (index >= 0) {
|
task->refer[i] = index;
|
mpp_buf_slot_set_flag(slots, index, SLOT_HAL_INPUT);
|
mpp_buf_slot_set_flag(slots, index, SLOT_CODEC_USE);
|
}
|
}
|
|
/*
|
* update dpb status assuming that hw has decoded the frame
|
*/
|
mpp_buf_slot_set_flag(slots, output, SLOT_QUEUE_USE);
|
mpp_buf_slot_enqueue(slots, output, QUEUE_DISPLAY);
|
|
// add new reference buffer
|
if (p->task_eos) {
|
for (i = 0; i < DUMMY_DEC_REF_COUNT; i++) {
|
mpp_buf_slot_clr_flag(slots, p->slot_index[i], SLOT_CODEC_USE);
|
p->slot_index[i] = -1;
|
}
|
} else {
|
// clear unreference buffer
|
RK_U32 replace_index = frame_count & 1;
|
if (p->slot_index[replace_index] >= 0)
|
mpp_buf_slot_clr_flag(slots, p->slot_index[replace_index], SLOT_CODEC_USE);
|
|
p->slot_index[replace_index] = output;
|
mpp_buf_slot_set_flag(slots, output, SLOT_CODEC_USE);
|
}
|
|
p->frame_count = ++frame_count;
|
|
return MPP_OK;
|
}
|
|
MPP_RET dummy_dec_callback(void *dec, void *err_info)
|
{
|
(void)dec;
|
(void)err_info;
|
return MPP_OK;
|
}
|
const ParserApi dummy_dec_parser = {
|
.name = "dummy_dec_parser",
|
.coding = MPP_VIDEO_CodingUnused,
|
.ctx_size = sizeof(DummyDec),
|
.flag = 0,
|
.init = dummy_dec_init,
|
.deinit = dummy_dec_deinit,
|
.prepare = dummy_dec_prepare,
|
.parse = dummy_dec_parse,
|
.reset = dummy_dec_reset,
|
.flush = dummy_dec_flush,
|
.control = dummy_dec_control,
|
.callback = dummy_dec_callback,
|
};
|
