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


static int QccSQInverseScalarQuantizationGeneral(int partition,
                                                 const QccSQScalarQuantizer 
                                                 *quantizer,
                                                 double *value)
{
  if (quantizer->levels == NULL)
    return(0);

  if (partition < 0)
    return(0);

  if (partition < quantizer->num_levels)
    *value = quantizer->levels[partition];
  else
    {
      QccErrorAddMessage("(QccSQInverseScalarQuantizer): Partition value (%d) is beyond number of levels (%d) in scalar quantizer",
                         partition, quantizer->num_levels);
      return(1);
    }

  return(0);
}


static int QccSQScalarQuantizationGeneral(double value,
                                          const
                                          QccSQScalarQuantizer *quantizer,
                                          double *distortion,
                                          int *partition)
{
  int index;

  if (quantizer->boundaries == NULL)
    return(0);
  if (quantizer->num_levels < 1)
    return(0);

  for (index = 0; index < quantizer->num_levels - 1; index++)
    if (value <= quantizer->boundaries[index])
      goto Return;

  index = quantizer->num_levels - 1;

 Return:
  if (partition != NULL)
    *partition = index;
  if ((distortion != NULL) && (quantizer->levels != NULL))
    *distortion = (value - quantizer->levels[index]) *
      (value - quantizer->levels[index]);

  return(0);
}


static int QccSQInverseScalarQuantizationUniform(int partition,
                                                 const QccSQScalarQuantizer
                                                 *quantizer,
                                                 double *value)
{
  *value = 
    partition * quantizer->stepsize;
  
  return(0);
}


static int QccSQScalarQuantizationUniform(double value,
                                          const
                                          QccSQScalarQuantizer *quantizer,
                                          double *distortion,
                                          int *partition)
{
  int index;
  double dist;
  double quantized_value;

  if (quantizer->stepsize)
    index = (int)rint(value / quantizer->stepsize);
  else
    index = 0;

  if (partition != NULL)
    *partition = index;

  if (distortion != NULL)
    {
      QccSQInverseScalarQuantizationUniform(index,
                                            quantizer,
                                            &quantized_value);
      dist = value - quantized_value;
      *distortion = dist * dist;
    }

  return(0);
}


static int QccSQInverseScalarQuantizationDeadZone(int partition,
                                                  const QccSQScalarQuantizer
                                                  *quantizer,
                                                  double *value)
{
  if (!partition)
    *value = 0;
  else
    if (partition < 0)
      *value = 
        -((((-partition) - 1) + 0.5) * quantizer->stepsize +
          quantizer->deadzone/2);
    else
      *value = 
        ((partition - 1) + 0.5) * quantizer->stepsize +
        quantizer->deadzone/2;
  
  return(0);
}


static int QccSQScalarQuantizationDeadZone(double value,
                                           const
                                           QccSQScalarQuantizer *quantizer,
                                           double *distortion,
                                           int *partition)
{
  int index;
  double dist;
  double quantized_value;

  if (fabs(value) <= quantizer->deadzone/2)
    index = 0;
  else
    if (quantizer->stepsize)
      if (value < 0) 
        index = 
          -(int)ceil(((-value) - quantizer->deadzone/2) /
                     quantizer->stepsize);
      else
        index = 
          (int)ceil((value - quantizer->deadzone/2) /
                    quantizer->stepsize);
  
    else
      index = 0;

  if (partition != NULL)
    *partition = index;

  if (distortion != NULL)
    {
      QccSQInverseScalarQuantizationDeadZone(index,
                                             quantizer,
                                             &quantized_value);
      dist = value - quantized_value;
      *distortion = dist * dist;
    }

  return(0);
}


int QccSQScalarQuantization(double value,
                            const QccSQScalarQuantizer *quantizer,
                            double *distortion,
                            int *partition)
{
  if (quantizer == NULL)
    return(0);

  switch (quantizer->type)
    {
    case QCCSQSCALARQUANTIZER_GENERAL:
      QccSQScalarQuantizationGeneral(value,
                                     quantizer,
                                     distortion,
                                     partition);
      break;

    case QCCSQSCALARQUANTIZER_UNIFORM:
      QccSQScalarQuantizationUniform(value,
                                     quantizer,
                                     distortion,
                                     partition);
      break;

    case QCCSQSCALARQUANTIZER_DEADZONE:
      QccSQScalarQuantizationDeadZone(value,
                                      quantizer,
                                      distortion,
                                      partition);
      break;
    }

  return(0);
}


int QccSQInverseScalarQuantization(int partition,
                                   const QccSQScalarQuantizer *quantizer,
                                   double *value)
{
  if (quantizer == NULL)
    return(0);
  if (value == NULL)
    return(0);
  
  switch (quantizer->type)
    {
    case QCCSQSCALARQUANTIZER_GENERAL:
      QccSQInverseScalarQuantizationGeneral(partition,
                                            quantizer,
                                            value);
      break;

    case QCCSQSCALARQUANTIZER_UNIFORM:
      QccSQInverseScalarQuantizationUniform(partition,
                                            quantizer,
                                            value);
      break;

    case QCCSQSCALARQUANTIZER_DEADZONE:
      QccSQInverseScalarQuantizationDeadZone(partition,
                                             quantizer,
                                             value);
      break;
    }

  return(0);
}


int QccSQScalarQuantizeVector(const QccVector data,
                              int data_length,
                              const QccSQScalarQuantizer *quantizer,
                              QccVector distortion,
                              int *partition)
{
  int index;

  if (data == NULL)
    return(0);
  if (quantizer == NULL)
    return(0);

  if (data_length < 1)
    return(0);

  if (distortion == NULL)
    if (partition == NULL)
      {
        for (index = 0; index < data_length; index++)
          if (QccSQScalarQuantization(data[index],
                                      quantizer,
                                      NULL, 
                                      NULL))
            {
              QccErrorAddMessage("(QccSQScalarQuantizerVector): Error calling QccSQScalarQuantization()");
              return(1);
            }
      }
    else
      {
        for (index = 0; index < data_length; index++)
          {
            if (QccSQScalarQuantization(data[index],
                                        quantizer,
                                        NULL, 
                                        &(partition[index])))
              {
                QccErrorAddMessage("(QccSQScalarQuantizerVector): Error calling QccSQScalarQuantization()");
                return(1);
              }
          }
      }
  else
    if (partition == NULL)
      {
        for (index = 0; index < data_length; index++)
          if (QccSQScalarQuantization(data[index],
                                      quantizer,
                                      &(distortion[index]), 
                                      NULL))
            {
              QccErrorAddMessage("(QccSQScalarQuantizerVector): Error calling QccSQScalarQuantization()");
              return(1);
            }
      }
    else
      {
        for (index = 0; index < data_length; index++)
          if (QccSQScalarQuantization(data[index],
                                      quantizer,
                                      &(distortion[index]), 
                                      &(partition[index])))
            {
              QccErrorAddMessage("(QccSQScalarQuantizerVector): Error calling QccSQScalarQuantization()");
              return(1);
            }
      }

  return(0);
}