/* *  * QccPack: Quantization, compression, and coding libraries * Copyright (C) 1997-2005  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 QccError;    }  if (QccWAVVectorFilterAlloc(&vector_filter_bank->highpass_analysis_filter))    {      QccErrorAddMessage("(QccWAVVectorFilterBankAlloc): Error calling QccWAVVectorFilterAlloc()");      goto QccError;    }  if (QccWAVVectorFilterAlloc(&vector_filter_bank->lowpass_synthesis_filter))    {      QccErrorAddMessage("(QccWAVVectorFilterBankAlloc): Error calling QccWAVVectorFilterAlloc()");      goto QccError;    }  if (QccWAVVectorFilterAlloc(&vector_filter_bank->highpass_synthesis_filter))    {      QccErrorAddMessage("(QccWAVVectorFilterBankAlloc): Error calling QccWAVVectorFilterAlloc()");      goto QccError;    }  return_value = 0;  goto QccReturn; QccError:  return_value = 1; QccReturn:  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,