tarp3d.c

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

  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;
  
  if (QccWAVSubbandPyramid3DSubbandSize(coefficients,
                                        subband,
                                        &subband_num_frames,
                                        &subband_num_rows,
                                        &subband_num_cols))
    {
      QccErrorAddMessage("(QccWAVTarp3DRefinementPassSubband): Error calling QccWAVSubbandPyramid3DSubbandSize()");
      return(1);
    }
  if (QccWAVSubbandPyramid3DSubbandOffsets(coefficients,
                                           subband,
                                           &subband_origin_frame,
                                           &subband_origin_row,
                                           &subband_origin_col))
    {
      QccErrorAddMessage("(QccWAVTarp3DRefinementPassSubband): Error calling QccWAVSubbandPyramid3DSubbandOffsets()");
      return(1);
    }
  
  for (frame = 0; frame < subband_num_frames; frame++)
    for (row = 0; row < subband_num_rows; row++)
      for (col = 0; col < subband_num_cols; col++)
        if (QccWAVTarp3DGetSignificance(state_array
                                        [subband_origin_frame + frame]
                                        [subband_origin_row + row]
                                        [subband_origin_col + col]) ==
            QCCTARP3D_PREVIOUSLY_SIGNIFICANT)
          {
            return_value =
              QccWAVTarp3DRefinementInputOutput(&coefficients->volume
                                                [subband_origin_frame + frame]
                                                [subband_origin_row + row]
                                                [subband_origin_col + col],
                                                threshold,
                                                model,
                                                buffer);
            if (return_value == 1)
              {
                QccErrorAddMessage("(QccWAVTarp3DRefinementPassSubband): Error calling QccWAVTarp3DRefinementPassInputOutput()");
                return(1);
              }
            else
              if (return_value == 2)
                return(2);
          }
        else
          if (QccWAVTarp3DGetSignificance(state_array
                                          [subband_origin_frame + frame]
                                          [subband_origin_row + row]
                                          [subband_origin_col + col]) ==
              QCCTARP3D_NEWLY_SIGNIFICANT)
            QccWAVTarp3DSetSignificance(&state_array
                                        [subband_origin_frame + frame]
                                        [subband_origin_row + row]
                                        [subband_origin_col + col],
                                        QCCTARP3D_PREVIOUSLY_SIGNIFICANT);
  
  return(0);
}


static int QccWAVTarp3DRefinementPass(QccWAVSubbandPyramid3D *coefficients,
                                      QccWAVSubbandPyramid3D *mask,
                                      unsigned char ***state_array,
                                      double threshold,
                                      QccENTArithmeticModel *model,
                                      QccBitBuffer *buffer)
{
  int subband;
  int num_subbands;
  int return_value;
  
  if (coefficients->transform_type ==
      QCCWAVSUBBANDPYRAMID3D_DYADIC)
    num_subbands =
      QccWAVSubbandPyramid3DNumLevelsToNumSubbandsDyadic(coefficients->spatial_num_levels);
  else
    num_subbands =
      QccWAVSubbandPyramid3DNumLevelsToNumSubbandsPacket(coefficients->temporal_num_levels,
                                                         coefficients->spatial_num_levels);
  
  for (subband = 0; subband < num_subbands; subband++)
    {
      return_value =
	QccWAVTarp3DRefinementPassSubband(coefficients,
                                          mask,
                                          state_array,
                                          threshold,
                                          subband,
                                          model,
                                          buffer);
      if (return_value == 1)
	{
	  QccErrorAddMessage("(QccWAVTarp3DRefinementPass): Error calling QccWAVTarp3DRefinementPassSubband()");
	  return(1);
	}
      else
	if (return_value == 2)
	  return(2);
    }
  
  return(0);
}


int QccWAVTarp3DEncode(const QccIMGImageCube *image,
                       const QccIMGImageCube *mask,
                       QccBitBuffer *buffer,
                       int transform_type,
                       int temporal_num_levels,
                       int spatial_num_levels,
                       double alpha,
                       const QccWAVWavelet *wavelet,
                       int target_bit_cnt)
{
  int return_value;
  QccENTArithmeticModel *model = NULL;
  QccWAVSubbandPyramid3D image_subband_pyramid;
  QccWAVSubbandPyramid3D mask_subband_pyramid;
  unsigned char ***state_array = NULL;
  double image_mean;
  int max_coefficient_bits;
  double threshold;
  int num_symbols[1] = { 2 };
  int frame, row, col;
  int bitplane = 0;

  if (image == NULL)
    return(0);
  if (buffer == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);
  
  QccWAVSubbandPyramid3DInitialize(&image_subband_pyramid);
  QccWAVSubbandPyramid3DInitialize(&mask_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 (QccWAVSubbandPyramid3DAlloc(&image_subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVTarp3DEncode): Error calling QccWAVSubbandPyramidAlloc()");
      goto Error;
    }
  
  if (mask != NULL)
    {
      if ((mask->num_frames != image->num_frames) ||
          (mask->num_rows != image->num_rows) ||
          (mask->num_cols != image->num_cols))
        {
          QccErrorAddMessage("(QccWAVTarp3DEncode): Mask and image cube must be same size");
          goto Error;
        }
      
      mask_subband_pyramid.temporal_num_levels = 0;
      mask_subband_pyramid.spatial_num_levels = 0;
      mask_subband_pyramid.num_frames = mask->num_frames;
      mask_subband_pyramid.num_rows = mask->num_rows;
      mask_subband_pyramid.num_cols = mask->num_cols;
      if (QccWAVSubbandPyramid3DAlloc(&mask_subband_pyramid))
        {
          QccErrorAddMessage("(QccWAVTarp3DEncode): Error calling QccWAVSubbandPyramid3DAlloc()");
          goto Error;
        }
    }
  
  if ((state_array =
       (unsigned char ***)malloc(sizeof(unsigned char **) * image->num_frames))
      == NULL)
    {
      QccErrorAddMessage("(QccWAVTarp3DEncode): Error allocating memory");
      goto Error;
    }
  for (frame = 0; frame < image->num_frames; frame++)
    {
      if ((state_array[frame] =
           (unsigned char **)malloc(sizeof(unsigned char *) *
                                    image->num_rows)) == NULL)
        {
          QccErrorAddMessage("(QccWAVTarp3DEncode): Error allocating memory");
          goto Error;
        }
      for (row = 0; row < image->num_rows; row++)
        if ((state_array[frame][row] =
             (unsigned char *)malloc(sizeof(unsigned char) *
                                     image->num_cols)) == NULL)
          {
            QccErrorAddMessage("(QccWAVTarp3DEncode): Error allocating memory");
            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++)
        state_array[frame][row][col] = 0;
  
  if (QccWAVTarp3DEncodeDWT(&image_subband_pyramid,
                            state_array,
                            image,
                            transform_type,
                            temporal_num_levels,
                            spatial_num_levels,
                            &image_mean,
                            &max_coefficient_bits,
                            ((mask != NULL) ? &mask_subband_pyramid : NULL),
                            mask,
                            wavelet))
    {
      QccErrorAddMessage("(QccWAVTarp3DEncode): Error calling QccWAVTarp3DEncodeDWT()");
      goto Error;
    }
  
  alpha = (double)((float)alpha);

  if (QccWAVTarp3DEncodeHeader(buffer,
                               transform_type,
                               temporal_num_levels,
                               spatial_num_levels,
                               image->num_frames,
                               image->num_rows,
                               image->num_cols, 
                               image_mean,
                               max_coefficient_bits,
                               alpha))
    {
      QccErrorAddMessage("(QccWAVTarp3DEncode): Error calling QccWAVTarp3DEncodeHeader()");
      goto Error;
    }
  
  if ((model = QccENTArithmeticEncodeStart(num_symbols,
					   1,
					   NULL,
					   target_bit_cnt)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarp3DEncode): Error calling QccENTArithmeticEncodeStart()");
      goto Error;
    }
  QccENTArithmeticSetModelAdaption(model, QCCENT_NONADAPTIVE);
  
  threshold = pow((double)2, (double)max_coefficient_bits);
  
  while (bitplane < QCCTARP3D_MAXBITPLANES)
    {
      return_value =
        QccWAVTarp3DSignificancePass(&image_subband_pyramid,
                                     ((mask != NULL) ?
                                      &mask_subband_pyramid : NULL),
                                     state_array,
                                     alpha,
                                     threshold,
                                     model,
                                     buffer);
      if (return_value == 1)
	{
	  QccErrorAddMessage("(QccWAVTarp3DEncode): Error calling QccWAVTarpSignificancePass()");
	  goto Error;
	}
      else
	if (return_value == 2)
	  goto Finished;
      
      return_value =
        QccWAVTarp3DRefinementPass(&image_subband_pyramid,
                                   ((mask != NULL) ?
                                    &mask_subband_pyramid : NULL),
                                   state_array,
                                   threshold,
                                   model,
                                   buffer);
        if (return_value == 1)
          {
            QccErrorAddMessage("(QccWAVTarp3DEncode): Error calling QccWAVTarp3DRefinementPass()");
            goto Error;
          }
        else
          if (return_value == 2)
            goto Finished;
      
      threshold /= 2.0;
      bitplane++;
    }
  
 Finished:
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccWAVSubbandPyramid3DFree(&image_subband_pyramid);
  QccWAVSubbandPyramid3DFree(&mask_subband_pyramid);
  if (state_array != NULL)
    {
      for (frame = 0; frame < image->num_frames; frame++)
        {
          if (state_array[frame] != NULL)
            {
              for (row = 0; row < image->num_rows; row++)
                if (state_array[frame][row] != NULL)
                  QccFree(state_array[frame][row]);
              QccFree(state_array[frame]);
            }
        }
      QccFree(state_array);
    }
  QccENTArithmeticFreeModel(model);
  return(return_value);
}


static int QccWAVTarp3DDecodeInverseDWT(QccWAVSubbandPyramid3D
                                        *image_subband_pyramid,
                                        QccWAVSubbandPyramid3D
                                        *mask_subband_pyramid,
                                        unsigned char ***state_array,
                                        QccIMGImageCube *image,
                                        double image_mean,
                                        const QccWAVWavelet *wavelet)
{
  int frame, row, col;

  for (frame = 0; frame < image_subband_pyramid->num_frames; frame++)
    for (row = 0; row < image_subband_pyramid->num_rows; row++)
      for (col = 0; col < image_subband_pyramid->num_cols; col++)
        if (QccWAVTarp3DGetSign(state_array[frame][row][col]))
          image_subband_pyramid->volume[frame][row][col] *= -1;
  
  if (mask_subband_pyramid != NULL)
    {
      if (QccWAVSubbandPyramid3DInverseShapeAdaptiveDWT(image_subband_pyramid,
                                                        mask_subband_pyramid,
                                                        wavelet))
        {
          QccErrorAddMessage("(QccWAVTarp3DDecodeInverseDWT): Error calling QccWAVSubbandPyramid3DInverseShapeAdaptiveDWT()");
          return(1);
        }
    }
  else