/*
 * Copyright (C) 2019 Rockchip Electronics Co., Ltd.
 * author: Zhihua Wang, hogan.wang@rock-chips.com
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL), available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#include "vpu_decode.h"
#include <assert.h>
#include <dlfcn.h>
#include <errno.h>

int vpu_decode_jpeg_init(struct vpu_decode* decode, int width, int height)
{
    int ret;
    decode->in_width = width;
    decode->in_height = height;

    ret = mpp_buffer_group_get_internal(&decode->memGroup, MPP_BUFFER_TYPE_ION);
    if (MPP_OK != ret) {
        printf("memGroup mpp_buffer_group_get failed\n");
        return ret;
    }

    ret = mpp_create(&decode->mpp_ctx, &decode->mpi);
    if (MPP_OK != ret) {
        printf("mpp_create failed\n");
        return -1;
    }

    ret = mpp_init(decode->mpp_ctx, MPP_CTX_DEC, MPP_VIDEO_CodingMJPEG);
    if (MPP_OK != ret) {
        printf("mpp_init failed\n");
        return -1;
    }

    MppApi* mpi = decode->mpi;
    MppCtx mpp_ctx = decode->mpp_ctx;
    MppFrame frame;
    ret = mpp_frame_init(&frame);
    if (!frame || (MPP_OK != ret)) {
        printf("failed to init mpp frame!");
        return MPP_ERR_NOMEM;
    }

    mpp_frame_set_fmt(frame, MPP_FMT_YUV420SP);
    mpp_frame_set_width(frame, decode->in_width);
    mpp_frame_set_height(frame, decode->in_height);
    mpp_frame_set_hor_stride(frame, MPP_ALIGN(decode->in_width, 16));
    mpp_frame_set_ver_stride(frame, MPP_ALIGN(decode->in_height, 16));

    ret = mpi->control(mpp_ctx, MPP_DEC_SET_FRAME_INFO, (MppParam)frame);
    mpp_frame_deinit(&frame);

    return 0;
}

int vpu_decode_jpeg_doing(struct vpu_decode* decode, void* in_data, RK_S32 in_size,
                          int out_fd, void* out_data)
{
    MPP_RET ret = MPP_OK;
    MppTask task = NULL;

    decode->pkt_size = in_size;
    if (decode->pkt_size <= 0) {
        printf("invalid input size %d\n", decode->pkt_size);
        return MPP_ERR_UNKNOW;
    }

    if (NULL == in_data) {
        ret = MPP_ERR_NULL_PTR;
        goto DECODE_OUT;
    }

    /* try import input buffer and output buffer */
    RK_U32 width = decode->in_width;
    RK_U32 height = decode->in_height;
    RK_U32 hor_stride = MPP_ALIGN(width, 16);
    RK_U32 ver_stride = MPP_ALIGN(height, 16);
    decode->hor_stride = hor_stride;
    decode->ver_stride = ver_stride;
    MppFrame frame = NULL;
    MppPacket packet = NULL;
    MppBuffer str_buf = NULL; /* input */
    MppBuffer pic_buf = NULL; /* output */
    MppCtx mpp_ctx = decode->mpp_ctx;
    MppApi* mpi = decode->mpi;

    ret = mpp_frame_init(&frame);
    if (MPP_OK != ret) {
        printf("mpp_frame_init failed\n");
        goto DECODE_OUT;
    }

    ret = mpp_buffer_get(decode->memGroup, &str_buf, decode->pkt_size);
    if (ret) {
        printf("allocate input picture buffer failed\n");
        goto DECODE_OUT;
    }
    memcpy((RK_U8*)mpp_buffer_get_ptr(str_buf), in_data, decode->pkt_size);

    if (out_fd > 0) {
        MppBufferInfo outputCommit;

        memset(&outputCommit, 0, sizeof(outputCommit));
        /* in order to avoid interface change use space in output to transmit
         * information */
        outputCommit.type = MPP_BUFFER_TYPE_ION;
        outputCommit.fd = out_fd;
        outputCommit.size = hor_stride * ver_stride * 2;
        outputCommit.ptr = out_data;

        ret = mpp_buffer_import(&pic_buf, &outputCommit);
        if (ret) {
            printf("import output stream buffer failed\n");
            goto DECODE_OUT;
        }
    } else {
        ret =
            mpp_buffer_get(decode->memGroup, &pic_buf, hor_stride * ver_stride * 2);
        if (ret) {
            printf("allocate output stream buffer failed\n");
            goto DECODE_OUT;
        }
    }

    mpp_packet_init_with_buffer(&packet, str_buf); /* input */
    mpp_frame_set_buffer(frame, pic_buf);          /* output */
    mpp_packet_set_length(packet, decode->pkt_size);

    // printf("mpp import input fd %d output fd %d\n",
    //        mpp_buffer_get_fd(str_buf), mpp_buffer_get_fd(pic_buf));

    ret = mpi->poll(mpp_ctx, MPP_PORT_INPUT, MPP_POLL_BLOCK);
    if (ret) {
        printf("mpp input poll failed\n");
        goto DECODE_OUT;
    }

    ret = mpi->dequeue(mpp_ctx, MPP_PORT_INPUT, &task); /* input queue */
    if (ret) {
        printf("mpp task input dequeue failed\n");
        goto DECODE_OUT;
    }

    assert(task);

    mpp_task_meta_set_packet(task, KEY_INPUT_PACKET, packet);
    mpp_task_meta_set_frame(task, KEY_OUTPUT_FRAME, frame);

    ret = mpi->enqueue(mpp_ctx, MPP_PORT_INPUT, task); /* input queue */
    if (ret) {
        printf("mpp task input enqueue failed\n");
        goto DECODE_OUT;
    }

    /* poll and wait here */
    ret = mpi->poll(mpp_ctx, MPP_PORT_OUTPUT, MPP_POLL_BLOCK);
    if (ret) {
        printf("mpp output poll failed\n");
        goto DECODE_OUT;
    }

    ret = mpi->dequeue(mpp_ctx, MPP_PORT_OUTPUT, &task); /* output queue */
    if (ret) {
        printf("mpp task output dequeue failed\n");
        goto DECODE_OUT;
    }

    assert(task);

    if (task) {
        RK_U32 err_info = 0;
        MppFrame frame_out = NULL;
        decode->fmt = MPP_FMT_YUV420SP;

        mpp_task_meta_get_frame(task, KEY_OUTPUT_FRAME, &frame_out);
        assert(frame_out == frame);

        err_info = mpp_frame_get_errinfo(frame_out);
        if (!err_info) {
            decode->fmt = mpp_frame_get_fmt(frame_out);
            if (MPP_FMT_YUV422SP != decode->fmt && MPP_FMT_YUV420SP != decode->fmt)
                printf("No support USB JPEG decode format!\n");
        }

        ret = mpi->enqueue(mpp_ctx, MPP_PORT_OUTPUT, task);
        if (ret) {
            printf("mpp task output enqueue failed\n");
            goto DECODE_OUT;
        }
        task = NULL;

        if (err_info)
            ret = MPP_NOK;
        else if (MPP_FMT_YUV422SP != decode->fmt && MPP_FMT_YUV420SP != decode->fmt)
            ret = MPP_NOK;
    }

DECODE_OUT:
    if (str_buf) {
        mpp_buffer_put(str_buf);
        str_buf = NULL;
    }

    if (pic_buf) {
        mpp_buffer_put(pic_buf);
        pic_buf = NULL;
    }

    if (frame)
        mpp_frame_deinit(&frame);

    if (packet)
        mpp_packet_deinit(&packet);

    return ret;
}

int vpu_decode_jpeg_done(struct vpu_decode* decode)
{
    MPP_RET ret = MPP_OK;
    ret = mpp_destroy(decode->mpp_ctx);
    if (ret != MPP_OK) {
        printf("something wrong with mpp_destroy! ret:%d\n", ret);
    }

    if (decode->memGroup) {
        mpp_buffer_group_put(decode->memGroup);
        decode->memGroup = NULL;
    }

    return ret;
}