tarp.c

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

                                           1,
                                           NULL,
                                           target_bit_cnt)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarpEncode): Error calling QccENTArithmeticEncodeStart()");
      goto Error;
    }
  QccENTArithmeticSetModelAdaption(model, QCCENT_NONADAPTIVE);

  threshold = pow((double)2, (double)max_coefficient_bits);
  
  beta = QccWAVTarpToFixedPoint((1 - alpha) * (1 - alpha) / 2 / alpha);

  while (bitplane < QCCTARP_MAXBITPLANES)
    {
      return_value = QccWAVTarpSignificancePass(&image_subband_pyramid,
                                                ((mask != NULL) ?
                                                 &mask_subband_pyramid : NULL),
                                                significance_map,
                                                sign_array,
                                                QccWAVTarpToFixedPoint(alpha),
                                                beta,
                                                threshold,
                                                model,
                                                output_buffer);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVTarpEncode): Error calling QccWAVTarpSignificancePass()");
          goto Error;
        }
      else
        if (return_value == 2)
          goto Finished;

      return_value = QccWAVTarpRefinementPass(&image_subband_pyramid,
                                              ((mask != NULL) ?
                                               &mask_subband_pyramid : NULL),
                                              significance_map,
                                              threshold,
                                              model,
                                              output_buffer);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVTarpEncode): Error calling QccWAVTarpRefinementPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          goto Finished;

      threshold /= 2.0;
      bitplane++;
    }

 Finished:
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccWAVSubbandPyramidFree(&image_subband_pyramid);
  QccWAVSubbandPyramidFree(&mask_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);
    }
  QccENTArithmeticFreeModel(model);
  return(return_value);
}


static int QccWAVTarpDecodeInverseDWT(QccWAVSubbandPyramid
                                      *image_subband_pyramid,
                                      QccWAVSubbandPyramid
                                      *mask_subband_pyramid,
                                      char **sign_array,
                                      QccIMGImageComponent *image,
                                      double image_mean,
                                      const QccWAVWavelet *wavelet)
{
  int row, col;
  
  for (row = 0; row < image_subband_pyramid->num_rows; row++)
    for (col = 0; col < image_subband_pyramid->num_cols; col++)
      if (sign_array[row][col])
        image_subband_pyramid->matrix[row][col] *= -1;
  
  if (mask_subband_pyramid != NULL)
    {
      if (QccWAVSubbandPyramidInverseShapeAdaptiveDWT(image_subband_pyramid,
                                                      mask_subband_pyramid,
                                                      wavelet))
        {
          QccErrorAddMessage("(QccWAVTarpDecodeInverseDWT): Error calling QccWAVSubbandPyramidInverseShapeAdaptiveDWT()");
          return(1);
        }
    }
  else
    if (QccWAVSubbandPyramidInverseDWT(image_subband_pyramid,
                                       wavelet))
      {
        QccErrorAddMessage("(QccWAVTarpDecodeInverseDWT): Error calling QccWAVSubbandPyramidInverseDWT()");
        return(1);
      }
  
  if (QccWAVSubbandPyramidAddMean(image_subband_pyramid,
                                  image_mean))
    {
      QccErrorAddMessage("(QccWAVTarpDecodeInverseDWT): Error calling QccWAVSubbandPyramidAddMean()");
      return(1);
    }
  
  if (mask_subband_pyramid != NULL)
    for (row = 0; row < image_subband_pyramid->num_rows; row++)
      for (col = 0; col < image_subband_pyramid->num_cols; col++)
        if (QccAlphaTransparent(mask_subband_pyramid->matrix[row][col]))
          image_subband_pyramid->matrix[row][col] = 0;

  if (QccMatrixCopy(image->image, image_subband_pyramid->matrix,
                    image->num_rows, image->num_cols))
    {
      QccErrorAddMessage("(QccWAVTarpDecodeInverseDWT): Error calling QccMatrixCopy()");
      return(1);
    }
  
  if (QccIMGImageComponentSetMaxMin(image))
    {
      QccErrorAddMessage("(QccWAVTarpDecodeInverseDWT): Error calling QccIMGImageComponentSetMaxMin()");
      return(1);
    }

  return(0);
}


int QccWAVTarpDecodeHeader(QccBitBuffer *input_buffer, 
                           double *alpha,
                           int *num_levels, 
                           int *num_rows, int *num_cols,
                           double *image_mean,
                           int *max_coefficient_bits)
{
  int return_value;
  unsigned char ch;

  if (QccBitBufferGetDouble(input_buffer, alpha))
    {
      QccErrorAddMessage("(QccWAVTarpDecodeHeader): Error calling QccBitBufferGetDouble()");
      goto Error;
    }

  if (QccBitBufferGetChar(input_buffer, &ch))
    {
      QccErrorAddMessage("(QccWAVTarpDecodeHeader): Error calling QccBitBufferGetChar()");
      goto Error;
    }
  *num_levels = (int)ch;
  
  if (QccBitBufferGetInt(input_buffer, num_rows))
    {
      QccErrorAddMessage("(QccWAVTarpDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  if (QccBitBufferGetInt(input_buffer, num_cols))
    {
      QccErrorAddMessage("(QccWAVTarpDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  if (QccBitBufferGetDouble(input_buffer, image_mean))
    {
      QccErrorAddMessage("(QccWAVTarpDecodeHeader): Error calling QccBitBufferGetDouble()");
      goto Error;
    }
  
  if (QccBitBufferGetInt(input_buffer, max_coefficient_bits))
    {
      QccErrorAddMessage("(QccWAVTarpDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);
}


int QccWAVTarpDecode(QccBitBuffer *input_buffer,
                     QccIMGImageComponent *image,
                     const QccIMGImageComponent *mask,
                     double alpha,
                     int num_levels,
                     const QccWAVWavelet *wavelet,
                     double image_mean,
                     int max_coefficient_bits,
                     int target_bit_cnt)
{
  int return_value;
  QccENTArithmeticModel *model = NULL;
  QccWAVSubbandPyramid image_subband_pyramid;
  QccWAVSubbandPyramid mask_subband_pyramid;
  char **sign_array = NULL;
  char **significance_map = NULL;
  double threshold;
  int row, col;
  int num_symbols[1] = { 2 };
  QccWAVWavelet lazy_wavelet_transform;
  QccWAVTarpFixedPoint beta;
  
  if (image == NULL)
    return(0);
  if (input_buffer == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);
  
  QccWAVSubbandPyramidInitialize(&image_subband_pyramid);
  QccWAVSubbandPyramidInitialize(&mask_subband_pyramid);
  QccWAVWaveletInitialize(&lazy_wavelet_transform);
  
  image_subband_pyramid.num_levels = num_levels;
  image_subband_pyramid.num_rows = image->num_rows;
  image_subband_pyramid.num_cols = image->num_cols;
  if (QccWAVSubbandPyramidAlloc(&image_subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVTarpDecode): Error calling QccWAVSubbandPyramidAlloc()");
      goto Error;
    }
  
  if (mask != NULL)
    {
      if ((mask->num_rows != image->num_rows) ||
          (mask->num_cols != image->num_cols))
        {
          QccErrorAddMessage("(QccWAVTarpDecode): Mask and image must be same size");
          goto Error;
        }

      if (QccWAVWaveletCreate(&lazy_wavelet_transform, "LWT.lft", "symmetric"))
        {
          QccErrorAddMessage("(QccWAVTarpDecode): Error calling QccWAVWaveletCreate()");
          goto Error;
        }

      mask_subband_pyramid.num_levels = 0;
      mask_subband_pyramid.num_rows = mask->num_rows;
      mask_subband_pyramid.num_cols = mask->num_cols;
      if (QccWAVSubbandPyramidAlloc(&mask_subband_pyramid))
        {
          QccErrorAddMessage("(QccWAVTarpDecode): Error calling QccWAVSubbandPyramidAlloc()");
          goto Error;
        }

      if (QccMatrixCopy(mask_subband_pyramid.matrix,
                        mask->image,
                        mask->num_rows,
                        mask->num_cols))
        {
          QccErrorAddMessage("(QccWAVTarpDecode): Error calling QccMatrixCopy()");
          goto Error;
        }

      if (QccWAVSubbandPyramidDWT(((mask != NULL) ?
                                   &mask_subband_pyramid : NULL),
                                  num_levels,
                                  &lazy_wavelet_transform))
        {
          QccErrorAddMessage("(QccWAVTarpDecode): Error calling QccWAVSubbandPyramidDWT()");
          goto Error;
        }
    }
  
  if ((sign_array = (char **)malloc(sizeof(char *) * image->num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarpDecode): 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("(QccWAVTarpDecode): Error allocating memory");
        goto Error;
      }
  
  if ((significance_map =
       (char **)malloc(sizeof(char *) * image->num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarpDecode): 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("(QccWAVTarpDecode): Error allocating memory");
        goto Error;
      }
  
  for (row = 0; row < image->num_rows; row++)
    for (col = 0; col < image->num_cols; col++)
      {
        image_subband_pyramid.matrix[row][col] = 0.0;
        sign_array[row][col] = 0;
        significance_map[row][col] = QCCTARP_INSIGNIFICANT;
      }
  
  if ((model =
       QccENTArithmeticDecodeStart(input_buffer,
                                   num_symbols,
                                   1,
                                   NULL,
                                   target_bit_cnt)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarpDecode): Error calling QccENTArithmeticDecodeStart()");
      goto Error;
    }
  QccENTArithmeticSetModelAdaption(model, QCCENT_NONADAPTIVE);

  threshold = pow((double)2, (double)max_coefficient_bits);
  
  beta = QccWAVTarpToFixedPoint((1 - alpha) * (1 - alpha) / 2 / alpha);

  while (1)
    {
      return_value = QccWAVTarpSignificancePass(&image_subband_pyramid,
                                                ((mask != NULL) ?
                                                 &mask_subband_pyramid : NULL),
                                                significance_map,
                                                sign_array,
                                                QccWAVTarpToFixedPoint(alpha),
                                                beta,
                                                threshold,
                                                model,
                                                input_buffer);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVTarpDecode): Error calling QccWAVTarpSignificancePass()");
          goto Error;
        }
      else
        if (return_value == 2)
          goto Finished;

      return_value = QccWAVTarpRefinementPass(&image_subband_pyramid,
                                              ((mask != NULL) ?
                                               &mask_subband_pyramid : NULL),
                                              significance_map,
                                              threshold,
                                              model,
                                              input_buffer);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVTarpDecode): Error calling QccWAVTarpRefinementPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          goto Finished;

      threshold /= 2.0;
    }

 Finished:
  if (QccWAVTarpDecodeInverseDWT(&image_subband_pyramid,
                                 ((mask != NULL) ?
                                  &mask_subband_pyramid : NULL),
                                 sign_array,
                                 image,
                                 image_mean,
                                 wavelet))
    {
      QccErrorAddMessage("(QccWAVTarpDecode): Error calling QccWAVTarpDecodeInverseDWT()");
      goto Error;
    }
  
  return_value = 0;
  QccErrorClearMessages();
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccWAVSubbandPyramidFree(&image_subband_pyramid);
  QccWAVSubbandPyramidFree(&mask_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);
    }
  QccENTArithmeticFreeModel(model);
  return(return_value);
}