rdwt.c

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

        }
      
      even_length = QccWAVWaveletDWTSubbandLength(signal_length,
                                                  1, 0, 0, 0);
      odd_length = QccWAVWaveletDWTSubbandLength(signal_length,
                                                 1, 1, 0, 0);
      
      if ((input_signals2 =
           (QccMatrix)malloc(sizeof(QccVector) * num_scales)) == NULL)
        {
          QccErrorAddMessage("(QccWAVWaveletInverseRedundantDWT1DRecursion): Error allocating memory");
          goto Error;
        }
      
      for (scale = 0; scale < num_scales; scale++)
        input_signals2[scale] = &(input_signals[scale][even_length]);
      
      if (QccWAVWaveletInverseRedundantDWT1DRecursion(input_signals,
                                                      temp_signal,
                                                      even_length,
                                                      num_scales - 1,
                                                      wavelet))
        {
          QccErrorAddMessage("(QccWAVWaveletInverseRedundantDWT1DRecursion): Error calling QccWAVWaveletInverseRedundantDWT1DRecursion()");
          goto Error;
        }
      
      if (QccWAVWaveletInverseRedundantDWT1DRecursion(input_signals2,
                                                      &(temp_signal
                                                        [even_length]),
                                                      odd_length,
                                                      num_scales - 1,
                                                      wavelet))
        {
          QccErrorAddMessage("(QccWAVWaveletInverseRedundantDWT1DRecursion): Error calling QccWAVWaveletInverseRedundantDWT1DRecursion()");
          goto Error;
        }
      
      if (QccWAVWaveletInverseLWT(temp_signal,
                                  input_signals[0],
                                  signal_length,
                                  0, 0))
        {
          QccErrorAddMessage("(QccWAVWaveletInverseRedundantDWT1DRecursion): Error calling QccWAVWaveletLWT()");
          goto Error;
        }
    }
  
  if (QccWAVWaveletRedundantSynthesis1D(input_signals[0],
                                        input_signals[num_scales],
                                        output_signal,
                                        signal_length,
                                        wavelet))
    {
      QccErrorAddMessage("(QccWAVWaveletInverseRedundantDWT1DRecursion): Error calling QccWAVWaveletRedundantSynthesis1D()");
      goto Error;
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccVectorFree(temp_signal);
  if (input_signals2 != NULL)
    QccFree(input_signals2);
  return(return_value);
}     


int QccWAVWaveletInverseRedundantDWT1D(const QccMatrix input_signals,
                                       QccVector output_signal,
                                       int signal_length,
                                       int num_scales,
                                       const QccWAVWavelet *wavelet)
{
  int return_value;
  QccMatrix input_signals2 = NULL;
  int num_subbands;

  num_subbands = num_scales + 1;

  if ((input_signals2 = QccMatrixAlloc(num_subbands,
                                       signal_length)) == NULL)
    {
      QccErrorAddMessage("(QccWAVWaveletInverseRedundantDWT1D): Error calling QccMatrixAlloc()");
      goto Error;
    }

  if (QccMatrixCopy(input_signals2, input_signals,
                    num_subbands, signal_length))
    {
      QccErrorAddMessage("(QccWAVWaveletInverseRedundantDWT1D): Error calling QccMatrixCopy()");
      goto Error;
    }

  if (QccWAVWaveletInverseRedundantDWT1DRecursion(input_signals2,
                                                  output_signal,
                                                  signal_length,
                                                  num_scales,
                                                  wavelet))
    {
      QccErrorAddMessage("(QccWAVWaveletInverseRedundantDWT1D): Error calling QccWAVWaveletInverseRedundantDWT1DRecursion()");
      goto Error;
    }

  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccMatrixFree(input_signals2, num_subbands);
  return(return_value);
}


typedef struct
{
  QccMatrix matrix;
  int subband_num_rows;
  int subband_num_cols;
  int subband_row_origin;
  int subband_col_origin;
} QccWAVRDWTSubband;


static void QccWAVRDWTSubbandSetInfo(QccWAVRDWTSubband *subband1,
                                     const QccWAVRDWTSubband *subband2,
                                     int polyphase)
{
  int high_band_row;
  int high_band_col;

  subband1->matrix = subband2->matrix;
  
  high_band_row = ((polyphase == 1) || (polyphase == 3));
  high_band_col = ((polyphase == 2) || (polyphase == 3));

  subband1->subband_num_rows =
    QccWAVWaveletDWTSubbandLength(subband2->subband_num_rows, 1,
                                  high_band_row, 0, 0);
  subband1->subband_num_cols =
    QccWAVWaveletDWTSubbandLength(subband2->subband_num_cols, 1,
                                  high_band_col, 0, 0);
  subband1->subband_row_origin = 
    ((high_band_row) ? 
     QccWAVWaveletDWTSubbandLength(subband2->subband_num_rows,
                                   1, 0, 0, 0) : 0) +
    subband2->subband_row_origin;
  subband1->subband_col_origin =
    ((high_band_col) ?
     QccWAVWaveletDWTSubbandLength(subband2->subband_num_cols,
                                   1, 0, 0, 0) : 0) +
    subband2->subband_col_origin;

  /*
    printf("%d: ", polyphase);
    printf("  %d x %d @ (%d, %d)\n",
    subband1->subband_num_rows,
    subband1->subband_num_cols,
    subband1->subband_row_origin,
    subband1->subband_col_origin);
  */
}


static void QccWAVRDWTSubbandCopy(const QccWAVRDWTSubband *input_subband,
                                  QccWAVRDWTSubband *output_subband)
{
  int row, col;
  
  for (row = 0; row < input_subband->subband_num_rows; row++)
    for (col = 0; col < input_subband->subband_num_cols; col++)
      input_subband->matrix
        [row + input_subband->subband_row_origin]
        [col + input_subband->subband_col_origin] =
        output_subband->matrix
        [row + output_subband->subband_row_origin]
        [col + output_subband->subband_col_origin];
}


QccMatrix *QccWAVWaveletRedundantDWT2DAlloc(int num_rows,
                                            int num_cols,
                                            int num_scales)
{
  int num_subbands;
  int subband;
  QccMatrix *rdwt = NULL;

  num_subbands = QccWAVSubbandPyramidNumLevelsToNumSubbands(num_scales);

  if ((rdwt = (QccMatrix *)malloc(sizeof(QccMatrix) * num_subbands)) == NULL)
    {
      QccErrorAddMessage("(QccWAVWaveletRedundantDWT2DAlloc): Error allocating memory()");
      return(NULL);
    }

  for (subband = 0; subband < num_subbands; subband++)
    if ((rdwt[subband] = QccMatrixAlloc(num_rows, num_cols)) == NULL)
      {
        QccErrorAddMessage("(QccWAVWaveletRedundantDWT2DAlloc): Error calling QccMatrixAlloc()");
        return(NULL);
      }

  return(rdwt);
}


void QccWAVWaveletRedundantDWT2DFree(QccMatrix *rdwt,
                                     int num_rows,
                                     int num_scales)
{
  int subband;
  int num_subbands;

  num_subbands = QccWAVSubbandPyramidNumLevelsToNumSubbands(num_scales);

  if (rdwt != NULL)
    {
      for (subband = 0; subband < num_subbands; subband++)
        QccMatrixFree(rdwt[subband], num_rows);
      QccFree(rdwt);
    }
}


static int QccWAVRDWTLWT2D(const QccWAVRDWTSubband *input_subband,
                           QccWAVRDWTSubband *output_subband)
{
  int return_value;
  int row, col;
  int num_rows, num_cols;
  QccVector input_column = NULL;
  QccVector output_column = NULL;

  num_rows = input_subband->subband_num_rows;
  num_cols = input_subband->subband_num_cols;

  if ((input_column = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVRDWTLWT2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((output_column = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVRDWTLWT2D): Error calling QccVectorAlloc()");
      goto Error;
    }

  for (row = 0; row < num_rows; row++)
    if (QccWAVWaveletLWT(&input_subband->matrix
                         [row + input_subband->subband_row_origin]
                         [input_subband->subband_col_origin],
                         &output_subband->matrix
                         [row + output_subband->subband_row_origin]
                         [output_subband->subband_col_origin],
                         num_cols,
                         0, 0))
      {
        QccErrorAddMessage("(QccWAVRDWTLWT2D): Error calling QccWAVWaveletLWT()");
        goto Error;
      }

  for (col = 0; col < num_cols; col++)
    {
      for (row = 0; row < num_rows; row++)
        input_column[row] =
          output_subband->matrix
          [row + output_subband->subband_row_origin]
          [col + output_subband->subband_col_origin];

      if (QccWAVWaveletLWT(input_column,
                           output_column,
                           num_rows,
                           0, 0))
        {
          QccErrorAddMessage("(QccWAVRDWTLWT2D): Error calling QccWAVWaveletLWT()");
          goto Error;
        }

      for (row = 0; row < num_rows; row++)
        output_subband->matrix
          [row + output_subband->subband_row_origin]
          [col + output_subband->subband_col_origin] = output_column[row];
    }

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


int QccWAVRDWTInverseLWT2D(const QccWAVRDWTSubband *input_subband,
                           QccWAVRDWTSubband *output_subband)
{
  int return_value;
  int row, col;
  int num_rows, num_cols;
  QccVector input_column = NULL;
  QccVector output_column = NULL;
  
  num_rows = input_subband->subband_num_rows;
  num_cols = input_subband->subband_num_cols;

  if ((input_column = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVRDWTInverseLWT2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((output_column = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVRDWTInverseLWT2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  
  for (row = 0; row < num_rows; row++)
    if (QccWAVWaveletInverseLWT(&input_subband->matrix
                                [row + input_subband->subband_row_origin]
                                [input_subband->subband_col_origin],
                                &output_subband->matrix
                                [row + output_subband->subband_row_origin]
                                [output_subband->subband_col_origin],
                                num_cols,
                                0, 0))
      {
        QccErrorAddMessage("(QccWAVRDWTInverseLWT2D): Error calling QccWAVWaveletInverseLWT()");
        goto Error;
      }
  
  for (col = 0; col < num_cols; col++)
    {
      for (row = 0; row < num_rows; row++)
        input_column[row] =
          output_subband->matrix
          [row + output_subband->subband_row_origin]
          [col + output_subband->subband_col_origin];
      
      if (QccWAVWaveletInverseLWT(input_column,
                                  output_column,
                                  num_rows,
                                  0, 0))
        {
          QccErrorAddMessage("(QccWAVRDWTInverseLWT2D): Error calling QccWAVWaveletInverseLWT()");
          goto Error;
        }
      
      for (row = 0; row < num_rows; row++)
        output_subband->matrix
          [row + output_subband->subband_row_origin]
          [col + output_subband->subband_col_origin] = output_column[row];
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccVectorFree(input_column);
  QccVectorFree(output_column);
  return(return_value);
}


static int QccWAVRDWTAnalysis2D(QccWAVRDWTSubband *input,
                                QccWAVRDWTSubband *baseband,
                                QccWAVRDWTSubband *horizontal,
                                QccWAVRDWTSubband *vertical,
                                QccWAVRDWTSubband *diagonal,
                                const QccWAVWavelet *wavelet)
{
  int return_value;
  int row, col;
  int num_rows, num_cols;
  QccVector input_column = NULL;
  QccVector output_column_low = NULL;
  QccVector output_column_high = NULL;
  
  num_rows = input->subband_num_rows;
  num_cols = input->subband_num_cols;
  
  if ((input_column = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVRDWTAnalysis2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((output_column_low = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVRDWTAnalysis2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((output_column_high = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVRDWTAnalysis2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  
  for (row = 0; row < num_rows; row++)
    if (QccWAVWaveletRedundantAnalysis1D(&input->matrix
                                         [row + input->subband_row_origin]
                                         [input->subband_col_origin],
                                         &baseband->matrix
                                         [row + baseband->subband_row_origin]
                                         [baseband->subband_col_origin],
                                         &vertical->matrix
                                         [row + vertical->subband_row_origin]
                                         [vertical->subband_col_origin],
                                         num_cols,
                                         wavelet))
      {
        QccErrorAddMessage("(QccWAVRDWTAnalysis2D): Error calling QccWAVWaveletRedundantAnalysis1D()");
        goto Error;
      }
  
  for (col = 0; col < num_cols; col++)
    {
      for (row = 0; row < num_rows; row++)