tarp3d.c

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

    if (QccWAVSubbandPyramid3DInverseDWT(image_subband_pyramid,
                                         wavelet))
      {
        QccErrorAddMessage("(QccWAVTarp3DDecodeInverseDWT): Error calling QccWAVSubbandPyramid3DInverseDWT()");
        return(1);
      }
  
  if (QccWAVSubbandPyramid3DAddMean(image_subband_pyramid,
                                    image_mean))
    {
      QccErrorAddMessage("(QccWAVTarp3DDecodeInverseDWT): Error calling QccWAVSubbandPyramid3DAddMean()");
      return(1);
    }
  
  if (mask_subband_pyramid != NULL)
    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 (QccAlphaTransparent(mask_subband_pyramid->volume
                                  [frame][row][col]))
            image_subband_pyramid->volume[frame][row][col] = 0;
  
  if (QccVolumeCopy(image->volume,
                    image_subband_pyramid->volume,
                    image->num_frames,
                    image->num_rows,
                    image->num_cols))
    {
      QccErrorAddMessage("(QccWAVTarp3DDecodeInverseDWT): Error calling QccVolumeCopy()");
      return(1);
    }
  
  if (QccIMGImageCubeSetMaxMin(image))
    {
      QccErrorAddMessage("(QccWAVTarp3DDecodeInverseDWT): QccError calling QccIMGImageCubeSetMaxMin()");
      return(1);
    }

  return(0);
}


int QccWAVTarp3DDecodeHeader(QccBitBuffer *buffer, 
                             int *transform_type,
                             int *temporal_num_levels, 
                             int *spatial_num_levels, 
                             int *num_frames,
                             int *num_rows,
                             int *num_cols,
                             double *image_mean,
                             int *max_coefficient_bits,
                             double *alpha)
{
  int return_value;
  unsigned char ch;
  
  if (QccBitBufferGetBit(buffer, transform_type))
    {
      QccErrorAddMessage("(QccWAVTarp3DDecodeHeader): Error calling QccBitBufferGetBit()");
      goto Error;
    }

  if (*transform_type == QCCWAVSUBBANDPYRAMID3D_PACKET)
    {
      if (QccBitBufferGetChar(buffer, &ch))
        {
          QccErrorAddMessage("(QccWAVTarp3DDecodeHeader): Error calling QccBitBufferGetChar()");
          goto Error;
        }
      *temporal_num_levels = (int)ch;
    }
  
  if (QccBitBufferGetChar(buffer, &ch))
    {
      QccErrorAddMessage("(QccWAVTarp3DDecodeHeader): Error calling QccBitBufferGetChar()");
      goto Error;
    }
  *spatial_num_levels = (int)ch;

  if (*transform_type == QCCWAVSUBBANDPYRAMID3D_DYADIC)
    *temporal_num_levels = *spatial_num_levels;

  if (QccBitBufferGetInt(buffer, num_frames))
    {
      QccErrorAddMessage("(QccWAVTarp3DDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  if (QccBitBufferGetInt(buffer, num_rows))
    {
      QccErrorAddMessage("(QccWAVTarp3DDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  if (QccBitBufferGetInt(buffer, num_cols))
    {
      QccErrorAddMessage("(QccWAVTarp3DDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  if (QccBitBufferGetDouble(buffer, image_mean))
    {
      QccErrorAddMessage("(QccWAVTarp3DDecodeHeader): Error calling QccBitBufferGetDouble()");
      goto Error;
    }
  
  if (QccBitBufferGetInt(buffer, max_coefficient_bits))
    {
      QccErrorAddMessage("(QccWAVTarp3DDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  if (QccBitBufferGetDouble(buffer, alpha))
    {
      QccErrorAddMessage("(QccWAVTarp3DDecodeHeader): Error calling QccBitBufferGetDouble()");
      goto Error;
    }

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


int QccWAVTarp3DDecode(QccBitBuffer *buffer,
                       QccIMGImageCube *image,
                       const QccIMGImageCube *mask,
                       int transform_type,
                       int temporal_num_levels,
                       int spatial_num_levels,
                       double alpha,
                       const QccWAVWavelet *wavelet,
                       double image_mean,
                       int max_coefficient_bits,
                       int target_bit_cnt)

{
  int return_value;
  QccENTArithmeticModel *model = NULL;
  QccWAVSubbandPyramid3D image_subband_pyramid;
  QccWAVSubbandPyramid3D mask_subband_pyramid;
  unsigned char ***state_array = NULL;
  double threshold;
  int frame, row, col;
  int num_symbols[1] = { 2 };
  QccWAVWavelet lazy_wavelet_transform;
  
  QccWAVSubbandPyramid3DInitialize(&image_subband_pyramid);
  QccWAVSubbandPyramid3DInitialize(&mask_subband_pyramid);
  QccWAVWaveletInitialize(&lazy_wavelet_transform);

  if (image == NULL)
    return(0);
  if (buffer == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);
  
  image_subband_pyramid.transform_type = transform_type;
  image_subband_pyramid.temporal_num_levels = temporal_num_levels;
  image_subband_pyramid.spatial_num_levels = spatial_num_levels;
  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("(QccWAVTarp3DDecode): Error calling QccWAVSubbandPyramid3DAlloc()");
      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("(QccWAVTarp3DDecode): Mask and image cube must be same size");
          goto Error;
        }
      
      if (QccWAVWaveletCreate(&lazy_wavelet_transform, "LWT.lft", "symmetric"))
        {
          QccErrorAddMessage("(QccWAVTarp3DDecode): Error calling QccWAVWaveletCreate()");
          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("(QccWAVTarp3DDecode): Error calling QccWAVSubbandPyramid3DAlloc()");
          goto Error;
        }
      
      if (QccVolumeCopy(mask_subband_pyramid.volume,
                        mask->volume,
                        mask->num_frames,
                        mask->num_rows,
                        mask->num_cols))
        {
          QccErrorAddMessage("(QccWAVTarp3DDecode): Error calling QccVolumeCopy()");
          goto Error;
        }
      
      if (QccWAVSubbandPyramid3DDWT(&mask_subband_pyramid,
                                    transform_type,
                                    temporal_num_levels,
                                    spatial_num_levels,
                                    &lazy_wavelet_transform))
        {
          QccErrorAddMessage("(QccWAVTarp3DDecode): Error calling QccWAVSubbandPyramid3DDWT()");
          goto Error;
        }
    }
  
  if ((state_array =
       (unsigned char ***)malloc(sizeof(unsigned char **) *
                                 image->num_frames)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarp3DDecode): 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("(QccWAVTarp3DDecode): 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("(QccWAVTarp3DDecode): 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++)
        {
          image_subband_pyramid.volume[frame][row][col] = 0.0;
          state_array[frame][row][col] = 0;
	}
  
  if ((model =
       QccENTArithmeticDecodeStart(buffer,
				   num_symbols,
				   1,
				   NULL,
                                   target_bit_cnt)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarp3DDecode): Error calling QccENTArithmeticDecodeStart()");
      goto Error;
    }
  QccENTArithmeticSetModelAdaption(model, QCCENT_NONADAPTIVE);
  
  threshold = pow((double)2, (double)max_coefficient_bits);
  
  while (1)
    {
      return_value = QccWAVTarp3DSignificancePass(&image_subband_pyramid,
                                                  ((mask != NULL) ?
                                                   &mask_subband_pyramid :
                                                   NULL),
                                                  state_array,
                                                  alpha,
                                                  threshold,
                                                  model,
                                                  buffer);
      if (return_value == 1)
	{
	  QccErrorAddMessage("(QccWAVTarp3DDecode): Error calling QccWAVTarp3DSignificancePass()");
	  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("(QccWAVTarp3DDecode): Error calling QccWAVTarp3DRefinementPass()");
	  goto Error;
	}
      else
	if (return_value == 2)
	  goto Finished;
      
      threshold /= 2.0;
    }
  
 Finished:
  if (QccWAVTarp3DDecodeInverseDWT(&image_subband_pyramid,
                                   ((mask != NULL) ?
                                    &mask_subband_pyramid : NULL),
				   state_array,
                                   image,
				   image_mean,
				   wavelet))
    {
      QccErrorAddMessage("(QccWAVTarp3DDecode): Error calling QccWAVTarp3DDecodeInverseDWT()");
      goto Error;
    }
  
  return_value = 0;
  QccErrorClearMessages();
  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);
}