lifting_cdf9_7.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"


#define ALPHA     -1.58615986717275
#define BETA      -0.05297864003258
#define GAMMA      0.88293362717904
#define DELTA      0.44350482244527
#define EPSILON    1.14960430535816


static void QccWAVCDF97AnalysisSymmetricEvenEven(QccVector signal,
                                                 int signal_length)
{
  int index;
  
  for (index = 1; index < signal_length - 2; index += 2)
    signal[index] +=
      ALPHA * (signal[index - 1] + signal[index + 1]);
  signal[signal_length - 1] +=
    2 * ALPHA * signal[signal_length - 2];
  
  signal[0] +=
    2 * BETA * signal[1];
  for (index = 2; index < signal_length; index += 2)
    signal[index] +=
      BETA * (signal[index + 1] + signal[index - 1]);
  
  for (index = 1; index < signal_length - 2; index += 2)
    signal[index] +=
      GAMMA * (signal[index - 1] + signal[index + 1]);
  signal[signal_length - 1] +=
    2 * GAMMA * signal[signal_length - 2];
  
  signal[0] =
    EPSILON * (signal[0] +
               2 * DELTA * signal[1]);
  for (index = 2; index < signal_length; index += 2)
    signal[index] =
      EPSILON * (signal[index] + 
                 DELTA * (signal[index + 1] + signal[index - 1]));
  
  for (index = 1; index < signal_length; index += 2)
    signal[index] /= (-EPSILON);
}


static void QccWAVCDF97AnalysisSymmetricEvenOdd(QccVector signal,
                                                int signal_length)
{
  int index;

  signal[0] +=
    2 * ALPHA * signal[1];
  for (index = 2; index < signal_length; index += 2)
    signal[index] +=
      ALPHA * (signal[index - 1] + signal[index + 1]);
  
  for (index = 1; index < signal_length - 2; index += 2)
    signal[index] +=
      BETA * (signal[index + 1] + signal[index - 1]);
  signal[signal_length - 1] +=
    2 * BETA * signal[signal_length - 2];
  
  signal[0] +=
    2 * GAMMA * signal[1];
  for (index = 2; index < signal_length; index += 2)
    signal[index] +=
      GAMMA * (signal[index - 1] + signal[index + 1]);
  
  for (index = 1; index < signal_length - 2; index += 2)
    signal[index] =
      EPSILON * (signal[index] + 
                 DELTA * (signal[index + 1] + signal[index - 1]));
  signal[signal_length - 1] =
    EPSILON * (signal[signal_length - 1] +
               2 * DELTA * signal[signal_length - 2]);
  
  for (index = 0; index < signal_length; index += 2)
    signal[index] /= (-EPSILON);
}


static void QccWAVCDF97AnalysisSymmetricOddEven(QccVector signal,
                                                int signal_length)
{
  int index;

  for (index = 1; index < signal_length - 1; index += 2)
    signal[index] +=
      ALPHA * (signal[index - 1] + signal[index + 1]);
  
  signal[0] +=
    2 * BETA * signal[1];
  for (index = 2; index < signal_length - 2; index += 2)
    signal[index] +=
      BETA * (signal[index + 1] + signal[index - 1]);
  signal[signal_length - 1] +=
    2 * BETA * signal[signal_length - 2];

  for (index = 1; index < signal_length - 1; index += 2)
    signal[index] +=
      GAMMA * (signal[index - 1] + signal[index + 1]);
  
  signal[0] =
    EPSILON * (signal[0] +
               2 * DELTA * signal[1]);
  for (index = 2; index < signal_length - 2; index += 2)
    signal[index] =
      EPSILON * (signal[index] + 
                 DELTA * (signal[index + 1] + signal[index - 1]));
  signal[signal_length - 1] =
    EPSILON * (signal[signal_length - 1] +
               2 * DELTA * signal[signal_length - 2]);

  for (index = 1; index < signal_length - 1; index += 2)
    signal[index] /= (-EPSILON);
}


static void QccWAVCDF97AnalysisSymmetricOddOdd(QccVector signal,
                                               int signal_length)
{
  int index;

  signal[0] +=
    2 * ALPHA * signal[1];
  for (index = 2; index < signal_length - 2; index += 2)
    signal[index] +=
      ALPHA * (signal[index - 1] + signal[index + 1]);
  signal[signal_length - 1] +=
    2 * ALPHA * signal[signal_length - 2];
  
  for (index = 1; index < signal_length; index += 2)
    signal[index] +=
      BETA * (signal[index + 1] + signal[index - 1]);
  
  signal[0] +=
    2 * GAMMA * signal[1];
  for (index = 2; index < signal_length - 2; index += 2)
    signal[index] +=
      GAMMA * (signal[index - 1] + signal[index + 1]);
  signal[signal_length - 1] +=
    2 * GAMMA * signal[signal_length - 2];
  
  for (index = 1; index < signal_length; index += 2)
    signal[index] =
      EPSILON * (signal[index] + 
                 DELTA * (signal[index + 1] + signal[index - 1]));
  
  for (index = 0; index < signal_length; index += 2)
    signal[index] /= (-EPSILON);
}


static void QccWAVCDF97AnalysisPeriodicEvenEven(QccVector signal,
                                                int signal_length)
{
  int index;
  
  for (index = 1; index < signal_length - 2; index += 2)
    signal[index] +=
      ALPHA * (signal[index - 1] + signal[index + 1]);
  signal[signal_length - 1] +=
    ALPHA * (signal[signal_length - 2] + signal[0]);
  
  signal[0] +=
    BETA * (signal[1] + signal[signal_length - 1]);
  for (index = 2; index < signal_length; index += 2)
    signal[index] +=
      BETA * (signal[index + 1] + signal[index - 1]);
  
  for (index = 1; index < signal_length - 2; index += 2)
    signal[index] +=
      GAMMA * (signal[index - 1] + signal[index + 1]);
  signal[signal_length - 1] +=
    GAMMA * (signal[signal_length - 2] + signal[0]);
  
  signal[0] =
    EPSILON * (signal[0] +
               DELTA * (signal[1] + signal[signal_length - 1]));
  for (index = 2; index < signal_length; index += 2)
    signal[index] =
      EPSILON * (signal[index] + 
                 DELTA * (signal[index + 1] + signal[index - 1]));
  
  for (index = 1; index < signal_length; index += 2)
    signal[index] /= (-EPSILON);
}


static void QccWAVCDF97AnalysisPeriodicEvenOdd(QccVector signal,
                                               int signal_length)
{
  int index;
  
  signal[0] +=
    ALPHA * (signal[signal_length - 1] + signal[1]);
  for (index = 2; index < signal_length; index += 2)
    signal[index] +=
      ALPHA * (signal[index - 1] + signal[index + 1]);
  
  for (index = 1; index < signal_length - 1; index += 2)
    signal[index] +=
      BETA * (signal[index + 1] + signal[index - 1]);
  signal[signal_length - 1] +=
    BETA * (signal[0] + signal[signal_length - 2]);
  
  signal[0] +=
    GAMMA * (signal[signal_length - 1] + signal[1]);
  for (index = 2; index < signal_length; index += 2)
    signal[index] +=
      GAMMA * (signal[index - 1] + signal[index + 1]);
  
  for (index = 1; index < signal_length - 1; index += 2)
    signal[index] =
      EPSILON * (signal[index] + 
                 DELTA * (signal[index + 1] + signal[index - 1]));
  signal[signal_length - 1] =
    EPSILON * (signal[signal_length - 1] +
               DELTA * (signal[0] + signal[signal_length - 2]));
  
  for (index = 0; index < signal_length; index += 2)
    signal[index] /= (-EPSILON);
}


static void QccWAVCDF97AnalysisBoundaryEvenEven(QccVector signal,
                                                int signal_length)
{
  int index;

  for (index = 1; index < signal_length - 2; index += 2)
    signal[index] +=
      ALPHA * (signal[index - 1] + signal[index + 1]);
  signal[signal_length - 1] +=
    ALPHA * (3*signal[signal_length - 2] - signal[signal_length - 4]);
  
  signal[0] +=
    BETA * (3*signal[1] - signal[3]);
  for (index = 2; index < signal_length; index += 2)
    signal[index] +=
      BETA * (signal[index + 1] + signal[index - 1]);
  
  for (index = 1; index < signal_length - 2; index += 2)
    signal[index] +=
      GAMMA * (signal[index - 1] + signal[index + 1]);
  signal[signal_length - 1] +=
    GAMMA * (3*signal[signal_length - 2] - signal[signal_length - 4]);
  
  signal[0] =
    EPSILON * (signal[0] +
               DELTA * (3*signal[1] - signal[3]));
  for (index = 2; index < signal_length; index += 2)
    signal[index] =
      EPSILON * (signal[index] + 
                 DELTA * (signal[index + 1] + signal[index - 1]));
  
  for (index = 1; index < signal_length; index += 2)
    signal[index] /= (-EPSILON);
}


static void QccWAVCDF97AnalysisBoundaryEvenOdd(QccVector signal,
                                               int signal_length)
{
  int index;

  signal[0] +=
    ALPHA * (3*signal[1] - signal[3]);
  for (index = 2; index < signal_length; index += 2)
    signal[index] +=
      ALPHA * (signal[index - 1] + signal[index + 1]);
  
  for (index = 1; index < signal_length - 1; index += 2)
    signal[index] +=
      BETA * (signal[index + 1] + signal[index - 1]);
  signal[signal_length - 1] +=
    BETA * (3*signal[signal_length - 2] - signal[signal_length - 4]);
  
  signal[0] +=
    GAMMA * (3*signal[1] - signal[3]);
  for (index = 2; index < signal_length; index += 2)
    signal[index] +=
      GAMMA * (signal[index - 1] + signal[index + 1]);
  
  for (index = 1; index < signal_length - 1; index += 2)
    signal[index] =
      EPSILON * (signal[index] + 
                 DELTA * (signal[index + 1] + signal[index - 1]));
  signal[signal_length - 1] =
    EPSILON * (signal[signal_length - 1] +
               DELTA * (3*signal[signal_length - 2] -
                        signal[signal_length - 4]));
  
  for (index = 0; index < signal_length; index += 2)
    signal[index] /= (-EPSILON);
}


static void QccWAVCDF97AnalysisBoundaryOddEven(QccVector signal,
                                               int signal_length)
{
  int index;

  for (index = 1; index < signal_length; index += 2)
    signal[index] +=
      ALPHA * (signal[index - 1] + signal[index + 1]);
  
  signal[0] +=
    BETA * (3*signal[1] - signal[3]);
  for (index = 2; index < signal_length - 1; index += 2)
    signal[index] +=
      BETA * (signal[index + 1] + signal[index - 1]);