tce.c

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

                            }
                        }
                      else
                        {
                          if (QccENTArithmeticDecode(buffer,model,&symbol, 1))
                            return(2);
                          coefficients->matrix[current_row][current_col] +=
                            (symbol == 1) ? threshold / 2 : -threshold / 2;
                        }
                      p =
                        p * QCCWAVTCE_ALPHA_1D + symbol * QCCWAVTCE_ALPHA_1D_O;
                    }
                  else
                    {
                      if (*p_char == QCCTCE_S_NEW)
                        *p_char = QCCTCE_S;
                      if (*p_char == QCCTCE_NZN_NEW)
                        *p_char = QCCTCE_NZN;     
                    }
                }
            }
        }
    } 

  return(0);
}


int QccWAVtceEncode(const QccIMGImageComponent *image,
                    int num_levels,
                    int target_bit_cnt,
                    double stepsize,
                    const QccWAVWavelet *wavelet,
                    QccBitBuffer *output_buffer)
{
  int return_value;
  QccENTArithmeticModel *model = NULL;
  QccWAVSubbandPyramid image_subband_pyramid; 
  char **sign_array = NULL;
  char **significance_map = NULL;
  double **p_estimation = NULL;
  double *subband_significance = NULL;
  double image_mean;
  int *max_coefficient_bits = NULL;
  double threshold;
  int num_symbols[1] = { 2 };
  int row, col; 
  int num_subbands; 
  int bitplane_cnt = 1;
  
  QccWAVSubbandPyramidInitialize(&image_subband_pyramid);

  if (image == NULL)
    return(0);
  if (output_buffer == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);
  
  if ((target_bit_cnt == QCCENT_ANYNUMBITS) &&
      (stepsize <= 0))
    {
      QccErrorAddMessage("(QccWAVtceEncode): Either a target bit cnt or a quantization stepsize must be specified");
      goto Error;
    } 
  if ((sign_array = (char **)malloc(sizeof(char *) * image->num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVtceEncode): Error allocating memory");
      goto Error;
    }
  for (row = 0; row < image->num_rows; row++)
    if ((sign_array[row] =
         (char *)malloc(sizeof(char) * image->num_cols)) == NULL)
      {
        QccErrorAddMessage("(QccWAVtceEncode): Error allocating memory");
        goto Error;
      }
  
  if ((significance_map =
       (char **)malloc(sizeof(char *) * image->num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVtceEncode): Error allocating memory");
      goto Error;
    }
  for (row = 0; row < image->num_rows; row++)
    if ((significance_map[row] =
         (char *)malloc(sizeof(char) * image->num_cols)) == NULL)
      {
        QccErrorAddMessage("(QccWAVtceEncode): Error allocating memory");
        goto Error;
      }

  for (row = 0; row < image->num_rows; row++)
    for (col = 0; col < image->num_cols; col++)
      significance_map[row][col] = QCCTCE_Z;
  
  num_subbands = QccWAVSubbandPyramidNumLevelsToNumSubbands(num_levels);
  
  if ((max_coefficient_bits =
       (int *)malloc(sizeof(int) * num_subbands)) == NULL)
    {
      QccErrorAddMessage("(QccWAVtceEncode): Error allocating memory");
      goto Error;
    }
  
  if ((p_estimation =
       (double **)malloc(sizeof(double *) * image->num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVtceEncode): Error allocating memory");
      goto Error;
    }
  
  for (row = 0; row < image->num_rows; row++)
    if ((p_estimation[row] =
         (double *)malloc(sizeof(double) * image->num_cols)) == NULL)
      {
        QccErrorAddMessage("(QccWAVtceEncode): Error allocating memory");
        goto Error;
      }
  
  for (row = 0; row < image->num_rows; row++)
    for (col = 0; col < image->num_cols; col++)
      p_estimation[row][col] = 0.0000001;
  
  if ((subband_significance =
       (double*)calloc(num_subbands, sizeof(double))) == NULL)
    {
      QccErrorAddMessage("(QccWAVtceEncode): Error allocating memory");
      goto Error;
    }    
  
  image_subband_pyramid.num_levels = 0;
  image_subband_pyramid.num_rows = image->num_rows;
  image_subband_pyramid.num_cols = image->num_cols;
  if (QccWAVSubbandPyramidAlloc(&image_subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVtceEncode): Error calling QccWAVSubbandPyramidAlloc()");
      goto Error;
    }
  
  //Wavelet transform and/or quantization
  if (QccWAVtceEncodeDWT(&image_subband_pyramid,
                         sign_array,
                         image,
                         num_levels,
                         &image_mean,
                         max_coefficient_bits,
                         stepsize,
                         wavelet))
    {
      QccErrorAddMessage("(QccWAVtceEncode): Error calling QccWAVtceEncodeDWT()");
      goto Error;
    }
  //encoder header information
  if (QccWAVtceEncodeHeader(output_buffer,
                            num_levels,
                            image->num_rows,
                            image->num_cols, 
                            image_mean,
                            stepsize,
                            max_coefficient_bits[0]))
    {
      QccErrorAddMessage("(QccWAVtceEncode): Error calling QccWAVtceEncodeHeader()");
      goto Error;
    }
  
  if (QccWAVtceEncodeBitPlaneInfo(output_buffer,
                                  num_subbands,
                                  max_coefficient_bits))
    {
      QccErrorAddMessage("(QccWAVtceEncode): Error calling QccWAVtceEncodeBitPlaneInfo()");
      goto Error;
    }
  
  if ((model = 
       QccENTArithmeticEncodeStart(num_symbols,
                                   1,
                                   NULL,
                                   target_bit_cnt)) == NULL)
    {
      QccErrorAddMessage("(QccWAVtceEncode): Error calling QccENTArithmeticEncodeStart()");
      goto Error;
    }
  QccENTArithmeticSetModelAdaption(model, QCCENT_NONADAPTIVE);
  
  threshold = pow((double)2, (double)max_coefficient_bits[0]);
  if (stepsize <= 0)
    // totally embedding without quantization
    while (1)
      {
        return_value = QccWAVtceNZNPass(&image_subband_pyramid,    
                                        significance_map,
                                        sign_array,
                                        threshold,
                                        p_estimation,
                                        subband_significance,
                                        model,
                                        output_buffer,
                                        max_coefficient_bits);
        
        if (return_value == 1)
          {
            QccErrorAddMessage("(QccWAVtceEncode): Error calling QccWAVtceNZNPass()");
            goto Error;
          }
        else
          {
            if (return_value == 2)
              goto Finished;
          }
        
        return_value = QccWAVtceIPPass(&image_subband_pyramid,    
                                       significance_map,
                                       sign_array,
                                       threshold,
                                       p_estimation,
                                       subband_significance,
                                       model,
                                       output_buffer,
                                       max_coefficient_bits);
        
        if (return_value == 1)
          {
            QccErrorAddMessage("(QccWAVtceEncode): Error calling QccWAVtceIPPass()");
            goto Error;
          }
        else
          {
            if (return_value == 2)
              goto Finished;
          }
        
        return_value = QccWAVtceSPass(&image_subband_pyramid,    
                                      significance_map,
                                      threshold,
                                      model,
                                      output_buffer,
                                      max_coefficient_bits);
        if (return_value == 1)
          {
            QccErrorAddMessage("(QccWAVtceEncode): Error calling QccWAVtceSPass()");
            goto Error;
          }
        else
          {
            if (return_value == 2)
              goto Finished;
          }  
        
        threshold /= 2.0;
      }
  else
    while (threshold > 0.75)
      {
        return_value = QccWAVtceNZNPass(&image_subband_pyramid,    
                                        significance_map,
                                        sign_array,
                                        threshold,
                                        p_estimation,
                                        subband_significance,
                                        model,
                                        output_buffer,
                                        max_coefficient_bits);
        
        if (return_value == 1)
          {
            QccErrorAddMessage("(QccWAVtceEncode): Error calling QccWAVtceNZNPass()");
            goto Error;
          }
        else
          {
            if (return_value == 2)
              goto Finished;
          }
        
        return_value = QccWAVtceIPPass(&image_subband_pyramid,    
                                       significance_map,
                                       sign_array,
                                       threshold,
                                       p_estimation,
                                       subband_significance,
                                       model,
                                       output_buffer,
                                       max_coefficient_bits);
        
        if (return_value == 1)
          {
            QccErrorAddMessage("(QccWAVtceEncode): Error calling QccWAVtceIPPass()");
            goto Error;
          }
        else
          {
            if (return_value == 2)
              goto Finished;
          }
        
        return_value = QccWAVtceSPass(&image_subband_pyramid,    
                                      significance_map,
                                      threshold,
                                      model,
                                      output_buffer,
                                      max_coefficient_bits);
        if (return_value == 1)
          {
            QccErrorAddMessage("(QccWAVtceEncode): Error calling QccWAVtceSPass()");
            goto Error;
          }
        else
          {
            if (return_value == 2)
              goto Finished;
          }

        bitplane_cnt++;
        threshold /= 2.0;
      }
  
  QccENTArithmeticEncodeFlush(model, output_buffer);
  
 Finished:
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccWAVSubbandPyramidFree(&image_subband_pyramid);
  if (sign_array != NULL)
    {
      for (row = 0; row < image->num_rows; row++)
        if (sign_array[row] != NULL)
          QccFree(sign_array[row]);
      QccFree(sign_array);
    }
  if (significance_map != NULL)
    {
      for (row = 0; row < image->num_rows; row++)
        if (significance_map[row] != NULL)
          QccFree(significance_map[row]);
      QccFree(significance_map);
    }
  if (p_estimation != NULL)
    {
      for (row = 0; row < image->num_rows; row++)
        if (p_estimation[row] != NULL)
          QccFree(p_estimation[row]);
      QccFree(p_estimation);
    }
  if (subband_significance != NULL)
    QccFree(subband_significance);
  if (max_coefficient_bits != NULL)
    QccFree(max_coefficient_bits);
  QccENTArithmeticFreeModel(model);
  return(return_value);
}


static int QccWAVtceDecodeInverseDWT(QccWAVSubbandPyramid
                                     *image_subband_pyramid,
                                     char **sign_array,
                                     QccIMGImageComponent *image,
                                     double image_mean,
                                     double stepsize,
                                     const QccWAVWavelet *wavelet)
{
  int row, col;
  int num_subbands,subband;
  int subband_origin_row;
  int subband_origin_col;
  int subband_num_rows;
  int subband_num_cols;
  
  num_subbands =
    QccWAVSubbandPyramidNumLevelsToNumSubbands(image_subband_pyramid->num_levels);
  
  if (stepsize > 0)