/* ///////////////////////////////////////////////////////////////////////
//
//               INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in accordance with the terms of that agreement.
//        Copyright (c) 2008 Intel Corporation. All Rights Reserved.
//
//  Description: Parses VC-1 bitstreams.
//
*/

#include "vc1parse.h"

#ifdef VBP
#include "viddec_pm.h"
#endif

/*----------------------------------------------------------------------------*/


/* put one bit into a buffer
 * used for bitplane decoding, each bit correspond to a MB
 * HW requires row to start at DW (32 bits) boundary
 * input: value - bit value
 *        mbx - image width in MB
 *        mby - image height in MB
 *        x   - x location (column) of MB in MB unit
 *        y   - y location (row) of MB in MB unit
 * output: outp - buffer to fill
 */
//#define put_bit(value,x,y,mbx,mby,invert,outp)
static inline void put_bit( uint32_t value, int x, int y, int mbx, int mby, uint8_t invert, uint32_t* outp)
{
    int bit;
    uint32_t *out;

    bit = mby;

    value ^= invert;
    if (!value) return; /* assume buffer is initialized with zeros */

    out = outp;
    /* go to corresponding row location in DW unit */
    out += (( mbx + 31 ) >> 5) * y;
    out +=  x >> 5; /* go to corresponding column location in DW unit */
    bit = x & 0x1f; /* compute remaining bits */
    *out |= 1 << bit; /* put bit */
}

/* if b is the bit at location (x,y)
 * b = b^invert
 * used for bitplane decoding, each bit correspond to a MB
 * HW requires row to start at DW (32 bits) boundary
 * input: value - bit value
 *        x   - x location (column) of MB in MB unit
 *        y   - y location (row) of MB in MB unit
 *        mbx - image width in MB
 * output: outp - buffer to fill
 * returns bit value
 */
static inline int xor_bit(  int x, int y, int mbx, uint32_t invert, uint32_t* outp)
{
    int bit;
    uint32_t *out;
    uint8_t value;
    //if (invert == 0) return; /* do nothing if XOR with 0 */

    out = outp;
    out += (( mbx + 31 ) >> 5) * y; /* go to corresponding row location in DW unit */
    out +=  x >> 5; /* go to corresponding row location in DW unit */
    bit = x & 0x1f; /* compute remaining bits */

    if (invert == 1)
        *out ^= (1 << bit); /* put XOR bit */
    value = (*out & (1 << bit)) >> bit; /* return bit value */

    return(value);

}

/* get bit at location (x,y)
 * used for bitplane decoding, each bit correspond to a MB
 * HW requires row to start at DW (32 bits) boundary
 * input: value - bit value
 *        x   - x location (column) of MB in MB unit
 *        y   - y location (row) of MB in MB unit
 *        mbx - image width in MB
 *        outp - bit buffer in dwords
 * returns bit value
 */
static inline int get_bit(  int x, int y, int mbx, uint32_t* outp)
{
    int bit;
    uint32_t *out;
    uint8_t value;

    out = outp;
    out += (( mbx + 31 ) >> 5) * y; /* go to corresponding row location in DW unit */
    out +=  x >> 5; /* go to corresponding row location in DW unit */
    bit = x & 0x1f; /* compute remaining bits */
    value = (*out & (1 << bit)) >> bit; /* return bit value */

    return(value);

}

static void vc1_InverseDiff(vc1_Bitplane *pBitplane, int32_t widthMB, int32_t heightMB)
{
    int32_t i, j, previousBit=0, temp;

    for (i = 0; i < heightMB; i++)
    {
        for (j = 0; j < widthMB; j++)
        {
            if ((i == 0 && j == 0))
            {
                previousBit=xor_bit(j, i, widthMB, pBitplane->invert,
                                    pBitplane->databits);
            }
            else if (j == 0) /* XOR with TOP */
            {
                previousBit = get_bit(0, i-1, widthMB, pBitplane->databits);
                temp=xor_bit(j, i, widthMB, previousBit,
                             pBitplane->databits);
                previousBit = temp;
            }
            //TODO isSameAsTop can be optimized
            else if (((i > 0) && (previousBit !=
                                  get_bit(j, i-1, widthMB, pBitplane->databits))))
            {
                temp=xor_bit(j, i, widthMB, pBitplane->invert,
                             pBitplane->databits);
                previousBit = temp;
            }
            else
            {
                temp=xor_bit(j, i, widthMB, previousBit,
                             pBitplane->databits);
                previousBit = temp;
            }
        }
    }
}


/*----------------------------------------------------------------------------*/
/* implement normal 2 mode bitplane decoding, SMPTE 412M 8.7.3.2
 * width, height are in MB unit.
 */
static void vc1_Norm2ModeDecode(void* ctxt, vc1_Bitplane *pBitplane,
                                int32_t width, int32_t height)
{
    int32_t i;
    int32_t tmp_databits = 0;

    int32_t row[2], col[2];
    int8_t tmp=0;

    /* disable pBitplane->invert in the Norm2 decode stage of
       VC1_BITPLANE_DIFF2_MODE */
    if (pBitplane->imode == VC1_BITPLANE_DIFF2_MODE)
    {
        tmp = pBitplane->invert;
        pBitplane->invert=0;
    }

    // By default, initialize the values for the even case
    col[0] = 0;   /* i%width; */
    row[0] = 0;   /* i/width; */
    col[1] = 1;   /* (i+1)%width; */
    row[1] = 0;   /* (i+1)/width; */

    // If width*height is odd, the first bit is the value of the bitplane
    // for the first macroblock
    if ((width*height) & 1) /* first bit if size is odd */
    {
        VC1_GET_BITS(1, tmp_databits);
        put_bit(tmp_databits, 0, 0, width, height, pBitplane->invert,
                pBitplane->databits);

        // Modify initialization for odd sizes
        col[0] = 1;   /* i%width; */
        col[1] = 2;   /* (i+1)%width; */

        // Consider special case where width is 1
        if(width == 1)
        {
            col[0] = 0;   /* i%width; */
            row[0] = 1;   /* i/width; */
            col[1] = 0;   /* (i+1)%width; */
            row[1] = 2;   /* (i+1)/width; */
        }
    }
    
    /* decode every pair of bits in natural scan order */
    for (i = (width*height) & 1; i < (width*height/2)*2; i += 2)
    {
        int32_t tmp = 0;

        //col[0]=i%width;
        //row[0]=i/width;
        //col[1]=(i+1)%width;
        //row[1]=(i+1)/width;

        VC1_GET_BITS(1, tmp);
        if (tmp == 0)
        {
            put_bit(0, col[0],row[0], width, height, pBitplane->invert,
                    pBitplane->databits);
            put_bit(0, col[1],row[1], width, height, pBitplane->invert,
                    pBitplane->databits);
        }
        else
        {
            VC1_GET_BITS(1, tmp);
            if (tmp == 1)
            {
                put_bit(1, col[0],row[0], width, height, pBitplane->invert,
                        pBitplane->databits);
            	put_bit(1, col[1],row[1], width, height, pBitplane->invert,
                        pBitplane->databits);
            }
            else
            {
                VC1_GET_BITS(1, tmp);
                if (tmp == 0)
                {
                    put_bit(1, col[0],row[0], width, height, pBitplane->invert,
                            pBitplane->databits);
            	    put_bit(0, col[1],row[1], width, height, pBitplane->invert,
                            pBitplane->databits);
                }
                else
                {
                    put_bit(0, col[0],row[0], width, height, pBitplane->invert,
                            pBitplane->databits);
            	    put_bit(1, col[1],row[1], width, height, pBitplane->invert,
                            pBitplane->databits);
                }
            }
        }

        // Consider special case where width is 1
        if(width == 1)
        {
            row[0] += 2;
            row[1] += 2;
        }
        else
        {
            col[0] += 2;   /* i%width; */
            if ( col[0] >= width )
            {
		// For odd sizes, col[0] can alternatively start at 0 and 1
                col[0] -= width;
                row[0]++;
            }

            col[1] += 2;   /* (i+1)%width; */
            if ( col[1] >= width )
            {
		// For odd sizes, col[1] can alternatively start at 0 and 1
                col[1] -= width;
                row[1]++;
            }
        }
    }

    /* restore value */
    pBitplane->invert=tmp;
}

/*----------------------------------------------------------------------------*/
/* compute Normal-6 mode bitplane decoding
 * algorithm is described in SMPTE 421M 8.7.3.4
 * width, height are in MB unit.
 */
static void vc1_Norm6ModeDecode(void* ctxt, vc1_Bitplane *pBitplane,
                                int32_t width, int32_t height)
{
    vc1_Status status;
    int32_t i, j, k;
    int32_t ResidualX = 0;
    int32_t ResidualY = 0;
    uint8_t _2x3tiled = (((width%3)!=0)&&((height%3)==0));

    int32_t row, col;
    int8_t tmp=0;

    /* disable pBitplane->invert in the Norm2 decode stage of
       VC1_BITPLANE_DIFF2_MODE */
    if (pBitplane->imode == VC1_BITPLANE_DIFF6_MODE)
    {
        tmp = pBitplane->invert;
        pBitplane->invert=0;
    }

    if (_2x3tiled)
    {
        int32_t sizeW = width/2;
        int32_t sizeH = height/3;

        for (i = 0; i < sizeH; i++)
        {
            row = 3*i; /* compute row location for tile */

            for (j = 0; j < sizeW; j++)
            {
                col = 2*j + (width & 1); /* compute column location for tile */

                /* get k=sum(bi2^i) were i is the ith bit of the tile */
                status = vc1_DecodeHuffmanOne(ctxt, &k, VC1_BITPLANE_K_TBL);
                VC1_ASSERT(status == VC1_STATUS_OK);

                /* put bits in tile */
                put_bit(k&1, col, row, width, height, pBitplane->invert,
                        pBitplane->databits);
                put_bit(((k&2)>>1), col+1, row, width, height,
                        pBitplane->invert,pBitplane->databits);

                put_bit(((k&4)>>2), col, row+1, width, height,
                        pBitplane->invert,pBitplane->databits);
                put_bit(((k&8)>>3), col+1, row+1, width, height,
                        pBitplane->invert,pBitplane->databits);

                put_bit(((k&16)>>4), col, row+2, width, height,
                        pBitplane->invert,pBitplane->databits);
                put_bit(((k&32)>>5), col+1, row+2, width,
                        height,pBitplane->invert, pBitplane->databits);
            }
        }
        ResidualX = width & 1;
        ResidualY = 0;
    }
    else /* 3x2 tile */
    {
        int32_t sizeW = width/3;
        int32_t sizeH = height/2;

        for (i = 0; i < sizeH; i++)
        {
            row = 2*i + (height&1) ; /* compute row location for tile */

            for (j = 0; j < sizeW; j++)
            {
                col = 3*j + (width%3); /* compute column location for tile */

                /* get k=sum(bi2^i) were i is the ith bit of the tile */
                status = vc1_DecodeHuffmanOne(ctxt, &k, VC1_BITPLANE_K_TBL);
                VC1_ASSERT(status == VC1_STATUS_OK);

                put_bit(k&1, col, row, width, height,pBitplane->invert,
                        pBitplane->databits);
                put_bit((k&2)>>1, col+1, row, width, height, pBitplane->invert,
                        pBitplane->databits);
                put_bit((k&4)>>2, col+2, row, width, height, pBitplane->invert,
                        pBitplane->databits);

                put_bit((k&8)>>3, col, row+1, width, height,pBitplane->invert,
                        pBitplane->databits);
                put_bit((k&16)>>4, col+1, row+1, width,
                        height,pBitplane->invert, pBitplane->databits);
                put_bit((k&32)>>5, col+2, row+1, width,
                        height,pBitplane->invert, pBitplane->databits);
            }
        }
        ResidualX = width % 3;
        ResidualY = height & 1;
    }

    for (i = 0; i < ResidualX; i++)
    {
        int32_t ColSkip;
        VC1_GET_BITS(1, ColSkip);

        //if (1 == ColSkip)
        {
            for(j = 0; j < height; j++)
            {
			int32_t Value = 0;
			if (1 == ColSkip) VC1_GET_BITS(1, Value);
			
			put_bit(Value, i, j, width, height,pBitplane->invert,pBitplane->databits);
            }
        }
    }

    for (j = 0; j < ResidualY; j++)
    {
        int32_t RowSkip;
        VC1_GET_BITS(1, RowSkip);
        //if (1 == RowSkip)
        {
            for (i = ResidualX; i < width; i++)
            {
				int32_t Value = 0;
				if (1 == RowSkip) VC1_GET_BITS(1, Value);
				
				put_bit(Value, i, j, width, height,pBitplane->invert,pBitplane->databits);
            }
        }
    }

    /* restore value */
    pBitplane->invert=tmp;

}

/*----------------------------------------------------------------------------*/
/* initialize bitplane to array of zeros
 * each row begins with a dword
 * input:
 *    width: widh in MB unit
 *    height: height in MB unit
 * returns even bitplane size in dwords
 */
int initBitplane(vc1_Bitplane *pBitplane,uint32_t width, uint32_t height)
{
    int i;
    int numDword = 0;

    numDword = ((width + 31)>>5) *  height;
    numDword += numDword & 1; /* add 1 in case numDword is odd */

    for (i=0;i<numDword;i++) pBitplane->databits[i] = 0;
    return(numDword);
}

/*----------------------------------------------------------------------------*/
/* modified IPP code for bitplane decoding
 *    width: width in MB unit
 *    height: height in MB unit
 */
vc1_Status vc1_DecodeBitplane(void* ctxt, vc1_Info *pInfo, 
                              uint32_t width, uint32_t height, vc1_bpp_type_t bpnum)
{
    uint32_t i, j;
    uint32_t tempValue;
    vc1_Status status = VC1_STATUS_OK;
    uint32_t biplaneSz; /* bitplane sz in dwords */
    vc1_Bitplane bp;
    vc1_Bitplane *bpp = &bp;

    // By default, set imode to raw 
    pInfo->metadata.bp_raw[bpnum - VIDDEC_WORKLOAD_VC1_BITPLANE0] = true;

    // bitplane data would be temporarily stored in the vc1 context
    bpp->databits = pInfo->bitplane;

    /* init bitplane to zero, function retunr bitplane buffer size in dword */
    biplaneSz = initBitplane(bpp, width, height);

    VC1_GET_BITS(1, tempValue);
    bpp->invert = (uint8_t) tempValue;

    if ((status = vc1_DecodeHuffmanOne(ctxt, &bpp->imode,VC1_BITPLANE_IMODE_TBL)) != VC1_STATUS_OK)
    {
        return status;
    }

    // If the imode is VC1_BITPLANE_RAW_MODE: bitplane information is in the MB layer
    // there is no need to parse for bitplane information in the picture layer
    // Only bits need to be appropriately set in the block control register
    // In all other modes, bitplane information follows and needs to be parsed and sent to the decoder

    if (bpp->imode == VC1_BITPLANE_NORM2_MODE)
    {
        vc1_Norm2ModeDecode(ctxt, bpp, width, height);
    }
    else if (bpp->imode == VC1_BITPLANE_DIFF2_MODE)
    {
        vc1_Norm2ModeDecode(ctxt, bpp, width, height);
        vc1_InverseDiff(bpp, width, height);
    }
    else if (bpp->imode == VC1_BITPLANE_NORM6_MODE)
    {
        vc1_Norm6ModeDecode(ctxt, bpp, width, height);

    }
    else if (bpp->imode == VC1_BITPLANE_DIFF6_MODE)
    {
        vc1_Norm6ModeDecode(ctxt, bpp, width, height);
        vc1_InverseDiff(bpp, width, height);
    }
    else if (bpp->imode == VC1_BITPLANE_ROWSKIP_MODE)
    {

        for (i = 0; i < height; i++)
        {
            VC1_GET_BITS(1, tempValue);
            /* if tempValue==0,  put row of zeros Dwords*/
            if (tempValue == 1)
            {
                for (j = 0; j < width; j++)
                {
                    VC1_GET_BITS(1, tempValue);
                    put_bit( tempValue, j, i, width, height, bpp->invert,bpp->databits);
                }
            }
            else if (bpp->invert) { //TO TEST
                for (j = 0; j < width; j++) {
                    put_bit( 0, j, i, width, height, bpp->invert, bpp->databits);
                }
            }
        }

    }
    else if (bpp->imode == VC1_BITPLANE_COLSKIP_MODE)
    {
        for (i = 0; i < width; i++)
        {
            VC1_GET_BITS(1, tempValue);
            /* if tempValue==0, and invert == 0, fill column with zeros */
            if (tempValue == 1)
            {
                for (j = 0; j < height; j++)
                {
                    VC1_GET_BITS(1, tempValue);
                    put_bit( tempValue, i, j, width, height, bpp->invert, bpp->databits);
                }
            } 
            else if (bpp->invert) { // fill column with ones
                for (j = 0; j < height; j++) {
                    put_bit( 0, i, j, width, height, bpp->invert, bpp->databits);
                }
            }//end for else  
        }
    }

    if(bpp->imode != VC1_BITPLANE_RAW_MODE)
    {
        uint32_t* pl;
        int sizeinbytes,nitems,i;
        viddec_workload_item_t    wi;
        uint32_t *bit_dw;

        pInfo->metadata.bp_raw[bpnum - VIDDEC_WORKLOAD_VC1_BITPLANE0] = false;

        sizeinbytes = ((( width + 31 ) / 32)) * (height) * 4;

        pl = bpp->databits;
        bit_dw = bpp->databits;

        // How many payloads must be generated
        nitems = (sizeinbytes + (sizeof(wi.data.data_payload) - 1)) /
            sizeof(wi.data.data_payload);

        // Dump DMEM to an array of workitems
        for( i = 0; i < nitems; i++ )
        {
            wi.vwi_type           =  bpnum;
            wi.data.data_offset   = (char *)pl - (char *)bit_dw; // offset within struct

            wi.data.data_payload[0] = pl[0];
            wi.data.data_payload[1] = pl[1];
            pl += 2;

            viddec_pm_append_workitem( ctxt, &wi, false);
        }
    }

#ifdef VBP
    {
      viddec_pm_cxt_t     *cxt    = (viddec_pm_cxt_t *)ctxt;
      vc1_viddec_parser_t *parser = (vc1_viddec_parser_t *)(cxt->codec_data);

      if (biplaneSz > 4096)
      {
        /* bigger than we got, so let's bail with a non meaningful error. */
        return VC1_STATUS_ERROR;
      }
      
      /* At this point bp contains the information we need for the bit-plane */
      /* bpnum is the enumeration that tells us which bitplane this is for.  */
      /* pInfo->picLayerHeader.ACPRED is one of the bitplanes I need to fill.*/
      switch (bpnum)
      {
        case VIDDEC_WORKLOAD_VC1_BITPLANE0:
          if (pInfo->picLayerHeader.PTYPE == VC1_B_FRAME)
          {
            if(bp.imode != VC1_BITPLANE_RAW_MODE)
            {
              pInfo->picLayerHeader.FORWARDMB.invert = bp.invert;
              pInfo->picLayerHeader.FORWARDMB.imode = bp.imode;
              for (i = 0; i < biplaneSz; i++)
              {
                parser->bp_forwardmb[i] = bp.databits[i];
              }
              pInfo->picLayerHeader.FORWARDMB.databits = parser->bp_forwardmb;
            }
            else
            {
              pInfo->picLayerHeader.raw_FORWARDMB = 1;
            }
          }
          if ( (pInfo->picLayerHeader.PTYPE == VC1_I_FRAME)
                || (pInfo->picLayerHeader.PTYPE == VC1_BI_FRAME) )
          {
            if(bp.imode != VC1_BITPLANE_RAW_MODE)
            {
              pInfo->picLayerHeader.ACPRED.invert = bp.invert;
              pInfo->picLayerHeader.ACPRED.imode = bp.imode;
              for (i = 0; i < biplaneSz; i++)
              {
                parser->bp_acpred[i] = bp.databits[i];
              }
              pInfo->picLayerHeader.ACPRED.databits = parser->bp_acpred;
            }
            else
            {
              pInfo->picLayerHeader.raw_ACPRED = 1;
            }
          }
          if (pInfo->picLayerHeader.PTYPE == VC1_P_FRAME)
          {
            if(bp.imode != VC1_BITPLANE_RAW_MODE)
            {
              pInfo->picLayerHeader.MVTYPEMB.invert = bp.invert;
              pInfo->picLayerHeader.MVTYPEMB.imode = bp.imode;
              for (i = 0; i < biplaneSz; i++)
              {
                parser->bp_mvtypemb[i] = bp.databits[i];
              }
              pInfo->picLayerHeader.MVTYPEMB.databits = parser->bp_mvtypemb;
            }
            else
            {
              pInfo->picLayerHeader.raw_MVTYPEMB = 1;
            }
          }
          break;
        case VIDDEC_WORKLOAD_VC1_BITPLANE1:
          if ( (pInfo->picLayerHeader.PTYPE == VC1_I_FRAME)
                || (pInfo->picLayerHeader.PTYPE == VC1_BI_FRAME) )
          {
            if(bp.imode != VC1_BITPLANE_RAW_MODE)
            {
              pInfo->picLayerHeader.OVERFLAGS.invert = bp.invert;
              pInfo->picLayerHeader.OVERFLAGS.imode = bp.imode;
              for (i = 0; i < biplaneSz; i++)
              {
                parser->bp_overflags[i] = bp.databits[i];
              }
              pInfo->picLayerHeader.OVERFLAGS.databits = parser->bp_overflags;
            }
            else
            {
              pInfo->picLayerHeader.raw_OVERFLAGS = 1;
            }
          }
          if ( (pInfo->picLayerHeader.PTYPE == VC1_P_FRAME)
                || (pInfo->picLayerHeader.PTYPE == VC1_B_FRAME) )
          {
            if(bp.imode != VC1_BITPLANE_RAW_MODE)
            {
              pInfo->picLayerHeader.SKIPMB.invert = bp.invert;
              pInfo->picLayerHeader.SKIPMB.imode = bp.imode;
              for (i = 0; i < biplaneSz; i++)
              {
                parser->bp_skipmb[i] = bp.databits[i];
              }
              pInfo->picLayerHeader.SKIPMB.databits = parser->bp_skipmb;
            }
            else
            {
              pInfo->picLayerHeader.raw_SKIPMB = 1;
            }
          }
          break;
        case VIDDEC_WORKLOAD_VC1_BITPLANE2:
          if ( (pInfo->picLayerHeader.PTYPE == VC1_P_FRAME)
                || (pInfo->picLayerHeader.PTYPE == VC1_B_FRAME) )
          {
            if(bp.imode != VC1_BITPLANE_RAW_MODE)
            {
              pInfo->picLayerHeader.DIRECTMB.invert = bp.invert;
              pInfo->picLayerHeader.DIRECTMB.imode = bp.imode;
              for (i = 0; i < biplaneSz; i++)
              {
                parser->bp_directmb[i] = bp.databits[i];
              }
              pInfo->picLayerHeader.DIRECTMB.databits = parser->bp_directmb;
            }
            else
            {
              pInfo->picLayerHeader.raw_DIRECTMB = 1;
            }
          }
          if ( (pInfo->picLayerHeader.PTYPE == VC1_I_FRAME)
                || (pInfo->picLayerHeader.PTYPE == VC1_BI_FRAME) )
          {
            if(bp.imode != VC1_BITPLANE_RAW_MODE)
            {
              pInfo->picLayerHeader.FIELDTX.invert = bp.invert;
              pInfo->picLayerHeader.FIELDTX.imode = bp.imode;
              for (i = 0; i < biplaneSz; i++)
              {
                parser->bp_fieldtx[i] = bp.databits[i];
              }
              pInfo->picLayerHeader.FIELDTX.databits = parser->bp_fieldtx;
            }
            else
            {
              pInfo->picLayerHeader.raw_FIELDTX = 1;
            }
          }
          break;
      }
    }
#endif
    
    return status;
}