/*
 * 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_encode.h"
#include <dlfcn.h>
#include <errno.h>
#include <assert.h>

int vpu_encode_jpeg_init(struct vpu_encode* encode,
        int width,
        int height,
        int quant,
        MppFrameFormat format)
{
    MPP_RET ret = MPP_OK;
    MppEncCfg cfg;
    MppCodingType type = MPP_VIDEO_CodingMJPEG;
    MppFrameFormat fmt = format;
    memset(encode, 0, sizeof(*encode));
    encode->width = width;
    encode->height = height;
    encode->enc_out_data = NULL;
    encode->enc_out_length = 0;

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

    MppApi* mpi = encode->mpi;
    MppCtx mpp_ctx = encode->mpp_ctx;
    ret = mpp_init(mpp_ctx, MPP_CTX_ENC, type);
    if (MPP_OK != ret) {
        printf("mpp_init failed\n");
        return -1;
    }

    ret = mpp_enc_cfg_init(&cfg);
    if (ret || !cfg) {
        printf("mpp_enc_cfg_init failed ret %d\n", ret);
        return -1;
    }

    mpp_enc_cfg_set_s32(cfg, "prep:width", width);
    mpp_enc_cfg_set_s32(cfg, "prep:height", height);
    mpp_enc_cfg_set_s32(cfg, "prep:hor_stride", width);
    mpp_enc_cfg_set_s32(cfg, "prep:ver_stride", height);
    mpp_enc_cfg_set_s32(cfg, "prep:format", fmt);

    mpp_enc_cfg_set_s32(cfg, "rc:mode", MPP_ENC_RC_MODE_FIXQP);

    mpp_enc_cfg_set_s32(cfg, "jpeg:quant", quant); /* range 0 - 10, worst -> best */

    ret = mpi->control(mpp_ctx, MPP_ENC_SET_CFG, cfg);
    if (ret) {
        printf("mpi control MPP_ENC_SET_CFG failed ret %d\n", ret);
        mpp_enc_cfg_deinit(cfg);
        return -1;
    }

    mpp_enc_cfg_deinit(cfg);

    return 0;
}

int vpu_encode_jpeg_doing(struct vpu_encode* encode,
        void* srcbuf,
        int src_fd,
        size_t src_size,
        void *dst_buf,
        int dst_fd,
        size_t dst_size)
{
    MPP_RET ret = MPP_OK;
    RK_U32 width = encode->width;
    RK_U32 height = encode->height;
    MppCtx mpp_ctx = encode->mpp_ctx;
    MppApi* mpi = encode->mpi;
    MppTask task = NULL;
    MppFrame frame = NULL;
    MppBuffer pic_buf = NULL;
    MppBuffer str_buf = NULL;
    MppBufferGroup memGroup = NULL;

    encode->enc_out_data = NULL;
    encode->enc_out_length = 0;

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

    mpp_frame_set_width(frame, width);
    mpp_frame_set_height(frame, height);
    mpp_frame_set_hor_stride(frame, width);
    mpp_frame_set_ver_stride(frame, height);
    mpp_frame_set_eos(frame, 1);

    if (src_fd > 0) {
        MppBufferInfo inputCommit;

        memset(&inputCommit, 0, sizeof(inputCommit));
        inputCommit.type = MPP_BUFFER_TYPE_ION;
        inputCommit.size = src_size;
        inputCommit.fd = src_fd;

        ret = mpp_buffer_import(&pic_buf, &inputCommit);
        if (ret) {
            printf("import input picture buffer failed\n");
            goto ENCODE_OUT;
        }
    } else {
        if (NULL == srcbuf) {
            ret = MPP_ERR_NULL_PTR;
            goto ENCODE_OUT;
        }

        ret = mpp_buffer_get(memGroup, &pic_buf, src_size);
        if (ret) {
            printf("allocate input picture buffer failed\n");
            goto ENCODE_OUT;
        }
        memcpy((RK_U8*)mpp_buffer_get_ptr(pic_buf), srcbuf, src_size);
    }

    if (dst_fd > 0) {
        MppBufferInfo outputCommit;

        memset(&outputCommit, 0, sizeof(outputCommit));
        outputCommit.type = MPP_BUFFER_TYPE_ION;
        outputCommit.fd = dst_fd;
        outputCommit.size = dst_size;
        outputCommit.ptr = dst_buf;

        ret = mpp_buffer_import(&str_buf, &outputCommit);
        if (ret) {
            printf("import output stream buffer failed\n");
            goto ENCODE_OUT;
        }
    } else {
        printf("output stream buffer error\n");
        goto ENCODE_OUT;
    }

    mpp_frame_set_buffer(frame, pic_buf);
    if (encode->packet)
        mpp_packet_deinit(&encode->packet);
    mpp_packet_init_with_buffer(&encode->packet, str_buf);
    mpp_packet_set_length(encode->packet, 0);
    //mpp_log_f("mpp import input fd %d output fd %d", mpp_buffer_get_fd(pic_buf),
    //          mpp_buffer_get_fd(str_buf));

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

    ret = mpi->dequeue(mpp_ctx, MPP_PORT_INPUT, &task);
    if (ret || NULL == task) {
        printf("mpp task input dequeue failed ret %d task %p\n", ret, task);
        goto ENCODE_OUT;
    }

    mpp_task_meta_set_frame(task, KEY_INPUT_FRAME, frame);
    mpp_task_meta_set_packet(task, KEY_OUTPUT_PACKET, encode->packet);

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

    ret = mpi->poll(mpp_ctx, MPP_PORT_OUTPUT, MPP_POLL_BLOCK);
    if (ret) {
        printf("mpp task output poll failed ret %d\n", ret);
        goto ENCODE_OUT;
    }

    ret = mpi->dequeue(mpp_ctx, MPP_PORT_OUTPUT, &task);
    if (ret || NULL == task) {
        printf("mpp task output dequeue failed ret %d task %p\n", ret, task);
        goto ENCODE_OUT;
    }

    if (task) {
        MppFrame packet_out = NULL;

        mpp_task_meta_get_packet(task, KEY_OUTPUT_PACKET, &packet_out);

        assert(packet_out == encode->packet);

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

    if ((encode->packet != NULL)) {
        size_t length = mpp_packet_get_length(encode->packet);

        encode->enc_out_data = dst_buf;
        encode->enc_out_length = length;
    }

    ret = mpi->reset(mpp_ctx);
    if (MPP_OK != ret) {
        printf("mpi->reset failed\n");
        goto ENCODE_OUT;
    }

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

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

    if (frame)
        mpp_frame_deinit(&frame);

    return ret;
}

void vpu_encode_jpeg_done(struct vpu_encode* encode)
{
    if (encode) {
        if (encode->packet)
            mpp_packet_deinit(&encode->packet);

        if (encode->mpp_ctx) {
            mpp_destroy(encode->mpp_ctx);
            encode->mpp_ctx = NULL;
        }
    }
}