wdr.c

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

                         perceptual_weights))
    {
      QccErrorAddMessage("(QccWAVwdrEncode): Error calling QccWAVwdrEncodeDWT()");
      goto Error;
    }
  
  if (QccWAVwdrEncodeHeader(buffer,
                            num_levels,
                            image->num_rows,
                            image->num_cols,
                            image_mean,
                            max_coefficient_bits))
    {
      QccErrorAddMessage("(QccWAVwdrEncode): Error calling QccWAVwdrEncodeHeader()");
      goto Error;
    }
  
  if (QccWAVwdrAlgorithmInitialize(&image_subband_pyramid,
                                   ((mask != NULL) ?
                                    &mask_subband_pyramid : NULL),
                                   num_levels,
                                   &ICS,
                                   &virtual_end))
    {
      QccErrorAddMessage("(QccWAVwdrEncode): Error calling QccWAVwdrAlgorithmInitialize()");
      goto Error;
    }
  
  threshold = pow((double)2, (double)max_coefficient_bits);
  
  while (bitplane < QCCWAVWDR_MAXBITPLANES)
    {
      stop = SCS.end; 
      relative_origin = 0;
      return_value =
        QccWAVwdrSortingPass(&image_subband_pyramid,
                             sign_array,
                             buffer,
                             threshold,
                             &ICS,
                             &TPS,
                             QCCWAVWDR_ENCODE,
                             target_bit_cnt,
                             &relative_origin,
                             virtual_end,
                             model);
      
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVwdrEncode): Error calling QccWAVwdrSortingPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          break;
      
      return_value = QccWAVwdrOutputVirtualEnd(buffer,
                                               relative_origin,
                                               virtual_end,
                                               target_bit_cnt,
                                               model);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVwdrEncode): Error calling QccWAVwdrOutputVirtualEnd()");
          goto Error;
        }
      else
        if (return_value == 2)
          break;
      
      QccWAVwdrUpdateIndex(&ICS);
      return_value =
        QccWAVwdrRefinementPass(&image_subband_pyramid,
                                buffer,
                                threshold,
                                &SCS,
                                stop,
                                QCCWAVWDR_ENCODE,
                                target_bit_cnt,
                                model);
      
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVwdrEncode): Error calling QccWAVwdrRefinementPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          break;
      
      if (QccListConcatenate(&SCS, &TPS))
        {
          QccErrorAddMessage("(QccWAVwdrEncode): Error calling QccListConcatenate()");
          return(1);
        }

      threshold /= 2.0;
      bitplane++;
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccWAVSubbandPyramidFree(&image_subband_pyramid);
  QccWAVSubbandPyramidFree(&mask_subband_pyramid);
  if (sign_array != NULL)
    {
      for (row = 0; row < image->num_rows; row++)
        if (sign_array[row] != NULL)
          QccFree(sign_array[row]);
      QccFree(sign_array);
    }
  QccListFree(&ICS);
  QccListFree(&SCS);
  QccListFree(&TPS);
  QccENTArithmeticFreeModel(model);    
  return(return_value);
}


int QccWAVwdrDecodeHeader(QccBitBuffer *buffer,
                          int *num_levels,
                          int *num_rows,
                          int *num_cols,
                          double *image_mean,
                          int *max_coefficient_bits)
{
  int return_value;
  unsigned char ch;

  if (QccBitBufferGetChar(buffer, &ch))
    {
      QccErrorAddMessage("(QccWAVwdrDecodeHeader): Error calling QccBitBufferGetChar()");
      goto Error;
    }
  *num_levels = (int)ch;
  
  if (QccBitBufferGetInt(buffer, num_rows))
    {
      QccErrorAddMessage("(QccWAVwdrDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  if (QccBitBufferGetInt(buffer, num_cols))
    {
      QccErrorAddMessage("(QccWAVwdrDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  if (QccBitBufferGetDouble(buffer, image_mean))
    {
      QccErrorAddMessage("(QccWAVwdrDecodeHeader): Error calling QccBitBufferGetDouble()");
      goto Error;
    }
  
  if (QccBitBufferGetInt(buffer, max_coefficient_bits))
    {
      QccErrorAddMessage("(QccWAVwdrDecodeHeader): Error calling QccBitBufferGetInt()");
      goto Error;
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);
}


int QccWAVwdrDecode(QccBitBuffer *buffer,
                    QccIMGImageComponent *image,
                    const QccIMGImageComponent *mask,
                    int num_levels,
                    const QccWAVWavelet *wavelet,
                    const QccWAVPerceptualWeights *perceptual_weights,
                    double image_mean,
                    int max_coefficient_bits,
                    int target_bit_cnt)
{
  int return_value;
  QccWAVSubbandPyramid image_subband_pyramid;
  QccWAVSubbandPyramid mask_subband_pyramid;
  QccENTArithmeticModel *model = NULL;    
  int **sign_array = NULL;
  QccList ICS;
  QccList SCS;
  QccList TPS;
  QccListNode *stop;
  double threshold;
  int row, col;
  QccWAVWavelet lazy_wavelet_transform;
  unsigned int relative_origin;
  unsigned int virtual_end;
  
  if (image == NULL)
    return(0);
  if (buffer == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);
  
  QccWAVSubbandPyramidInitialize(&image_subband_pyramid);
  QccWAVSubbandPyramidInitialize(&mask_subband_pyramid);
  QccListInitialize(&ICS);
  QccListInitialize(&SCS);
  QccListInitialize(&TPS);
  QccWAVWaveletInitialize(&lazy_wavelet_transform);
  
  image_subband_pyramid.num_levels = num_levels;
  image_subband_pyramid.num_rows = image->num_rows;
  image_subband_pyramid.num_cols = image->num_cols;
  if (QccWAVSubbandPyramidAlloc(&image_subband_pyramid))
    {
      QccErrorAddMessage("(QccWDRDecode): Error calling QccWAVSubbandPyramidAlloc()");
      goto Error;
    }
  
  if (mask != NULL)
    {
      if ((mask->num_rows != image->num_rows) ||
          (mask->num_cols != image->num_cols))
        {
          QccErrorAddMessage("(QccWDRDecode): Mask and image must be same size");
          goto Error;
        }
      
      if (QccWAVWaveletCreate(&lazy_wavelet_transform, "LWT.lft", "symmetric"))
        {
          QccErrorAddMessage("(QccWDRDecode): Error calling QccWAVWaveletCreate()");
          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("(QccWDRDecode): Error calling QccWAVSubbandPyramidAlloc()");
          goto Error;
        }
      
      if (QccMatrixCopy(mask_subband_pyramid.matrix, mask->image,
                        mask->num_rows, mask->num_cols))
        {
          QccErrorAddMessage("(QccWDRDecode): Error calling QccMatrixCopy()");
          goto Error;
        }
      
      if (QccWAVSubbandPyramidDWT(&mask_subband_pyramid, num_levels,
                                  &lazy_wavelet_transform))
        {
          QccErrorAddMessage("(QccWDRDecode): Error calling QccWAVSubbandPyramidDWT()");
          goto Error;
        }
    }
  
  if ((sign_array = (int **)malloc(sizeof(int *) * image->num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWDRDecode): Error allocating memory");
      goto Error;
    }
  
  for (row = 0; row < image->num_rows; row++)
    if ((sign_array[row] =
         (int *)malloc(sizeof(int) * image->num_cols)) == NULL)
      {
        QccErrorAddMessage("(QccWDRDecode): Error allocating memory");
        goto Error;
      }
  
  for (row = 0; row < image->num_rows; row++)
    for (col = 0; col < image->num_cols; col++)
      {
        image_subband_pyramid.matrix[row][col] = 0.0;
        sign_array[row][col] = 0;
      }
  
  if ((model = QccENTArithmeticDecodeStart(buffer,
                                           QccWAVwdrArithmeticContexts,
                                           QCCWAVWDR_NUM_CONTEXTS,
                                           NULL,
                                           target_bit_cnt)) == NULL)
    {
      QccErrorAddMessage("(QccWAVwdrDecode): Error calling QccENTArithmeticDecodeStart()");
      goto Error;
    }
  
  if (QccWAVwdrAlgorithmInitialize(&image_subband_pyramid,
                                   ((mask != NULL) ?
                                    &mask_subband_pyramid : NULL),
                                   num_levels,
                                   &ICS,
                                   &virtual_end))
    {
      QccErrorAddMessage("(QccWAVwdrDecode): Error calling QccWAVwdrAlgorithmInitialize()");
      goto Error;
    }
  
  threshold = pow((double)2, (double)max_coefficient_bits);
  
  while (1)
    {
      stop = SCS.end;
      relative_origin = 0;		
      return_value =
        QccWAVwdrSortingPass(&image_subband_pyramid,
                             sign_array,
                             buffer,
                             threshold,
                             &ICS,
                             &TPS,
                             QCCWAVWDR_DECODE,
                             0,
                             &relative_origin,
                             virtual_end,
                             model);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVwdrDecode): Error calling QccWAVwdrSortingPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          break;
      
      QccWAVwdrUpdateIndex(&ICS);		
      return_value =
        QccWAVwdrRefinementPass(&image_subband_pyramid,
                                buffer,
                                threshold,
                                &SCS,
                                stop,
                                QCCWAVWDR_DECODE,
                                0,
                                model);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVwdrDecode): Error calling QccWAVwdrRefinementPass()");
          goto Error;
        }
      else
        if (return_value == 2)
          break;
      
      if (QccListConcatenate(&SCS, &TPS))
        {
          QccErrorAddMessage("(QccWAVwdrEncode): Error calling QccListConcatenate()");
          return(1);
        }

      threshold /= 2.0;
    }
  
  if (QccWAVwdrDecodeInverseDWT(&image_subband_pyramid,
                                ((mask != NULL) ?
                                 &mask_subband_pyramid : NULL),
                                sign_array,
                                image,
                                image_mean,
                                wavelet,
                                perceptual_weights))
    {
      QccErrorAddMessage("(QccWDRDecode): Error calling QccWDRDecodeInverseDWT()");
      goto Error;
    }
  
  return_value = 0;
  QccErrorClearMessages();
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccWAVSubbandPyramidFree(&image_subband_pyramid);
  QccWAVSubbandPyramidFree(&mask_subband_pyramid);
  QccWAVWaveletFree(&lazy_wavelet_transform);
  if (sign_array != NULL)
    {
      for (row = 0; row < image->num_rows; row++)
        if (sign_array[row] != NULL)
          QccFree(sign_array[row]);
      QccFree(sign_array);
    }
  QccListFree(&ICS);
  QccListFree(&SCS);
  QccListFree(&TPS);
  QccENTArithmeticFreeModel(model);
  return(return_value);
}