vector_filter_bank.c

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

/*
 * 
 * QccPack: Quantization, compression, and coding libraries
 * Copyright (C) 1997-2009  James E. Fowler
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 675 Mass Ave, Cambridge,
 * MA 02139, USA.
 * 
 */


#include "libQccPack.h"


int QccWAVVectorFilterBankInitialize(QccWAVVectorFilterBank
                                     *vector_filter_bank)
{
  if (vector_filter_bank == NULL)
    return(0);
  
  QccStringMakeNull(vector_filter_bank->filename);

  QccStringCopy(vector_filter_bank->magic_num,
                QCCWAVVECTORFILTERBANK_MAGICNUM);
  QccGetQccPackVersion(&vector_filter_bank->major_version,
                       &vector_filter_bank->minor_version,
                       NULL);
  
  QccWAVVectorFilterInitialize(&vector_filter_bank->lowpass_analysis_filter);
  QccWAVVectorFilterInitialize(&vector_filter_bank->highpass_analysis_filter);
  QccWAVVectorFilterInitialize(&vector_filter_bank->lowpass_synthesis_filter);
  QccWAVVectorFilterInitialize(&vector_filter_bank->highpass_synthesis_filter);

  return(0);
}


int QccWAVVectorFilterBankAlloc(QccWAVVectorFilterBank *vector_filter_bank)
{
  int return_value;
  
  if (vector_filter_bank == NULL)
    return(0);
  
  if (QccWAVVectorFilterAlloc(&vector_filter_bank->lowpass_analysis_filter))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankAlloc): Error calling QccWAVVectorFilterAlloc()");
      goto Error;
    }
  if (QccWAVVectorFilterAlloc(&vector_filter_bank->highpass_analysis_filter))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankAlloc): Error calling QccWAVVectorFilterAlloc()");
      goto Error;
    }
  if (QccWAVVectorFilterAlloc(&vector_filter_bank->lowpass_synthesis_filter))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankAlloc): Error calling QccWAVVectorFilterAlloc()");
      goto Error;
    }
  if (QccWAVVectorFilterAlloc(&vector_filter_bank->highpass_synthesis_filter))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankAlloc): Error calling QccWAVVectorFilterAlloc()");
      goto Error;
    }

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


void QccWAVVectorFilterBankFree(QccWAVVectorFilterBank *vector_filter_bank)
{
  if (vector_filter_bank == NULL)
    return;
  
  QccWAVVectorFilterFree(&vector_filter_bank->lowpass_analysis_filter);
  QccWAVVectorFilterFree(&vector_filter_bank->highpass_analysis_filter);
  QccWAVVectorFilterFree(&vector_filter_bank->lowpass_synthesis_filter);
  QccWAVVectorFilterFree(&vector_filter_bank->highpass_synthesis_filter);
  
}


int QccWAVVectorFilterBankMakeOrthogonal(QccWAVVectorFilterBank
                                         *vector_filter_bank,
                                         const QccWAVVectorFilter
                                         *lowpass_vector_filter,
                                         const QccWAVVectorFilter
                                         *highpass_vector_filter)
{
  if (vector_filter_bank == NULL)
    return(0);
  if (lowpass_vector_filter == NULL)
    return(0);
  if (highpass_vector_filter == NULL)
    return(0);
  
  if (lowpass_vector_filter->causality != QCCWAVVECTORFILTER_CAUSAL)
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankMakeOrthogonal): Error lowpass filter must be causal");
      return(1);
    }
  if (highpass_vector_filter->causality != QCCWAVVECTORFILTER_CAUSAL)
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankMakeOrthogonal): Error highpass filter must be causal");
      return(1);
    }
  
  vector_filter_bank->lowpass_analysis_filter.length =
    vector_filter_bank->highpass_analysis_filter.length =
    vector_filter_bank->lowpass_synthesis_filter.length =
    vector_filter_bank->highpass_synthesis_filter.length =
    lowpass_vector_filter->length;
  
  vector_filter_bank->lowpass_analysis_filter.dimension =
    vector_filter_bank->highpass_analysis_filter.dimension =
    vector_filter_bank->lowpass_synthesis_filter.dimension =
    vector_filter_bank->highpass_synthesis_filter.dimension =
    lowpass_vector_filter->dimension;
  
  if (QccWAVVectorFilterBankAlloc(vector_filter_bank))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankMakeOrthogonal): Error calling QccWAVVectorFilterBankAlloc()");
      return(1);
    }
  
  /*   H^T[n]  */
  if (QccWAVVectorFilterCopy(&vector_filter_bank->lowpass_synthesis_filter,
                             lowpass_vector_filter,
                             1))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankMakeOrthogonal): Error calling QccWAVVectorFilterCopy()");
      return(1);
    }
  
  /*  H[-n]  */
  if (QccWAVVectorFilterReversal(lowpass_vector_filter,
                                 &(vector_filter_bank->lowpass_analysis_filter)))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankMakeOrthogonal): Error calling QccWAVVectorFilterReversal()");
      return(1);
    }
  
  /*  G^T[n] */
  if (QccWAVVectorFilterCopy(&(vector_filter_bank->highpass_synthesis_filter),
                             highpass_vector_filter,
                             1))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankMakeOrthogonal): Error calling QccWAVVectorFilterCopy()");
      return(1);
    }
  
  /*  G[-n]  */
  if (QccWAVVectorFilterReversal(highpass_vector_filter,
                                 &(vector_filter_bank->highpass_analysis_filter)))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankMakeOrthogonal): Error calling QccWAVVectorFilterReversal()");
      return(1);
    }
  
  return(0);
}


int QccWAVVectorFilterBankMakeBiorthogonal(QccWAVVectorFilterBank
                                           *vector_filter_bank,
                                           const QccWAVVectorFilter
                                           *primary_lowpass_vector_filter,
                                           const QccWAVVectorFilter
                                           *primary_highpass_vector_filter,
                                           const QccWAVVectorFilter
                                           *dual_lowpass_vector_filter,
                                           const QccWAVVectorFilter
                                           *dual_highpass_vector_filter)
{
  if (vector_filter_bank == NULL)
    return(0);
  if (primary_lowpass_vector_filter == NULL)
    return(0);
  if (primary_highpass_vector_filter == NULL)
    return(0);
  if (dual_lowpass_vector_filter == NULL)
    return(0);
  if (dual_highpass_vector_filter == NULL)
    return(0);
  
  vector_filter_bank->lowpass_analysis_filter.length =
    dual_lowpass_vector_filter->length;
  vector_filter_bank->highpass_analysis_filter.length =
    dual_highpass_vector_filter->length;
  vector_filter_bank->lowpass_synthesis_filter.length =
    primary_lowpass_vector_filter->length;
  vector_filter_bank->highpass_synthesis_filter.length =
    primary_highpass_vector_filter->length;

  vector_filter_bank->lowpass_analysis_filter.dimension =
    dual_lowpass_vector_filter->dimension;
  vector_filter_bank->highpass_analysis_filter.dimension =
    dual_highpass_vector_filter->dimension;
  vector_filter_bank->lowpass_synthesis_filter.dimension =
    primary_lowpass_vector_filter->dimension;
  vector_filter_bank->highpass_synthesis_filter.dimension =
    primary_highpass_vector_filter->dimension;
  
  if (QccWAVVectorFilterBankAlloc(vector_filter_bank))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankMakeBiorthogonal): Error calling QccWAVVectorFilterBankAlloc()");
      return(1);
    }
  
  /*  ~H[-n]  */
  if (QccWAVVectorFilterReversal(dual_lowpass_vector_filter,
                                 &(vector_filter_bank->lowpass_analysis_filter)))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankMakeBiorthogonal): Error calling QccWAVVectorFilterReversal()");
      return(1);
    }

  /*   H^T[n]  */
  if (QccWAVVectorFilterCopy(&vector_filter_bank->lowpass_synthesis_filter,
                             primary_lowpass_vector_filter,
                             1))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankMakeBiorthogonal): Error calling QccWAVVectorFilterCopy()");
      return(1);
    }

  /*  ~G[-n]  */
  if (QccWAVVectorFilterReversal(dual_highpass_vector_filter,
                                 &(vector_filter_bank->highpass_analysis_filter)))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankMakeBiorthogonal): Error calling QccWAVVectorFilterReversal()");
      return(1);
    }

  /*   G^T[n]  */
  if (QccWAVVectorFilterCopy(&vector_filter_bank->highpass_synthesis_filter,
                             primary_highpass_vector_filter,
                             1))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankMakeBiorthogonal): Error calling QccWAVVectorFilterCopy()");
      return(1);
    }

  return(0);
}


static int QccWAVVectorFilterBankReadHeader(FILE *infile,
                                            QccWAVVectorFilterBank
                                            *vector_filter_bank)
{
  
  if ((infile == NULL) || (vector_filter_bank == NULL))
    return(0);
  
  if (QccFileReadMagicNumber(infile,
                             vector_filter_bank->magic_num, 
                             &vector_filter_bank->major_version,
                             &vector_filter_bank->minor_version))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankReadHeader): Error reading magic number in filter bank %s",
                         vector_filter_bank->filename);
      return(1);
    }
  
  if (strcmp(vector_filter_bank->magic_num, QCCWAVVECTORFILTERBANK_MAGICNUM))
    {
      QccErrorAddMessage("(QccWAVVectorFilterBankReadHeader): %s is not of filter-bank (%s) type",
                         vector_filter_bank->filename,
                         QCCWAVVECTORFILTERBANK_MAGICNUM);
      return(1);
    }
  
  if (QccCompareQccPackVersions(vector_filter_bank->major_version,
                                vector_filter_bank->minor_version,
                                0, 17) < 0)
    vector_filter_bank->orthogonality =
      QCCWAVVECTORFILTERBANK_ORTHOGONAL;
  else
    {
      fscanf(infile, "%d", &vector_filter_bank->orthogonality);
      if (ferror(infile) || feof(infile))
        {
          QccErrorAddMessage("(QccWAVVectorFilterBankReadHeader): Error reading orthogonality of vector filter bank");
          return(1);
        }
    }

  return(0);
}


static int QccWAVVectorFilterBankReadData(FILE *infile,