/*
 * Copyright 2020 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.
 *
 */
#include <math.h>
#include <stdlib.h>
#include <unistd.h>

#include "RTNodeVFilterVideoOutput.h"          // NOLINT
#include "RTNodeCommon.h"
#include "RTVideoFrame.h"
#include <sys/time.h>
#ifdef RV1126_RV1109
#include "drmDsp.h"
#endif

#ifdef LOG_TAG
#undef LOG_TAG
#endif

#define LOG_TAG "RTNodeVFilterVideoOutput"
#define kStubRockitVideoOutputDemo                MKTAG('r', 'k', 'v', 'o')

static RK_S32 VO_ENABLE()
{
    /* Enable VO */
    VO_PUB_ATTR_S VoPubAttr;
    VO_VIDEO_LAYER_ATTR_S stLayerAttr;
    RK_S32 s32Ret;
    VO_CHN_ATTR_S stChnAttr;
    VO_CHN VoChn;
    VoChn = 0;

    s32Ret = RK_MPI_SYS_Init();
    RT_LOGD("RK_MPI_SYS_Init ret = %d", s32Ret);

    VO_LAYER VoLayer = RK356X_VOP_LAYER_CLUSTER_0;
    VO_DEV VoDev = RK356X_VO_DEV_HD0;

    RK_MPI_VO_DisableLayer(VoLayer);
    RK_MPI_VO_DisableLayer(RK356X_VOP_LAYER_ESMART_0);
    RK_MPI_VO_DisableLayer(RK356X_VOP_LAYER_ESMART_1);
    RK_MPI_VO_DisableLayer(RK356X_VOP_LAYER_SMART_0);
    RK_MPI_VO_DisableLayer(RK356X_VOP_LAYER_SMART_1);
    RK_MPI_VO_Disable(VoDev);
    RT_LOGD("[%s] unint VO config first\n", __func__);

    memset(&VoPubAttr, 0, sizeof(VO_PUB_ATTR_S));
    memset(&stLayerAttr, 0, sizeof(VO_VIDEO_LAYER_ATTR_S));

    stLayerAttr.enPixFormat = RK_FMT_YUV420SP;
    stLayerAttr.stDispRect.s32X = 0;
    stLayerAttr.stDispRect.s32Y = 0;
    stLayerAttr.u32DispFrmRt = 30;
    stLayerAttr.stDispRect.u32Width = 1920;
    stLayerAttr.stDispRect.u32Height = 1080;
    stLayerAttr.stImageSize.u32Width = 1920;
    stLayerAttr.stImageSize.u32Height = 1080;

    s32Ret = RK_MPI_VO_GetPubAttr(VoDev, &VoPubAttr);
    if (s32Ret != RK_SUCCESS)
    {
        return s32Ret;
    }

    VoPubAttr.enIntfType = VO_INTF_HDMI;
    VoPubAttr.enIntfSync = VO_OUTPUT_1080P60;

    s32Ret = RK_MPI_VO_SetPubAttr(VoDev, &VoPubAttr);
    if (s32Ret != RK_SUCCESS)
    {
        return s32Ret;
    }
    s32Ret = RK_MPI_VO_Enable(VoDev);
    if (s32Ret != RK_SUCCESS)
    {
        return s32Ret;
    }

    s32Ret = RK_MPI_VO_SetLayerAttr(VoLayer, &stLayerAttr);
    if (s32Ret != RK_SUCCESS)
    {
        RK_LOGE("[%s] RK_MPI_VO_SetLayerAttr failed,s32Ret:%d\n", __func__, s32Ret);
        return RK_FAILURE;
    }

    s32Ret = RK_MPI_VO_BindLayer(VoLayer, VoDev, VO_LAYER_MODE_VIDEO);
    if (s32Ret != RK_SUCCESS)
    {
        RK_LOGE("[%s] RK_MPI_VO_BindLayer failed,s32Ret:%d\n", __func__, s32Ret);
        return RK_FAILURE;
    }


    s32Ret = RK_MPI_VO_EnableLayer(VoLayer);
    if (s32Ret != RK_SUCCESS)
    {
        RK_LOGE("[%s] RK_MPI_VO_EnableLayer failed,s32Ret:%d\n", __func__, s32Ret);
        return RK_FAILURE;
    }

    stChnAttr.stRect.s32X = 0;
    stChnAttr.stRect.s32Y = 0;
    stChnAttr.stRect.u32Width = stLayerAttr.stImageSize.u32Width;
    stChnAttr.stRect.u32Height = stLayerAttr.stImageSize.u32Height;
    stChnAttr.u32Priority = 0;
    if (1)
    {
        stChnAttr.u32FgAlpha = 128;
        stChnAttr.u32BgAlpha = 0;
    }
    else
    {
        stChnAttr.u32FgAlpha = 0;
        stChnAttr.u32BgAlpha = 128;
    }

    s32Ret = RK_MPI_VO_SetChnAttr(VoLayer, 0, &stChnAttr);
    if (s32Ret != RK_SUCCESS)
    {
        RK_LOGE("[%s] set chn Attr failed,s32Ret:%d\n", __func__, s32Ret);
        return RK_FAILURE;
    }

    s32Ret = RK_MPI_VO_EnableChn(VoLayer, 0);
    if (s32Ret != RK_SUCCESS)
    {
        RK_LOGE("[%s] Enalbe chn failed, s32Ret = %d\n", __func__, s32Ret);
        return RK_FAILURE;
    }

    return RK_SUCCESS;
}

RTNodeVFilterVideoOutput::RTNodeVFilterVideoOutput() {
    mLock = new RtMutex();
    RT_ASSERT(RT_NULL != mLock);
}

RTNodeVFilterVideoOutput::~RTNodeVFilterVideoOutput() {
    rt_safe_delete(mLock);
}

RT_RET RTNodeVFilterVideoOutput::open(RTTaskNodeContext *context) {
    RT_LOGD("wttt RTNodeVFilterVideoOutput open");
    RtMetaData* inputMeta   = context->options();
    drmInitSuccess = 0;

#ifdef RK356X
    VO_ENABLE();
    pstVFrame = (VIDEO_FRAME_INFO_S *)(calloc(sizeof(VIDEO_FRAME_INFO_S), 1));

#endif

#ifdef RV1126_RV1109
    if (initDrmDsp() < 0)
    {
        RT_LOGE("DRM display init failed\n");
    } else {
        drmInitSuccess = 1;
    }
#endif


    gettimeofday(&beginTime, NULL);
    frameCount = 0;

    return RT_OK;
}

RT_RET RTNodeVFilterVideoOutput::process(RTTaskNodeContext *context) {
    RT_RET         err       = RT_OK;
    RTVideoFrame *srcBuffer = RT_NULL;
    RtMutex::RtAutolock autoLock(mLock);
    RK_S32                ret = RT_OK;

    INT32 count = context->inputQueueSize("image:nv12");
    while (count) {
        srcBuffer = reinterpret_vframe(context->dequeInputBuffer("image:nv12"));
        if (srcBuffer == RT_NULL)
            continue;

        count--;

#ifdef RV1126_RV1109
        if (drmInitSuccess)
        {
            ret = drmDspFrame(srcBuffer->getWidth(), srcBuffer->getHeight(), srcBuffer->getData(), DRM_FORMAT_NV12);
            if (ret == RT_OK) {
                if (!access(HDMI_RKVO_DEBUG_FPS, 0)) {
                    ++frameCount;
                    if (frameCount == 100) {
                        struct timeval now_time;
                        gettimeofday(&now_time, NULL);
                        float use_times = (now_time.tv_sec * 1000 + now_time.tv_usec / 1000) -
                            (beginTime.tv_sec * 1000 + beginTime.tv_usec / 1000);
                        beginTime.tv_sec = now_time.tv_sec;
                        beginTime.tv_usec = now_time.tv_usec;
                        float fps = (1000 * frameCount) / use_times;
                        frameCount = 0;
                        RT_LOGE("hdmi rkvo fps = %0.1f", fps);
                    }
                }
            } else {
                RT_LOGE("drmDspFrame failed ret = %d", ret);
            }
        }
#endif
#ifdef RK356X
        RK_VOID               *pMblk;
        VO_LAYER              VoVideoLayer;
        VO_CHN                VoChn;

        VoVideoLayer = RK356X_VOP_LAYER_CLUSTER_0;
        VoChn = 0;
        /*fill pMbBlk*/
        pstVFrame->stVFrame.pMbBlk = srcBuffer;
        pstVFrame->stVFrame.u32Width = srcBuffer->getWidth();
        pstVFrame->stVFrame.u32Height = srcBuffer->getHeight();
        pstVFrame->stVFrame.u32VirWidth = srcBuffer->getWidth();
        pstVFrame->stVFrame.u32VirHeight = srcBuffer->getHeight();
        pstVFrame->stVFrame.enPixelFormat = RK_FMT_YUV420SP;
        pstVFrame->stVFrame.enCompressMode = COMPRESS_MODE_NONE;
        do {
            ret = RK_MPI_VO_SendFrame(VoVideoLayer, VoChn, pstVFrame, -1);
            if (ret == RT_OK) {
                if (!access(HDMI_RKVO_DEBUG_FPS, 0)) {
                    ++frameCount;
                    if (frameCount == 100) {
                        struct timeval now_time;
                        gettimeofday(&now_time, NULL);
                        float use_times = (now_time.tv_sec * 1000 + now_time.tv_usec / 1000) -
                            (beginTime.tv_sec * 1000 + beginTime.tv_usec / 1000);
                        beginTime.tv_sec = now_time.tv_sec;
                        beginTime.tv_usec = now_time.tv_usec;
                        float fps = (1000 * frameCount) / use_times;
                        frameCount = 0;
                        RT_LOGE("hdmi rkvo fps = %0.1f", fps);
                    }
                }
                break;
            } else {
                RT_LOGE("RK_MPI_VO_SendFrame failed ret = %d", ret);
                RK_MPI_VO_DestroyGraphicsFrameBuffer(pMblk);
                break;
            }
        } while (0);
#endif
        srcBuffer->release();
    }
    return err;
}

RT_RET RTNodeVFilterVideoOutput::close(RTTaskNodeContext *context) {
    RT_LOGD("wttt RTNodeVFilterVideoOutput close");
    RT_RET err = RT_OK;
#ifdef RV1126_RV1109
    if (drmInitSuccess)
    {
        deInitDrmDsp();
    }
#endif

#ifdef RK356X
    if(pstVFrame)
        free(pstVFrame);
#endif

    return err;
}

RT_RET RTNodeVFilterVideoOutput::invokeInternal(RtMetaData *meta) {

    RT_LOGD("wttt RTNodeVFilterVideoOutput invokeInternal");
    const char *command;
    if (RT_NULL == meta) {
        return RT_ERR_NULL_PTR;
    }

    return RT_OK;
}

static RTTaskNode* createVideoOutputFilter() {
    RT_LOGD("wttt RTNodeVFilterVideoOutput createVideoOutputFilter");
    return new RTNodeVFilterVideoOutput();
}

/*****************************************
 * register node stub to RTTaskNodeFactory
 *****************************************/
RTNodeStub node_stub_filter_video_output {
    .mUid          = kStubRockitVideoOutputDemo,
    .mName         = "rkvo",
    .mVersion      = "v1.0",
    .mCreateObj    = createVideoOutputFilter,
    .mCapsSrc      = { "video/x-raw", RT_PAD_SRC, RT_MB_TYPE_VFRAME, {RT_NULL, RT_NULL} },
    .mCapsSink     = { "video/x-raw", RT_PAD_SINK, RT_MB_TYPE_VFRAME, {RT_NULL, RT_NULL} },
};

RT_NODE_FACTORY_REGISTER_STUB(node_stub_filter_video_output);