wavelet.c

spiht的压缩解压缩c编写的

#include "spiht.h"
#include "spihtdecode.h"

int QccWAVInit()
{
  return(0);
}

int QccWAVWaveletInitialize(QccWAVWavelet *wavelet)
{
  if (wavelet == NULL)
    return(0);

  wavelet->implementation = -1;
  wavelet->boundary = -1;
  QccWAVFilterBankInitialize(&wavelet->filter_bank);
  QccWAVLiftingSchemeInitialize(&wavelet->lifting_scheme);

  return(0);
}

void QccWAVWaveletFree(QccWAVWavelet *wavelet)
{
  if (wavelet == NULL)
    return;

  QccWAVFilterBankFree(&wavelet->filter_bank);
}

int QccWAVWaveletCreate(QccWAVWavelet *wavelet,
                        const QccString wavelet_filename,
                        const QccString boundary)
{
  FILE *infile;
  QccString magic_number;
  QccString wavelet_filename1;

  if (wavelet == NULL)
    return(0);
  if (wavelet_filename == NULL)
    return(0);
  if (boundary == NULL)
    return(0);

  QccStringCopy(wavelet_filename1, wavelet_filename);

  if (QccSetEnv(QCCWAVWAVELET_PATH_ENV,
                QCCMAKESTRING(QCCPACK_WAVELET_PATH_DEFAULT)))
    {
      QccErrorAddMessage("(QccWAVInit): Error calling QccSetEnv()");
      QccErrorExit();
    }

  if ((infile = 
       QccFilePathSearchOpenRead(wavelet_filename1, 
                                 QCCWAVWAVELET_PATH_ENV,
                                 QCCMAKESTRING(QCCPACK_WAVELET_PATH_DEFAULT)))
      == NULL)
    {
      QccErrorAddMessage("(QccWAVWaveletCreate): Error calling QccFilePathSearchOpenRead()");
      return(1);
    }
  
  if (QccFileReadMagicNumber(infile, magic_number,
                             NULL, NULL))
    {
      QccErrorAddMessage("(QccWAVWaveletCreate): Error calling QccFileReadMagicNumber()");
      return(1);
    }
  
  QccFileClose(infile);

  if (!strncmp(magic_number, QCCWAVFILTERBANK_MAGICNUM, 3))
    wavelet->implementation =  QCCWAVWAVELET_IMPLEMENTATION_FILTERBANK;
  else
    if (!strncmp(magic_number, QCCWAVLIFTINGSCHEME_MAGICNUM, 3))
      wavelet->implementation =  QCCWAVWAVELET_IMPLEMENTATION_LIFTED       ;
    else
      {
        QccErrorAddMessage("(QccWAVWaveletCreate): Unrecognized wavelet implementation");
        return(1);
      }

  if (!strncmp(boundary, "periodic", 3))
    wavelet->boundary = QCCWAVWAVELET_BOUNDARY_PERIODIC_EXTENSION;
  else
    if (!strncmp(boundary, "symmetric", 3))
      wavelet->boundary = QCCWAVWAVELET_BOUNDARY_SYMMETRIC_EXTENSION;
    else
      if (!strncmp(boundary, "boundary", 3))
        wavelet->boundary = QCCWAVWAVELET_BOUNDARY_BOUNDARY_WAVELET;
      else
        {
          QccErrorAddMessage("(QccWAVWaveletCreate): Undefined boundary");
          return(1);
        }

  switch (wavelet->implementation)
    {
    case QCCWAVWAVELET_IMPLEMENTATION_FILTERBANK:
      QccStringCopy(wavelet->filter_bank.filename, wavelet_filename1);
      if (QccWAVFilterBankRead(&wavelet->filter_bank))
        {
          QccErrorAddMessage("(QccWAVWaveletCreate): Error calling QccWAVFilterBankRead()");
          return(1);
        }
      break;
    case QCCWAVWAVELET_IMPLEMENTATION_LIFTED:
      QccStringCopy(wavelet->lifting_scheme.filename, wavelet_filename1);
      if (QccWAVLiftingSchemeRead(&wavelet->lifting_scheme))
        {
          QccErrorAddMessage("(QccWAVWaveletCreate): Error calling QccWAVLiftingSchemeRead()");
          return(1);
        }
      break;
    default:
      QccErrorAddMessage("(QccWAVWaveletCreate): Undefined wavelet implementation");
      return(1);
    }

  return(0);
}

int QccWAVWaveletAnalysis1D(const QccVector input_signal,
                            QccVector output_signal,
                            int signal_length,
                            int phase,
                            const QccWAVWavelet *wavelet)
{
  int return_value;

  if (input_signal == NULL)
    return(0);
  if (output_signal == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);

  QccVectorZero(output_signal, signal_length);

  switch (wavelet->implementation)
    {
    case QCCWAVWAVELET_IMPLEMENTATION_FILTERBANK:
      if (QccWAVFilterBankAnalysis(input_signal,
                                   output_signal,
                                   signal_length,
                                   phase,
                                   &wavelet->filter_bank,
                                   wavelet->boundary))
        {
          QccErrorAddMessage("(QccWAVWaveletAnalysis1D): Error calling QccWAVFilterBankAnalysis()");
          goto QccError;
        }
      break;
    case QCCWAVWAVELET_IMPLEMENTATION_LIFTED:
      if (QccWAVLiftingAnalysis(input_signal,
                                output_signal,
                                signal_length,
                                phase,
                                &wavelet->lifting_scheme,
                                wavelet->boundary))
        {
          QccErrorAddMessage("(QccWAVWaveletAnalysis1D): Error calling QccWAVLiftingAnalysis()");
          goto QccError;
        }
      break;
    default:
      QccErrorAddMessage("(QccWAVWaveletAnalysis1D): Undefined implementation (%d)",
                         wavelet->implementation);
      goto QccError;
    }

  return_value = 0;
  goto QccReturn;
 QccError:
  return_value = 1;
 QccReturn:
  return(return_value);
}

int QccWAVWaveletSynthesis1D(const QccVector input_signal,
                             QccVector output_signal,
                             int signal_length,
                             int phase,
                             const QccWAVWavelet *wavelet)
{
  int return_value;

  if (input_signal == NULL)
    return(0);
  if (output_signal == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);

  QccVectorZero(output_signal, signal_length);

  switch (wavelet->implementation)
    {
    case QCCWAVWAVELET_IMPLEMENTATION_FILTERBANK:
      if (QccWAVFilterBankSynthesis(input_signal,
                                    output_signal,
                                    signal_length,
                                    phase,
                                    &wavelet->filter_bank,
                                    wavelet->boundary))
        {
          QccErrorAddMessage("(QccWAVWaveletSynthesis1D): Error calling QccWAVFilterBankSynthesis()");
          goto QccError;
        }
      break;
    case QCCWAVWAVELET_IMPLEMENTATION_LIFTED:
      if (QccWAVLiftingSynthesis(input_signal,
                                 output_signal,
                                 signal_length,
                                 phase,
                                 &wavelet->lifting_scheme,
                                 wavelet->boundary))
        {
          QccErrorAddMessage("(QccWAVWaveletSynthesis1D): Error calling QccWAVLiftingSynthesis()");
          goto QccError;
        }
      break;
    default:
      QccErrorAddMessage("(QccWAVWaveletSynthesis1D): Undefined implementation (%d)",
                         wavelet->implementation);
      goto QccError;
    }

  return_value = 0;
  goto QccReturn;
 QccError:
  return_value = 1;
 QccReturn:
  return(return_value);
}

int QccWAVWaveletAnalysis2D(const QccMatrix input_matrix,
                            QccMatrix output_matrix,
                            int num_rows,
                            int num_cols,
                            int phase_row,
                            int phase_col,
                            const QccWAVWavelet *wavelet)
{
  int return_value;
  int row, col;
  QccVector input_column = NULL;
  QccVector output_column = NULL;

  if (input_matrix == NULL)
    return(0);
  if (output_matrix == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);

  if ((input_column = QccVectorAlloc(num_rows)) == NULL)
    {
        QccErrorAddMessage("(QccWAVWaveletAnalysis2D): Error calling QccVectorAlloc()");
        goto QccError;
    }
  if ((output_column = QccVectorAlloc(num_rows)) == NULL)
    {
        QccErrorAddMessage("(QccWAVWaveletAnalysis2D): Error calling QccVectorAlloc()");
        goto QccError;
    }

  for (row = 0; row < num_rows; row++)
    if (QccWAVWaveletAnalysis1D(input_matrix[row],
                                output_matrix[row],
                                num_cols,
                                phase_row,
                                wavelet))
      {
        QccErrorAddMessage("(QccWAVWaveletAnalysis2D): Error calling QccWAVWaveletAnalysis1D()");
        goto QccError;
      }

  for (col = 0; col < num_cols; col++)
    {
      for (row = 0; row < num_rows; row++)
        input_column[row] = output_matrix[row][col];

      if (QccWAVWaveletAnalysis1D(input_column,
                                  output_column,
                                  num_rows,
                                  phase_col,
                                  wavelet))
        {
          QccErrorAddMessage("(QccWAVWaveletAnalysis2D): Error calling QccWAVWaveletAnalysis1D()");
          goto QccError;
        }
      
      for (row = 0; row < num_rows; row++)
        output_matrix[row][col] = output_column[row];
    }

  return_value = 0;
  goto QccReturn;
 QccError:
  return_value = 1;
 QccReturn:
  QccVectorFree(input_column);
  QccVectorFree(output_column);
  return(return_value);
}

int QccWAVWaveletSynthesis2D(const QccMatrix input_matrix,
                             QccMatrix output_matrix,
                             int num_rows,
                             int num_cols,
                             int phase_row,
                             int phase_col,
                             const QccWAVWavelet *wavelet)
{
  int return_value;
  int row, col;
  QccVector input_column = NULL;
  QccVector output_column = NULL;
  QccVector input_row = NULL;

  if (input_matrix == NULL)
    return(0);
  if (output_matrix == NULL)
    return(0);
  if (wavelet == NULL)
    return(0);

  if ((input_column = QccVectorAlloc(num_rows)) == NULL)
    {
        QccErrorAddMessage("(QccWAVWaveletSynthesis2D): Error calling QccVectorAlloc()");
        goto QccError;
    }
  if ((output_column = QccVectorAlloc(num_rows)) == NULL)
    {
        QccErrorAddMessage("(QccWAVWaveletSynthesis2D): Error calling QccVectorAlloc()");
        goto QccError;
    }

  if ((input_row = QccVectorAlloc(num_cols)) == NULL)
    {
        QccErrorAddMessage("(QccWAVWaveletSynthesis2D): Error calling QccVectorAlloc()");
        goto QccError;
    }

  for (col = 0; col < num_cols; col++)
    {
      for (row = 0; row < num_rows; row++)
        input_column[row] = input_matrix[row][col];

      if (QccWAVWaveletSynthesis1D(input_column,
                                   output_column,
                                   num_rows,
                                   phase_col,
                                   wavelet))
        {
          QccErrorAddMessage("(QccWAVWaveletSynthesis2D): Error calling QccWAVWaveletSynthesis1D()");
          goto QccError;
        }
      
      for (row = 0; row < num_rows; row++)
        output_matrix[row][col] = output_column[row];
    }

  for (row = 0; row < num_rows; row++)
    {
      for (col = 0; col < num_cols; col++)
        input_row[col] = output_matrix[row][col];

      if (QccWAVWaveletSynthesis1D(input_row,
                                   output_matrix[row],
                                   num_cols,
                                   phase_row,
                                   wavelet))
        {
          QccErrorAddMessage("(QccWAVWaveletSynthesis2D): Error calling QccWAVWaveletSynthesis1D()");
          goto QccError;
        }
    }

  return_value = 0;
  goto QccReturn;
 QccError:
  return_value = 1;
 QccReturn:
  QccVectorFree(input_column);
  QccVectorFree(output_column);
  QccVectorFree(input_row);
  return(return_value);
}