tce3d_lossless.c

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

                  else 
                    p4[row][col] = alpha * p4[row][col-1] + filter_coef * QCCWAVTCE3D_REFINE_HOLDER;
                }
              else
                {
                  v = (*p_char == QCCTCE3D_S_NEW);
                  if(col==0)
                    p4[row][col] = alpha * QCCTCE3D_BOUNDARY_VALUE + filter_coef * v;
                  else 
                    p4[row][col] = alpha * p4[row][col-1] + filter_coef *v;
                 
                }        
            }
        }//bb
      for (row = 0; row < subband_num_rows; row++)
        for (col = 0; col < subband_num_cols; col++)
          {
            p3[row][col]=p3[row][col]+alpha*p5[col];
            if(col==0)
              p5[col]=p1[row][col]+alpha*p5[col]+alpha* QCCTCE3D_BOUNDARY_VALUE; 
            else
              p5[col]=p1[row][col]+alpha*p5[col]+alpha*p4[row][col-1];

          }
    }//bbb
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return: 
  QccVectorFree(p2); 
  QccVectorFree(p5);
  QccMatrixFree(p1,subband_num_rows); 
  QccMatrixFree(p3,subband_num_rows); 
  QccMatrixFree(p4,subband_num_rows); 
  return(return_value); 
}


static int QccWAVtce3DIntIPPass(QccWAVSubbandPyramid3DInt *coefficients,    
                                char ***significance_map,
                                char ***sign_array,
                                int threshold,
                                double ***p_estimation,
                                double *subband_significance,
                                QccENTArithmeticModel *model,
                                QccBitBuffer *buffer,
                                int *max_coefficient_bits,
                                double alpha)
{
  int subband,num_subbands; 
  int return_value;

  num_subbands =
    QccWAVSubbandPyramid3DIntNumLevelsToNumSubbandsPacket(coefficients->temporal_num_levels,
                                                          coefficients->spatial_num_levels);
  
  
  for (subband = 0; subband < num_subbands; subband++)
    {
      if ((threshold - 0.000001) <
          pow((double)2, (double)max_coefficient_bits[subband]))
        {
          return_value =
            QccWAVtce3DIntRevEst(coefficients,
                                 significance_map,
                                 subband,
                                 subband_significance,
                                 p_estimation,
                                 alpha);
          if (return_value == 1)
            {
              QccErrorAddMessage("(QccWAVtce3DIntIPPass): Error calling QccWAVtceRevEst()");
              return(1);
            }
          else
            {
              if (return_value == 2)
                return(2);
            }
          
          return_value = QccWAVtce3DIntIPBand(coefficients,
                                              significance_map,
                                              sign_array,
                                              p_estimation,
                                              subband_significance,
                                              subband,
                                              threshold,
                                              model,
                                              buffer,
                                              alpha);

          if (return_value == 1)
            {
              QccErrorAddMessage("(QccWAVtce3DIntIPPass): Error calling QccWAVtceIPBand()");
              return(1);
            }
          else
            {
              if (return_value == 2)
                return(2);
            }
        }
    } 

  return(0);
}


int static QccWAVtce3DIntSPass(QccWAVSubbandPyramid3DInt *coefficients,    
                               char ***significance_map,
                               int threshold,
                               QccENTArithmeticModel *model,
                               QccBitBuffer *buffer,
                               int *max_coefficient_bits)
{
  
  int subband,num_subbands; 
  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;
  char *p_char;
  int symbol;
  double p = 0.4;

  num_subbands =
    QccWAVSubbandPyramid3DIntNumLevelsToNumSubbandsPacket(coefficients->temporal_num_levels,
                                                          coefficients->spatial_num_levels);
 
  for (subband = 0; subband < num_subbands; subband++)
    {
      if ((threshold - 0.000001) <
          pow((double)2, (double)(max_coefficient_bits[subband])))
        { 
          if (QccWAVSubbandPyramid3DIntSubbandSize(coefficients,
                                                   subband,
                                                   &subband_num_frames,
                                                   &subband_num_rows,
                                                   &subband_num_cols))
            {
              QccErrorAddMessage("(QccWAVtce3DIntSPass): Error calling QccWAVSubbandPyramid3DIntSubbandSize()");
              return(1);
            }
          if (QccWAVSubbandPyramid3DIntSubbandOffsets(coefficients,
                                                      subband,
                                                      &subband_origin_frame,
                                                      &subband_origin_row,
                                                      &subband_origin_col))
            {
              QccErrorAddMessage("(QccWAVtce3DIntSPass): Error calling QccWAVSubbandPyramid3DIntSubbandOffsets()");
              return(1);
            }  
          
          for (frame = 0; frame < subband_num_frames; frame++) 
            {
              current_frame = subband_origin_frame + frame;
              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_frame][current_row][current_col]);

                      if (*p_char == QCCTCE3D_S)
                        { 
                      
                          if (QccWAVTce3DUpdateModel(model, p))
                            {
                              QccErrorAddMessage("(QccWAVtce3DIntSPass): Error calling QccWAVtceUpdateModel()");
                              return(1);
                            }
                      
                          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);
                              if (return_value == 1)
                                return(1);
                              else
                                {
                                  if (return_value == 2)
                                    return(2);
                                }
                            }
                          else
                            {
                              if (QccENTArithmeticDecode(buffer,model,&symbol, 1))
                                return(2);
                              coefficients->volume[current_frame][current_row][current_col] -=
                                threshold;
                              coefficients->volume[current_frame][current_row][current_col] +=
                                (symbol == 1) ? threshold + (threshold >> 1) : (threshold >> 1) ;
                            }
                          p =
                            p * QCCWAVTCE3D_ALPHA_1D + symbol * QCCWAVTCE3D_ALPHA_1D_O;
                        }
                      else
                        {
                          if (*p_char == QCCTCE3D_S_NEW)
                            *p_char = QCCTCE3D_S;
                          if (*p_char == QCCTCE3D_NZN_NEW)
                            *p_char = QCCTCE3D_NZN;     
                        }
                    }
                }
            }
        }
    } 

  return(0);
}


int QccWAVtce3DLosslessEncode(const QccIMGImageCube *image,
                              QccBitBuffer *buffer,
                              int transform_type,
                              int temporal_num_levels,
                              int spatial_num_levels,
                              double alpha,
                              const QccWAVWavelet *wavelet)
{
  int return_value;
  QccENTArithmeticModel *model = NULL;
  QccWAVSubbandPyramid3DInt image_subband_pyramid;
  char ***sign_array = NULL;
  char ***significance_map = NULL;
  double ***p_estimation = NULL;
  double *subband_significance = NULL;
  int image_mean;
  int *max_coefficient_bits=NULL;
  int threshold;
  int num_symbols[1] = { 2 };
  int frame, row, col;
  int bitplane = 0;
  int num_subbands;
  int max_max_coefficient_bits = 0;
  int subband;

  if (image == NULL)
    return(0);
  if (buffer == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);
  
  QccWAVSubbandPyramid3DIntInitialize(&image_subband_pyramid);
  
  image_subband_pyramid.spatial_num_levels = 0;
  image_subband_pyramid.temporal_num_levels = 0;
  image_subband_pyramid.num_frames = image->num_frames;
  image_subband_pyramid.num_rows = image->num_rows;
  image_subband_pyramid.num_cols = image->num_cols;
  if (QccWAVSubbandPyramid3DIntAlloc(&image_subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVtce3DLosslessEncode): Error calling QccWAVSubbandPyramid3DIntAlloc()");
      goto Error;
    }
  
  if ((sign_array =
       ( char ***)malloc(sizeof( char **) * image->num_frames))
      == NULL)
    {
      QccErrorAddMessage("(QccWAVtce3DLosslessEncode): Error allocating memory1");
      goto Error;
    }
  for (frame = 0; frame < image->num_frames; frame++)
    {
      if ((sign_array[frame] =
           (char **)malloc(sizeof( char *) *
                           image->num_rows)) == NULL)
        {
          QccErrorAddMessage("(QccWAVtce3DLosslessEncode): Error allocating memory2");
          goto Error;
        }
      for (row = 0; row < image->num_rows; row++)
        if ((sign_array[frame][row] =
             ( char *)malloc(sizeof( char) *
                             image->num_cols)) == NULL)
          {
            QccErrorAddMessage("(QccWAVtce3DLosslessEncode): Error allocating memory3");
            goto Error;
          }
    }
  
  if ((significance_map =
       ( char ***)malloc(sizeof( char **) * image->num_frames))
      == NULL)
    {
      QccErrorAddMessage("(QccWAVtce3DLosslessEncode): Error allocating memory4");
      goto Error;
    }
  for (frame = 0; frame < image->num_frames; frame++)
    {
      if ((significance_map[frame] =
           (char **)malloc(sizeof( char *) *
                           image->num_rows)) == NULL)
        {
          QccErrorAddMessage("(QccWAVtce3DLosslessEncode): Error allocating memory5");
          goto Error;
        }
      for (row = 0; row < image->num_rows; row++)
        if ((significance_map[frame][row] =
             ( char *)malloc(sizeof( char) *
                             image->num_cols)) == NULL)
          {
            QccErrorAddMessage("(QccWAVtce3DLosslessEncode): Error allocating memory6");
            goto Error;
          }
    }
  
  for (frame = 0; frame < image->num_frames; frame++)
    for (row = 0; row < image->num_rows; row++)
      for (col = 0; col < image->num_cols; col++)
        significance_map[frame][row][col] = QCCTCE3D_Z;

 
  
  if ((p_estimation =
       (double ***)malloc(sizeof(double **) * image->num_frames))
      == NULL)
    {
      QccErrorAddMessage("(QccWAVtce3DLosslessEncode): Error allocating memory7");
      goto Error;
    }
  for (frame = 0; frame < image->num_frames; frame++)
    {
      if ((p_estimation[frame] =
           (double **)malloc(sizeof(double *) *
                             image->num_rows)) == NULL)
        {
          QccErrorAddMessage("(QccWAVtce3DLosslessEncode): Error allocating mem