klttce3d.c

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

                          
                                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->volume[current_frame][current_row][current_col] =
                                    1.5 * threshold;
                              }

                            p =
                              p * QCCWAVKLTTCE3D_ALPHA_1D + symbol * QCCWAVKLTTCE3D_ALPHA_1D_O;
			   
                            if (symbol)
                              {
                                subband_significance[subband]++;
                                significance_map[current_frame][current_row][current_col] =
                                  QCCWAVKLTTCE3D_S_NEW;
                          
                                if (QccWAVTce3DUpdateModel(model, 0.5))
                                  {
                                    QccErrorAddMessage("(QccWAVklttce3DNZNPass): Error calling QccWAVklttceUpdateModel()");
                                    return(1);
                                  }
                          
                                if (buffer->type == QCCBITBUFFER_OUTPUT)
                                  {
                                    symbol =
                                      (int)(sign_array[current_frame][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_frame][current_row][current_col] =
                                      (char)symbol;
                                  }
                          
                                QccWAV3DUpdateNZNStatus(subband_origin_frame,
                                                        subband_origin_row,
                                                        subband_origin_col,
                                                        subband_num_frames,
                                                        subband_num_rows,
                                                        subband_num_cols,
                                                        frame,
                                                        row,
                                                        col,
                                                        significance_map,
                                                        subband);
                              }
                          }
                      } 
                  }    
              }
          }
      }
    }

  return(0);
}


static int QccWAVklttce3DIPBand(QccWAVSubbandPyramid3D *coefficients,
                                char ***significance_map,
                                char ***sign_array,
                                double ***p_estimation,
                                double *subband_significance,
                                int subband,
                                double threshold,
                                QccENTArithmeticModel *model,
                                QccBitBuffer *buffer,
                                double alpha,int **max_coefficient_bits)
{
  int return_value;
  int subband_origin_frame;
  int subband_origin_row;
  int subband_origin_col;
  int subband_num_frames;
  int subband_num_rows;
  int subband_num_cols;
  int frame,row, col;
  int current_frame,current_row, current_col;
  QccMatrix p1=NULL;
  QccVector p2 = NULL;
  QccMatrix p3=NULL;
  QccMatrix p4=NULL;
  QccVector p5 = NULL;
  double p;
  double p_forward;
  double p_parent = 0;
  int parent_subband;   
  double scale;
  double parent_density = 0;
  double child_density; 
  int v;
  int symbol;
  double p_lowerbound = 0;
  double weight[2];
  double filter_coef;
  double increment;
  char *p_char;
 
  // initialization all the constants
  filter_coef = (1 - alpha) * (1 - alpha)*(1 - alpha) / (3*alpha + alpha*alpha*alpha)/3;
 
  weight[0] = (1 - alpha) * (1 - alpha)* (1 - alpha)/((1 + alpha)*(1 + alpha)*(1 + alpha));
  weight[1] = (2*3*alpha + 2*alpha*alpha*alpha) / ((1 + alpha)*(1 + alpha)*(1 + alpha));

  if (QccWAVSubbandPyramid3DSubbandSize(coefficients,
                                        subband,
                                        &subband_num_frames,
                                        &subband_num_rows,
                                        &subband_num_cols))
    {
      QccErrorAddMessage("(QccWAVklttce3DIPBand): Error calling QccWAVSubbandPyramid3DSubbandSize()");
      goto Error;
    }
  if (QccWAVSubbandPyramid3DSubbandOffsets(coefficients,
                                           subband,
                                           &subband_origin_frame,
                                           &subband_origin_row,
                                           &subband_origin_col))
    {
      QccErrorAddMessage("(QccWAVklttce3DIPBand): Error calling QccWAVSubbandPyramid3DSubbandOffsets()");
      goto Error;
    }
  
  if ((p1 = QccMatrixAlloc(subband_num_rows,subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVklttce3DIPBand): Error calling QccMatrixAlloc()");
      goto Error;
    }
  if ((p2 = QccVectorAlloc(subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVklttce3DIPBand): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((p3 = QccMatrixAlloc(subband_num_rows,subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVklttce3DIPBand): Error calling QccMatrixAlloc()");
      goto Error;
    }
  if ((p4 = QccMatrixAlloc(subband_num_rows,subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVklttce3DIPBand): Error calling QccMatrixAlloc()");
      goto Error;
    }
  if ((p5 = QccVectorAlloc(subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVklttce3DIPBand): Error calling QccVectorAlloc()");
      goto Error;
    }

  child_density =
    subband_significance[subband] / (subband_num_frames*subband_num_rows * subband_num_cols);
  p_lowerbound = 1.0 / (subband_num_frames*subband_num_rows * subband_num_cols);
  
  if ((subband%(3*coefficients->spatial_num_levels+1))<=3)
    {
      if ((subband%(3*coefficients->spatial_num_levels+1))==0)
	{
	  
          parent_subband = 0;
          parent_density =
            subband_significance[parent_subband] /
            (subband_num_frames*subband_num_rows * subband_num_cols) ;
	}

      if ((subband%(3*coefficients->spatial_num_levels+1))==1)
	{
	  parent_subband = subband - 1;
          parent_density =
            subband_significance[parent_subband] /
            (subband_num_frames*subband_num_rows * subband_num_cols) ;
	}
      if ((subband%(3*coefficients->spatial_num_levels+1))==2)
	{
	  parent_subband = subband - 2;
          parent_density =
            subband_significance[parent_subband] /
            (subband_num_frames*subband_num_rows * subband_num_cols) ;
	}
      if ((subband%(3*coefficients->spatial_num_levels+1))==3)
	{
	  parent_subband = subband - 3;
          parent_density =
            subband_significance[parent_subband] /
            (subband_num_frames*subband_num_rows * subband_num_cols) ;
	}
    }
  else
    {
      parent_subband = subband - 3;
      parent_density =
        subband_significance[parent_subband] /
        (subband_num_frames*subband_num_rows * subband_num_cols) * 4;
    }
  
  for (row = 0; row < subband_num_rows; row++)
    for (col = 0; col < subband_num_cols; col++)
      p3[row][col]= p_estimation[0][subband_origin_row+row][subband_origin_col+col];

  scale =
    QccMathMax(child_density, p_lowerbound) /
    QccMathMax(parent_density, p_lowerbound); 
  increment =
    1.0 / (subband_num_frames*subband_num_rows * subband_num_cols) /
    QccMathMax(parent_density, p_lowerbound);

  for (frame = 0; frame < subband_num_frames; frame++)
    {//aaaa
      current_frame=subband_origin_frame+frame;

      if ((threshold - 0.000001) <
          pow((double)2, (double)max_coefficient_bits[subband][frame]))
        {
          for (col = 0; col < subband_num_cols; col++)
            p2[col] =p_estimation[current_frame][subband_origin_row][subband_origin_col+col]; 

          for (row = 0; row < subband_num_rows; row++)
            {  //aaa  
              current_row = subband_origin_row + row;
              for (col = 0; col < subband_num_cols; col++)
                { //aa  
                  current_col = subband_origin_col + col;
                  p_char = &(significance_map[current_frame][current_row][current_col]);
                  if (col == 0)
                    p_forward =alpha * (QCCWAVKLTTCE3D_BOUNDARY_VALUE + p2[col] +
                                        p3[row][col]);
                  else
                    p_forward = alpha * (p1[row][col-1] + p2[col] + p3[row][col]);
          
                  if (*p_char < QCCWAVKLTTCE3D_S)
                    { //a     
                      p = p_forward + p_estimation[current_frame][current_row][current_col];

                      if (current_frame != 0)
                        { //b
                          if ((subband%(3*coefficients->spatial_num_levels+1))<=3)
                            {
		              if ((subband%(3*coefficients->spatial_num_levels+1))==0)
                                {
                                  if ((subband/(3*coefficients->spatial_num_levels+1))<=1)
                                    p_parent = p_estimation[current_frame-1][current_row][current_col];
			          else
                                    p_parent = p_estimation[current_frame/2][current_row][current_col];
	   
                                } 

			      if ((subband%(3*coefficients->spatial_num_levels+1))==1)
			        p_parent = p_estimation[current_frame][current_row-subband_num_rows][current_col];

			      if ((subband%(3*coefficients->spatial_num_levels+1))==2)
			        p_parent = p_estimation[current_frame][current_row][current_col-subband_num_cols];

			      if ((subband%(3*coefficients->spatial_num_levels+1))==3)
			        p_parent = p_estimation[current_frame][current_row-subband_num_rows][current_col-subband_num_cols];
			    }
                          else
                            p_parent = p_estimation[current_frame][current_row/2][current_col/2];
                          {          
                            p_parent = QccMathMin(p_parent*scale, 0.8);
                            p =
                              p * QCCWAVKLTTCE3D_CURRENT_SCALE +
                              QCCWAVKLTTCE3D_PARENT_SCALE * p_parent;
                          }
                        }//b
                      if (p>1)
                        {
                          p=1;
                        }
                      if (QccWAVTce3DUpdateModel(model, p))
                        {
                          QccErrorAddMessage("(QccWAVklttce3DIPBand): Error calling QccWAVklttceUpdateModel()");
                          return_value = 1;
                          goto Error;
                        }
                      if (buffer->type == QCCBITBUFFER_OUTPUT)
                        {
                          if (coefficients->volume[current_frame][current_row][current_col] >=
                              threshold)
                            {
                              symbol = 1;
                              coefficients->volume[current_frame][current_row][current_col] -=
                                threshold;
                            }
                          else
                            symbol = 0;
                          return_value =
                            QccENTArithmeticEncode(&symbol, 1,model, buffer);
                        }
                      else
                        {
                          if (QccENTArithmeticDecode(buffer,model,&symbol, 1))
                            {
                              return_value = 2;
                              goto Return;
                            }
                          else
                            return_value = 0;
                  
                          if (symbol)
                            coefficients->volume[current_frame][current_row][current_col] =
                              1.5 * threshold;
                        }
                      v = symbol;
	                
                      if (symbol)