wdr3d.c

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

  while (bitplane < QCCWAVWDR3D_MAXBITPLANES)
    {
      stop = SCS.end; 
      relative_origin = 0;
      return_value =
        QccWAVwdr3DSortingPass(&image_subband_pyramid,
                               sign_array,
                               output_buffer,
                               threshold,
                               &ICS,
                               &TPS,
                               QCCWAVWDR3D_ENCODE,
                               target_bit_cnt,
                               &relative_origin,
                               virtual_end,
                               model);
      
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVwdr3DEncode): Error calling QccWAVwdr3DSortingPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          break;
      
      return_value = QccWAVwdr3DOutputVirtualEnd(output_buffer,
                                                 relative_origin,
                                                 virtual_end,
                                                 target_bit_cnt,
                                                 model);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVwdr3DEncode): Error calling QccWAVwdr3DOutputVirtualEnd()");
          goto Error;
        }
      else
        if (return_value == 2)
          break;
      
      QccWAVwdr3DUpdateIndex(&ICS);
      return_value =
        QccWAVwdr3DRefinementPass(&image_subband_pyramid,
                                  output_buffer,
                                  threshold,
                                  &SCS,
                                  stop,
                                  QCCWAVWDR3D_ENCODE,
                                  target_bit_cnt,
                                  model);
      
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVwdr3DEncode): Error calling QccWAVwdr3DRefinementPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          break;
      
      if (QccListConcatenate(&SCS, &TPS))
        {
          QccErrorAddMessage("(QccWAVwdr3DEncode): Error calling QccListConcatenate()");
          return(1);
        }
      
      threshold /= 2.0;
      bitplane++;
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccWAVSubbandPyramid3DFree(&image_subband_pyramid);
  QccWAVSubbandPyramid3DFree(&mask_subband_pyramid);
  if (sign_array != NULL)
    {
      for (frame = 0; frame < image_cube->num_frames; frame++)
        if (sign_array[frame] != NULL)
          {
            for (row = 0; row < image_cube->num_rows; row++)
              if (sign_array[frame][row] != NULL)
                free(sign_array[frame][row]);
            free(sign_array[frame]);
          }
      free(sign_array);
    }
  QccListFree(&ICS);
  QccListFree(&SCS);
  QccListFree(&TPS);
  QccENTArithmeticFreeModel(model);    
  return(return_value);
}


int QccWAVwdr3DDecodeHeader(QccBitBuffer *input_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)
{
  int return_value;
  unsigned char ch;
  
  if (QccBitBufferGetBit(input_buffer, transform_type))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecodeHeader): Error calling QccBitBufferGetBit()");
      goto Error;
    }
  
  if (*transform_type == QCCWAVSUBBANDPYRAMID3D_PACKET)
    {
      if (QccBitBufferGetChar(input_buffer, &ch))
        {
          QccErrorAddMessage("(QccWAVwdr3DDecodeHeader): Error calling QccBitBufferGetChar()");
          goto Error;
        }
      *temporal_num_levels = (int)ch;
    }
  
  if (QccBitBufferGetChar(input_buffer, &ch))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecodeHeader): Error calling QccBitBufferGetChar()");
      goto Error;
    }
  *spatial_num_levels = (int)ch;
  
  if (*transform_type == QCCWAVSUBBANDPYRAMID3D_DYADIC)
    *temporal_num_levels = *spatial_num_levels;
  
  if (QccBitBufferGetInt(input_buffer, num_frames))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  if (QccBitBufferGetInt(input_buffer, num_rows))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  if (QccBitBufferGetInt(input_buffer, num_cols))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  if (QccBitBufferGetDouble(input_buffer, image_mean))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecodeHeader): Error calling QccBitBufferGetDouble()");
      goto Error;
    }
  
  if (QccBitBufferGetInt(input_buffer, max_coefficient_bits))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);
}


int QccWAVwdr3DDecode(QccBitBuffer *input_buffer,
                      QccIMGImageCube *image_cube,
                      QccIMGImageCube *mask,
                      int transform_type,
                      int temporal_num_levels,
                      int spatial_num_levels,
                      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 ***sign_array = NULL;
  double threshold;
  int frame;
  int row, col;
  QccWAVWavelet lazy_wavelet_transform;
  QccList ICS;
  QccList SCS;
  QccList TPS;
  QccListNode *stop;
  unsigned int relative_origin;
  unsigned int virtual_end;
  
  if (image_cube == NULL)
    return(0);
  if (input_buffer == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);
  
  QccWAVSubbandPyramid3DInitialize(&image_subband_pyramid);
  QccWAVSubbandPyramid3DInitialize(&mask_subband_pyramid);
  QccListInitialize(&ICS);
  QccListInitialize(&SCS);
  QccListInitialize(&TPS);
  QccWAVWaveletInitialize(&lazy_wavelet_transform);
  
  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_cube->num_frames;
  image_subband_pyramid.num_rows = image_cube->num_rows;
  image_subband_pyramid.num_cols = image_cube->num_cols;
  
  if (QccWAVSubbandPyramid3DAlloc(&image_subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecode): Error calling QccWAVSubbandPyramid3DAlloc()");
      goto Error;
    }
  
  if (mask != NULL)
    {
      if ((mask->num_frames != image_cube->num_frames) ||
          (mask->num_rows != image_cube->num_rows) ||
          (mask->num_cols != image_cube->num_cols))
        {
          QccErrorAddMessage("(QccWAVwdr3DDecode): Mask and image cube must be same size");
          goto Error;
        }
      
      if (QccWAVWaveletCreate(&lazy_wavelet_transform, "LWT.lft", "symmetric"))
        {
          QccErrorAddMessage("(QccWAVwdr3DDecode): 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("(QccWAVwdr3DDecode): Error calling QccWAVSubbandPyramid3DAlloc()");
          goto Error;
        }
      
      if (QccVolumeCopy(mask_subband_pyramid.volume,
                        mask->volume,
                        mask->num_frames,
                        mask->num_rows,
                        mask->num_cols))
        {
          QccErrorAddMessage("(QccWAVwdr3DDecode): Error calling QccVolumeCopy()");
          goto Error;
        }
      
      if (QccWAVSubbandPyramid3DDWT(&mask_subband_pyramid,
                                    transform_type,
                                    temporal_num_levels,
                                    spatial_num_levels,
                                    &lazy_wavelet_transform))
        {
          QccErrorAddMessage("(QccWAVwdr3DDecode): Error calling QccWAVSubbandPyramid3DDWT()");
          goto Error;
        }
    }
  
  if ((sign_array =
       (unsigned char ***)malloc(sizeof(unsigned char **) *
                                 (image_cube->num_frames))) == NULL)
    {
      QccErrorAddMessage("(QccWAVwdr3DDecode): Error allocating memory");
      goto Error;
    }
  for (frame = 0; frame < (image_cube->num_frames); frame++)
    {
      if ((sign_array[frame] =
           (unsigned char **)malloc(sizeof(unsigned char *) *
                                    (image_cube->num_rows))) == NULL)
        {
          QccErrorAddMessage("(QccWAVwdr3DDecode): Error allocating memory");
          goto Error;
        }
      for (row = 0; row < (image_cube->num_rows); row++)
        if ((sign_array[frame][row] =
             (unsigned char *)malloc(sizeof(unsigned char) *
                                     (image_cube->num_cols))) == NULL)
          {
            QccErrorAddMessage("(QccWAVwdr3DDecode): Error allocating memory");
            goto Error;
          }
    }
  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++)
        {
          image_subband_pyramid.volume[frame][row][col] = 0.0;
          sign_array[frame][row][col] = 0;
        }
  
  if ((model = QccENTArithmeticDecodeStart(input_buffer,
                                           QccWAVwdr3DArithmeticContexts,
                                           QCCWAVWDR3D_NUM_CONTEXTS,
                                           NULL,
                                           target_bit_cnt)) == NULL)
    {
      QccErrorAddMessage("(QccWAVwdr3DDecode): Error calling QccENTArithmeticDecodeStart()");
      goto Error;
    }
  
  if (QccWAVwdr3DAlgorithmInitialize(&image_subband_pyramid,
                                     ((mask != NULL) ?
                                      &mask_subband_pyramid : NULL),
                                     &ICS,
                                     &virtual_end))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecode): Error calling QccWAVwdr3DAlgorithmInitialize()");
      goto Error;
    }
  
  threshold = pow((double)2, (double)max_coefficient_bits);
  
  while (1)
    {
      stop = SCS.end;
      relative_origin = 0;
      return_value =
        QccWAVwdr3DSortingPass(&image_subband_pyramid,
                               sign_array,
                               input_buffer,
                               threshold,
                               &ICS,
                               &TPS,
                               QCCWAVWDR3D_DECODE,
                               0,
                               &relative_origin,
                               virtual_end,
                               model);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVwdr3DDecode): Error calling QccWAVwdr3DSortingPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          break;
      
      QccWAVwdr3DUpdateIndex(&ICS);
      return_value =
        QccWAVwdr3DRefinementPass(&image_subband_pyramid,
                                  input_buffer,
                                  threshold,
                                  &SCS,
                                  stop,
                                  QCCWAVWDR3D_DECODE,
                                  0,
                                  model);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVwdr3DDecode): Error calling QccWAVwdr3DRefinementPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          break;
      
      if (QccListConcatenate(&SCS, &TPS))
        {
          QccErrorAddMessage("(QccWAVwdr3DEncode): Error calling QccListConcatenate()");
          return(1);
        }
      
      threshold /= 2.0;
    }
  
  if (QccWAVwdr3DDecodeInverseDWT(&image_subband_pyramid,
                                  ((mask != NULL) ?
                                   &mask_subband_pyramid : NULL),
                                  sign_array,
                                  image_cube,
                                  image_mean,
                                  wavelet))
    {
      QccErrorAddMessage("(QccWAVwdr3DDecode): Error calling QccWAVDecodeInverseDWT()");
      goto Error;
    }
  
  return_value = 0;
  QccErrorClearMessages();
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccWAVSubbandPyramid3DFree(&image_subband_pyramid);
  QccWAVSubbandPyramid3DFree(&mask_subband_pyramid);
  if (sign_array != NULL)
    {
      for (frame = 0; frame < (image_cube->num_frames); frame++)
        if (sign_array[frame] != NULL)
          {
            for (row = 0; row < (image_cube->num_rows); row++)
              if (sign_array[frame][row] != NULL)
                free(sign_array[frame][row]);
            free(sign_array[frame]);
          }
      free(sign_array);
    }
  QccENTArithmeticFreeModel(model);
  QccListFree(&ICS);
  QccListFree(&SCS);
  QccListFree(&TPS);
  QccWAVWaveletFree(&lazy_wavelet_transform);
  return(return_value);  
}