libqccpackwav.h

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.
 * 
 */


#ifndef LIBQCCPACKWAV_H
#define LIBQCCPACKWAV_H


/*  filter_bank.c  */
#define QCCWAVFILTERBANK_MAGICNUM "FBK"
#define QCCWAVFILTERBANK_DEFAULT "CohenDaubechiesFeauveau.9-7.fbk"
#define QCCWAVFILTERBANK_ORTHOGONAL 0
#define QCCWAVFILTERBANK_BIORTHOGONAL 1
#define QCCWAVFILTERBANK_GENERAL 2
#define QCCWAVFILTERBANK_PHASE_EVEN 0
#define QCCWAVFILTERBANK_PHASE_ODD 1
typedef struct
{
  QccString filename;
  QccString magic_num;
  int major_version;
  int minor_version;
  int orthogonality;
  QccFilter lowpass_analysis_filter;
  QccFilter highpass_analysis_filter;
  QccFilter lowpass_synthesis_filter;
  QccFilter highpass_synthesis_filter;
} QccWAVFilterBank;
int QccWAVFilterBankInitialize(QccWAVFilterBank *filter_bank);
int QccWAVFilterBankAlloc(QccWAVFilterBank *filter_bank);
void QccWAVFilterBankFree(QccWAVFilterBank *filter_bank);
int QccWAVFilterBankSetFilterTapIncrement(QccWAVFilterBank *filter_bank,
                                          int filter_tap_increment);
int QccWAVFilterBankPrint(const QccWAVFilterBank *filter_bank);
int QccWAVFilterBankMakeOrthogonal(QccWAVFilterBank *filter_bank,
                                   const QccFilter *primary_filter);
int QccWAVFilterBankMakeBiorthogonal(QccWAVFilterBank *filter_bank,
                                     const QccFilter *primary_filter,
                                     const QccFilter *dual_filter);
int QccWAVFilterBankBiorthogonal(const QccWAVFilterBank *filter_bank);
int QccWAVFilterBankRead(QccWAVFilterBank *filter_bank);
int QccWAVFilterBankWrite(const QccWAVFilterBank *filter_bank);
int QccWAVFilterBankAnalysis(QccVector signal,
                             int signal_length,
                             int phase,
                             const QccWAVFilterBank *filter_bank,
                             int boundary_extension);
int QccWAVFilterBankSynthesis(QccVector signal,
                              int signal_length,
                              int phase,
                              const QccWAVFilterBank *filter_bank,
                              int boundary_extension);
int QccWAVFilterBankRedundantAnalysis(const QccVector input_signal,
                                      QccVector output_signal_low,
                                      QccVector output_signal_high,
                                      int signal_length,
                                      const QccWAVFilterBank *filter_bank,
                                      int boundary_extension);
int QccWAVFilterBankRedundantSynthesis(const QccVector input_signal_low,
                                       const QccVector input_signal_high,
                                       QccVector output_signal,
                                       int signal_length,
                                       const QccWAVFilterBank *filter_bank,
                                       int boundary_extension);


/*  vector_filter.c  */
#define QCCWAVVECTORFILTER_CAUSAL 0
#define QCCWAVVECTORFILTER_ANTICAUSAL 1
typedef struct
{
  int dimension;
  int length;
  int causality;
  QccMatrix *coefficients;
} QccWAVVectorFilter;
int QccWAVVectorFilterInitialize(QccWAVVectorFilter *vector_filter);
int QccWAVVectorFilterAlloc(QccWAVVectorFilter *vector_filter);
void QccWAVVectorFilterFree(QccWAVVectorFilter *vector_filter);
int QccWAVVectorFilterCopy(QccWAVVectorFilter *vector_filter1,
                           const QccWAVVectorFilter *vector_filter2,
                           int transpose);
int QccWAVVectorFilterReversal(const QccWAVVectorFilter *vector_filter1,
                               QccWAVVectorFilter *vector_filter2);
int QccWAVVectorFilterRead(FILE *infile,
                           QccWAVVectorFilter *vector_filter);
int QccWAVVectorFilterWrite(FILE *outfile,
                            const QccWAVVectorFilter *vector_filter);
int QccWAVVectorFilterPrint(const QccWAVVectorFilter *vector_filter);


/*  vector_filter_bank.c  */
#define QCCWAVVECTORFILTERBANK_MAGICNUM "VFB"
#define QCCWAVVECTORFILTERBANK_DEFAULT "LebrunVetterli.Balanced.2x2.7.vfb"
#define QCCWAVVECTORFILTERBANK_ORTHOGONAL 0
#define QCCWAVVECTORFILTERBANK_BIORTHOGONAL 1
typedef struct
{
  QccString filename;
  QccString magic_num;
  int major_version;
  int minor_version;
  int orthogonality;
  QccWAVVectorFilter lowpass_analysis_filter;
  QccWAVVectorFilter highpass_analysis_filter;
  QccWAVVectorFilter lowpass_synthesis_filter;
  QccWAVVectorFilter highpass_synthesis_filter;
} QccWAVVectorFilterBank;
int QccWAVVectorFilterBankInitialize(QccWAVVectorFilterBank
                                     *vector_filter_bank);
int QccWAVVectorFilterBankAlloc(QccWAVVectorFilterBank *vector_filter_bank);
void QccWAVVectorFilterBankFree(QccWAVVectorFilterBank *vector_filter_bank);
int QccWAVVectorFilterBankMakeOrthogonal(QccWAVVectorFilterBank
                                         *vector_filter_bank,
                                         const QccWAVVectorFilter
                                         *lowpass_vector_filter,
                                         const QccWAVVectorFilter
                                         *highpass_vector_filter);
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);
int QccWAVVectorFilterBankRead(QccWAVVectorFilterBank *vector_filter_bank);
int QccWAVVectorFilterBankWrite(const QccWAVVectorFilterBank
                                *vector_filter_bank);
int QccWAVVectorFilterBankPrint(const QccWAVVectorFilterBank
                                *vector_filter_bank);
int QccWAVVectorFilterBankAnalysis(const QccDataset *input_signal,
                                   QccDataset *output_signal,
                                   const QccWAVVectorFilterBank
                                   *vector_filter_bank);
int QccWAVVectorFilterBankSynthesis(const QccDataset *input_signal,
                                    QccDataset *output_signal,
                                    const QccWAVVectorFilterBank
                                    *vector_filter_bank);


/*  lazy_wavelet.c  */
int QccWAVWaveletLWT(const QccVector input_signal,
                     QccVector output_signal,
                     int signal_length,
                     int signal_origin,
                     int subsample_pattern);
int QccWAVWaveletInverseLWT(const QccVector input_signal,
                            QccVector output_signal,
                            int signal_length,
                            int signal_origin,
                            int subsample_pattern);
int QccWAVWaveletLWT2D(const QccMatrix input_matrix,
                       QccMatrix output_matrix,
                       int num_rows,
                       int num_cols,
                       int origin_row,
                       int origin_col,
                       int subsample_pattern_row,
                       int subsample_pattern_col);
int QccWAVWaveletInverseLWT2D(const QccMatrix input_matrix,
                              QccMatrix output_matrix,
                              int num_rows,
                              int num_cols,
                              int origin_row,
                              int origin_col,
                              int subsample_pattern_row,
                              int subsample_pattern_col);
int QccWAVWaveletLWT3D(const QccVolume input_volume,
                       QccVolume output_volume,
                       int num_frames,
                       int num_rows,
                       int num_cols,
                       int origin_frame,
                       int origin_row,
                       int origin_col,
                       int subsample_pattern_frame,
                       int subsample_pattern_row,
                       int subsample_pattern_col);
int QccWAVWaveletInverseLWT3D(const QccVolume input_volume,
                              QccVolume output_volume,
                              int num_frames,
                              int num_rows,
                              int num_cols,
                              int origin_frame,
                              int origin_row,
                              int origin_col,
                              int subsample_pattern_frame,
                              int subsample_pattern_row,
                              int subsample_pattern_col);


/*  lazy_wavelet_int.c  */
int QccWAVWaveletLWTInt(const QccVectorInt input_signal,
                        QccVectorInt output_signal,
                        int signal_length,
                        int signal_origin,
                        int subsample_pattern);
int QccWAVWaveletInverseLWTInt(const QccVectorInt input_signal,
                               QccVectorInt output_signal,
                               int signal_length,
                               int signal_origin,
                               int subsample_pattern);
int QccWAVWaveletLWT2DInt(const QccMatrixInt input_matrix,
                          QccMatrixInt output_matrix,
                          int num_rows,
                          int num_cols,
                          int origin_row,
                          int origin_col,
                          int subsample_pattern_row,
                          int subsample_pattern_col);
int QccWAVWaveletInverseLWT2DInt(const QccMatrixInt input_matrix,
                                 QccMatrixInt output_matrix,
                                 int num_rows,
                                 int num_cols,
                                 int origin_row,
                                 int origin_col,
                                 int subsample_pattern_row,
                                 int subsample_pattern_col);
int QccWAVWaveletLWT3DInt(const QccVolumeInt input_volume,
                          QccVolumeInt output_volume,
                          int num_frames,
                          int num_rows,
                          int num_cols,
                          int origin_frame,
                          int origin_row,
                          int origin_col,
                          int subsample_pattern_frame,
                          int subsample_pattern_row,
                          int subsample_pattern_col);
int QccWAVWaveletInverseLWT3DInt(const QccVolumeInt input_volume,
                                 QccVolumeInt output_volume,
                                 int num_frames,
                                 int num_rows,
                                 int num_cols,
                                 int origin_frame,
                                 int origin_row,
                                 int origin_col,