/*
*
* 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 "mpg4d_api"

#include <string.h>

#include "mpp_mem.h"
#include "mpp_debug.h"
#include "mpp_common.h"

#include "mpg4d_api.h"
#include "mpg4d_parser.h"
#include "mpp_packet_impl.h"
#include "mpp_dec_cb_param.h"

#define MPG4D_INIT_STREAM_SIZE      SZ_64K

typedef struct {
    // parameter interact with mpp_dec
    MppBufSlots     frame_slots;
    MppBufSlots     packet_slots;
    RK_S32          task_count;
    RK_U8           *stream;
    size_t          stream_size;
    size_t          left_length;
    MppPacket       task_pkt;
    RK_U32          got_eos;

    // runtime parameter
    RK_U32          need_split;
    RK_U32          frame_count;
    RK_U32          internal_pts;

    // parser context
    Mpg4dParser     parser;
} Mpg4dCtx;

static MPP_RET mpg4d_init(void *dec, ParserCfg *cfg)
{
    Mpg4dParser parser = NULL;
    MppPacket task_pkt = NULL;
    Mpg4dCtx *p;
    MPP_RET ret;
    RK_U8 *stream;
    size_t stream_size = MPG4D_INIT_STREAM_SIZE;

    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(RK_U8, stream_size);
    if (NULL == stream) {
        mpp_err_f("failed to malloc stream buffer size %d\n", stream_size);
        return MPP_ERR_MALLOC;
    }

    ret = mpp_packet_init(&task_pkt, stream, stream_size);
    if (ret) {
        mpp_err_f("failed to create mpp_packet for task\n");
        goto ERR_RET;
    }

    // reset task packet length to zero
    // NOTE: set length must after set pos
    mpp_packet_set_pos(task_pkt, stream);
    mpp_packet_set_length(task_pkt, 0);

    ret = mpp_mpg4_parser_init(&parser, cfg->frame_slots);
    if (ret) {
        mpp_err_f("failed to init parser\n");
        goto ERR_RET;
    }

    p = (Mpg4dCtx *)dec;
    p->frame_slots  = cfg->frame_slots;
    p->packet_slots = cfg->packet_slots;
    p->task_count   = 2;
#ifdef __ANDROID__
    p->need_split   = 1;//cfg->need_split;
#else
    p->need_split   = cfg->cfg->base.split_parse;
#endif
    p->internal_pts = cfg->cfg->base.internal_pts;
    p->stream       = stream;
    p->stream_size  = stream_size;
    p->task_pkt     = task_pkt;
    p->parser       = parser;
    p->left_length  = 0;
    return MPP_OK;
ERR_RET:
    if (task_pkt) {
        mpp_packet_deinit(&task_pkt);
    }
    if (stream) {
        mpp_free(stream);
        stream = NULL;
    }
    return ret;
}

static MPP_RET mpg4d_deinit(void *dec)
{
    Mpg4dCtx *p;
    if (NULL == dec) {
        mpp_err_f("found NULL intput\n");
        return MPP_ERR_NULL_PTR;
    }

    p = (Mpg4dCtx *)dec;
    if (p->parser) {
        mpp_mpg4_parser_deinit(p->parser);
        p->parser = NULL;
    }

    if (p->task_pkt) {
        mpp_packet_deinit(&p->task_pkt);
    }

    if (p->stream) {
        mpp_free(p->stream);
        p->stream = NULL;
    }
    return MPP_OK;
}

static MPP_RET mpg4d_reset(void *dec)
{
    if (NULL == dec) {
        mpp_err_f("found NULL intput\n");
        return MPP_ERR_NULL_PTR;
    }

    Mpg4dCtx *p = (Mpg4dCtx *)dec;
    p->left_length  = 0;
    p->got_eos = 0;
    mpp_packet_set_length(p->task_pkt, 0);
    mpp_packet_set_flag(p->task_pkt, 0);

    return mpp_mpg4_parser_reset(p->parser);
}

static MPP_RET mpg4d_flush(void *dec)
{
    if (NULL == dec) {
        mpp_err_f("found NULL intput\n");
        return MPP_ERR_NULL_PTR;
    }

    Mpg4dCtx *p = (Mpg4dCtx *)dec;
    return mpp_mpg4_parser_flush(p->parser);
}

static MPP_RET mpg4d_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;
}

static MPP_RET mpg4d_prepare(void *dec, MppPacket pkt, HalDecTask *task)
{
    Mpg4dCtx *p;
    RK_U8 *pos;
    size_t length;
    RK_U32 eos;

    if (NULL == dec || NULL == pkt || NULL == task) {
        mpp_err_f("found NULL intput dec %p pkt %p task %p\n", dec, pkt, task);
        return MPP_ERR_NULL_PTR;
    }

    task->valid = 0;
    p = (Mpg4dCtx *)dec;
    pos     = mpp_packet_get_pos(pkt);
    length  = mpp_packet_get_length(pkt);
    eos     = mpp_packet_get_eos(pkt);

    if (p->got_eos) {
        mpp_log_f("has got eos packet.\n");
        mpp_packet_set_length(pkt, 0);
        return MPP_OK;
    }

    if (NULL == p->stream) {
        mpp_err("failed to malloc task buffer for hardware with size %d\n", length);
        return MPP_ERR_UNKNOW;
    }
    mpp_packet_set_length(p->task_pkt, p->left_length);

    /*
    * Check have enough buffer to store stream
    * NOTE: total length is the left size plus the new incoming
    *       packet length.
    */
    size_t total_length = MPP_ALIGN(p->left_length + length, 16) + 64; // add extra 64 bytes in tails

    if (total_length > p->stream_size) {
        RK_U8 *dst = NULL;
        do {
            p->stream_size <<= 1;
        } while (total_length > p->stream_size);

        dst = mpp_malloc_size(RK_U8, p->stream_size);
        mpp_assert(dst);
        // NOTE: copy remaining stream to new buffer
        if (p->left_length > 0) {
            memcpy(dst, p->stream, p->left_length);
        }
        mpp_free(p->stream);
        p->stream = dst;
        mpp_packet_set_data(p->task_pkt, p->stream);
        mpp_packet_set_size(p->task_pkt, p->stream_size);
    }

    if (!p->need_split ||
        (mpp_packet_get_flag(pkt) & MPP_PACKET_FLAG_EXTRA_DATA)) {
        p->got_eos = eos;
        task->flags.eos = eos;
        // NOTE: empty eos packet
        if (eos && !length) {
            mpg4d_flush(dec);
            return MPP_OK;
        }
        /*
         * Copy packet mode:
         * Decoder's user will insure each packet is one frame for process
         * Parser will just copy packet to the beginning of stream buffer
         */
        memcpy(p->stream, pos, length);
        mpp_packet_set_pos(p->task_pkt, p->stream);
        mpp_packet_set_length(p->task_pkt, length);
        mpp_packet_set_pts(p->task_pkt, mpp_packet_get_pts(pkt));
        // set input packet length to 0 here
        // indicate that the input packet has been all consumed
        mpp_packet_set_pos(pkt, pos + length);
        mpp_packet_set_length(pkt, 0);
        /* this step will enable the task and goto parse stage */
        task->valid = 1;
    } else {
        /*
         * Split packet mode:
         * Input packet can be any length and no need to be bound of on frame
         * Parser will do split frame operation to find the beginning and end of one frame
         */
        if (MPP_OK == mpp_mpg4_parser_split(p->parser, p->task_pkt, pkt)) {
            p->left_length = 0;
            task->valid = 1;
        } else {
            task->valid = 0;
            p->left_length = mpp_packet_get_length(p->task_pkt);
        }
        p->got_eos = mpp_packet_get_eos(p->task_pkt);
        task->flags.eos = p->got_eos;
    }
    task->input_packet = p->task_pkt;

    return MPP_OK;
}

static MPP_RET mpg4d_parse(void *dec, HalDecTask *task)
{
    MPP_RET ret;
    Mpg4dCtx *p;

    if (NULL == dec || NULL == task) {
        mpp_err_f("found NULL intput dec %p task %p\n", dec, task);
        return MPP_ERR_NULL_PTR;
    }
    p = (Mpg4dCtx *)dec;
    ret = mpp_mpg4_parser_decode(p->parser, task->input_packet);
    if (ret) {
        // found error on decoding drop this task and clear remaining length
        task->valid  = 0;
        task->output = -1;
        mpp_packet_set_length(task->input_packet, 0);

        return MPP_NOK;
    }

    mpp_mpg4_parser_setup_syntax(p->parser, &task->syntax);
    mpp_mpg4_parser_setup_hal_output(p->parser, &task->output);
    mpp_mpg4_parser_setup_refer(p->parser, task->refer, MAX_DEC_REF_NUM);
    mpp_mpg4_parser_update_dpb(p->parser);

    if (p->got_eos) {
        task->flags.eos = 1;
        mpg4d_flush(dec);
        return MPP_OK;
    }

    p->frame_count++;

    return MPP_OK;
}

static MPP_RET mpg4d_callback(void *dec, void *err_info)
{
    Mpg4dCtx *p_Dec = (Mpg4dCtx *)dec;
    DecCbHalDone *ctx = (DecCbHalDone *)err_info;

    if (NULL == dec || NULL == err_info) {
        mpp_err_f("found NULL input dec %p err_info %p\n", dec, err_info);
        return MPP_ERR_NULL_PTR;
    }

    MppFrame mframe = NULL;
    HalDecTask *task_dec = (HalDecTask *)ctx->task;

    mpp_buf_slot_get_prop(p_Dec->frame_slots, task_dec->output, SLOT_FRAME_PTR, &mframe);
    if (mframe) {
        RK_U32 task_err = task_dec->flags.parse_err || task_dec->flags.ref_err;
        if (ctx->hard_err || task_err) {
            mpp_frame_set_errinfo(mframe, MPP_FRAME_ERR_UNKNOW);
            mpp_log_f("[CALLBACK] g_no=%d, out_idx=%d, dpberr=%d, harderr=%d, ref_flag=%d, errinfo=%d, discard=%d\n",
                      p_Dec->frame_count, task_dec->output, task_err, ctx->hard_err, task_dec->flags.used_for_ref,
                      mpp_frame_get_errinfo(mframe), mpp_frame_get_discard(mframe));
        }
    }
    return MPP_OK;
}

const ParserApi api_mpg4d_parser = {
    .name = "api_mpg4d_parser",
    .coding = MPP_VIDEO_CodingMPEG4,
    .ctx_size = sizeof(Mpg4dCtx),
    .flag = 0,
    .init = mpg4d_init,
    .deinit = mpg4d_deinit,
    .prepare = mpg4d_prepare,
    .parse = mpg4d_parse,
    .reset = mpg4d_reset,
    .flush = mpg4d_flush,
    .control = mpg4d_control,
    .callback = mpg4d_callback,
};