#include <stdio.h>

#include <log.h>
#include <vdecoder.h>
#include "memoryAdapter.h"
#include <errno.h>

#define SAVE_RGB (1)
typedef struct VideoFrame
{
    // Intentional public access modifier:
    uint32_t mWidth;
    uint32_t mHeight;
    uint32_t mDisplayWidth;
    uint32_t mDisplayHeight;
    uint32_t mSize;            // Number of bytes in mData
    uint8_t* mData;            // Actual binary data
    int32_t  mRotationAngle;   // rotation angle, clockwise
}VideoFrame;

#if SAVE_RGB
//-------------------------------------------------------------------
char* gOutPutPath = NULL;
 /*
　　位图文件的组成
          结构名称 符 号
	位图文件头 (bitmap-file header) BITMAPFILEHEADER bmfh
	位图信息头 (bitmap-information header) BITMAPINFOHEADER bmih
	彩色表　(color table) RGBQUAD aColors[]
	图象数据阵列字节 BYTE aBitmapBits[]
  */
typedef struct bmp_header
{
	short twobyte           ;//两个字节，用来保证下面成员紧凑排列，这两个字符不能写到文件中
	     //14B
	char bfType[2]          ;//!文件的类型,该值必需是0x4D42，也就是字符'BM'
	unsigned int bfSize     ;//!说明文件的大小，用字节为单位
	unsigned int bfReserved1;//保留，必须设置为0
	unsigned int bfOffBits  ;//!说明从文件头开始到实际的图象数据之间的字节的偏移量，这里为14B+sizeof(BMPINFO)
}BMPHEADER;

typedef struct bmp_info
{
	     //40B
	 unsigned int biSize         ;//!BMPINFO结构所需要的字数
	 int biWidth                 ;//!图象的宽度，以象素为单位
	 int biHeight                ;//!图象的宽度，以象素为单位,如果该值是正数，说明图像是倒向的，如果该值是负数，则是正向的
	 unsigned short biPlanes     ;//!目标设备说明位面数，其值将总是被设为1
	 unsigned short biBitCount   ;//!比特数/象素，其值为1、4、8、16、24、或32
	 unsigned int biCompression  ;//说明图象数据压缩的类型
	 #define BI_RGB        0L    //没有压缩
	 #define BI_RLE8       1L    //每个象素8比特的RLE压缩编码，压缩格式由2字节组成（重复象素计数和颜色索引）；
	 #define BI_RLE4       2L    //每个象素4比特的RLE压缩编码，压缩格式由2字节组成
	 #define BI_BITFIELDS  3L    //每个象素的比特由指定的掩码决定。
	 unsigned int biSizeImage    ;//图象的大小，以字节为单位。当用BI_RGB格式时，可设置为0
	 int biXPelsPerMeter         ;//水平分辨率，用象素/米表示
	 int biYPelsPerMeter         ;//垂直分辨率，用象素/米表示
	 unsigned int biClrUsed      ;//位图实际使用的彩色表中的颜色索引数（设为0的话，则说明使用所有调色板项）
	 unsigned int biClrImportant ;//对图象显示有重要影响的颜色索引的数目，如果是0，表示都重要。
}BMPINFO;

typedef struct tagRGBQUAD
{
	unsigned char rgbBlue;
	unsigned char rgbGreen;
	unsigned char rgbRed;
	unsigned char rgbReserved;
} RGBQUAD;

typedef struct tagBITMAPINFO
{
	BMPINFO    bmiHeader;
	//RGBQUAD    bmiColors[1];
	unsigned int rgb[3];
} BITMAPINFO;


static int get_rgb565_header(int w, int h, BMPHEADER * head, BITMAPINFO * info)
{
    int size = 0;
    if (head && info)
    {
        size = w * h * 2;
        memset(head, 0, sizeof(* head));
        memset(info, 0, sizeof(* info));
         head->bfType[0] = 'B';
         head->bfType[1] = 'M';
         head->bfOffBits = 14 + sizeof(* info);
         head->bfSize = head->bfOffBits + size;
         head->bfSize = (head->bfSize + 3) & ~3;
         size = head->bfSize - head->bfOffBits;

         info->bmiHeader.biSize = sizeof(info->bmiHeader);
         info->bmiHeader.biWidth = w;
         info->bmiHeader.biHeight = -h;
         info->bmiHeader.biPlanes = 1;
         info->bmiHeader.biBitCount = 16;
         info->bmiHeader.biCompression = BI_BITFIELDS;
         info->bmiHeader.biSizeImage = size;

         info->rgb[0] = 0xF800;
         info->rgb[1] = 0x07E0;
         info->rgb[2] = 0x001F;

         logd("rgb565:%dbit,%d*%d,%d\n", info->bmiHeader.biBitCount, w, h, head->bfSize);
     }
     return size;
 }


static int save_bmp_rgb565(FILE* fp, int width, int height, unsigned char* pData)
{
	int success = 0;
	int size = 0;
	BMPHEADER head;
	BITMAPINFO info;
	size = get_rgb565_header(width, height, &head, &info);
	if(size > 0)
	{
        fwrite(head.bfType,1,2,fp);
        fwrite(&head.bfSize,1,4,fp);
        fwrite(&head.bfReserved1,1,4,fp);
        fwrite(&head.bfOffBits,1,4,fp);

		fwrite(&info,1,sizeof(info), fp);
		fwrite(pData,1,size, fp);
		success = 1;
	}
	logd("*****success=%d\n", success);
	return success;
}



#endif

#if 0
static int get_rgb888_header(int w, int h, BMPHEADER * head, BITMAPINFO * info)
{
    int size = 0;
    if (head && info)
    {
        size = w * h * 3;
        memset(head, 0, sizeof(* head));
        memset(info, 0, sizeof(* info));
         head->bfType[0] = 'B';
         head->bfType[1] = 'M';
         head->bfOffBits = 14 + sizeof(* info);
         head->bfSize = head->bfOffBits + size;
         head->bfSize = (head->bfSize + 3) & ~3;
         size = head->bfSize - head->bfOffBits;

         info->bmiHeader.biSize = sizeof(info->bmiHeader);
         info->bmiHeader.biWidth = w;
         info->bmiHeader.biHeight = -h;
         info->bmiHeader.biPlanes = 1;
         info->bmiHeader.biBitCount = 24;
         info->bmiHeader.biCompression = BI_RGB;
         info->bmiHeader.biSizeImage = size;

         logd("rgb888:%dbit,%d*%d,%d\n", info->bmiHeader.biBitCount, w, h, head->bfSize);
     }
     return size;
 }


static int save_bmp_rgb888(FILE* fp, int width, int height, unsigned char* pData)
{
	int success = 0;
	int size = 0;
	BMPHEADER head;
	BITMAPINFO info;
	size = get_rgb888_header(width, height, &head, &info);
	if(size > 0)
	{
		fwrite(head.bfType,1,14,fp);
		fwrite(&info,1,sizeof(info), fp);
		fwrite(pData,1,size, fp);
		success = 1;
	}
	logd("*****success=%d\n", success);
	return success;
}

static int transformPictureMb32ToRGB888(VideoPicture* pPicture, unsigned char* pData, int nWidth, int nHeight)
{
    unsigned char*   pClipTable;
    unsigned char*   pClip;
    static const int nClipMin = -278;
    static const int nClipMax = 535;

    unsigned short*  pDst = NULL;
    unsigned char*   pSrcY = NULL;
    unsigned char*   pSrcVU = NULL;

    int x = 0;
    int y = 0;
    int nMbWidth = 0;
    int nMbHeight = 0;
    int nVMb = 0;
    int nHMb = 0;
    int yPos = 0;
    int pos = 0;
    int uvPos = 0;

    //* initialize the clip table.
    pClipTable = (unsigned char*)malloc(nClipMax - nClipMin + 1);
    if(pClipTable == NULL)
    {
        loge("can not allocate memory for the clip table, quit.");
        return -1;
    }
    for(x=nClipMin; x<=nClipMax; x++)
    {
        pClipTable[x-nClipMin] = (x<0) ? 0 : (x>255) ? 255 : x;
    }
    pClip = &pClipTable[-nClipMin];

    //* flush cache.
    MemAdapterFlushCache(pPicture->pData0, pPicture->nWidth*pPicture->nHeight);
    MemAdapterFlushCache(pPicture->pData1, pPicture->nHeight*pPicture->nHeight/2);

    pDst  = (unsigned short*)pData;
    logd("+++++ pDst: %p", pDst);
    pSrcY = (unsigned char*)pPicture->pData0;
    pSrcVU  = (unsigned char*)pPicture->pData1;

    nMbWidth = pPicture->nWidth/32;
    nMbHeight = pPicture->nHeight/32;

	for(nVMb=0; nVMb<nMbHeight;nVMb++)
	{
		for(nHMb=0; nHMb<nMbWidth; nHMb++)
		{
			#if 1
			pos = 3*(nVMb*pPicture->nWidth*32+nHMb*32);
			#else
			pos = nVMb*pPicture->nWidth*32+nHMb*32;
			#endif

			for(y=0; y<32; y++)
			{
				yPos = (nVMb*nMbWidth+nHMb)*1024+y*32;
				uvPos = ((nVMb/2)*nMbWidth*1024)+nHMb*1024+(y/2)*32+ (((nVMb%2)==1) ? 512 : 0);
				for(x=0; x<32; x+=2)
				{
					signed y1 = (signed)pSrcY[yPos+x+0] - 16;
					signed y2 = (signed)pSrcY[yPos+x+1] - 16;
					signed u  = (signed)pSrcVU[uvPos+x+0] - 128;
					signed v  = (signed)pSrcVU[uvPos+x+1] - 128;
					signed u_b = u * 517;
					signed u_g = -u * 100;
					signed v_g = -v * 208;
					signed v_r = v * 409;
					signed tmp1 = y1 * 298;
					signed b1 = (tmp1 + u_b) / 256;
					signed g1 = (tmp1 + v_g + u_g) / 256;
					signed r1 = (tmp1 + v_r) / 256;
					signed tmp2 = y2 * 298;
					signed b2 = (tmp2 + u_b) / 256;
					signed g2 = (tmp2 + v_g + u_g) / 256;
					signed r2 = (tmp2 + v_r) / 256;

				#if 1

					pDst[pos+0] = pClip[r1];
                    pDst[pos+1] = pClip[g1];
                    pDst[pos+2] = pClip[b1];
                    pDst[pos+3] = pClip[r2];
                    pDst[pos+4] = pClip[g2];
                    pDst[pos+5] = pClip[b2];
                    pos += 6;

				}
				pos += 3*(nMbWidth-1)*32;

				#else
					unsigned int rgb1 = ((pClip[r1] >> 3) << 11) |
										((pClip[g1] >> 2) << 5)  |
										(pClip[b1] >> 3);

					unsigned int rgb2 = ((pClip[r2] >> 3) << 11) |
										((pClip[g2] >> 2) << 5)  |
										(pClip[b2] >> 3);
					*(unsigned int *)(&pDst[pos]) = (rgb2 << 16) | rgb1;
					pos += 2;
				}
				pos += (nMbWidth-1)*32;
				#endif
			}
		}
	}

	logd("pos: %d", pos);
	pDst  = (unsigned short*)pData;
	for(y=0; y<pPicture->nTopOffset; y++)
	{
		memset(pDst+y*nWidth, 0, 2*nWidth);
	}
	for(y=pPicture->nBottomOffset; y<nHeight; y++)
	{
		memset(pDst+y*nWidth, 0, 2*nWidth);
	}

	for(y=pPicture->nTopOffset; y<pPicture->nBottomOffset; y++)
	{
		memset(pDst+y*nWidth, 0, 2*pPicture->nLeftOffset);
		memset(pDst+y*nWidth+pPicture->nRightOffset, 0, 2*(nWidth-pPicture->nRightOffset));
	}

#if 1
    FILE* outFp = fopen("/mnt/UDISK/rgb.data", "wb");
    if(outFp != NULL)
    {
	logd("************save_bmp_rgb565\n");
	save_bmp_rgb888(outFp, nWidth, nHeight, pData);
	fwrite(pDst, 1, nWidth*nHeight*3, outFp);
	fclose(outFp);
    }
#endif

    free(pClipTable);

    return 0;
}
#endif

static int transformPictureMb32ToRGB(struct ScMemOpsS* memops, VideoPicture* pPicture, unsigned char* pData, int nWidth, int nHeight)
{
    unsigned char*   pClipTable;
    unsigned char*   pClip;
    static const int nClipMin = -278;
    static const int nClipMax = 535;

    unsigned short*  pDst = NULL;
    unsigned char*   pSrcY = NULL;
    unsigned char*   pSrcVU = NULL;

    int x = 0;
    int y = 0;
    int nMbWidth = 0;
    int nMbHeight = 0;
    int nVMb = 0;
    int nHMb = 0;
    int yPos = 0;
    int pos = 0;
    int uvPos = 0;

    //* initialize the clip table.
    pClipTable = (unsigned char*)malloc(nClipMax - nClipMin + 1);
    if(pClipTable == NULL)
    {
        loge("can not allocate memory for the clip table, quit.");
        return -1;
    }
    for(x=nClipMin; x<=nClipMax; x++)
    {
        pClipTable[x-nClipMin] = (x<0) ? 0 : (x>255) ? 255 : x;
    }
    pClip = &pClipTable[-nClipMin];

    //* flush cache.
    CdcMemFlushCache(memops, pPicture->pData0, pPicture->nWidth*pPicture->nHeight);
    CdcMemFlushCache(memops, pPicture->pData1, pPicture->nHeight*pPicture->nHeight/2);

    pDst  = (unsigned short*)pData;
    logd("+++++ pDst: %p", pDst);
    pSrcY = (unsigned char*)pPicture->pData0;
    pSrcVU  = (unsigned char*)pPicture->pData1;

    nMbWidth = pPicture->nWidth/32;
    nMbHeight = pPicture->nHeight/32;

	for(nVMb=0; nVMb<nMbHeight;nVMb++)
	{
		for(nHMb=0; nHMb<nMbWidth; nHMb++)
		{
			pos = nVMb*pPicture->nWidth*32+nHMb*32;
			for(y=0; y<32; y++)
			{
				yPos = (nVMb*nMbWidth+nHMb)*1024+y*32;
				uvPos = ((nVMb/2)*nMbWidth*1024)+nHMb*1024+(y/2)*32+ (((nVMb%2)==1) ? 512 : 0);
				for(x=0; x<32; x+=2)
				{
					signed y1 = (signed)pSrcY[yPos+x+0] - 16;
					signed y2 = (signed)pSrcY[yPos+x+1] - 16;
					signed u  = (signed)pSrcVU[uvPos+x+0] - 128;
					signed v  = (signed)pSrcVU[uvPos+x+1] - 128;
					signed u_b = u * 517;
					signed u_g = -u * 100;
					signed v_g = -v * 208;
					signed v_r = v * 409;
					signed tmp1 = y1 * 298;
					signed b1 = (tmp1 + u_b) / 256;
					signed g1 = (tmp1 + v_g + u_g) / 256;
					signed r1 = (tmp1 + v_r) / 256;
					signed tmp2 = y2 * 298;
					signed b2 = (tmp2 + u_b) / 256;
					signed g2 = (tmp2 + v_g + u_g) / 256;
					signed r2 = (tmp2 + v_r) / 256;
					unsigned int rgb1 = ((pClip[r1] >> 3) << 11) |
										((pClip[g1] >> 2) << 5)  |
										(pClip[b1] >> 3);

					unsigned int rgb2 = ((pClip[r2] >> 3) << 11) |
										((pClip[g2] >> 2) << 5)  |
										(pClip[b2] >> 3);
					*(unsigned int *)(&pDst[pos]) = (rgb2 << 16) | rgb1;
					pos += 2;
				}
				pos += (nMbWidth-1)*32;
			}
		}
	}

	logd("pos: %d", pos);
	pDst  = (unsigned short*)pData;
	for(y=0; y<pPicture->nTopOffset; y++)
	{
		memset(pDst+y*nWidth, 0, 2*nWidth);
	}
	for(y=pPicture->nBottomOffset; y<nHeight; y++)
	{
		memset(pDst+y*nWidth, 0, 2*nWidth);
	}

	for(y=pPicture->nTopOffset; y<pPicture->nBottomOffset; y++)
	{
		memset(pDst+y*nWidth, 0, 2*pPicture->nLeftOffset);
		memset(pDst+y*nWidth+pPicture->nRightOffset, 0, 2*(nWidth-pPicture->nRightOffset));
	}

#if SAVE_RGB
	FILE* outFp = NULL;
	if(gOutPutPath != NULL){
		outFp = fopen(gOutPutPath, "wb");
	}else{
		outFp = fopen("/tmp/rgb.bmp", "wb");
	}
    if(outFp != NULL){
		logd("************save_bmp_rgb565\n");
		save_bmp_rgb565(outFp, nWidth, nHeight, pData);
		fclose(outFp);
    }else{
		loge("fopen output path fail\n");
	}
#endif

    free(pClipTable);

    return 0;
}


static char * readJpegData(char *path, int *pLen)
{
    FILE *fp = NULL;
    int ret = 0;
    char *data = NULL;

    fp = fopen(path, "rb");
    if(fp == NULL)
    {
        loge("read jpeg file error, errno(%d)", errno);
        return NULL;
    }

    fseek(fp,0,SEEK_END);
    *pLen = ftell(fp);
    rewind(fp);
    data = (char *) malloc (sizeof(char)*(*pLen));

    if(data == NULL)
      {
          loge("malloc memory fail");
          fclose(fp);
          return NULL;
      }

    ret = fread (data,1,*pLen,fp);
    if (ret != *pLen)
    {
        loge("read file fail");
        fclose(fp);
        free(data);
        return NULL;
    }

    if(fp != NULL)
    {
        fclose(fp);
    }
    return data;
}

static int dumpData(char *path, uint8_t *data, int len)
{
    FILE *fp;
    fp = fopen(path, "a+");

    if(fp != NULL)
    {
        logd("dump data '%d'", len);
        fwrite(data, 1, len, fp);
        fclose(fp);
    }
    else
    {
        loge("saving picture open file error, errno(%d)", errno);
        return -1;
    }
    return 0;
}


int main(int argc, char** argv)
{
    int ret;

    VConfig vConfig;
    char *jpegData = NULL;
    int dataLen =0;
    char * uri= NULL;
    VideoDecoder *pVideo;
    VideoPicture *videoPicture = NULL;

	struct ScMemOpsS* memops = MemAdapterGetOpsS();
	if(memops == NULL)
	{
		return -1;
	}
	CdcMemOpen(memops);
	AddVDPlugin();

    if (argc != 3)
    {
        logd("argc must be '3'");
		logd("usage:");
		logd("jpegdecodedemo /mnt/UDISK/test.jpg /mnt/UDISK/save.bmp");
        return 0;
    }
    uri = argv[1];
#if SAVE_RGB
	gOutPutPath = argv[2];
#endif
    jpegData = readJpegData(uri , &dataLen);
	logd("dataLen = %d",dataLen);
    if (dataLen <= 0  || jpegData == NULL)
   {
        loge("read file fail");
        return 0;
    }

    memset(&vConfig, 0x00, sizeof(VConfig));
    vConfig.bDisable3D = 0;
    vConfig.bDispErrorFrame = 0;
    vConfig.bNoBFrames = 0;
    vConfig.bRotationEn = 0;
    vConfig.bScaleDownEn = 0;
    vConfig.nHorizonScaleDownRatio = 0;
    vConfig.nVerticalScaleDownRatio = 0;
    vConfig.eOutputPixelFormat =PIXEL_FORMAT_YUV_MB32_420;
    vConfig.nDeInterlaceHoldingFrameBufferNum = 0;
    vConfig.nDisplayHoldingFrameBufferNum = 0;
    vConfig.nRotateHoldingFrameBufferNum = 0;
    vConfig.nDecodeSmoothFrameBufferNum = 1;
	if(dataLen < 2*1024*1024){
		vConfig.nVbvBufferSize = 2*1024*1024;
	}else{
		int cnt = dataLen/(4*1024);
		logd("cnt = %d",cnt);
		vConfig.nVbvBufferSize = (cnt+1)*4*1024;
	}
	logd("vConfig.nVbvBufferSize = %d",vConfig.nVbvBufferSize);
    vConfig.bThumbnailMode = 0;
    vConfig.memops = memops;
    VideoStreamInfo videoInfo;
    memset(&videoInfo, 0x00, sizeof(VideoStreamInfo));
    videoInfo.eCodecFormat = VIDEO_CODEC_FORMAT_MJPEG;

    pVideo = CreateVideoDecoder();
    if(!pVideo)
    {
        loge("create video decoder failed\n");
        return 0;
    }
    logd("create video decoder ok\n");


    if ((InitializeVideoDecoder(pVideo, &videoInfo, &vConfig)) != 0)
    {
        loge("InitializeVideoDecoder  failed !\n");
        return 0;
    }
    logd("Initialize video decoder ok\n");

    char *buf, *ringBuf;
    int buflen, ringBufLen;
	if((RequestVideoStreamBuffer(pVideo,
                                dataLen,
                                (char**)&buf,
                                &buflen,
                                (char**)&ringBuf,
                                &ringBufLen,
                                0)) != 0){
		loge("Request Video Stream Buffer failed\n");
        return 0;
	}
    logd("Request Video Stream Buffer ok\n");

    if(buflen + ringBufLen < dataLen)
    {
        loge("#####Error: request buffer failed, buffer is not enough\n");
        return 0;
    }

    logd("goto to copy Video Stream Data ok!\n");
    // copy stream to video decoder SBM
    if(buflen >= dataLen)
    {
        memcpy(buf,jpegData,dataLen);
    }
    else
    {
        memcpy(buf,jpegData,buflen);
        memcpy(ringBuf,jpegData+buflen,dataLen-buflen);
    }
    logd("Copy Video Stream Data ok!\n");

    VideoStreamDataInfo DataInfo;
    memset(&DataInfo, 0, sizeof(DataInfo));
    DataInfo.pData = buf;
    DataInfo.nLength = dataLen;
    DataInfo.bIsFirstPart = 1;
    DataInfo.bIsLastPart = 1;

    if (SubmitVideoStreamData(pVideo, &DataInfo, 0))
    {
        loge("#####Error: Submit Video Stream Data failed!\n");
        return 0;
    }
    logd("Submit Video Stream Data ok!\n");

    // step : decode stream now
    int endofstream = 0;
    int dropBFrameifdelay = 0;
    int64_t currenttimeus = 0;
    int decodekeyframeonly = 0;

    ret = DecodeVideoStream(pVideo, endofstream, decodekeyframeonly,dropBFrameifdelay, currenttimeus);
    logd("decoder ret is %d",ret);
    switch (ret)
    {
        case VDECODE_RESULT_KEYFRAME_DECODED:
        case VDECODE_RESULT_FRAME_DECODED:
        case VDECODE_RESULT_NO_FRAME_BUFFER:
        {
            ret = ValidPictureNum(pVideo, 0);
            if (ret>= 0)
            {
                videoPicture = RequestPicture(pVideo, 0);
                if (videoPicture == NULL){
                    loge("decoder fail");
                    return 0;
                }
                logd("decoder one pic...");
                logd("pic nWidth is %d,nHeight is %d",videoPicture->nWidth,videoPicture->nHeight);

                VideoFrame jpegData;
                jpegData.mWidth = videoPicture->nWidth;
                jpegData.mHeight = videoPicture->nHeight;
                jpegData.mSize = jpegData.mWidth*jpegData.mWidth*2;
                jpegData.mData = (unsigned char*)malloc(jpegData.mSize);
                if(jpegData.mData == NULL)
                {
					return -1;
                }

                transformPictureMb32ToRGB(memops, videoPicture, jpegData.mData, jpegData.mWidth, jpegData.mHeight);

                char path[1024] = "./pic.rgb";
                dumpData(path, (uint8_t *)jpegData.mData, jpegData.mWidth * jpegData.mHeight * 2);
                sync();
            }
            else
            {
               logd("no ValidPictureNum ret is %d",ret);
            }

            break;
        }

        case VDECODE_RESULT_OK:
        case VDECODE_RESULT_CONTINUE:
        case VDECODE_RESULT_NO_BITSTREAM:
        case VDECODE_RESULT_RESOLUTION_CHANGE:
        case VDECODE_RESULT_UNSUPPORTED:
        default:
            loge("video decode Error: %d!\n", ret);
            return 0;
    }

	if (jpegData != NULL)
	{
		free(jpegData);
		jpegData = NULL;
	}

	CdcMemClose(memops);

    return 0;
}