/************************************************************************* COPYRIGHT AND WARRANTY INFORMATION** Copyright 2001, International Telecommunications Union, Geneva** DISCLAIMER OF WARRANTY** These software programs are available to the user without any* license fee or royalty on an "as is" basis. The ITU disclaims* any and all warranties, whether express, implied, or* statutory, including any implied warranties of merchantability* or of fitness for a particular purpose.  In no event shall the* contributor or the ITU be liable for any incidental, punitive, or* consequential damages of any kind whatsoever arising from the* use of these programs.** This disclaimer of warranty extends to the user of these programs* and user's customers, employees, agents, transferees, successors,* and assigns.** The ITU does not represent or warrant that the programs furnished* hereunder are free of infringement of any third-party patents.* Commercial implementations of ITU-T Recommendations, including* shareware, may be subject to royalty fees to patent holders.* Information regarding the ITU-T patent policy is available from* the ITU Web site at http://www.itu.int.** THIS IS NOT A GRANT OF PATENT RIGHTS - SEE THE ITU-T PATENT POLICY.*************************************************************************//*! ************************************************************************************* * \file cabac.c * * \brief *    CABAC entropy coding routines * * \author *    Main contributors (see contributors.h for copyright, address and affiliation details) *    - Detlev Marpe                    <marpe@hhi.de> ************************************************************************************** */#include <stdlib.h>#include <math.h>#include <memory.h>#include "cabac.h"/*! ************************************************************************ * \brief *    Allocation of contexts models for the motion info *    used for arithmetic encoding ************************************************************************ */MotionInfoContexts* create_contexts_MotionInfo(void){  int j;  MotionInfoContexts *enco_ctx;  enco_ctx = (MotionInfoContexts*) calloc(1, sizeof(MotionInfoContexts) );  if( enco_ctx == NULL )    no_mem_exit("create_contexts_MotionInfo: enco_ctx");  for (j=0; j<2; j++)  {    enco_ctx->mb_type_contexts[j] = (BiContextTypePtr) malloc(NUM_MB_TYPE_CTX  * sizeof( BiContextType ) );    if( enco_ctx->mb_type_contexts[j] == NULL )      no_mem_exit("create_contexts_MotionInfo: enco_ctx->mb_type_contexts");    enco_ctx->mv_res_contexts[j] = (BiContextTypePtr) malloc(NUM_MV_RES_CTX  * sizeof( BiContextType ) );    if( enco_ctx->mv_res_contexts[j] == NULL )      no_mem_exit("create_contexts_MotionInfo: enco_ctx->mv_res_contexts");  }  enco_ctx->ref_no_contexts = (BiContextTypePtr) malloc(NUM_REF_NO_CTX * sizeof( BiContextType ) );  if( enco_ctx->ref_no_contexts == NULL )    no_mem_exit("create_contexts_MotionInfo: enco_ctx->ref_no_contexts");  enco_ctx->delta_qp_contexts = (BiContextTypePtr) malloc(NUM_DELTA_QP_CTX * sizeof( BiContextType ) );  if( enco_ctx->delta_qp_contexts == NULL )    no_mem_exit("create_contexts_MotionInfo: enco_ctx->delta_qp_contexts");  return enco_ctx;}/*! ************************************************************************ * \brief *    Allocates of contexts models for the texture info *    used for arithmetic encoding ************************************************************************ */TextureInfoContexts* create_contexts_TextureInfo(void){  int j,k;  TextureInfoContexts *enco_ctx;  enco_ctx = (TextureInfoContexts*) calloc(1, sizeof(TextureInfoContexts) );  if( enco_ctx == NULL )    no_mem_exit("create_contexts_TextureInfo: enco_ctx");  for (j=0; j < 6; j++)  {    enco_ctx->ipr_contexts[j] = (BiContextTypePtr) malloc(NUM_IPR_CTX  * sizeof( BiContextType ) );    if( enco_ctx->ipr_contexts[j] == NULL )      no_mem_exit("create_contexts_TextureInfo: enco_ctx->ipr_contexts");  }  for (k=0; k<2; k++)    for (j=0; j<3; j++)    {      enco_ctx->cbp_contexts[k][j] = (BiContextTypePtr) malloc(NUM_CBP_CTX  * sizeof( BiContextType ) );      if( enco_ctx->cbp_contexts[k][j] == NULL )        no_mem_exit("create_contexts_TextureInfo: enco_ctx->cbp_contexts");    }  for (j=0; j < NUM_TRANS_TYPE; j++)  {    enco_ctx->level_context[j] = (BiContextTypePtr) malloc(NUM_LEVEL_CTX  * sizeof( BiContextType ) );    if( enco_ctx->level_context[j] == NULL )      no_mem_exit("create_contexts_TextureInfo: enco_ctx->level_context");    enco_ctx->run_context[j] = (BiContextTypePtr) malloc(NUM_RUN_CTX  * sizeof( BiContextType ) );    if( enco_ctx->run_context[j] == NULL )      no_mem_exit("create_contexts_TextureInfo: enco_ctx->run_context");  }  return enco_ctx;}/*! ************************************************************************ * \brief *    Initializes an array of contexts models with some pre-defined *    counts (ini_flag = 1) or with a flat histogram (ini_flag = 0) ************************************************************************ */void init_contexts_MotionInfo(MotionInfoContexts *enco_ctx, int ini_flag){  int i,j;  int scale_factor;  int qp_factor;  int ini[3];  if ( (img->width*img->height) <=  (IMG_WIDTH * IMG_HEIGHT) ) //  format <= QCIF    scale_factor=1;  else    scale_factor=2;  if(img->qp <= 10)    qp_factor=0;  else    qp_factor=img->qp-10;  for (j=0; j<2; j++)  {    if (ini_flag)    {      for (i=0; i < NUM_MB_TYPE_CTX; i++)      {        ini[0] = MB_TYPE_Ini[j][i][0]+(MB_TYPE_Ini[j][i][3]*qp_factor)/10;        ini[1] = MB_TYPE_Ini[j][i][1]+(MB_TYPE_Ini[j][i][4]*qp_factor)/10;        ini[2] = MB_TYPE_Ini[j][i][2]*scale_factor;        biari_init_context(enco_ctx->mb_type_contexts[j] + i,ini[0],ini[1],ini[2]);      }    }    else    {      for (i=0; i < NUM_MB_TYPE_CTX; i++)        biari_init_context(enco_ctx->mb_type_contexts[j] + i,1,1,100);    }    if (ini_flag)    {      for (i=0; i < NUM_MV_RES_CTX; i++)        biari_init_context(enco_ctx->mv_res_contexts[j] + i,MV_RES_Ini[j][i][0]*scale_factor,MV_RES_Ini[j][i][1]*scale_factor,MV_RES_Ini[j][i][2]*scale_factor);    }    else    {      for (i=0; i < NUM_MV_RES_CTX; i++)        biari_init_context(enco_ctx->mv_res_contexts[j] + i,1,1,1000);    }  }  if (ini_flag)  {    for (i=0; i < NUM_REF_NO_CTX; i++)      biari_init_context(enco_ctx->ref_no_contexts + i,REF_NO_Ini[i][0]*scale_factor,REF_NO_Ini[i][1]*scale_factor,REF_NO_Ini[i][2]*scale_factor);  }  else  {    for (i=0; i < NUM_REF_NO_CTX; i++)      biari_init_context(enco_ctx->ref_no_contexts + i,1,1,1000);  }  if (ini_flag)  {    for (i=0; i < NUM_DELTA_QP_CTX; i++)      biari_init_context(enco_ctx->delta_qp_contexts + i,DELTA_QP_Ini[i][0]*scale_factor,DELTA_QP_Ini[i][1]*scale_factor,DELTA_QP_Ini[i][2]*scale_factor);  }  else  {    for (i=0; i < NUM_DELTA_QP_CTX; i++)      biari_init_context(enco_ctx->delta_qp_contexts + i,1,1,1000);  }}/*! ************************************************************************ * \brief *    Initializes an array of contexts models with some pre-defined *    counts (ini_flag = 1) or with a flat histogram (ini_flag = 0) ************************************************************************ */void init_contexts_TextureInfo(TextureInfoContexts *enco_ctx, int ini_flag){  int i,j,k;  int scale_factor;  int qp_factor;  int ini[3];  if ( (img->width*img->height) <=  (IMG_WIDTH * IMG_HEIGHT) ) //  format <= QCIF   scale_factor=1;  else   scale_factor=2;  if(img->qp <= 10)    qp_factor=0;  else    qp_factor=img->qp-10;  for (j=0; j < 6; j++)  {    if (ini_flag)    {      for (i=0; i < NUM_IPR_CTX; i++)        biari_init_context(enco_ctx->ipr_contexts[j] + i,IPR_Ini[j][i][0]*scale_factor,IPR_Ini[j][i][1]*scale_factor,IPR_Ini[j][i][2]*scale_factor);    }    else    {      for (i=0; i < NUM_IPR_CTX; i++)        biari_init_context(enco_ctx->ipr_contexts[j] + i,2,1,50);    }  }  for (k=0; k<2; k++)    for (j=0; j<3; j++)    {      if (ini_flag)      {        for (i=0; i < NUM_CBP_CTX; i++)        {          ini[0] = CBP_Ini[k][j][i][0]+(CBP_Ini[k][j][i][3]*qp_factor)/10;          ini[1] = CBP_Ini[k][j][i][1]+(CBP_Ini[k][j][i][4]*qp_factor)/10;          ini[2] = CBP_Ini[k][j][i][2]*scale_factor;          biari_init_context(enco_ctx->cbp_contexts[k][j] + i,ini[0],ini[1],ini[2]);        }      }      else      {        for (i=0; i < NUM_CBP_CTX; i++)          biari_init_context(enco_ctx->cbp_contexts[k][j] + i,1,1,100);      }    }  for (j=0; j < NUM_TRANS_TYPE; j++)  {    if (ini_flag)    {      for (i=0; i < NUM_LEVEL_CTX; i++)      {        ini[0] = (Level_Ini[j][i][0]+(Level_Ini[j][i][3]*qp_factor)/10)*scale_factor;        ini[1] = (Level_Ini[j][i][1]+(Level_Ini[j][i][4]*qp_factor)/10)*scale_factor;        ini[2] = Level_Ini[j][i][2]*scale_factor;        biari_init_context(enco_ctx->level_context[j] + i,ini[0],ini[1],ini[2]);      }    }    else    {      for (i=0; i < NUM_LEVEL_CTX; i++)        biari_init_context(enco_ctx->level_context[j] + i,1,1,100);    }    if (ini_flag)    {      for (i=0; i < NUM_RUN_CTX; i++)      {        ini[0] = Run_Ini[j][i][0]*scale_factor;        ini[1] = Run_Ini[j][i][1]*scale_factor;        ini[2] = Run_Ini[j][i][2]*scale_factor;        biari_init_context(enco_ctx->run_context[j] + i,ini[0],ini[1],ini[2]);      }    }    else    {      for (i=0; i < NUM_RUN_CTX; i++)        biari_init_context(enco_ctx->run_context[j] + i,1,1,100);    }  }}/*! ************************************************************************ * \brief *    Frees the memory of the contexts models *    used for arithmetic encoding of the motion info. ************************************************************************ */void delete_contexts_MotionInfo(MotionInfoContexts *enco_ctx){  int j;  if( enco_ctx == NULL )    return;  for (j=0; j<2; j++)  {    if (enco_ctx->mb_type_contexts[j] != NULL)      free(enco_ctx->mb_type_contexts[j] );    if (enco_ctx->mv_res_contexts[j]  != NULL)      free(enco_ctx->mv_res_contexts[j] );  }  if (enco_ctx->ref_no_contexts != NULL)    free(enco_ctx->ref_no_contexts);  if (enco_ctx->delta_qp_contexts != NULL)    free(enco_ctx->delta_qp_contexts);  free( enco_ctx );  return;}/*! ************************************************************************ * \brief *    Frees the memory of the contexts models *    used for arithmetic encoding of the texture info. ************************************************************************ */void delete_contexts_TextureInfo(TextureInfoContexts *enco_ctx){  int j,k;  if( enco_ctx == NULL )    return;  for (j=0; j < 6; j++)  {    if (enco_ctx->ipr_contexts[j] != NULL)      free(enco_ctx->ipr_contexts[j]);  }  for (k=0; k<2; k++)    for (j=0; j<3; j++)    {      if (enco_ctx->cbp_contexts[k][j] != NULL)        free(enco_ctx->cbp_contexts[k][j]);    }