tarp.c

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

  for (col = 0; col < subband_num_cols; col++)
    p2[col] = QCCTARP_BOUNDARY_VALUE;

  for (row = 0; row < subband_num_rows; row++)
    {
      p1 = QCCTARP_BOUNDARY_VALUE;

      for (col = 0; col < subband_num_cols; col++)
        {
          transparent =
            (mask != NULL) ?
            QccAlphaTransparent(mask->matrix
                                [subband_origin_row + row]
                                [subband_origin_col + col]) : 0;

          if (!transparent)
            {
              p = QccWAVTarpFixedPointMult(alpha, (p1 + p2[col]));
              
              return_value =
                QccWAVTarpSignificanceInputOutput(&coefficients->matrix
                                                  [subband_origin_row + row]
                                                  [subband_origin_col + col],
                                                  p,
                                                  threshold,
                                                  &sign_array
                                                  [subband_origin_row + row]
                                                  [subband_origin_col + col],
                                                  &significance_map
                                                  [subband_origin_row + row]
                                                  [subband_origin_col + col],
                                                  model,
                                                  buffer);
              if (return_value == 2)
                goto Return;
              else
                if (return_value)
                  {
                    QccErrorAddMessage("(QccWAVTarpSignificancePassSubband): Error calling QccWAVTarpSignificanceInputOutput()");
                    goto Error;
                  }
              
              v =
                (significance_map[subband_origin_row + row]
                 [subband_origin_col + col] != QCCTARP_INSIGNIFICANT) ?
                QccWAVTarpToFixedPoint(1.0) : 0;
              p1 =
                QccWAVTarpFixedPointMult(alpha, p1) +
                QccWAVTarpFixedPointMult(beta, v);
            }

          p2[col] = p1 + QccWAVTarpFixedPointMult(alpha, p2[col]);

        }

      p3 = QCCTARP_BOUNDARY_VALUE;

      for (col = subband_num_cols - 1; col >= 0; col--)
        {
          transparent =
            (mask != NULL) ?
            QccAlphaTransparent(mask->matrix
                                [subband_origin_row + row]
                                [subband_origin_col + col]) : 0;

          p2[col] += QccWAVTarpFixedPointMult(alpha, p3);

          if (!transparent)
            {
              v =
                (significance_map[subband_origin_row + row]
                 [subband_origin_col + col] != QCCTARP_INSIGNIFICANT) ?
                QccWAVTarpToFixedPoint(1.0) : 0;
              p3 =
                QccWAVTarpFixedPointMult(alpha, p3) +
                QccWAVTarpFixedPointMult(beta, v);
            }
        }
    }

  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccWAVTarpFixedPointVectorFree(p2);
  return(return_value);
}


static int QccWAVTarpSignificancePass(QccWAVSubbandPyramid *coefficients,
                                      const QccWAVSubbandPyramid *mask,
                                      char **significance_map,
                                      char **sign_array,
                                      QccWAVTarpFixedPoint alpha,
                                      QccWAVTarpFixedPoint beta,
                                      double threshold,
                                      QccENTArithmeticModel *model,
                                      QccBitBuffer *buffer)
{
  int subband;
  int num_subbands;
  int return_value;

  num_subbands =
    QccWAVSubbandPyramidNumLevelsToNumSubbands(coefficients->num_levels);

  for (subband = 0; subband < num_subbands; subband++)
    {
      return_value =
        QccWAVTarpSignificancePassSubband(coefficients,
                                          mask,
                                          significance_map,
                                          sign_array,
                                          alpha,
                                          beta,
                                          subband,
                                          threshold,
                                          model,
                                          buffer);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVTarpSignificancePass): Error calling QccWAVTarpSignificancePassSubband()");
          return(1);
        }
      else
        if (return_value == 2)
          return(2);
    }

  return(0);
}


static int QccWAVTarpRefinementInputOutput(double *coefficient,
                                           double threshold,
                                           QccENTArithmeticModel *model,
                                           QccBitBuffer *buffer)
{
  int return_value;
  int symbol;

  if (QccWAVTarpUpdateModel(model, QccWAVTarpToFixedPoint(0.5)))
    {
      QccErrorAddMessage("(QccWAVTarpRefinementInputOutput): Error calling QccWAVTarpUpdateModel()");
      return(1);
    }
  
  if (buffer->type == QCCBITBUFFER_OUTPUT)
    {
      if (*coefficient >= threshold)
        {
          symbol = 1;
          *coefficient -= threshold;
        }
      else
        symbol = 0;

      return_value =
        QccENTArithmeticEncode(&symbol, 1,
                               model, buffer);
      if (return_value == 2)
        return(2);
      else
        if (return_value)
          {
            QccErrorAddMessage("(QccWAVTarpRefinementInputOutput): Error calling QccENTArithmeticEncode()");
            return(1);
          }
    }
  else
    {
      if (QccENTArithmeticDecode(buffer,
                                 model,
                                 &symbol, 1))
        return(2);

      *coefficient +=
        (symbol == 1) ? threshold / 2 : -threshold / 2;
    }

  return(0);
}


static int QccWAVTarpRefinementPassSubband(QccWAVSubbandPyramid *coefficients,
                                           const QccWAVSubbandPyramid *mask,
                                           char **significance_map,
                                           double threshold,
                                           int subband,
                                           QccENTArithmeticModel *model,
                                           QccBitBuffer *buffer)
{
  int return_value;
  int subband_origin_row;
  int subband_origin_col;
  int subband_num_rows;
  int subband_num_cols;
  int row, col;
  int transparent;

  if (QccWAVSubbandPyramidSubbandSize(coefficients,
                                      subband,
                                      &subband_num_rows,
                                      &subband_num_cols))
    {
      QccErrorAddMessage("(QccWAVTarpRefinementPassSubband): Error calling QccWAVSubbandPyramidSubbandSize()");
      return(1);
    }
  if (QccWAVSubbandPyramidSubbandOffsets(coefficients,
                                         subband,
                                         &subband_origin_row,
                                         &subband_origin_col))
    {
      QccErrorAddMessage("(QccWAVTarpRefinementPassSubband): Error calling QccWAVSubbandPyramidSubbandOffsets()");
      return(1);
    }
  
  for (row = 0; row < subband_num_rows; row++)
    for (col = 0; col < subband_num_cols; col++)
      {
        transparent =
          (mask != NULL) ?
          QccAlphaTransparent(mask->matrix
                              [subband_origin_row + row]
                              [subband_origin_col + col]) : 0;
        
        if (!transparent)
          {
            if (significance_map[subband_origin_row + row]
                [subband_origin_col + col] == QCCTARP_PREVIOUSLY_SIGNIFICANT)
              {
                return_value =
                  QccWAVTarpRefinementInputOutput(&coefficients->matrix
                                                  [subband_origin_row + row]
                                                  [subband_origin_col + col],
                                                  threshold,
                                                  model,
                                                  buffer);
                if (return_value == 1)
                  {
                    QccErrorAddMessage("(QccWAVTarpRefinementPassSubband): Error calling QccWAVTarpRefinementPassInputOutput()");
                    return(1);
                  }
                else
                  if (return_value == 2)
                    return(2);
              }
            else
              if (significance_map[subband_origin_row + row]
                  [subband_origin_col + col] == QCCTARP_NEWLY_SIGNIFICANT)
                significance_map[subband_origin_row + row]
                  [subband_origin_col + col] = QCCTARP_PREVIOUSLY_SIGNIFICANT;
          }
      }

  return(0);
}


static int QccWAVTarpRefinementPass(QccWAVSubbandPyramid *coefficients,
                                    const QccWAVSubbandPyramid *mask,
                                    char **significance_map,
                                    double threshold,
                                    QccENTArithmeticModel *model,
                                    QccBitBuffer *buffer)
{
  int subband;
  int num_subbands;
  int return_value;

  num_subbands =
    QccWAVSubbandPyramidNumLevelsToNumSubbands(coefficients->num_levels);

  for (subband = 0; subband < num_subbands; subband++)
    {
      return_value =
        QccWAVTarpRefinementPassSubband(coefficients,
                                        mask,
                                        significance_map,
                                        threshold,
                                        subband,
                                        model,
                                        buffer);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVTarpRefinementPass): Error calling QccWAVTarpRefinementPassSubband()");
          return(1);
        }
      else
        if (return_value == 2)
          return(2);
    }

  return(0);
}


int QccWAVTarpEncode(const QccIMGImageComponent *image,
                     const QccIMGImageComponent *mask,
                     double alpha,
                     int num_levels,
                     int target_bit_cnt,
                     const QccWAVWavelet *wavelet,
                     QccBitBuffer *output_buffer)
{
  int return_value;
  QccENTArithmeticModel *model = NULL;
  QccWAVSubbandPyramid image_subband_pyramid;
  QccWAVSubbandPyramid mask_subband_pyramid;
  char **sign_array = NULL;
  char **significance_map = NULL;
  double image_mean;
  int max_coefficient_bits;
  double threshold;
  int num_symbols[1] = { 2 };
  int row, col;
  QccWAVTarpFixedPoint beta;
  int bitplane = 0;

  if (image == NULL)
    return(0);
  if (output_buffer == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);
  
  QccWAVSubbandPyramidInitialize(&image_subband_pyramid);
  QccWAVSubbandPyramidInitialize(&mask_subband_pyramid);

  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("(QccWAVTarpEncode): Error calling QccWAVSubbandPyramidAlloc()");
      goto Error;
    }
  
  if (mask != NULL)
    {
      if ((mask->num_rows != image->num_rows) ||
          (mask->num_cols != image->num_cols))
        {
          QccErrorAddMessage("(QccWAVTarpEncode): Mask and image must be same size");
          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("(QccWAVTarpEncode): Error calling QccWAVSubbandPyramidAlloc()");
          goto Error;
        }
    }
  
  if ((sign_array = (char **)malloc(sizeof(char *) * image->num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarpEncode): 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("(QccWAVTarpEncode): Error allocating memory");
        goto Error;
      }
  
  if ((significance_map =
       (char **)malloc(sizeof(char *) * image->num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarpEncode): 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("(QccWAVTarpEncode): 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] = QCCTARP_INSIGNIFICANT;

  if (QccWAVTarpEncodeDWT(&image_subband_pyramid,
                          sign_array,
                          image,
                          num_levels,
                          &image_mean,
                          &max_coefficient_bits,
                          ((mask != NULL) ? &mask_subband_pyramid : NULL),
                          mask,
                          wavelet))
    {
      QccErrorAddMessage("(QccWAVTarpEncode): Error calling QccWAVTarpEncodeDWT()");
      goto Error;
    }
  
  alpha = (double)((float)alpha);

  if (QccWAVTarpEncodeHeader(output_buffer,
                             alpha,
                             num_levels,
                             image->num_rows, image->num_cols, 
                             image_mean,
                             max_coefficient_bits))
    {
      QccErrorAddMessage("(QccWAVTarpEncode): Error calling QccWAVTarpEncodeHeader()");
      goto Error;
    }
  
  if ((model = QccENTArithmeticEncodeStart(num_symbols,