bisk3d.c

QccPack-0.54-1 released (2007-04-30) is being developed and tested on Fedora Core Linux. QccPack pro

  if (QccWAVbisk3DEncodeHeader(output_buffer,
                               image_subband_pyramid->transform_type,
                               image_subband_pyramid->temporal_num_levels,
                               image_subband_pyramid->spatial_num_levels,
                               image_subband_pyramid->num_frames,
                               image_subband_pyramid->num_rows,
                               image_subband_pyramid->num_cols,
                               image_mean,
                               max_coefficient_bits))
    {
      QccErrorAddMessage("(QccWAVbisk3DEncode2): Error calling QccWAVbisk3DEncodeHeader()");
      goto Error;
    }
  
  
  if ((model = QccENTArithmeticEncodeStart(QccWAVbisk3DNumSymbols,
                                           QCCBISK3D_NUM_CONTEXTS,
                                           NULL,
                                           target_bit_cnt)) == NULL)
    {
      QccErrorAddMessage("(QccWAVbisk3DEncode2): Error calling QccENTArithmeticEncodeStart()");
      goto Error;
    }
  
  threshold = pow((double)2, (double)max_coefficient_bits);
  
  if (QccWAVbisk3DInitialization(&LIS,
                                 &LSP,
                                 image_subband_pyramid,
                                 mask_subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVbisk3DEncode2): Error calling QccWAVbisk3DInitialization()");
      goto Error;
    }
  
  while (bitplane < QCCBISK3D_MAXBITPLANES)
    {
      return_value = QccWAVbisk3DSortingPass(image_subband_pyramid,
                                             mask_subband_pyramid,
                                             state_array,
                                             threshold,
                                             &LIS,
                                             &LSP,
                                             model,
                                             output_buffer);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVbisk3DEncode2): Error calling QccWAVbisk3DSortingPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          goto Finished;
      
      return_value = QccWAVbisk3DRefinementPass(image_subband_pyramid,
                                                &LSP,
                                                threshold,
                                                model,
                                                output_buffer);
      
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVbisk3DEncode2): Error calling QccWAVbiskRefinementPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          goto Finished;
      
      threshold /= 2.0;
      bitplane++;
    }
  
  
 Finished:
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  if (state_array != NULL)
    {
      for (frame = 0; frame < image_subband_pyramid->num_frames; frame++)
        if (state_array[frame] != NULL)
          {
            for (row = 0; row < image_subband_pyramid->num_rows; row++)
              if (state_array[frame][row] != NULL)
                free(state_array[frame][row]);
            free(state_array[frame]);
          }
      free(state_array);
    }
  QccENTArithmeticFreeModel(model);
  QccWAVbisk3DFreeLIS(&LIS);
  QccListFree(&LSP);
  return(return_value);
}


int QccWAVbisk3DEncode(const QccIMGImageCube *image_cube,
                       const QccIMGImageCube *mask,
                       int transform_type,
                       int temporal_num_levels,
                       int spatial_num_levels,
                       const QccWAVWavelet *wavelet,
                       QccBitBuffer *output_buffer,
                       int target_bit_cnt)
{
  int return_value;
  QccWAVSubbandPyramid3D image_subband_pyramid;
  QccWAVSubbandPyramid3D mask_subband_pyramid;
  double image_mean = 0;

  if (image_cube == NULL)
    return(0);
  if (output_buffer == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);

  QccWAVSubbandPyramid3DInitialize(&image_subband_pyramid);
  QccWAVSubbandPyramid3DInitialize(&mask_subband_pyramid);

  image_subband_pyramid.temporal_num_levels = 0;
  image_subband_pyramid.spatial_num_levels = 0;
  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;
  image_subband_pyramid.transform_type = transform_type;
  if (QccWAVSubbandPyramid3DAlloc(&image_subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVbisk3DEncode): 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("(QccWAVbisk3DEncode): Mask and image 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("(QccWAVbisk3DEncode): Error calling QccWAVSubbandPyramidAlloc()");
          goto Error;
        }
    }

  if (QccWAVbisk3DEncodeDWT(&image_subband_pyramid,
                            image_cube,
                            transform_type,
                            temporal_num_levels,
                            spatial_num_levels,
                            &image_mean,
                            ((mask != NULL) ? &mask_subband_pyramid : NULL),
                            mask,
                            wavelet))
    {
      QccErrorAddMessage("(QccWAVbisk3DEncode): Error calling QccWAVbisk3DEncodeDWT()");
      goto Error;
    }

  if (QccWAVbisk3DEncode2(&image_subband_pyramid,
                          (mask != NULL) ?
                          &mask_subband_pyramid : NULL,
                          image_mean,
                          output_buffer,
                          target_bit_cnt))
    {
      QccErrorAddMessage("(QccWAVbisk3DEncode): Error calling QccWAVbisk3DEncode2()");
      goto Error;
    }

  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccWAVSubbandPyramid3DFree(&image_subband_pyramid);
  QccWAVSubbandPyramid3DFree(&mask_subband_pyramid);
  return(return_value);
}


int QccWAVbisk3DDecodeHeader(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("(QccWAVbisk3DDecodeHeader): Error calling QccBitBufferGetBit()");
      goto Error;
    }

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

  if (QccBitBufferGetChar(input_buffer, &ch))
    {
      QccErrorAddMessage("(QccWAVbisk3DDecodeHeader): 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("(QccWAVbisk3DDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }

  if (QccBitBufferGetInt(input_buffer, num_rows))
    {
      QccErrorAddMessage("(QccWAVbisk3DDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }

  if (QccBitBufferGetInt(input_buffer, num_cols))
    {
      QccErrorAddMessage("(QccWAVbisk3DDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }

  if (QccBitBufferGetDouble(input_buffer, image_mean))
    {
      QccErrorAddMessage("(QccWAVbisk3DDecodeHeader): Error calling QccBitBufferGetDouble()");
      goto Error;
    }

  if (QccBitBufferGetInt(input_buffer, max_coefficient_bits))
    {
      QccErrorAddMessage("(QccWAVbisk3DDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }

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


int QccWAVbisk3DDecode2(QccBitBuffer *input_buffer,
                        QccWAVSubbandPyramid3D *image_subband_pyramid,
                        QccWAVSubbandPyramid3D *mask_subband_pyramid,
                        int max_coefficient_bits,
                        int target_bit_cnt)
{
  int return_value;
  QccENTArithmeticModel *model = NULL;
  unsigned char ***state_array = NULL;
  double threshold;
  int frame;
  int row, col;
  QccList LIS;
  QccList LSP;

  if (image_subband_pyramid == NULL)
    return(0);
  if (input_buffer == NULL)
    return(0);

  QccListInitialize(&LIS);
  QccListInitialize(&LSP);

  if ((state_array =
       (unsigned char ***)malloc(sizeof(unsigned char **) *
                                 (image_subband_pyramid->num_frames))) == NULL)
    {
      QccErrorAddMessage("(QccWAVbisk3DDecode2): Error allocating memory");
      goto Error;
    }
  for (frame = 0; frame < image_subband_pyramid->num_frames; frame++)
    {
      if ((state_array[frame] =
           (unsigned char **)malloc(sizeof(unsigned char *) *
                                    image_subband_pyramid->num_rows)) ==
          NULL)
        {
          QccErrorAddMessage("(QccWAVbisk3DDecode2): Error allocating memory");
          goto Error;
        }
      for (row = 0; row < image_subband_pyramid->num_rows; row++)
        if ((state_array[frame][row] =
             (unsigned char *)malloc(sizeof(unsigned char) *
                                     image_subband_pyramid->num_cols)) ==
            NULL)
          {
            QccErrorAddMessage("(QccWAVbisk3DDecode2): 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;
          state_array[frame][row][col] = 0;
        }
  
  if ((model = QccENTArithmeticDecodeStart(input_buffer,
                                           QccWAVbisk3DNumSymbols,
                                           QCCBISK3D_NUM_CONTEXTS,
                                           NULL,
                                           target_bit_cnt)) == NULL)
    {
      QccErrorAddMessage("(QccWAVbisk3DDecode2): Error calling QccENTArithmeticDecodeStart()");
      goto Error;
    }
  
  threshold = pow((double)2, (double)max_coefficient_bits);
  
  if (QccWAVbisk3DInitialization(&LIS,
                                 &LSP,
                                 image_subband_pyramid,
                                 mask_subband_pyramid))
    {
      QccErrorAddMessage("(QccWAVbisk3DDecode2): Error calling QccWAVbisk3DInitialization()");
      goto Error;
    }
  
  while (1)
    {
      return_value = QccWAVbisk3DSortingPass(image_subband_pyramid,
                                             mask_subband_pyramid,
                                             state_array,
                                             threshold,
                                             &LIS,
                                             &LSP,
                                             model,
                                             input_buffer);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVbisk3DDecode2): Error calling QccWAVbisk3DSortingPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          goto Finished;
      
      return_value = QccWAVbisk3DRefinementPass(image_subband_pyramid,
                                                &LSP,
                                                threshold,
                                                model,
                                                input_buffer);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVbisk3DDecode2): Error calling QccWAVbisk3DRefinementPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          goto Finished;
      
      threshold /= 2.0;
    }
  
 Finished:
  if (QccWAVbisk3DDecodeApplySigns(image_subband_pyramid,
                                   mask_subband_pyramid,
                                   state_array))
    {
      QccErrorAddMessage("(QccWAVbisk3DDecode2): Error calling QccWAVbisk