/*
 * Copyright (C) 2016 Rockchip Electronics Co., Ltd.
 * Authors:
 *  Zhiqin Wei <wzq@rock-chips.com>
 *
 * 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 LOG_NDEBUG 0
#define LOG_TAG "rgaSlt"

#include <stdint.h>
#include <sys/types.h>
#include <math.h>
#include <fcntl.h>
#include <utils/misc.h>
#include <signal.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>
#include <stdint.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <linux/stddef.h>

#include <utils/Atomic.h>
#include <utils/Errors.h>
#include <utils/Log.h>
#include <utils/Thread.h>
#include <cutils/properties.h>
#include <ui/PixelFormat.h>
#include <ui/GraphicBuffer.h>
#include <ui/GraphicBufferMapper.h>
#include <hardware/hardware.h>

#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GLES/gl.h>
#include <GLES/glext.h>

#ifndef ANDROID_8
#include <binder/IPCThreadState.h>
#endif

#include "RockchipRga.h"
#include "RgaUtils.h"

///////////////////////////////////////////////////////

#define EN_GRAPHICBUFFER 0

using namespace android;

int main() {
    int ret = 0;
    int srcWidth,srcHeight,srcFormat;
    int dstWidth,dstHeight,dstFormat;

    srcWidth = 1280;
    srcHeight = 720;
    srcFormat = HAL_PIXEL_FORMAT_RGBA_8888;

    dstWidth = 1280;
    dstHeight = 720;
    dstFormat = HAL_PIXEL_FORMAT_RGBA_8888;

    RockchipRga& rkRga(RockchipRga::get());

#if EN_GRAPHICBUFFER
    char* buf = NULL;
//    GraphicBufferMapper &mgbMapper = GraphicBufferMapper::get();

    /********** apply for src_buffer **********/
#ifdef ANDROID_7_DRM
    sp<GraphicBuffer> gbs(new GraphicBuffer(srcWidth,srcHeight,srcFormat,
                                            GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_FB));
#else
    sp<GraphicBuffer> gbs(new GraphicBuffer(srcWidth,srcHeight,srcFormat,
                                            GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN));
#endif

    if (gbs->initCheck()) {
        printf("GraphicBuffer_src error : %s\n",strerror(errno));
        return ret;
    } else
        printf("GraphicBuffer_src %s \n","ok");

    /********** apply for dst_buffer **********/
#ifdef ANDROID_7_DRM
    sp<GraphicBuffer> gbd(new GraphicBuffer(dstWidth,dstHeight,dstFormat,
                                            GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_FB));
#else
    sp<GraphicBuffer> gbd(new GraphicBuffer(dstWidth,dstHeight,dstFormat,
                                            GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN));
#endif

    if (gbd->initCheck()) {
        printf("GraphicBuffer_dst error : %s\n",strerror(errno));
        return ret;
    } else
        printf("GraphicBuffer_dst %s \n","ok");

    /********** map buffer_address to userspace **********/

    /*
    #ifdef ANDROID_8
        buffer_handle_t importedHandle_src;
        buffer_handle_t importedHandle_dst;
        mgbMapper.importBuffer(gbs->handle, &importedHandle_src);
        mgbMapper.importBuffer(gbd->handle, &importedHandle_dst);
        gbs->handle = importedHandle_src;
        gbd->handle = importedHandle_dst;
    #else
        mgbMapper.registerBuffer(gbs->handle);
        mgbMapper.registerBuffer(gbd->handle);
    #endif
    */

    /********** write data to src_buffer or init buffer**********/
    ret = gbs->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)&buf);

    if (ret) {
        printf("lock buffer_src error : %s\n",strerror(errno));
        return ret;
    } else
        printf("lock buffer_src %s \n","ok");

#if 1
    get_buf_from_file(buf, srcFormat, srcWidth, srcHeight, 0);
#else
    memset(buf,0x55,4*1280*720);
#endif
    ret = gbs->unlock();
    if (ret) {
        printf("unlock buffer_src error : %s\n",strerror(errno));
        return ret;
    } else
        printf("unlock buffer_src %s \n","ok");

    /********** write data to dst_buffer or init buffer **********/
    ret = gbd->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)&buf);
    if (ret) {
        printf("lock buffer_dst error : %s\n",strerror(errno));
        return ret;
    } else
        printf("lock buffer_dst %s \n","ok");

    memset(buf,0x00,4*1280*720);

    ret = gbd->unlock();
    if (ret) {
        printf("unlock buffer_src error : %s\n",strerror(errno));
        return ret;
    } else
        printf("unlock buffer_src %s \n","ok");

    /********** rga_info_t Init **********/
    rga_info_t src;
    rga_info_t dst;

    memset(&src, 0, sizeof(rga_info_t));
    src.fd = -1;
    src.mmuFlag = 1;
    src.hnd = gbs->handle;

    memset(&dst, 0, sizeof(rga_info_t));
    dst.fd = -1;
    dst.mmuFlag = 1;
    dst.hnd = gbd->handle;

    /********** get src_Fd **********/
    ret = rkRga.RkRgaGetBufferFd(gbs->handle, &src.fd);
    printf("src.fd =%d\n",src.fd);
    ALOGD("src.fd =%d\n",src.fd);
    if (ret) {
        printf("rgaGetsrcFd fail : %s,hnd=%p \n",
               strerror(errno),(void*)(gbd->handle));
    }
    /********** get dst_Fd **********/
    ret = rkRga.RkRgaGetBufferFd(gbd->handle, &dst.fd);
    printf("dst.fd =%d \n",dst.fd);
    if (ret) {
        printf("rgaGetdstFd error : %s,hnd=%p\n",
               strerror(errno),(void*)(gbd->handle));
    }
    /********** if not fd, try to check phyAddr and virAddr **************/
#ifndef RK3188
    if(src.fd <= 0|| dst.fd <= 0)

    {
        /********** check phyAddr and virAddr ,if none to get virAddr **********/
        if (( src.phyAddr != 0 || src.virAddr != 0 ) || src.hnd != NULL ) {
            ret = RkRgaGetHandleMapAddress( gbs->handle, &src.virAddr );
            printf("src.virAddr =%p\n",src.virAddr);
            if(!src.virAddr) {
                printf("err! src has not fd and address for render ,Stop!\n");
                break;
            }
        }

        /********** check phyAddr and virAddr ,if none to get virAddr **********/
        if (( dst.phyAddr != 0 || dst.virAddr != 0 ) || dst.hnd != NULL ) {
            ret = RkRgaGetHandleMapAddress( gbd->handle, &dst.virAddr );
            printf("dst.virAddr =%p\n",dst.virAddr);
            if(!dst.virAddr) {
                printf("err! dst has not fd and address for render ,Stop!\n");
                break;
            }
        }
    }
#endif /* #ifndef RK3188 */
#else
    char *src_va = NULL;
    char *dst_va = NULL;

    src_va = (char *)malloc(srcWidth*srcHeight*get_bpp_from_format(srcFormat));
    dst_va = (char *)malloc(dstWidth*dstHeight*get_bpp_from_format(dstFormat));

#if 1
    get_buf_from_file(src_va, srcFormat, srcWidth, srcHeight, 0);
#else
    memset(src_va,0x00,srcWidth*srcHeight*get_bpp_from_format(srcFormat));
#endif

#if 0
    get_buf_from_file(dst_va, dstFormat, dstWidth, dstHeight, 0);
#else
    memset(dst_va,0x00,dstWidth*dstHeight*get_bpp_from_format(dstFormat));
#endif

    /********** rga_info_t Init **********/
    rga_info_t src;
    rga_info_t dst;

    memset(&src, 0, sizeof(rga_info_t));
    memset(&dst, 0, sizeof(rga_info_t));

    src.virAddr = src_va;
    src.mmuFlag = 1;

    dst.virAddr =dst_va;
    dst.mmuFlag = 1;
#endif /* #if EN_GRAPHICBUFFER */

    while(1) {
        /********** set the rect_info **********/
        rga_set_rect(&src.rect, 0,0,srcWidth,srcHeight,srcWidth/*stride*/,srcHeight,srcFormat);
        rga_set_rect(&dst.rect, 0,0,dstWidth,dstHeight,dstWidth/*stride*/,dstHeight,dstFormat);

        /************ set the rga_mod ,rotation\composition\scale\copy .... **********/

        /********** call rga_Interface **********/
        ret = rkRga.RkRgaBlit(&src, &dst, NULL);
        if (ret) {
            printf("rgaFillColor error : %s\n",
                   strerror(errno));
        }

#if EN_GRAPHICBUFFER
        {
            /********** output buf data to file **********/
            char* dstbuf = NULL;

            ret = gbd->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)&dstbuf);
            output_buf_data_to_file(dstbuf, dstFormat, dstWidth, dstHeight, 0);
            ret = gbd->unlock();

            /********** rga slt check **********/
            ret = gbd->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)&dstbuf);
            if (ret) {
                printf("lock buffer_dst error : %s\n",strerror(errno));
                return ret;
            } else
                printf("lock buffer_dst %s \n","ok");

            ret = gbs->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)&buf);
            if (ret) {
                printf("lock buffer_src error : %s\n",strerror(errno));
                return ret;
            } else
                printf("lock buffer_src %s \n","ok");

            int size = dstWidth * dstHeight * 4;
            unsigned int *pstd = (unsigned int *)buf;
            unsigned int *pnow = (unsigned int *)dstbuf;
            int errCount = 0;
            int rightCount = 0;
            printf("[  num   : srcInfo    dstInfo ] \n");
            for (int i = 0; i < size / 4; i++) {
                if (*pstd != *pnow) {
                    printf("[X%.8d:0x%x 0x%x]  ", i, *pstd,*pnow);
                    if (i % 4 == 0 )
                        printf("\n");
                    errCount ++;

                } else {
                    if (i % (640*1024) == 0)
                        printf("[Y%.8d:0x%.8x 0x%.8x]\n", i, *pstd,*pnow);
                    rightCount++;
                }
                pstd++;
                pnow++;
                if (errCount > 64)
                    break;
            }
            ret = gbs->unlock();
            if (ret) {
                printf("unlock buffer_src error : %s\n",strerror(errno));
                return ret;
            }

            ret = gbd->unlock();
            if (ret) {
                printf("unlock buffer_dst error : %s\n",strerror(errno));
                return ret;
            }

            printf("errCount=%d,rightCount=%d\n", errCount, rightCount);
            if(errCount != 0) {
                printf("rga slt err !! \n");
                return 1;
            } else {
                printf("rga slt sucess !! \n");
                return 0;
            }
        }
#else
        {
            /********** output buf data to file **********/
            output_buf_data_to_file(dst_va, dstFormat, dstWidth, dstHeight, 0);

            int size = dstWidth * dstHeight * 4;
            unsigned int *pstd = (unsigned int *)src_va;
            unsigned int *pnow = (unsigned int *)dst_va;
            int errCount = 0;
            int rightCount = 0;
            printf("[  num   : srcInfo    dstInfo ] \n");
            for (int i = 0; i < size / 4; i++) {
                if (*pstd != *pnow) {
                    printf("[X%.8d:0x%x 0x%x]  ", i, *pstd,*pnow);
                    if (i % 4 == 0 )
                        printf("\n");
                    errCount ++;

                } else {
                    if (i % (640*1024) == 0)
                        printf("[Y%.8d:0x%.8x 0x%.8x]\n", i, *pstd,*pnow);
                    rightCount++;
                }
                pstd++;
                pnow++;
                if (errCount > 64)
                    break;
            }

            printf("errCount=%d,rightCount=%d\n", errCount, rightCount);
            if(errCount != 0) {
                printf("rga slt err !! \n");
                return 1;
            } else {
                printf("rga slt sucess !! \n");
                return 0;
            }
        }
#endif /* #if EN_GRAPHICBUFFER */
        break;
    }

#if !EN_GRAPHICBUFFER
    free(src_va);
    free(dst_va);
#endif
    return 0;
}