tce.c

spiht for linux this is used to decod and encode vedio i wich all enjoy

            p_forward;
        }
      
      p3 = p2[subband_num_cols-1]*(1 - alpha_v)/(1 + alpha_h);  
      for (col = subband_num_cols - 1; col >= 0; col--)
        {   
          p2[col] = p2[col] + alpha_h * p3;
          p_char = &(significance_map[current_row][subband_origin_col + col]);
          if (*p_char == QCCTCE_S)
            p3 = alpha_h * p3 + filter_coef * QCCWAVTCE_REFINE_HOLDER;  
          else
            {
              v = (*p_char == QCCTCE_S_NEW);
              p3 = alpha_h * p3 + filter_coef * v;
            }
        }
    }
  
  for (row = subband_num_rows - 1; row >= 0; row--)
    {
      p1 = p2[subband_num_cols-1]*(1 - alpha_v)/(1 + alpha_h); 
      current_row = subband_origin_row + row;
      for (col = subband_num_cols-1; col >=0; col--)
        {   
          current_col = subband_origin_col + col; 
          p_char = &(significance_map[current_row][current_col]);
          p_estimation[current_row][current_col] +=
            alpha_h*p1 + alpha_v*p2[col];
          if (*p_char == QCCTCE_S)
            {
              p_estimation[current_row][current_col]=
                QCCWAVTCE_REFINE_HOLDER * weight[0] +
                p_estimation[current_row][current_col] * weight[1];
              p1 = alpha_h * p1 + filter_coef * QCCWAVTCE_REFINE_HOLDER;
            }
          else
            {
              v = (*p_char == QCCTCE_S_NEW);
              p_estimation[current_row][current_col] =
                v * weight[0] +
                p_estimation[current_row][current_col] * weight[1];
              p1 = alpha_h * p1 + filter_coef * v;
            }    
          p2[col] = p1 + alpha_v * p2[col];   
        }
      
      p3 = p2[0]*(1 - alpha_v)/(1 + alpha_h);
      for (col = 0; col < subband_num_cols; col++)
        {
          p2[col] = p2[col] + alpha_h * p3;
          current_col = subband_origin_col + col; 
          p_char = &(significance_map[current_row][current_col]);
          if (*p_char == QCCTCE_S)
            p3 = alpha_h * p3 + filter_coef * QCCWAVTCE_REFINE_HOLDER;
          else
            {
              v = (*p_char == QCCTCE_S_NEW);
              p3 = alpha_h * p3 + filter_coef * v;
            }        
        }
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return: 
  QccVectorFree(p2); 
  return(return_value); 
}


static int QccWAVtceIPPass(QccWAVSubbandPyramid *coefficients,    
                           char **significance_map,
                           char **sign_array,
                           double threshold,
                           double **p_estimation,
                           double *subband_significance,
                           QccENTArithmeticModel *model,
                           QccBitBuffer *buffer,
                           int *max_coefficient_bits)
{
  int subband,num_subbands; 
  int return_value;
  
  num_subbands =
    QccWAVSubbandPyramidNumLevelsToNumSubbands(coefficients->num_levels);
  
  for (subband = 0; subband < num_subbands; subband++)
    {
      if ((threshold - 0.000001) <
          pow((double)2, (double)max_coefficient_bits[subband]))
        {
          return_value =
            QccWAVtceRevEst(coefficients,
                            significance_map,
                            subband,
                            subband_significance,
                            p_estimation);
          if (return_value == 1)
            {
              QccErrorAddMessage("(QccWAVtceIPPass): Error calling QccWAVtceRevEst()");
              return(1);
            }
          else
            {
              if (return_value == 2)
                return(2);
            }
          
          return_value = QccWAVtceIPBand(coefficients,
                                         significance_map,
                                         sign_array,
                                         p_estimation,
                                         subband_significance,
                                         subband,
                                         threshold,
                                         model,
                                         buffer);
          if (return_value == 1)
            {
              QccErrorAddMessage("(QccWAVtceIPPass): Error calling QccWAVtceIPBand()");
              return(1);
            }
          else
            {
              if (return_value == 2)
                return(2);
            }
        }
    } 

  return(0);
}


static int QccWAVtceNZNPass(QccWAVSubbandPyramid *coefficients,    
                            char **significance_map,
                            char **sign_array,
                            double threshold,
                            double** p_estimation,
                            double *subband_significance,
                            QccENTArithmeticModel *model,
                            QccBitBuffer *buffer,
                            int *max_coefficient_bits)
{ 
  int subband,num_subbands;
  int return_value;
  int subband_origin_row;
  int subband_origin_col;
  int subband_num_rows;
  int subband_num_cols;
  int row, col;
  int current_row, current_col;
  int symbol;
  double p = 0.5;
  
  num_subbands =
    QccWAVSubbandPyramidNumLevelsToNumSubbands(coefficients->num_levels);
  
  for (subband = 0; subband < num_subbands; subband++)
    {
      if ((threshold - 0.000001) <
          pow((double)2, (double)(max_coefficient_bits[subband]-1)))
        {   
          if (QccWAVSubbandPyramidSubbandSize(coefficients,
                                              subband,
                                              &subband_num_rows,
                                              &subband_num_cols))
            {
              QccErrorAddMessage("(QccWAVtceNZNPass): Error calling QccWAVSubbandPyramidSubbandSize()");
              return(1);
            }
          if (QccWAVSubbandPyramidSubbandOffsets(coefficients,
                                                 subband,
                                                 &subband_origin_row,
                                                 &subband_origin_col))
            {
              QccErrorAddMessage("(QccWAVtceNZNPass): Error calling QccWAVSubbandPyramidSubbandOffsets()");
              return(1);
            }
          
          for (row = 0; row < subband_num_rows; row++)
            {
              current_row = subband_origin_row + row;
              for (col = 0; col < subband_num_cols; col++)
                { 
                  current_col = subband_origin_col + col;
                  if (significance_map[current_row][current_col] == QCCTCE_NZN)
                    {
                      if (QccWAVtceUpdateModel(model, p))
                        {
                          QccErrorAddMessage("(QccWAVtceNZNPass): Error calling QccWAVtceUpdateModel()");
                          return_value = 1;
                          return(1);
                        }
                      if (buffer->type == QCCBITBUFFER_OUTPUT)
                        {
                          if (coefficients->matrix[current_row][current_col] >=
                              threshold)
                            {
                              symbol = 1;
                              coefficients->matrix[current_row][current_col] -=
                                threshold;
                            }
                          else
                            symbol = 0;
                          
                          return_value =
                            QccENTArithmeticEncode(&symbol, 1, model, buffer);
                          if (return_value == 1)
                            return(1);
                          else
                            {
                              if (return_value == 2)
                              return(2);
                            }
                        }
                      else
                        {
                          if (QccENTArithmeticDecode(buffer,
                                                     model,
                                                     &symbol,
                                                     1))   
                            return(2);
                          
                          if (symbol)
                            coefficients->matrix[current_row][current_col] =
                              1.5 * threshold;
                        }

                      p =
                        p * QCCWAVTCE_ALPHA_1D + symbol * QCCWAVTCE_ALPHA_1D_O;
                      if (symbol)
                        {
                          subband_significance[subband]++;
                          significance_map[current_row][current_col] =
                            QCCTCE_S_NEW;
                          
                          if (QccWAVtceUpdateModel(model, 0.5))
                            {
                              QccErrorAddMessage("(QccWAVtceNZNPass): Error calling QccWAVtceUpdateModel()");
                              return(1);
                            }
                          
                          if (buffer->type == QCCBITBUFFER_OUTPUT)
                            {
                              symbol =
                                (int)(sign_array[current_row][current_col]);
                              
                              return_value =
                                QccENTArithmeticEncode(&symbol,
                                                       1,
                                                       model,
                                                       buffer);
                              if (return_value == 1)
                                return(1);
                              else
                                {
                                  if (return_value == 2)
                                    return(2);
                                }       
                            }
                          else
                            {
                              if (QccENTArithmeticDecode(buffer,
                                                         model,
                                                         &symbol,
                                                         1))
                                return(2);
                              
                              sign_array[current_row][current_col] =
                                (char)symbol;
                            }
                          
                          QccWAVUpdateNZNStatus(subband_origin_row,
                                                subband_origin_col,
                                                subband_num_rows,
                                                subband_num_cols,
                                                row,
                                                col,
                                                significance_map,
                                                subband);
                        }
                    }     
                }
            }
        }
    }

  return(0);
}


int static QccWAVtceSPass(QccWAVSubbandPyramid *coefficients,    
                          char **significance_map,
                          double threshold,
                          QccENTArithmeticModel *model,
                          QccBitBuffer *buffer,
                          int *max_coefficient_bits)
{
  
  int subband,num_subbands; 
  int return_value;
  int subband_origin_row;
  int subband_origin_col;
  int subband_num_rows;
  int subband_num_cols;
  int row, col;
  int current_row, current_col;
  char *p_char;
  int symbol;
  double p = 0.4;
  
  num_subbands =
    QccWAVSubbandPyramidNumLevelsToNumSubbands(coefficients->num_levels);
  
  for (subband = 0; subband < num_subbands; subband++)
    {
      if ((threshold - 0.000001) <
          pow((double)2, (double)(max_coefficient_bits[subband])))
        {
          if (QccWAVSubbandPyramidSubbandSize(coefficients,
                                              subband,
                                              &subband_num_rows,
                                              &subband_num_cols))
            {
              QccErrorAddMessage("(QccWAVtceSPass): Error calling QccWAVSubbandPyramidSubbandSize()");
              return(1);
            }
          if (QccWAVSubbandPyramidSubbandOffsets(coefficients,
                                                 subband,
                                                 &subband_origin_row,
                                                 &subband_origin_col))
            {
              QccErrorAddMessage("(QccWAVtceSPass): Error calling QccWAVSubbandPyramidSubbandOffsets()");
              return(1);
            }
          
          for (row = 0; row < subband_num_rows; row++)
            {
              current_row = subband_origin_row + row;
              for (col = 0; col < subband_num_cols; col++)
                {     
                  current_col = subband_origin_col + col;
                  p_char = &(significance_map[current_row][current_col]);
                  if (*p_char == QCCTCE_S)
                    { 
                      
                      if (QccWAVtceUpdateModel(model, p))
                        {
                          QccErrorAddMessage("(QccWAVtceSPass): Error calling QccWAVtceUpdateModel()");
                          return(1);
                        }
                      
                      if (buffer->type == QCCBITBUFFER_OUTPUT)
                        {
                          if (coefficients->matrix[current_row][current_col] >=
                              threshold)
                            {
                              symbol = 1;
                              coefficients->matrix[current_row][current_col] -=
                                threshold;
                            }
                          else
                            symbol = 0;
                          
                          return_value =
                            QccENTArithmeticEncode(&symbol, 1, model, buffer);
                          if (return_value == 1)
                            return(1);
                          else
                            {
                              if (return_value == 2)
                                return(2);