vector_filter_bank.c

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

                                          QccWAVVectorFilterBank
                                          *vector_filter_bank)
{
  int return_value;
  QccWAVVectorFilter primary_lowpass_vector_filter;
  QccWAVVectorFilter primary_highpass_vector_filter;
  QccWAVVectorFilter dual_lowpass_vector_filter;
  QccWAVVectorFilter dual_highpass_vector_filter;
  
  if (infile == NULL)
    return(0);
  if (vector_filter_bank == NULL)
    return(0);
  
  QccWAVVectorFilterInitialize(&primary_lowpass_vector_filter);
  QccWAVVectorFilterInitialize(&primary_highpass_vector_filter);
  QccWAVVectorFilterInitialize(&dual_lowpass_vector_filter);
  QccWAVVectorFilterInitialize(&dual_highpass_vector_filter);
  
  switch (vector_filter_bank->orthogonality)
    {
    case QCCWAVVECTORFILTERBANK_ORTHOGONAL:
      if (QccWAVVectorFilterRead(infile,
                                 &primary_lowpass_vector_filter))
        {
          QccErrorAddMessage("(QccWAVVectorFilterBankReadData): Error calling QccWAVVectorFilterRead()");
          goto Error;
        }
      if (QccWAVVectorFilterRead(infile,
                                 &primary_highpass_vector_filter))
        {
          QccErrorAddMessage("(QccWAVVectorFilterBankReadData): Error calling QccWAVVectorFilterRead()");
          goto Error;
        }
      
      if (QccWAVVectorFilterBankMakeOrthogonal(vector_filter_bank,
                                               &primary_lowpass_vector_filter,
                                               &primary_highpass_vector_filter))
        {
          QccErrorAddMessage("(QccWAVVectorFilterBankReadData): Error calling QccWAVVectorFilterBankMakeOrthogonal()");
          goto Error;
        }
      break;

    case QCCWAVVECTORFILTERBANK_BIORTHOGONAL:
      if (QccWAVVectorFilterRead(infile,
                                 &primary_lowpass_vector_filter))
        {
          QccErrorAddMessage("(QccWAVVectorFilterBankReadData): Error calling QccWAVVectorFilterRead()");
          goto Error;
        }
      if (QccWAVVectorFilterRead(infile,
                                 &primary_highpass_vector_filter))
        {
          QccErrorAddMessage("(QccWAVVectorFilterBankReadData): Error calling QccWAVVectorFilterRead()");
          goto Error;
        }
      if (QccWAVVectorFilterRead(infile,
                                 &dual_lowpass_vector_filter))
        {
          QccErrorAddMessage("(QccWAVVectorFilterBankReadData): Error calling QccWAVVectorFilterRead()");
          goto Error;
        }
      if (QccWAVVectorFilterRead(infile,
                                 &dual_highpass_vector_filter))
        {
          QccErrorAddMessage("(QccWAVVectorFilterBankReadData): Error calling QccWAVVectorFilterRead()");
          goto Error;
        }

      if (QccWAVVectorFilterBankMakeBiorthogonal(vector_filter_bank,
                                                 &primary_lowpass_vector_filter,
                                                 &primary_highpass_vector_filter,
                                                 &dual_lowpass_vector_filter,
                                                 &dual_highpass_vector_filter))
        {
          QccErrorAddMessage("(QccWAVVectorFilterBankReadData): Error calling QccWAVVectorFilterBankMakeBiorthogonal()");
          goto Error;
        }
      break;

    default:
      QccErrorAddMessage("(QccWAVVectorFilterBankReadData): Undefined orthogonality value in vector filter bank");
      goto Error;
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccWAVVectorFilterFree(&primary_lowpass_vector_filter);
  QccWAVVectorFilterFree(&primary_highpass_vector_filter);
  QccWAVVectorFilterFree(&dual_lowpass_vector_filter);
  QccWAVVectorFilterFree(&dual_highpass_vector_filter);
  return(return_value);
}


int QccWAVVectorFilterBankRead(QccWAVVectorFilterBank *vector_filter_bank)
{
  FILE *infile = NULL;

  if (vector_filter_bank == NULL)
    return(0);
  
  if ((infile = 
       QccFileOpen(vector_filter_bank->filename, "r")) == NULL)
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankRead): Error calling QccFileOpen()");
      return(1);
    }

  if (QccWAVVectorFilterBankReadHeader(infile, vector_filter_bank))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankRead): Error calling QccWAVVectorFilterBankReadHeader()");
      return(1);
    }
  
  if (QccWAVVectorFilterBankReadData(infile, vector_filter_bank))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankRead): Error calling QccWAVVectorFilterBankReadData()");
      return(1);
    }
  
  QccFileClose(infile);
  return(0);
}


static int QccWAVVectorFilterBankWriteHeader(FILE *outfile,
                                             const QccWAVVectorFilterBank
                                             *vector_filter_bank)
{
  if ((outfile == NULL) || (vector_filter_bank == NULL))
    return(0);
  
  if (QccFileWriteMagicNumber(outfile, QCCWAVVECTORFILTERBANK_MAGICNUM))
    goto Error;
  
  fprintf(outfile, "%d\n", vector_filter_bank->orthogonality);
  if (ferror(outfile))
    goto Error;

  return(0);
  
 Error:
  QccErrorAddMessage("(QccWAVVectorFilterBankWriteHeader): Error writing header to %s",
                     vector_filter_bank->filename);
  return(1);
  
}


static int QccWAVVectorFilterBankWriteData(FILE *outfile,
                                           const QccWAVVectorFilterBank
                                           *vector_filter_bank)
{
  if (outfile == NULL)
    return(0);
  if (vector_filter_bank == NULL)
    return(0);
  
  if (QccWAVVectorFilterWrite(outfile,
                              &(vector_filter_bank->lowpass_synthesis_filter)))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankWriteData): Error calling QccWAVVectorFilterWrite()");
      return(1);
    }

  if (QccWAVVectorFilterWrite(outfile,
                              &(vector_filter_bank->highpass_synthesis_filter)))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankWriteData): Error calling QccWAVVectorFilterWrite()");
      return(1);
    }

  return(0);
}


int QccWAVVectorFilterBankWrite(const QccWAVVectorFilterBank
                                *vector_filter_bank)
{
  FILE *outfile;
  
  if (vector_filter_bank == NULL)
    return(0);
  
  if ((outfile = QccFileOpen(vector_filter_bank->filename, "w")) == NULL)
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankWrite): Error calling QccFileOpen()");
      return(1);
    }
  
  if (QccWAVVectorFilterBankWriteHeader(outfile, vector_filter_bank))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankWrite): Error calling QccWAVVectorFilterBankWriteHeader()");
      return(1);
    }
  
  if (QccWAVVectorFilterBankWriteData(outfile, vector_filter_bank))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankWrite): Error calling QccWAVVectorFilterBankWriteData()");
      return(1);
    }
  
  QccFileClose(outfile);
  return(0);
}


int QccWAVVectorFilterBankPrint(const QccWAVVectorFilterBank
                                *vector_filter_bank)
{
  if (vector_filter_bank == NULL)
    return(0);
  
  if (QccFilePrintFileInfo(vector_filter_bank->filename,
                           vector_filter_bank->magic_num,
                           vector_filter_bank->major_version,
                           vector_filter_bank->minor_version))
    return(1);
  
  
  switch (vector_filter_bank->orthogonality)
    {
    case QCCWAVVECTORFILTERBANK_ORTHOGONAL:
      printf("  Orthogonal vector filter bank\n\n");
      break;
    case QCCWAVVECTORFILTERBANK_BIORTHOGONAL:
      printf("  Biorthogonal vector filter bank\n\n");
      break;
    default:
      break;
    }
  
  printf("---------------- Lowpass Analysis Filter ----------------\n");
  if (QccWAVVectorFilterPrint(&vector_filter_bank->lowpass_analysis_filter))
    goto Error;
  
  printf("---------------- Highpass Analysis Filter ----------------\n");
  if (QccWAVVectorFilterPrint(&vector_filter_bank->highpass_analysis_filter))
    goto Error;
  
  printf("---------------- Lowpass Synthesis Filter ----------------\n");
  if (QccWAVVectorFilterPrint(&vector_filter_bank->lowpass_synthesis_filter))
    goto Error;
  
  printf("---------------- Highpass Synthesis Filter ----------------\n");
  if (QccWAVVectorFilterPrint(&vector_filter_bank->highpass_synthesis_filter))
    goto Error;
  
  return(0);
  
 Error:
  QccErrorAddMessage("(QccWAVVectorFilterBankPrint): Error calling QccWAVVectorFilterPrint()");
  return(1);
}


static int QccWAVVectorFilterBankAnalysisFilter(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 / 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_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;