/*COPYRIGHT, LICENSE AND WARRANTY INFORMATIONThis software module has been originally developed by Nokia Corporation. Provided that a person, entity or a company willing to use the Software (hereinafter Licensee) comply with all the terms and conditions of this Statement and subject to the limitations set forth in this Statement Nokia grants to such Licensee a non-exclusive, sub-licensable, worldwide, limited license under copyrights owned by Nokia to use the Software for the sole purpose of creating, manufacturing, selling, marketing, or  distributing (including the right to make modifications to the Software) a fully compliant decoder implementation (hereinafter "Decoder") of ITU-T Recommendation H.264 / ISO/IEC International Standard 14496-10 and an encoder implementation producing output that is decodable with the Decoder.Nokia retains the ownership of copyrights to the Software. There is no patent nor other intellectual property right of Nokia licensed under this Statement (except the copyright license above). Licensee hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if patent licenses  are required, it is their responsibility to acquire the license before utilizing the Software.The license by Nokia is subject to that the Licensee grants to Nokia the non-exclusive, worldwide, royalty-free, perpetual and irrevocable covenant that the Licensee(s) shall not bring a suit before any court or administrative agency or otherwise assert a claim for infringement under the Licensee intellectual property rights that, but for a license, would be infringed by the Software against     (a)  Nokia or Nokia's Affiliate; or     (b)  other recipient of a license and covenant not to sue with respect         to the Software from Nokia; or    (c)  contractor, customer or distributor of a party listed above in a         or b,  which suit or claim is related to the Software or use thereof.The Licensee(s) further agrees to grant a reciprocal license to Nokia (as granted by Nokia to the Licensee(s) on the modifications made by Licensee(s) to the Software. THE SOFTWARE IS PROVIDED "AS IS" AND THE ORIGINAL DEVELOPER DISCLAIMS ANY AND ALL WARRANTIES WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. THOSE INTENDING TO USE THE SOFTWARE ARE EXPRESSLY ADVISED THAT ITS USE MAY INFRINGE EXISTING PATENTS AND BE SUBJECT TO ROYALTY PAYMENTS TO PATENT OWNERS. ANYONE USING THE SOFTWARE ON THE BASIS OF THIS LICENSE AGREES TO OBTAIN THE NECESSARY PERMISSIONS FROM ANY AND ALL APPLICABLE PATENT OWNERS FOR SUCH USE.IN NO EVENT SHALL THE ORIGINAL DEVELOPER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.This copyright, license and warranty information notice must be retained in all copies and derivative works of the Software or substantial portions thereof.*/#include "vlcutility.h"#include "macroblock.h"#include "stream.h"#include "vlc.h"static const vlcCode_s numCoefsTrailTabChroma[4][5] = {  {{1,2},{7,6},{4,6},{3,6},{2,6}},  {{0,0},{1,1},{6,6},{3,7},{3,8}},  {{0,0},{0,0},{1,3},{2,7},{2,8}},  {{0,0},{0,0},{0,0},{5,6},{0,7}},};/* * streamGetMbTypeIntra * * Parameters: *      intraType             Type of the intra macroblock *      intra16x16Mode        16x16 intra prediction mode *      cbpY                  Coded Block Pattern for luma *      cbpChromaDC           Coded Block Pattern for chroma DC *      cbpC                  Coded Block Pattern for chroma AC * * Function: *      Get intra-macroblock mb_type. * * Returns: *      mb_type. */int streamGetMbTypeIntra(int intraType,                          int intra16x16Mode,                         int cbpY,                          int cbpChromaDC,                          int cbpC){  int mbType;  mbType = 0;  if (intraType == MBK_INTRA_TYPE2)  {    int ac, nc;    // In intra type 2, MB type includes information about coded blocks    ac = (cbpY == 0) ? 0 : 12;    nc = vlcuGetChromaNC(cbpChromaDC, cbpC);    mbType += 1 + ac + nc * 4 + intra16x16Mode;  }  return mbType;}/* * streamGetMbTypeInter * * Parameters: *      interMode             Inter motion mode, more details below ... *      refIndices            Reference frame indices * * Function: *      Get inter-macroblock mb_type. * * Returns: *      mb_type. */int streamGetMbTypeInter(int    interMode,                         u_int8 refIndices[4]){  if (interMode == MOT_8x8) {    // mbType == 3, P_8x8,     multiple reference frames    // mbType == 4, P_8x8ref0, single reference frame, no ref_idx to follow    return ((refIndices[0] | refIndices[1] |       refIndices[2] | refIndices[3]) != 0) ? 3 : 4;  }  else {    // interMode == 0 not allowed    // interMode == 1, mbType = 0, P_L0_16x16    // interMode == 2, mbType = 1, P_L0_16x8    // interMode == 3, mbType = 2, P_L0_8x16    return interMode - 1;  }}/* * streamCountIntraSyntaxBits: * * Parameters: *      mb                    Macroblock object *      picType               Picture type (intra/inter) * * Function: *      Count additional intra-MB syntax bits, used only in helping make mode  *      decision when rate distortion optimization is enabled. *       * Returns: *      number of bits in the header. */int streamCountIntraSyntaxBits(macroblock_s *mb,                                int          picType){  int mbType, bitsHdr;  bitsHdr = 0;  if (IS_SLICE_P(picType))     bitsHdr = vlcuUVLCSize(mb->numSkipped);  /* Send Macroblock type */  mbType = ((IS_SLICE_P(picType)) ? 5 : 0) + streamGetMbTypeIntra    (mb->intraType, mb->intra16x16mode, mb->cbpY, mb->cbpChromaDC, mb->cbpC);  bitsHdr += uvlcBitsUnsigned[mbType];  // bits on intra4x4 modes were counted in the intra4x4 prediction  // bits on 8x8 chroma intra mode were counted in chroma8x8 prediction  // Send coded block pattern  if (mb->intraType != MBK_INTRA_TYPE2)  {    int cbp;    cbp  = vlcuGetLuma8x8cbp(mb->cbpY);    cbp |= vlcuGetChromaNC(mb->cbpChromaDC, mb->cbpC) << 4;    bitsHdr += vlcuUVLCSize(cbpCode[cbp][0]);    // for MBK_INTRA_TYPE2, cbp is included in mbtype  }  // Send delta QP  if ((mb->intraType == MBK_INTRA_TYPE2) ||     (mb->cbpY | mb->cbpChromaDC | mb->cbpC) != 0)  {    int deltaQp;    CALCULATE_DELTA_QP(deltaQp, mb->qp, mb->prevQp);    bitsHdr += uvlcBitsSigned[511 + deltaQp];  }  return bitsHdr;}/* * streamSend4x4Blk * * Parameters: *      stream                bitbuffer for CAVLC  *      mb                    Macroblock object *      nonzeroBlkFlag        0, it's known all the coefficients are zero *      comp                  Color component index *      blkX                  Horizontal block index within MB *      blkY                  Vertical block index within MB *      coef                  4x4 coefficients *      blkCategory           Block category, 1 of 5 types *      numCoefs              Number of nonzero coefficients encoded * * Function: *      Send coefficients of 4x4 block.  *      nonzeroBlkFlag can be used to save some process time, as it is usually  *      known whether this block has any non-zero coefficients at all before  *      this function is called. * * Returns: *      Number of bits for coefficients. */int streamSend4x4Blk(void         *stream,                      macroblock_s *mb,                     int          nonzeroBlkFlag,                     int          comp,                     int          blkX,                     int          blkY,                     int          coef[4][4],                      int          blkCategory,                     int          *numCoefs){  int i;  int tmpCoef[4*4];  int len;  int dcSkip;  vlcCoefBlkStat_s blkStat;  dcSkip = (blkCategory == BLK_CAT_Y_I16x16_AC) || (blkCategory == BLK_CAT_C_AC);  vlcuZigZagScan4x4(coef, tmpCoef);  blkStat.totalCoef = 0;  blkStat.numTrailingZeros = (int8)(16 - dcSkip);  if (nonzeroBlkFlag)  {    i = 15;    while (i >= dcSkip && tmpCoef[i] == 0) i --;    blkStat.numTrailingZeros = (int8) (15 - i);    nonzeroBlkFlag = (16 - dcSkip) > blkStat.numTrailingZeros;  }    if (nonzeroBlkFlag)  {    vlcCollectCoefBlkStat(tmpCoef, 15, dcSkip, & blkStat);    len = vlcSendCoeffToken(stream, mb, comp, blkX, blkY,       blkStat.numTrailingOnes, blkStat.totalCoef);    len += vlcEncodeCoefBlk(stream, & blkStat, 16, dcSkip, 0);  }  else    len = vlcSendCoeffToken(stream, mb, comp, blkX, blkY, 0, 0);  *numCoefs = blkStat.totalCoef;  return len;}/* * streamSend2x2ChromaDC * * Parameters: *      stream                bitbuffer for CAVLC *      tmpCoef               2x2 coefficients * * Function: *      Send coefficients of 2x2 block,  *      A 2x2 block is formed with transformed coefficients of the 4 DC  *      coefficients from 4 4x4 blocks.  * * Returns: *      Number of bits for coefficients. */static int streamSend2x2ChromaDC(void         *stream,                                  int          tmpCoef[4]){  int i, len;  const vlcCode_s *pVlc;  vlcCoefBlkStat_s blkStat;  // Count trailing zero coefficients  i = 3;  while (i >= 0 && tmpCoef[i] == 0) i --;  blkStat.numTrailingZeros = (int8) (3 - i);  blkStat.totalCoef = 0;      // Send totalCoef & numTrailingOnes  vlcCollectCoefBlkStat(tmpCoef, 3, 0, & blkStat);  pVlc = & numCoefsTrailTabChroma[blkStat.numTrailingOnes][blkStat.totalCoef];  len = bibPutBits(stream, pVlc->code, pVlc->len);    if (blkStat.numTrailingZeros < 4)  len += vlcEncodeCoefBlk(stream, & blkStat, 4, 0, 1);  return len;}/* * streamSendMbType: * * Parameters: *      stream                bitbuffer for CAVLC