/*
|
*
|
* 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 "vp9d_api"
|
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
|
#include "mpp_mem.h"
|
#include "mpp_packet_impl.h"
|
|
#include "vp9d_codec.h"
|
#include "vp9d_parser.h"
|
#include "vp9d_api.h"
|
|
/*!
|
***********************************************************************
|
* \brief
|
* alloc all buffer
|
***********************************************************************
|
*/
|
|
MPP_RET vp9d_init(void *ctx, ParserCfg *init)
|
{
|
MPP_RET ret = MPP_OK;
|
RK_U8 *buf = NULL;
|
RK_S32 size = SZ_512K;
|
Vp9CodecContext *vp9_ctx = (Vp9CodecContext *)ctx;
|
|
if (!vp9_ctx || !init) {
|
mpp_err("vp9d init fail");
|
return MPP_ERR_NULL_PTR;
|
}
|
|
if ((ret = vp9d_parser_init(vp9_ctx, init)) != MPP_OK)
|
goto _err_exit;
|
|
if ((ret = vp9d_split_init(vp9_ctx)) != MPP_OK)
|
goto _err_exit;
|
|
buf = mpp_malloc(RK_U8, size);
|
if (!buf) {
|
mpp_err("vp9 init malloc stream buffer fail");
|
ret = MPP_ERR_NOMEM;
|
goto _err_exit;
|
}
|
|
if ((ret = mpp_packet_init(&vp9_ctx->pkt, (void *)buf, size)) != MPP_OK)
|
goto _err_exit;
|
|
return ret;
|
|
_err_exit:
|
vp9d_deinit(vp9_ctx);
|
return ret;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* free all buffer
|
***********************************************************************
|
*/
|
MPP_RET vp9d_deinit(void *ctx)
|
{
|
RK_U8 *buf = NULL;
|
Vp9CodecContext *vp9_ctx = (Vp9CodecContext *)ctx;
|
|
if (vp9_ctx) {
|
vp9d_parser_deinit(vp9_ctx);
|
vp9d_split_deinit(vp9_ctx);
|
if (vp9_ctx->pkt) {
|
buf = mpp_packet_get_data(vp9_ctx->pkt);
|
MPP_FREE(buf);
|
mpp_packet_deinit(&vp9_ctx->pkt);
|
}
|
}
|
|
return MPP_OK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* reset
|
***********************************************************************
|
*/
|
MPP_RET vp9d_reset(void *ctx)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
|
Vp9CodecContext *vp9_ctx = (Vp9CodecContext *)ctx;
|
vp9d_paser_reset(vp9_ctx);
|
return ret = MPP_OK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* flush
|
***********************************************************************
|
*/
|
MPP_RET vp9d_flush(void *ctx)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
|
(void)ctx;
|
return ret = MPP_OK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* prepare
|
***********************************************************************
|
*/
|
MPP_RET vp9d_prepare(void *ctx, MppPacket pkt, HalDecTask *task)
|
{
|
MPP_RET ret = MPP_OK;
|
Vp9CodecContext *vp9_ctx = (Vp9CodecContext *)ctx;
|
SplitContext_t *ps = (SplitContext_t *)vp9_ctx->priv_data2;
|
RK_S64 pts = -1;
|
RK_S64 dts = -1;
|
RK_U8 *buf = NULL;
|
RK_S32 length = 0;
|
RK_U8 *out_data = NULL;
|
RK_S32 out_size = -1;
|
RK_S32 consumed = 0;
|
RK_U8 *pos = NULL;
|
task->valid = -1;
|
|
pts = mpp_packet_get_pts(pkt);
|
dts = mpp_packet_get_dts(pkt);
|
vp9_ctx->eos = mpp_packet_get_eos(pkt);
|
buf = pos = mpp_packet_get_pos(pkt);
|
length = (RK_S32)mpp_packet_get_length(pkt);
|
|
consumed = vp9d_split_frame(ps, &out_data, &out_size, buf, length);
|
pos += (consumed >= 0) ? consumed : length;
|
|
mpp_packet_set_pos(pkt, pos);
|
vp9d_dbg(VP9D_DBG_STRMIN, "pkt_len=%d, pts=%lld\n", length, pts);
|
if (out_size > 0) {
|
vp9d_get_frame_stream(vp9_ctx, out_data, out_size);
|
task->input_packet = vp9_ctx->pkt;
|
task->valid = 1;
|
mpp_packet_set_pts(vp9_ctx->pkt, pts);
|
mpp_packet_set_dts(vp9_ctx->pkt, dts);
|
task->flags.eos = vp9_ctx->eos;
|
} else {
|
task->valid = 0;
|
task->flags.eos = vp9_ctx->eos;
|
}
|
|
(void)pts;
|
(void)dts;
|
(void)task;
|
return ret = MPP_OK;
|
}
|
|
|
/*!
|
***********************************************************************
|
* \brief
|
* parser
|
***********************************************************************
|
*/
|
MPP_RET vp9d_parse(void *ctx, HalDecTask *in_task)
|
{
|
Vp9CodecContext *vp9_ctx = (Vp9CodecContext *)ctx;
|
MPP_RET ret = MPP_OK;
|
vp9_parser_frame(vp9_ctx, in_task);
|
|
return ret;
|
}
|
/*!
|
***********************************************************************
|
* \brief
|
* callback
|
***********************************************************************
|
*/
|
MPP_RET vp9d_callback(void *decoder, void *info)
|
{
|
MPP_RET ret = MPP_ERR_UNKNOW;
|
Vp9CodecContext *vp9_ctx = (Vp9CodecContext *)decoder;
|
vp9_parser_update(vp9_ctx, info);
|
|
return ret = MPP_OK;
|
}
|
|
/*!
|
***********************************************************************
|
* \brief
|
* api struct interface
|
***********************************************************************
|
*/
|
|
const ParserApi api_vp9d_parser = {
|
.name = "vp9d_parse",
|
.coding = MPP_VIDEO_CodingVP9,
|
.ctx_size = sizeof(Vp9CodecContext),
|
.flag = 0,
|
.init = vp9d_init,
|
.deinit = vp9d_deinit,
|
.prepare = vp9d_prepare,
|
.parse = vp9d_parse,
|
.reset = vp9d_reset,
|
.flush = vp9d_flush,
|
.control = NULL,
|
.callback = vp9d_callback,
|
};
|
