rdwt.c

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

        input_column[row] = 
          baseband->matrix
          [row + baseband->subband_row_origin]
          [col + baseband->subband_col_origin];
      
      if (QccWAVWaveletRedundantAnalysis1D(input_column,
                                           output_column_low,
                                           output_column_high,
                                           num_rows,
                                           wavelet))
        {
          QccErrorAddMessage("(QccWAVRDWTAnalysis2D): Error calling QccWAVWaveletRedundantAnalysis1D()");
          goto Error;
        }
      
      for (row = 0; row < num_rows; row++)
        {
          baseband->matrix
            [row + baseband->subband_row_origin]
            [col + baseband->subband_col_origin] = output_column_low[row];
          horizontal->matrix
            [row + horizontal->subband_row_origin]
            [col + horizontal->subband_col_origin] = output_column_high[row];
          
          input_column[row] =
            vertical->matrix
            [row + vertical->subband_row_origin]
            [col + vertical->subband_col_origin];
        }
      
      if (QccWAVWaveletRedundantAnalysis1D(input_column,
                                           output_column_low,
                                           output_column_high,
                                           num_rows,
                                           wavelet))
        {
          QccErrorAddMessage("(QccWAVRDWTAnalysis2D): Error calling QccWAVWaveletRedundantAnalysis1D()");
          goto Error;
        }
      
      for (row = 0; row < num_rows; row++)
        {
          vertical->matrix
            [row + vertical->subband_row_origin]
            [col + vertical->subband_col_origin] = output_column_low[row];
          diagonal->matrix
            [row + diagonal->subband_row_origin]
            [col + diagonal->subband_col_origin] = output_column_high[row];
        }
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccVectorFree(input_column);
  QccVectorFree(output_column_low);
  QccVectorFree(output_column_high);
  return(return_value);
}


static int QccWAVRDWTSynthesis2D(QccWAVRDWTSubband *baseband,
                                 QccWAVRDWTSubband *horizontal,
                                 QccWAVRDWTSubband *vertical,
                                 QccWAVRDWTSubband *diagonal,
                                 QccWAVRDWTSubband *output,
                                 const QccWAVWavelet *wavelet)
{
  int return_value;
  int row, col;
  int num_rows, num_cols;
  QccVector input_column_low = NULL;
  QccVector input_column_high = NULL;
  QccVector output_column = NULL;

  num_rows = baseband->subband_num_rows;
  num_cols = baseband->subband_num_cols;
  
  if ((input_column_low = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVRDWTAnalysis2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((input_column_high = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVRDWTAnalysis2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((output_column = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccWAVRDWTAnalysis2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  
  for (col = 0; col < num_cols; col++)
    {
      for (row = 0; row < num_rows; row++)
        {
          input_column_low[row] =
            vertical->matrix
            [row + vertical->subband_row_origin]
            [col + vertical->subband_col_origin];
          input_column_high[row] = 
            diagonal->matrix
            [row + diagonal->subband_row_origin]
            [col + diagonal->subband_col_origin];
        }

      if (QccWAVWaveletRedundantSynthesis1D(input_column_low,
                                            input_column_high,
                                            output_column,
                                            num_rows,
                                            wavelet))
        {
          QccErrorAddMessage("(QccWAVRDWTSynthesis2D): Error calling QccWAVWaveletRedundantSynthesis1D()");
          goto Error;
        }
      
      /****/

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

          input_column_low[row] =
            baseband->matrix
            [row + baseband->subband_row_origin]
            [col + baseband->subband_col_origin];
          input_column_high[row] = 
            horizontal->matrix
            [row + horizontal->subband_row_origin]
            [col + horizontal->subband_col_origin];
          
        }
      
      if (QccWAVWaveletRedundantSynthesis1D(input_column_low,
                                            input_column_high,
                                            output_column,
                                            num_rows,
                                            wavelet))
        {
          QccErrorAddMessage("(QccWAVRDWTSynthesis2D): Error calling QccWAVWaveletRedundantSynthesis1D()");
          goto Error;
        }
      
      for (row = 0; row < num_rows; row++)
        baseband->matrix
          [row + baseband->subband_row_origin]
          [col + baseband->subband_col_origin] =
          output_column[row];
    }

  for (row = 0; row < num_rows; row++)
    if (QccWAVWaveletRedundantSynthesis1D(&baseband->matrix
                                          [row + baseband->subband_row_origin]
                                          [baseband->subband_col_origin],
                                          &vertical->matrix
                                          [row + vertical->subband_row_origin]
                                          [vertical->subband_col_origin],
                                          &output->matrix
                                          [row + output->subband_row_origin]
                                          [output->subband_col_origin],
                                          num_cols,
                                          wavelet))
      {
        QccErrorAddMessage("(QccWAVRDWTSynthesis2D): Error calling QccWAVWaveletRedundantSynthesis1D()");
        goto Error;
      }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccVectorFree(input_column_low);
  QccVectorFree(input_column_high);
  QccVectorFree(output_column);
  return(return_value);
}


static
int QccWAVWaveletRedundantDWT2DRecursion(QccWAVRDWTSubband
                                         *input_subband,
                                         QccWAVRDWTSubband
                                         *output_subbands,
                                         int num_scales,
                                         const QccWAVWavelet *wavelet)
{
  int return_value = 0;
  QccWAVRDWTSubband baseband[4];
  QccWAVRDWTSubband *new_output_subbands[4] = 
    {NULL, NULL, NULL, NULL};
  int num_subbands;
  int subband;
  int polyphase;
  
  if (QccWAVRDWTAnalysis2D(input_subband,
                           &output_subbands[0],
                           &output_subbands[3*num_scales - 2],
                           &output_subbands[3*num_scales - 1],
                           &output_subbands[3*num_scales],
                           wavelet))
    {
      QccErrorAddMessage("(QccWAVWaveletRedundantDWT2DRecursion): Error calling QccWAVRDWTAnalysis2D()");
      goto Error;
    }
  
  if (num_scales == 1)
    goto Return;
  
  if (QccWAVRDWTLWT2D(&output_subbands[0],
                      input_subband))
    {
      QccErrorAddMessage("(QccWAVWaveletRedundantDWT1D): Error calling QccWAVRDWTLWT2D()");
      goto Error;
    }
  
  num_subbands = QccWAVSubbandPyramidNumLevelsToNumSubbands(num_scales - 1);
  
  for (polyphase = 0; polyphase < 4; polyphase++)
    {
      QccWAVRDWTSubbandSetInfo(&baseband[polyphase],
                               input_subband,
                               polyphase);
      
      if ((new_output_subbands[polyphase] =
           (QccWAVRDWTSubband *)
           malloc(sizeof(QccWAVRDWTSubband) * num_subbands))
          == NULL)
        {
          QccErrorAddMessage("(QccWAVWaveletRedundantDWT2DRecursion): Error allocating memory");
          goto Error;
        }
      
      for (subband = 0; subband < num_subbands; subband++)
        QccWAVRDWTSubbandSetInfo(&new_output_subbands
                                 [polyphase][subband],
                                 &output_subbands[subband],
                                 polyphase);
    }
  
  for (polyphase = 0; polyphase < 4; polyphase++)
    if (QccWAVWaveletRedundantDWT2DRecursion(&baseband[polyphase],
                                             new_output_subbands[polyphase],
                                             num_scales - 1,
                                             wavelet))
      {
        QccErrorAddMessage("(QccWAVWaveletRedundantDWT2DRecursion): Error calling QccWAVWaveletRedundantDWT2DRecursion()");
        goto Error;
      }
  
  for (subband = 0; subband < num_subbands; subband++)
    {
      if (QccWAVRDWTInverseLWT2D(&output_subbands[subband],
                                 input_subband))
        {
          QccErrorAddMessage("(QccWAVWaveletRedundantDWT2DRecursion): Error calling QccWAVRDWTInverseLWT2D()");
          goto Error;
        }

      QccWAVRDWTSubbandCopy(&output_subbands[subband], input_subband);
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  for (polyphase = 0; polyphase < 4; polyphase++)
    if (new_output_subbands[polyphase] != NULL)
      QccFree(new_output_subbands[polyphase]);
  return(return_value);
}


int QccWAVWaveletRedundantDWT2D(const QccMatrix input_matrix,
                                QccMatrix *output_matrices,
                                int num_rows,
                                int num_cols,
                                int num_scales,
                                const QccWAVWavelet *wavelet)
{
  int return_value = 0;
  int max_scales;
  int subband;
  int num_subbands;
  QccWAVRDWTSubband *subbands = NULL;
  QccWAVRDWTSubband temp_subband;
  QccMatrix temp_matrix = NULL;

  if (input_matrix == NULL)
    return(0);
  if (output_matrices == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);
  if (num_scales <= 0)
    return(0);
  
  max_scales = (int)QccMathMin(floor(QccMathLog2(num_rows)),
                               floor(QccMathLog2(num_cols)));
  
  if (max_scales < num_scales)
    {
      QccErrorAddMessage("(QccWAVWaveletRedundantDWT2D): %d transform scales not supported for size %dx%d matrices - use %d or fewer scales",
                         num_scales,
                         num_cols,
                         num_rows,
                         max_scales);
      goto Error;
    }
  
  num_subbands = QccWAVSubbandPyramidNumLevelsToNumSubbands(num_scales);

  if ((subbands =
       (QccWAVRDWTSubband *)
       malloc(num_subbands * sizeof(QccWAVRDWTSubband))) ==
      NULL)
    {
      QccErrorAddMessage("(QccWAVWaveletRedundantDWT2D): Error allocating memory");
      goto Error;
    }

  if ((temp_matrix =
       QccMatrixAlloc(num_rows, num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVWaveletRedundantDWT2D): Error calling QccMatrixAlloc()");
      goto Error;
    }

  temp_subband.matrix = temp_matrix;  
  temp_subband.subband_num_rows = num_rows;
  temp_subband.subband_num_cols = num_cols;
  temp_subband.subband_row_origin = 0;
  temp_subband.subband_col_origin = 0;

  if (QccMatrixCopy(temp_matrix,
                    input_matrix,
                    num_rows,
                    num_cols))
    {
      QccErrorAddMessage("(QccWAVWaveletRedundantDWT2D): Error calling QccMatrixCopy()");
      goto Error;
    }

  for (subband = 0; subband < num_subbands; subband++)
    {
      subbands[subband].matrix = output_matrices[subband];
      subbands[subband].subband_num_rows = num_rows;
      subbands[subband].subband_num_cols = num_cols;
      subbands[subband].subband_row_origin = 0;
      subbands[subband].subband_col_origin = 0;
    }

  if (QccWAVWaveletRedundantDWT2DRecursion(&temp_subband,
                                           subbands,
                                           num_scales,
                                           wavelet))
    {
      QccErrorAddMessage("(QccWAVWaveletRedundantDWT2D): Error calling QccWAVWaveletRedundantDWT2DRecursion()");
      goto Error;
    }

  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccMatrixFree(temp_matrix, num_rows);
  if (subbands != NULL)
    QccFree(subbands);
  return(return_value);
}


void QccWAVWaveletRedundantDWT2DSubsampleGetPattern(int subband,
                                                    int num_scales,
                                                    int pattern_row,
                                                    int pattern_col,
                                                    int *index_skip,
                                                    int *offset_row,
                                                    int *offset_col,
                                                    const QccWAVWavelet
                                                    *wavelet)
{
  int scale =
    QccWAVSubbandPyramidCalcLevelFromSubband(subband,
                                             num_scales);

  *index_skip = (1 << scale);

  *offset_row = pattern_row;
  *offset_col = pattern_col;
  
  if (QccWAVWaveletBiorthogonal(wavelet) && subband)
    switch ((subband - 1) % 3)
      {
      case 0:
        *offset_row += (1 << (scale - 1));
        break;
      case 1:
        *offset_col += (1 << (scale - 1));
        break;
      case 2:
        *offset_row += (1 << (scale - 1));
        *offset_col += (1 << (scale - 1));
        break;
      }
      
  if (*offset_row >= *index_skip)
    *offset_row = QccMathModulus(*offset_row, *index_skip);
  if (*offset_col >= *index_skip)
    *offset_col = QccMathModulus(*offset_col, *index_skip);
}