/*
* Copyright (c) 2008-2016 Allwinner Technology Co. Ltd.
* All rights reserved.
*
* File : pixelformat.c
* Description :display engine 2.0 rotation processing base functions implement
* History :
*   Author  : xyliu <xyliu@allwinnertech.com>
*   Date    : 2016/04/13
*   Comment :
*
*
*/

#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "vdecoder.h"
#include "log.h"

/*******************************************************************************
Function name: map32x32_to_yuv_Y
Description:
    1. we should know : vdecbuf_uv is 32*32 align too
    2. must match gpuBuf_uv size.
    3. gpuBuf_uv size is half of gpuBuf_y size
    4. we guarantee: vdecbufSize>=gpuBufSize
    5. uv's macroblock is also 16*16. Vdec_macroblock is also twomb(32*32).
    6. if coded_width is stride/2, we can support gpu_buf_width 16byte align and 8byte align!
       But need outer set right value of coded_width, must meet gpu_uv_buf_width align's request!
Parameters:
    1. mode = 0:yv12, 1:thumb yuv420p
    2. coded_width and coded_height is uv size, already half of y_size
Return:

*******************************************************************************/
#ifdef CEDARX_DECODER_ARM32
void ConvertMb32420ToNv21Y(char* pSrc,char* pDst,int nWidth, int nHeight)
{
    int nMbWidth = 0;
    int nMbHeight = 0;
    int i = 0;
    int j = 0;
    int m = 0;
    int n = 0;
    int k = 0;
    int nLineStride=0;
    int lineNum = 0;
    int offset = 0;
    int maxNum = 0;
    char* ptr = NULL;
    char bufferU[32];
    int nWidthMatchFlag = 0;
    int nCopyMbWidth = 0;

    nLineStride = (nWidth + 15) &~15;
    nMbWidth = (nWidth+31)&~31;
    nMbWidth /= 32;

    nMbHeight = (nHeight+31)&~31;
    nMbHeight /= 32;
    ptr = pSrc;

    nWidthMatchFlag = 0;
    nCopyMbWidth = nMbWidth-1;

    if(nMbWidth*32 == nLineStride)
    {
        nWidthMatchFlag = 1;
        nCopyMbWidth = nMbWidth;

    }
    for(i=0; i<nMbHeight; i++)
    {
        char *dstAsm = NULL;
        char *srcAsm = NULL;
        CEDARC_UNUSE(dstAsm);
        CEDARC_UNUSE(srcAsm);
        for(j=0; j<nCopyMbWidth; j++)
        {
            for(m=0; m<32; m++)
            {
                if((i*32 + m) >= nHeight)
                  {
                    ptr += 32;
                    continue;
                  }
                srcAsm = ptr;
                lineNum = i*32 + m;           //line num
                offset =  lineNum*nLineStride + j*32;
                dstAsm = pDst+ offset;

                 asm volatile (
                                "vld1.8         {d0 - d3}, [%[srcAsm]]              \n\t"
                                "vst1.8         {d0 - d3}, [%[dstAsm]]              \n\t"
                                   : [dstAsm] "+r" (dstAsm), [srcAsm] "+r" (srcAsm)
                                   :  //[srcY] "r" (srcY)
                                   : "cc", "memory", "d0", "d1", "d2", "d3", \
                                    "d4", "d5", "d6", "d16", "d17", "d18",  \
                                    "d19", "d20", "d21", "d22", "d23",  \
                                    "d24", "d28", "d29", "d30", "d31");
                ptr += 32;
            }
        }

        if(nWidthMatchFlag == 1)
        {
            continue;
        }
        for(m=0; m<32; m++)
        {
            if((i*32 + m) >= nHeight)
            {
                ptr += 32;
                continue;
               }
            dstAsm = bufferU;
            srcAsm = ptr;
             lineNum = i*32 + m;           //line num
            offset =  lineNum*nLineStride + j*32;

                asm volatile (
                      "vld1.8         {d0 - d3}, [%[srcAsm]]              \n\t"
                      "vst1.8         {d0 - d3}, [%[dstAsm]]              \n\t"
                         : [dstAsm] "+r" (dstAsm), [srcAsm] "+r" (srcAsm)
                         :  //[srcY] "r" (srcY)
                        : "cc", "memory", "d0", "d1", "d2", "d3", \
                            "d4", "d5", "d6", "d16", "d17", "d18", \
                            "d19", "d20", "d21", "d22", "d23", \
                            "d24", "d28", "d29", "d30", "d31");
               ptr += 32;
               for(k=0; k<32; k++)
               {
                   if((j*32+ k) >= nLineStride)
                      {
                       break;
                     }
                    pDst[offset+k] = bufferU[k];
               }
        }
    }
}

void ConvertMb32420ToNv21C(char* pSrc,char* pDst,int nPicWidth, int nPicHeight)
{
    int nMbWidth = 0;
    int nMbHeight = 0;
    int i = 0;
    int j = 0;
    int m = 0;
    int n = 0;
    int k = 0;
    int nLineStride=0;
    int lineNum = 0;
    int offset = 0;
    int maxNum = 0;
    char* ptr = NULL;
    char bufferV[16], bufferU[16];
    int nWidth = 0;
    int nHeight = 0;

    nWidth = (nPicWidth+1)/2;
    nHeight = (nPicHeight+1)/2;

    nLineStride = (nWidth*2 + 15) &~15;
    nMbWidth = (nWidth*2+31)&~31;
    nMbWidth /= 32;

    nMbHeight = (nHeight+31)&~31;
    nMbHeight /= 32;

    ptr = pSrc;

    for(i=0; i<nMbHeight; i++)
    {
        char *dst0Asm = NULL;
        char *dst1Asm = NULL;
        char *srcAsm = NULL;
        CEDARC_UNUSE(dst0Asm);
        CEDARC_UNUSE(dst1Asm);
        CEDARC_UNUSE(srcAsm);
        for(j=0; j<nMbWidth; j++)
        {
            for(m=0; m<32; m++)
            {
                if((i*32 + m) >= nHeight)
                {
                    ptr += 32;
                    continue;
                }

                dst0Asm = bufferU;
                dst1Asm = bufferV;
                srcAsm = ptr;
                lineNum = i*32 + m;           //line num
                offset =  lineNum*nLineStride + j*32;

                asm volatile(
                        "vld2.8         {d0-d3}, [%[srcAsm]]              \n\t"
                        "vst1.8         {d0,d1}, [%[dst0Asm]]              \n\t"
                        "vst1.8         {d2,d3}, [%[dst1Asm]]              \n\t"
                        : [dst0Asm] "+r" (dst0Asm), [dst1Asm] "+r" (dst1Asm), [srcAsm] "+r" (srcAsm)
                        :  //[srcY] "r" (srcY)
                        : "cc", "memory", "d0", "d1", "d2", "d3", \
                            "d4", "d5", "d6", "d16", "d17", "d18", \
                            "d19", "d20", "d21", "d22", "d23", "d24", \
                            "d28", "d29", "d30", "d31"
                     );
                ptr += 32;

                for(k=0; k<16; k++)
                {
                    if((j*32+ 2*k) >= nLineStride)
                    {
                        break;
                    }
                    pDst[offset+2*k]   = bufferV[k];
                       pDst[offset+2*k+1] = bufferU[k];
                }
            }
        }
    }
}

void ConvertMb32422ToNv21C(char* pSrc,char* pDst,int nPicWidth, int nPicHeight)
{
    int nMbWidth = 0;
    int nMbHeight = 0;
    int i = 0;
    int j = 0;
    int m = 0;
    int n = 0;
    int k = 0;
    int nLineStride=0;
    int lineNum = 0;
    int offset = 0;
    int maxNum = 0;
    char* ptr = NULL;
    char bufferV[16], bufferU[16];
    int nWidth = 0;
    int nHeight = 0;

    nWidth = (nPicWidth+1)/2;
    nHeight = (nPicHeight+1)/2;

    nLineStride = (nWidth*2 + 15) &~15;
    nMbWidth = (nWidth*2+31)&~31;
    nMbWidth /= 32;

    nMbHeight = (nHeight*2+31)&~31;
    nMbHeight /= 32;

    ptr = pSrc;

    for(i=0; i<nMbHeight; i++)
    {
        char *dst0Asm = NULL;
        char *dst1Asm = NULL;
        char *srcAsm = NULL;
        CEDARC_UNUSE(dst0Asm);
        CEDARC_UNUSE(dst1Asm);
        CEDARC_UNUSE(srcAsm);
        for(j=0; j<nMbWidth; j++)
        {
            for(m=0; m<16; m++)
            {
                if((i*16 + m) >= nHeight)
                {
                    ptr += 64;
                    continue;
                }

                dst0Asm = bufferU;
                dst1Asm = bufferV;
                srcAsm = ptr;
                lineNum = i*16 + m;           //line num
                offset =  lineNum*nLineStride + j*32;

                asm volatile(
                        "vld2.8         {d0-d3}, [%[srcAsm]]              \n\t"
                        "vst1.8         {d0,d1}, [%[dst0Asm]]              \n\t"
                        "vst1.8         {d2,d3}, [%[dst1Asm]]              \n\t"
                        : [dst0Asm] "+r" (dst0Asm), [dst1Asm] "+r" (dst1Asm), [srcAsm] "+r" (srcAsm)
                        :  //[srcY] "r" (srcY)
                        : "cc", "memory", "d0", "d1", "d2", "d3", "d4", \
                            "d5", "d6", "d16", "d17", "d18", "d19", "d20", \
                            "d21", "d22", "d23", "d24", "d28", "d29", "d30", "d31"
                     );
                ptr += 64;

                for(k=0; k<16; k++)
                {
                    if((j*32+ 2*k) >= nLineStride)
                    {
                        break;
                    }
                    pDst[offset+2*k]   = bufferV[k];
                       pDst[offset+2*k+1] = bufferU[k];
                }
            }
        }
    }

}

void ConvertMb32420ToYv12C(char* pSrc,char* pDstU, char*pDstV,int nPicWidth, int nPicHeight)
{
    int nMbWidth = 0;
    int nMbHeight = 0;
    int i = 0;
    int j = 0;
    int m = 0;
    int n = 0;
    int k = 0;
    int nLineStride=0;
    int lineNum = 0;
    int offset = 0;
    int maxNum = 0;
    char* ptr = NULL;
    int nWidth = 0;
    int nHeight = 0;
    char bufferV[16], bufferU[16];
    int nWidthMatchFlag = 0;
    int nCopyMbWidth = 0;

    nWidth = (nPicWidth+1)/2;
    nHeight = (nPicHeight+1)/2;

    //nLineStride = ((nPicWidth+ 15) &~15)/2;
    nLineStride = (nWidth+7)&~7;

    nMbWidth = (nWidth*2+31)&~31;
    nMbWidth /= 32;

    nMbHeight = (nHeight+31)&~31;
    nMbHeight /= 32;

    ptr = pSrc;

    nWidthMatchFlag = 0;
    nCopyMbWidth = nMbWidth-1;

    if(nMbWidth*16 == nLineStride)
    {
        nWidthMatchFlag = 1;
        nCopyMbWidth = nMbWidth;
    }

    for(i=0; i<nMbHeight; i++)
    {
        char *dst0Asm = NULL;
        char *dst1Asm = NULL;
        char *srcAsm = NULL;
        CEDARC_UNUSE(dst0Asm);
        CEDARC_UNUSE(dst1Asm);
        CEDARC_UNUSE(srcAsm);
        for(j=0; j<nCopyMbWidth; j++)
        {
            for(m=0; m<32; m++)
            {
                if((i*32 + m) >= nHeight)
                {
                    ptr += 32;
                    continue;
                }

                srcAsm = ptr;
                lineNum = i*32 + m;           //line num
                offset =  lineNum*nLineStride + j*16;
                dst0Asm = pDstU+offset;
                dst1Asm = pDstV+offset;
                asm volatile(
                        "vld2.8         {d0-d3}, [%[srcAsm]]              \n\t"
                        "vst1.8         {d0,d1}, [%[dst0Asm]]              \n\t"
                        "vst1.8         {d2,d3}, [%[dst1Asm]]              \n\t"
                        : [dst0Asm] "+r" (dst0Asm), [dst1Asm] "+r" (dst1Asm), [srcAsm] "+r" (srcAsm)
                        :  //[srcY] "r" (srcY)
                        : "cc", "memory", "d0", "d1", "d2", "d3", \
                            "d4", "d5", "d6", "d16", "d17", "d18", \
                            "d19", "d20", "d21", "d22", "d23", "d24",  \
                            "d28", "d29", "d30", "d31"
                     );
                ptr += 32;
            }
        }

        if(nWidthMatchFlag == 1)
        {
            continue;
        }
        for(m=0; m<32; m++)
        {
            if((i*32 + m) >= nHeight)
            {
                ptr += 32;
                continue;
            }

               srcAsm = ptr;
               lineNum = i*32 + m;           //line num
            offset =  lineNum*nLineStride + j*16;
               dst0Asm = bufferU;
            dst1Asm = bufferV;
               asm volatile(
                       "vld2.8         {d0-d3}, [%[srcAsm]]              \n\t"
                    "vst1.8         {d0,d1}, [%[dst0Asm]]              \n\t"
                     "vst1.8         {d2,d3}, [%[dst1Asm]]              \n\t"
                       : [dst0Asm] "+r" (dst0Asm), [dst1Asm] "+r" (dst1Asm), [srcAsm] "+r" (srcAsm)
                    :  //[srcY] "r" (srcY)
                    : "cc", "memory", "d0", "d1", "d2", "d3", "d4", \
                        "d5", "d6", "d16", "d17", "d18", "d19",  \
                        "d20", "d21", "d22", "d23", "d24", "d28", \
                        "d29", "d30", "d31"
                 );
               ptr += 32;

               for(k=0; k<16; k++)
               {
                   if((j*16+ k) >= nLineStride)
                   {
                       break;
                   }
                   pDstV[offset+k] = bufferV[k];
                   pDstU[offset+k] = bufferU[k];
               }
        }
    }
}

void ConvertMb32422ToYv12C(char* pSrc,char* pDstU, char*pDstV,int nPicWidth, int nPicHeight)
{
    int nMbWidth = 0;
    int nMbHeight = 0;
    int i = 0;
    int j = 0;
    int m = 0;
    int n = 0;
    int k = 0;
    int nLineStride=0;
    int lineNum = 0;
    int offset = 0;
    int maxNum = 0;
    char* ptr = NULL;

    int nWidth = 0;
    int nHeight = 0;
    char bufferV[16], bufferU[16];
    int nWidthMatchFlag = 0;
    int nCopyMbWidth = 0;

    nWidth = (nPicWidth+1)/2;
    nHeight = (nPicHeight+1)/2;

    nLineStride = (nWidth+7)&~7;

    nMbWidth = (nWidth*2+31)&~31;
    nMbWidth /= 32;

    nMbHeight = (nHeight*2+31)&~31;
    nMbHeight /= 32;

    ptr = pSrc;

    nWidthMatchFlag = 0;
    nCopyMbWidth = nMbWidth-1;

    if(nMbWidth*16 == nLineStride)
    {
        nWidthMatchFlag = 1;
        nCopyMbWidth = nMbWidth;
    }

    for(i=0; i<nMbHeight; i++)
    {
        char *dst0Asm = NULL;
        char *dst1Asm = NULL;
        char *srcAsm = NULL;
        CEDARC_UNUSE(dst0Asm);
        CEDARC_UNUSE(dst1Asm);
        CEDARC_UNUSE(srcAsm);
        for(j=0; j<nCopyMbWidth; j++)
        {
            for(m=0; m<16; m++)
            {
                if((i*16 + m) >= nHeight)
                {
                    ptr += 64;
                    continue;
                }

                srcAsm = ptr;
                lineNum = i*16 + m;           //line num
                offset =  lineNum*nLineStride + j*16;
                dst0Asm = pDstU+offset;
                dst1Asm = pDstV+offset;

                asm volatile(
                        "vld2.8         {d0-d3}, [%[srcAsm]]              \n\t"
                        "vst1.8         {d0,d1}, [%[dst0Asm]]              \n\t"
                        "vst1.8         {d2,d3}, [%[dst1Asm]]              \n\t"
                        : [dst0Asm] "+r" (dst0Asm), [dst1Asm] "+r" (dst1Asm), [srcAsm] "+r" (srcAsm)
                        :  //[srcY] "r" (srcY)
                        : "cc", "memory", "d0", "d1", "d2", "d3", "d4", \
                            "d5", "d6", "d16", "d17", "d18", "d19", "d20", \
                            "d21", "d22", "d23", "d24", "d28", "d29", "d30", "d31"
                     );
                ptr += 64;
            }
        }

        if(nWidthMatchFlag==1)
        {
            continue;
        }
        for(m=0; m<16; m++)
        {
            if((i*16 + m) >= nHeight)
            {
                ptr += 64;
                continue;
            }

            dst0Asm = bufferU;
            dst1Asm = bufferV;
               srcAsm = ptr;
               lineNum = i*16 + m;           //line num
            offset =  lineNum*nLineStride + j*16;

               asm volatile(
                        "vld2.8         {d0-d3}, [%[srcAsm]]              \n\t"
                         "vst1.8         {d0,d1}, [%[dst0Asm]]              \n\t"
                        "vst1.8         {d2,d3}, [%[dst1Asm]]              \n\t"
                        : [dst0Asm] "+r" (dst0Asm), [dst1Asm] "+r" (dst1Asm), [srcAsm] "+r" (srcAsm)
                        :  //[srcY] "r" (srcY)
                        : "cc", "memory", "d0", "d1", "d2", "d3", "d4", \
                            "d5", "d6", "d16", "d17", "d18", "d19", "d20", \
                            "d21", "d22", "d23", "d24", "d28", "d29", "d30", "d31"
                        );
               ptr += 64;

               for(k=0; k<16; k++)
            {
                   if((j*16+ k) >= nLineStride)
                   {
                       break;
                   }
                pDstV[offset+k] = bufferV[k];
                      pDstU[offset+k] = bufferU[k];
            }
        }
    }
}
#endif

//****************************************************************//
//****************************************************************//

void ConvertPixelFormat(VideoPicture* pPictureIn, VideoPicture* pPictureOut)
{
    int   nMemSizeY = 0;
    int   nMemSizeC = 0;
    int   nLineStride = 0;
    int   nHeight16Align = 0;
    //int   nHeight32Align = 0;
    //int   nHeight64Align = 0;
    int   nHeight = 0;
    int   i = 0;
    int      j = 0;

    nHeight        = pPictureIn->nHeight;
    nLineStride    = (pPictureIn->nWidth+15) &~15;
    nHeight16Align = (nHeight+15) & ~15;
    //nHeight32Align = (nHeight+31) & ~31;
    //nHeight64Align = (nHeight+63) & ~63;

    pPictureOut->nLineStride = (pPictureIn->nWidth+15) & ~15;
    pPictureOut->nHeight     = pPictureIn->nHeight;
    pPictureOut->nWidth      = pPictureIn->nWidth;
    pPictureOut->nTopOffset  = pPictureIn->nTopOffset;
    pPictureOut->nBottomOffset  = pPictureIn->nBottomOffset;
    pPictureOut->nLeftOffset  = pPictureIn->nLeftOffset;
    pPictureOut->nRightOffset  = pPictureIn->nRightOffset;

    if(pPictureOut->ePixelFormat==PIXEL_FORMAT_YV12)
    {
#ifdef CEDARX_DECODER_ARM32
        if(pPictureIn->ePixelFormat == PIXEL_FORMAT_YUV_MB32_420)
        {
            nMemSizeY = nLineStride*nHeight16Align;
            nMemSizeC = nMemSizeY>>2;

            ConvertMb32420ToNv21Y(pPictureIn->pData0,pPictureOut->pData0, \
                    pPictureIn->nWidth, pPictureIn->nHeight);
            ConvertMb32420ToYv12C(pPictureIn->pData1, \
                    (char*)(pPictureOut->pData0+nMemSizeY+nMemSizeC), \
                    (char*)(pPictureOut->pData0+nMemSizeY), \
                    pPictureIn->nWidth, pPictureIn->nHeight);

        }
        else if(pPictureIn->ePixelFormat == PIXEL_FORMAT_YUV_MB32_422)
        {
            nMemSizeY = nLineStride*nHeight16Align;
            nMemSizeC = nMemSizeY>>2;
            ConvertMb32420ToNv21Y(pPictureIn->pData0,pPictureOut->pData0, \
                    pPictureIn->nWidth, pPictureIn->nHeight);
            ConvertMb32422ToYv12C(pPictureIn->pData1, \
                    (char*)(pPictureOut->pData0+nMemSizeY+nMemSizeC), \
                    (char*)(pPictureOut->pData0+nMemSizeY), \
                    pPictureIn->nWidth, pPictureIn->nHeight);
        }
#endif

        if(pPictureIn->ePixelFormat == PIXEL_FORMAT_NV21)
        {
            nMemSizeY = nLineStride*nHeight16Align;
            memcpy(pPictureOut->pData0, pPictureIn->pData0, nMemSizeY);
            nMemSizeC = nMemSizeY>>2;
            pPictureOut->pData1 = pPictureOut->pData0 + nMemSizeY;
            pPictureOut->pData2 = pPictureOut->pData1 + nMemSizeC;
            pPictureIn->pData1  = pPictureIn->pData0 + nMemSizeY;

            for(i=0; i<(pPictureIn->nHeight+1)/2; i++)
            {
                for(j=0; j<(pPictureIn->nWidth+1)/2; j++)
                {
                    pPictureOut->pData1[i*nLineStride/2+j] = \
                        pPictureIn->pData1[i*nLineStride+2*j];
                    pPictureOut->pData2[i*nLineStride/2+j] = \
                        pPictureIn->pData1[i*nLineStride+2*j+1];
                }
            }
        }
        else if(pPictureIn->ePixelFormat == PIXEL_FORMAT_YUV_PLANER_420)
        {
            nMemSizeY = nLineStride*nHeight16Align;
            memcpy(pPictureOut->pData0, pPictureIn->pData0, nMemSizeY);
            nMemSizeC = nMemSizeY>>2;
            memcpy(pPictureOut->pData0+nMemSizeY, \
                pPictureIn->pData0+nMemSizeY+nMemSizeC, nMemSizeC);
            memcpy(pPictureOut->pData0+nMemSizeY+nMemSizeC, \
                pPictureIn->pData0+nMemSizeY, nMemSizeC);
        }
    }
    else if(pPictureOut->ePixelFormat==PIXEL_FORMAT_NV21)
    {
#ifdef CEDARX_DECODER_ARM32
        if(pPictureIn->ePixelFormat == PIXEL_FORMAT_YUV_MB32_420)
        {
            nMemSizeY = nLineStride*nHeight16Align;
            //nMemSizeY = nLineStride*nHeight;
            nMemSizeC = nMemSizeY>>2;
            ConvertMb32420ToNv21Y(pPictureIn->pData0,pPictureOut->pData0, \
                    pPictureIn->nWidth, pPictureIn->nHeight);
            ConvertMb32420ToNv21C(pPictureIn->pData1, \
                    pPictureOut->pData0+nMemSizeY, \
                    pPictureIn->nWidth, pPictureIn->nHeight);
        }
        else if(pPictureIn->ePixelFormat == PIXEL_FORMAT_YUV_MB32_422)
        {
            nMemSizeY = nLineStride*nHeight16Align;
            nMemSizeC = nMemSizeY>>2;
            ConvertMb32420ToNv21Y(pPictureIn->pData0,pPictureOut->pData0, \
                pPictureIn->nWidth, pPictureIn->nHeight);
            ConvertMb32422ToNv21C(pPictureIn->pData1, \
                (char*)(pPictureOut->pData0+nMemSizeY), \
                pPictureIn->nWidth, pPictureIn->nHeight);
        }
#endif
        if(pPictureIn->ePixelFormat == PIXEL_FORMAT_YV12)
        {
            nMemSizeY = nLineStride*nHeight16Align;
            memcpy(pPictureOut->pData0, pPictureIn->pData0, nMemSizeY);
            nMemSizeC = nMemSizeY>>2;
            pPictureIn->pData1 = pPictureIn->pData0 + nMemSizeY;
            pPictureIn->pData2 = pPictureIn->pData1 + nMemSizeC;
            pPictureOut->pData1 = pPictureOut->pData0 + nMemSizeY;

            for(i=0; i<(pPictureIn->nHeight+1)/2; i++)
            {
                for(j=0; j<(pPictureIn->nWidth+1)/2; j++)
                {
                    pPictureOut->pData1[i*nLineStride+2*j]   = \
                        pPictureIn->pData1[i*nLineStride/2+j];
                    pPictureOut->pData1[i*nLineStride+2*j+1] = \
                        pPictureIn->pData2[i*nLineStride/2+j];
                }
            }
        }
        else if(pPictureIn->ePixelFormat == PIXEL_FORMAT_YUV_PLANER_420)
        {
            nMemSizeY = nLineStride*nHeight16Align;
            memcpy(pPictureOut->pData0, pPictureIn->pData0, nMemSizeY);
            nMemSizeC = nMemSizeY>>2;
            pPictureIn->pData1 = pPictureIn->pData0 + nMemSizeY;
            pPictureIn->pData2 = pPictureIn->pData1 + nMemSizeC;
            pPictureOut->pData1 = pPictureOut->pData0 + nMemSizeY;

            for(i=0; i<(pPictureIn->nHeight+1)/2; i++)
            {
                for(j=0; j<(pPictureIn->nWidth+1)/2; j++)
                {
                    pPictureOut->pData1[i*nLineStride+2*j]   = \
                        pPictureIn->pData2[i*nLineStride/2+j];
                    pPictureOut->pData1[i*nLineStride+2*j+1] = \
                        pPictureIn->pData1[i*nLineStride/2+j];
                 }
            }
        }
    }
    //AdapterMemFlushCache((void*)pPictureOut->pData0, nMemSizeY+2*nMemSizeC);
}

int RotatePicture0Degree(VideoPicture* pPictureIn,
            VideoPicture* pPictureOut,
            int nGpuYAlign,
            int nGpuCAlign)
{
    int nMemSizeY = 0;
    int nMemSizeC = 0;
    int nLineStride = 0;
    int ePixelFormat = 0;
    int nHeight16Align = 0;
    int nHeight32Align = 0;
    int nHeight64Align = 0;

    nLineStride    = pPictureIn->nLineStride;
    ePixelFormat   = pPictureIn->ePixelFormat;
    nHeight16Align = (pPictureIn->nHeight+15) &~15;
    nHeight32Align = (pPictureIn->nHeight+31) &~31;
    nHeight64Align = (pPictureIn->nHeight+63) &~63;

    switch(pPictureOut->ePixelFormat)
    {
        case PIXEL_FORMAT_YUV_PLANER_420:
        case PIXEL_FORMAT_YUV_PLANER_422:
        case PIXEL_FORMAT_YUV_PLANER_444:
        case PIXEL_FORMAT_YV12:
        case PIXEL_FORMAT_NV21:
            //* for decoder,
            //* height of Y component is required to be 16 aligned,
            //* for example, 1080 becomes to 1088.
            //* width and height of U or V component are both required to be 8 aligned.

            //* nLineStride should be 16 aligned.
            nMemSizeY = nLineStride*nHeight16Align;
            if(ePixelFormat == PIXEL_FORMAT_YUV_PLANER_420 ||
                    ePixelFormat == PIXEL_FORMAT_YV12 ||
                    ePixelFormat == PIXEL_FORMAT_NV21)
                nMemSizeC = nMemSizeY>>2;
            else if(ePixelFormat == PIXEL_FORMAT_YUV_PLANER_422)
                nMemSizeC = nMemSizeY>>1;
            else
                nMemSizeC = nMemSizeY;  //* PIXEL_FORMAT_YUV_PLANER_444

            //* copy relay on gpuYAlign and gpuCAlign if the format is YV12
            if(pPictureOut->ePixelFormat == PIXEL_FORMAT_YV12)
            {
                //* we can memcpy directly if gpuYAlign is 16 and gpuCAlign is 8
                if(nGpuYAlign == 16 && nGpuCAlign == 8)
                {
                    memcpy(pPictureOut->pData0, pPictureIn->pData0, nMemSizeY+nMemSizeC*2);
                }
                else if(nGpuYAlign == 16 && nGpuCAlign == 16)
                {
                    int i;
                    int nCpyWidthSize = pPictureOut->nLineStride;
                    char* pDstData = pPictureOut->pData0;
                    char* pSrcData = pPictureIn->pData0;
                    //* cpy y
                    for(i = 0;i < pPictureIn->nHeight;i++)
                    {
                        memcpy(pDstData,pSrcData,pPictureIn->nWidth);
                        pDstData += nCpyWidthSize;
                        pSrcData += pPictureIn->nLineStride;
                    }
                    //* cpy v
                    pDstData = pPictureOut->pData0 + pPictureOut->nLineStride*pPictureOut->nHeight;
                    pSrcData = pPictureIn->pData0 + nMemSizeY;
                    nCpyWidthSize = (nCpyWidthSize/2 + 15) & ~15;

                    for(i = 0;i < pPictureIn->nHeight/2;i++)
                    {
                        memcpy(pDstData,pSrcData,pPictureIn->nWidth/2);
                        pDstData += nCpyWidthSize;
                        pSrcData += pPictureIn->nLineStride/2;
                    }
                    //* cpy u
                    int nCSize = nCpyWidthSize*pPictureOut->nHeight/2;
                    pDstData = pPictureOut->pData0 + \
                            pPictureOut->nLineStride*pPictureOut->nHeight + nCSize;
                    pSrcData = pPictureIn->pData0 + nMemSizeY+nMemSizeC;
                    for(i = 0;i < pPictureIn->nHeight/2;i++)
                    {
                        memcpy(pDstData,pSrcData,pPictureIn->nWidth/2);
                        pDstData += nCpyWidthSize;
                        pSrcData += pPictureIn->nLineStride/2;
                    }
                }
                else if(nGpuYAlign == 32 && nGpuCAlign == 16)
                {
                    int i;
                    int nCpyWidthSize = pPictureOut->nLineStride;
                    char* pDstData = pPictureOut->pData0;
                    char* pSrcData = pPictureIn->pData0;
                    //* cpy y
                    for(i = 0;i < pPictureIn->nHeight;i++)
                    {
                        memcpy(pDstData,pSrcData,pPictureIn->nWidth);
                        pDstData += nCpyWidthSize;
                        pSrcData += pPictureIn->nLineStride;
                    }
                    //* cpy v
                    pDstData = pPictureOut->pData0 + \
                            pPictureOut->nLineStride*pPictureOut->nHeight;
                    pSrcData = pPictureIn->pData0 + nMemSizeY;
                    for(i = 0;i < pPictureIn->nHeight/2;i++)
                    {
                        memcpy(pDstData,pSrcData,pPictureIn->nWidth/2);
                        pDstData += nCpyWidthSize/2;
                        pSrcData += pPictureIn->nLineStride/2;
                    }
                    //* cpy u
                    pDstData = pPictureOut->pData0 + \
                            pPictureOut->nLineStride*pPictureOut->nHeight*5/4;
                    pSrcData = pPictureIn->pData0 + nMemSizeY+nMemSizeC;
                    for(i = 0;i < pPictureIn->nHeight/2;i++)
                    {
                        memcpy(pDstData,pSrcData,pPictureIn->nWidth/2);
                        pDstData += nCpyWidthSize/2;
                        pSrcData += pPictureIn->nLineStride/2;
                    }
                }
                else
                {
                    loge("the nGpuYAlign[%d] and nGpuCAlign[%d] is not surpport!", \
                        nGpuYAlign,nGpuCAlign);
                    return -1;
                }
            }
            else
            {
                memcpy(pPictureOut->pData0, pPictureIn->pData0, nMemSizeY+nMemSizeC*2);
            }
            break;

        case PIXEL_FORMAT_YUV_MB32_420:
        case PIXEL_FORMAT_YUV_MB32_422:
        case PIXEL_FORMAT_YUV_MB32_444:
            //* for decoder,
            //* height of Y component is required to be 32 aligned.
            //* height of UV component are both required to be 32 aligned.
            //* nLineStride should be 32 aligned.
            nMemSizeY = nLineStride*nHeight32Align;
            if(ePixelFormat == PIXEL_FORMAT_YUV_MB32_420)
                nMemSizeC = nLineStride*nHeight64Align/4;
            else if(ePixelFormat == PIXEL_FORMAT_YUV_MB32_422)
                nMemSizeC = nLineStride*nHeight64Align/2;
            else
                nMemSizeC = nLineStride*nHeight64Align;

            memcpy(pPictureOut->pData0, pPictureIn->pData0, nMemSizeY);
            memcpy(pPictureOut->pData1, pPictureIn->pData1, nMemSizeC*2);
            //AdapterMemFlushCache((void*)pPictureOut->pData0, nMemSizeY);
            //AdapterMemFlushCache((void*)pPictureOut->pData1, 2*nMemSizeC);
            break;

        default:
            loge("pixel format incorrect, ePixelFormat=%d", ePixelFormat);
            return -1;
    }
    return 0;
}

int RotatePicture90Degree(VideoPicture* pPictureIn, VideoPicture* pPictureOut)
{
    int nLeftOffset = 0;
    int nRightOffset = 0;
    int nBottomOffset = 0;
    int nTopOffset = 0;

    pPictureOut->nLineStride = (pPictureIn->nHeight+15) &~15;
    pPictureOut->nHeight = pPictureIn->nWidth;
    pPictureOut->nWidth = pPictureIn->nHeight;

    if(pPictureOut->ePixelFormat==PIXEL_FORMAT_YV12
            ||(pPictureOut->ePixelFormat == PIXEL_FORMAT_NV21)
            ||(pPictureOut->ePixelFormat == PIXEL_FORMAT_NV12))
    {
        int i;
        int j;
        for(j=0; j<pPictureIn->nHeight; j++)
        {
            for(i=0; i<pPictureIn->nWidth; i++)
            {
                pPictureOut->pData0[i*pPictureOut->nLineStride+pPictureIn->nHeight-j-1] = \
                    pPictureIn->pData0[j*pPictureIn->nLineStride+i];
            }
        }

        int nHeight           = pPictureIn->nHeight/2;
        int nWidth            = pPictureIn->nWidth/2;
        int nLineStride       = pPictureIn->nLineStride/2;
        int nRotateLineStride = pPictureOut->nLineStride/2;

        int nMemSizeY = 0;
        int nMemSizeC = 0;
        if(pPictureOut->ePixelFormat==PIXEL_FORMAT_YV12)
        {
            nMemSizeY = pPictureIn->nLineStride*((pPictureIn->nHeight+15)&~15);
            nMemSizeC = nMemSizeY>>2;
            pPictureIn->pData1  =  pPictureIn->pData0 + nMemSizeY;
            pPictureIn->pData2  =  pPictureIn->pData1 + nMemSizeC;

            nMemSizeY = pPictureOut->nLineStride*((pPictureOut->nHeight+15)&~15);
            nMemSizeC = nMemSizeY>>2;
            pPictureOut->pData1 =  pPictureOut->pData0+ nMemSizeY;
            pPictureOut->pData2 =  pPictureOut->pData1+ nMemSizeC;

            for(j=0; j<nHeight; j++)
            {
                for(i=0; i<nWidth; i++)
                {
                    pPictureOut->pData1[i*nRotateLineStride+nHeight-j-1] = \
                        pPictureIn->pData1[j*nLineStride+i];
                    pPictureOut->pData2[i*nRotateLineStride+nHeight-j-1] = \
                        pPictureIn->pData2[j*nLineStride+i];
                }
            }
        }
        else if((pPictureOut->ePixelFormat==PIXEL_FORMAT_NV21)|| \
            (pPictureOut->ePixelFormat==PIXEL_FORMAT_NV12))
        {
            nMemSizeY = pPictureIn->nLineStride*((pPictureIn->nHeight+15)&~15);
            pPictureIn->pData1  =  pPictureIn->pData0 + nMemSizeY;

            nMemSizeY = pPictureOut->nLineStride*((pPictureOut->nHeight+15)&~15);
            nMemSizeC = nMemSizeY>>2;
            CEDARC_UNUSE(nMemSizeC);
            pPictureOut->pData1 =  pPictureOut->pData0+ nMemSizeY;

            for(j=0; j<nHeight; j++)
            {
                for(i=0; i<nWidth; i++)
                {
                    pPictureOut->pData1[2*i*nRotateLineStride+2*nHeight-(2*j+1)-1] = \
                        pPictureIn->pData1[2*j*nLineStride+2*i];
                    pPictureOut->pData1[2*i*nRotateLineStride+2*nHeight-(2*j)-1] = \
                        pPictureIn->pData1[2*j*nLineStride+2*i+1];
                }
            }
        }
    }

    //AdapterMemFlushCache((void*)pPictureOut->pData0, nMemSizeY+2*nMemSizeC);

    nLeftOffset = pPictureIn->nLeftOffset;
    nRightOffset = pPictureIn->nWidth - pPictureIn->nRightOffset;
    nTopOffset = pPictureIn->nTopOffset;
    nBottomOffset = pPictureIn->nHeight - pPictureIn->nTopOffset;

    pPictureOut->nLeftOffset   = nBottomOffset;
    pPictureOut->nBottomOffset = nRightOffset;
    pPictureOut->nRightOffset  = nTopOffset;
    pPictureOut->nTopOffset    = nLeftOffset;
    pPictureOut->nRightOffset  = pPictureOut->nWidth - pPictureOut->nRightOffset;
    pPictureOut->nBottomOffset  = pPictureOut->nHeight -pPictureOut->nBottomOffset;
    return 0;
}

int RotatePicture180Degree(VideoPicture* pPictureIn, VideoPicture* pPictureOut)
{
    //int nRotateLineStride = 0;
    int nLeftOffset = 0;
    int nRightOffset = 0;
    int nBottomOffset = 0;
    int nTopOffset = 0;

    pPictureOut->nLineStride = pPictureIn->nLineStride;

    if(pPictureOut->ePixelFormat==PIXEL_FORMAT_YV12
            ||(pPictureOut->ePixelFormat == PIXEL_FORMAT_NV21)
            ||(pPictureOut->ePixelFormat == PIXEL_FORMAT_NV12))
    {

        int i;
        int j;
        for(j=0; j<pPictureIn->nHeight; j++)
        {
            for(i=0; i<pPictureIn->nWidth; i++)
            {
                int index = (pPictureIn->nHeight-1-j)*pPictureIn->nLineStride+ \
                    (pPictureIn->nWidth-1-i);
                pPictureOut->pData0[index] = pPictureIn->pData0[j*pPictureIn->nLineStride+i];
            }
        }

        int nHeight           = pPictureIn->nHeight/2;
        int nWidth            = pPictureIn->nWidth/2;
        int nLineStride       = pPictureIn->nLineStride/2;

        int nMemSizeY;
        int nMemSizeC;
        if(pPictureOut->ePixelFormat==PIXEL_FORMAT_YV12)
        {
            nMemSizeY = pPictureIn->nLineStride*((pPictureIn->nHeight+15)&~15);
            nMemSizeC = nMemSizeY>>2;
            pPictureOut->pData1 =  pPictureOut->pData0+ nMemSizeY;
            pPictureOut->pData2 =  pPictureOut->pData1+ nMemSizeC;
            pPictureIn->pData1  =  pPictureIn->pData0 + nMemSizeY;
            pPictureIn->pData2  =  pPictureIn->pData1 + nMemSizeC;

            for(j=0; j<nHeight; j++)
            {
                for(i=0; i<nWidth; i++)
                {
                    pPictureOut->pData1[(nHeight-1-j)*nLineStride+(nWidth-1-i)] = \
                        pPictureIn->pData1[j*nLineStride+i];
                    pPictureOut->pData2[(nHeight-1-j)*nLineStride+(nWidth-1-i)] =  \
                        pPictureIn->pData2[j*nLineStride+i];
                }
            }
        }
        else if((pPictureOut->ePixelFormat==PIXEL_FORMAT_NV21)|| \
            (pPictureOut->ePixelFormat==PIXEL_FORMAT_NV12))
        {
             nMemSizeY = pPictureIn->nLineStride*((pPictureIn->nHeight+15)&~15);
             nMemSizeC = nMemSizeY>>2;
             CEDARC_UNUSE(nMemSizeC);

             pPictureOut->pData1 =  pPictureOut->pData0+ nMemSizeY;
             pPictureIn->pData1  =  pPictureIn->pData0 + nMemSizeY;
             for(j=0; j<nHeight; j++)
             {
                 for(i=0; i<nWidth; i++)
                 {
                     pPictureOut->pData1[2*(nHeight-1-j)*nLineStride+2*(nWidth-1-i)] = \
                        pPictureIn->pData1[2*j*nLineStride+2*i];
                     pPictureOut->pData1[2*(nHeight-1-j)*nLineStride+2*(nWidth-1-i)+1] = \
                        pPictureIn->pData1[2*j*nLineStride+2*i+1];
                 }
             }
        }
    }

    //AdapterMemFlushCache((void*)pPictureOut->pData0, nMemSizeY+2*nMemSizeC);
    pPictureOut->nHeight = pPictureIn->nHeight;
    pPictureOut->nWidth = pPictureIn->nWidth;

    nLeftOffset = pPictureIn->nLeftOffset;
    nRightOffset = pPictureIn->nWidth - pPictureIn->nRightOffset;
    nTopOffset = pPictureIn->nTopOffset;
    nBottomOffset = pPictureIn->nHeight - pPictureIn->nTopOffset;

    pPictureOut->nLeftOffset   = nRightOffset;
    pPictureOut->nBottomOffset = nTopOffset;
    pPictureOut->nRightOffset  = nLeftOffset;
    pPictureOut->nTopOffset    = nBottomOffset;

    pPictureOut->nRightOffset  = pPictureOut->nWidth - pPictureOut->nRightOffset;
    pPictureOut->nBottomOffset = pPictureOut->nHeight -pPictureOut->nBottomOffset;
    return 0;
}

int RotatePicture270Degree(VideoPicture* pPictureIn, VideoPicture* pPictureOut)
{
    int nLeftOffset = 0;
    int nRightOffset = 0;
    int nBottomOffset = 0;
    int nTopOffset = 0;

    pPictureOut->nLineStride = (pPictureIn->nHeight+15) &~15;
    pPictureOut->nHeight = pPictureIn->nWidth;
    pPictureOut->nWidth = pPictureIn->nHeight;

    if(pPictureOut->ePixelFormat==PIXEL_FORMAT_YV12
            ||(pPictureOut->ePixelFormat == PIXEL_FORMAT_NV21)
            ||(pPictureOut->ePixelFormat == PIXEL_FORMAT_NV12))

    {
        int i = 0;
        int j = 0;
        for(j=0; j<pPictureIn->nHeight; j++)
        {
            for(i=0; i<pPictureIn->nWidth; i++)
            {
                pPictureOut->pData0[(pPictureIn->nWidth-1-i)*pPictureOut->nLineStride+j] = \
                    pPictureIn->pData0[j*pPictureIn->nLineStride+i];
            }
        }

        int nHeight           = pPictureIn->nHeight/2;
        int nWidth            = pPictureIn->nWidth/2;
        int nLineStride       = pPictureIn->nLineStride/2;
        int nRotateLineStride = pPictureOut->nLineStride/2;

        int nMemSizeY = 0;
        int nMemSizeC = 0;
        if(pPictureOut->ePixelFormat==PIXEL_FORMAT_YV12)
        {
            nMemSizeY = pPictureIn->nLineStride*((pPictureIn->nHeight+15)&~15);
            nMemSizeC = nMemSizeY>>2;

            pPictureIn->pData1  =  pPictureIn->pData0 + nMemSizeY;
            pPictureIn->pData2  =  pPictureIn->pData1 + nMemSizeC;

            nMemSizeY = pPictureOut->nLineStride*((pPictureOut->nHeight+15)&~15);
            nMemSizeC = nMemSizeY>>2;
            pPictureOut->pData1 =  pPictureOut->pData0+ nMemSizeY;
            pPictureOut->pData2 =  pPictureOut->pData1+ nMemSizeC;

            for(j=0; j<nHeight; j++)
            {
                for(i=0; i<nWidth; i++)
                {
                    pPictureOut->pData1[(nWidth-1-i)*nRotateLineStride+j] = \
                        pPictureIn->pData1[j*nLineStride+i];
                    pPictureOut->pData2[(nWidth-1-i)*nRotateLineStride+j] = \
                        pPictureIn->pData2[j*nLineStride+i];
                }
            }
        }
        else if((pPictureOut->ePixelFormat==PIXEL_FORMAT_NV21) || \
            (pPictureOut->ePixelFormat==PIXEL_FORMAT_NV12))
        {
            nMemSizeY = pPictureIn->nLineStride*((pPictureIn->nHeight+15)&~15);
            pPictureIn->pData1  =  pPictureIn->pData0 + nMemSizeY;

            nMemSizeY = pPictureOut->nLineStride*((pPictureOut->nHeight+15)&~15);
            nMemSizeC = nMemSizeY>>2;
            CEDARC_UNUSE(nMemSizeC);

            for(j=0; j<nHeight; j++)
            {
                for(i=0; i<nWidth; i++)
                {
                    pPictureOut->pData1[2*(nWidth-1-i)*nRotateLineStride+2*j] = \
                        pPictureIn->pData1[2*j*nLineStride+2*i];
                    pPictureOut->pData1[2*(nWidth-1-i)*nRotateLineStride+2*j+1] = \
                        pPictureIn->pData1[2*j*nLineStride+2*i+1];
                }
            }
        }
    }

    //AdapterMemFlushCache((void*)pPictureOut->pData0, nMemSizeY+2*nMemSizeC);
    nLeftOffset = pPictureIn->nLeftOffset;
    nRightOffset = pPictureIn->nWidth - pPictureIn->nRightOffset;
    nTopOffset = pPictureIn->nTopOffset;
    nBottomOffset = pPictureIn->nHeight - pPictureIn->nTopOffset;

    pPictureOut->nLeftOffset   = nTopOffset;
    pPictureOut->nBottomOffset = nLeftOffset;
    pPictureOut->nRightOffset  = nBottomOffset;
    pPictureOut->nTopOffset    = nRightOffset;

    pPictureOut->nRightOffset  = pPictureOut->nWidth - pPictureOut->nRightOffset;
    pPictureOut->nBottomOffset = pPictureOut->nHeight -pPictureOut->nBottomOffset;
    return 0;
}