vector_filter_bank.c

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

    case QCCWAVVECTORFILTER_ANTICAUSAL:
      for (output_index = 0; output_index < signal_length / 2; output_index++)
        {
          QccVectorZero(output_signal[output_index],
                        vector_dimension);
          for (filter_index = 0;
               filter_index < filter->length; filter_index++)
            {
              input_index =
                QccMathModulus(2 * output_index + filter_index, signal_length);
              
              if (QccMatrixVectorMultiply(filter->coefficients
                                          [filter->length - 1 - filter_index],
                                          input_signal[input_index],
                                          tmp_vector,
                                          vector_dimension,
                                          vector_dimension))
                {
                  QccErrorAddMessage("(QccWAVVectorFilterBankAnalysisFilter): Error calling QccMatrixVectorMultiply()");
                  goto Error;
                }
              
              QccVectorAdd(output_signal[output_index],
                           tmp_vector,
                           vector_dimension);
            }
        }
      break;

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


static int QccWAVVectorFilterBankSynthesisFilter(const QccVector *input_signal,
                                                 QccVector *output_signal,
                                                 int signal_length,
                                                 int vector_dimension,
                                                 const QccWAVVectorFilter
                                                 *filter)
{
  int return_value;
  int filter_index;
  int input_index;
  int output_index;
  QccVector tmp_vector = NULL;

  if ((tmp_vector = QccVectorAlloc(vector_dimension)) == NULL)
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankAnalysisFilter): Error calling QccVectorAlloc()");
      goto Error;
    }
  
  switch (filter->causality)
    {
    case QCCWAVVECTORFILTER_CAUSAL:
      for (output_index = 0; output_index < signal_length; output_index++)
        for (filter_index = 0;
             filter_index < filter->length; filter_index++)
          {
            input_index =
              QccMathModulus(output_index - filter_index, signal_length);
            
            if (!(input_index % 2))
              {
                if (QccMatrixVectorMultiply(filter->coefficients[filter_index],
                                            input_signal[input_index / 2],
                                            tmp_vector,
                                            vector_dimension,
                                            vector_dimension))
                  {
                    QccErrorAddMessage("(QccWAVVectorFilterBankAnalysisFilter): Error calling QccMatrixVectorMultiply()");
                    goto Error;
                  }
                
                QccVectorAdd(output_signal[output_index],
                             tmp_vector,
                             vector_dimension);
              }
          }
      break;

    case QCCWAVVECTORFILTER_ANTICAUSAL:
      for (output_index = 0; output_index < signal_length; output_index++)
        for (filter_index = 0;
             filter_index < filter->length; filter_index++)
          {
            input_index =
              QccMathModulus(output_index + filter_index, signal_length);
            
            if (!(input_index %2))
              {
                if (QccMatrixVectorMultiply(filter->coefficients
                                            [filter->length - 1 -
                                            filter_index],
                                            input_signal[input_index / 2],
                                            tmp_vector,
                                            vector_dimension,
                                            vector_dimension))
                  {
                    QccErrorAddMessage("(QccWAVVectorFilterBankAnalysisFilter): Error calling QccMatrixVectorMultiply()");
                    goto Error;
                  }
                
                QccVectorAdd(output_signal[output_index],
                             tmp_vector,
                             vector_dimension);
              }
          }
      break;

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


int QccWAVVectorFilterBankAnalysis(const QccDataset *input_signal,
                                   QccDataset *output_signal,
                                   const QccWAVVectorFilterBank
                                   *vector_filter_bank)
{
  int signal_length;
  int vector_dimension;
  int return_value = 0;

  if (input_signal == NULL)
    return(0);
  if (output_signal == NULL)
    return(0);
  if (vector_filter_bank == NULL)
    return(0);
  
  signal_length = input_signal->num_vectors;
  vector_dimension = input_signal->vector_dimension;

  if ((vector_filter_bank->lowpass_analysis_filter.dimension !=
       vector_dimension) ||
      (vector_filter_bank->highpass_analysis_filter.dimension !=
       vector_dimension) ||
      (vector_filter_bank->lowpass_synthesis_filter.dimension !=
       vector_dimension) ||
      (vector_filter_bank->highpass_synthesis_filter.dimension !=
       vector_dimension))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankAnalysis): Vector filter bank filters must have same vector dimension as input signal");
      goto Error;
    }

  if ((signal_length != output_signal->num_vectors) ||
      (vector_dimension != output_signal->vector_dimension))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankAnalysis): Input and output signals must have same length and same vector dimension");
      goto Error;
    }

  if (signal_length < 2)
    {
      QccDatasetCopy(output_signal, input_signal);
      goto Return;
    }
  
  if (signal_length % 2)
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankAnalysis): Signal length must be even");
      goto Error;
    }

  if (QccWAVVectorFilterBankAnalysisFilter(input_signal->vectors,
                                           &output_signal->vectors[0],
                                           signal_length,
                                           vector_dimension,
                                           &vector_filter_bank->lowpass_analysis_filter))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankAnalysis): Error calling QcCWAVVectorFilterBankAnalysisFilter()");
      goto Error;
    }

  if (QccWAVVectorFilterBankAnalysisFilter(input_signal->vectors,
                                           &output_signal->vectors
                                           [signal_length / 2],
                                           signal_length,
                                           vector_dimension,
                                           &vector_filter_bank->highpass_analysis_filter))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankAnalysis): Error calling QccWAVVectorFilterBankAnalysisFilter()");
      goto Error;
    }

  if (QccDatasetSetMaxMinValues(output_signal))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankAnalysis): Error calling QccDatasetSetMaxMinValues()");
      goto Error;
    }

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


int QccWAVVectorFilterBankSynthesis(const QccDataset *input_signal,
                                    QccDataset *output_signal,
                                    const QccWAVVectorFilterBank
                                    *vector_filter_bank)
{
  int signal_length;
  int vector_dimension;
  int return_value = 0;
  int output_index;

  if (input_signal == NULL)
    return(0);
  if (output_signal == NULL)
    return(0);
  if (vector_filter_bank == NULL)
    return(0);
  
  signal_length = input_signal->num_vectors;
  vector_dimension = input_signal->vector_dimension;

  if ((vector_filter_bank->lowpass_analysis_filter.dimension !=
       vector_dimension) ||
      (vector_filter_bank->highpass_analysis_filter.dimension !=
       vector_dimension) ||
      (vector_filter_bank->lowpass_synthesis_filter.dimension !=
       vector_dimension) ||
      (vector_filter_bank->highpass_synthesis_filter.dimension !=
       vector_dimension))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankSynthesis): Vector filter bank filters must have same vector dimension as input signal");
      goto Error;
    }

  if ((signal_length != output_signal->num_vectors) ||
      (vector_dimension != output_signal->vector_dimension))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankSynthesis): Input and output signals must have same length and same vector dimension");
      goto Error;
    }

  if (signal_length < 2)
    {
      QccDatasetCopy(output_signal, input_signal);
      goto Return;
    }
  
  if (signal_length % 2)
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankSynthesis): Signal length must be even");
      goto Error;
    }

  for (output_index = 0; output_index < signal_length; output_index++)
    QccVectorZero(output_signal->vectors[output_index], vector_dimension);

  if (QccWAVVectorFilterBankSynthesisFilter(&input_signal->vectors[0],
                                            output_signal->vectors,
                                            signal_length,
                                            vector_dimension,
                                            &vector_filter_bank->lowpass_synthesis_filter))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankSynthesis): Error calling QccWAVVectorFilterBankSynthesisFilter()");
      goto Error;
    }

  if (QccWAVVectorFilterBankSynthesisFilter(&input_signal->vectors
                                            [signal_length / 2],
                                            output_signal->vectors,
                                            signal_length,
                                            vector_dimension,
                                            &vector_filter_bank->highpass_synthesis_filter))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankSynthesis): Error calling QccWAVVectorFilterBankSynthesisFilter()");
      goto Error;
    }

  if (QccDatasetSetMaxMinValues(output_signal))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankSynthesis): Error calling QccDatasetSetMaxMinValues()");
      goto Error;
    }

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