filter.c

spiht的压缩解压缩c编写的

                filter->coefficients[filter_index];
            }
        }
      break;
      
    case QCCFILTER_ANTICAUSAL:
      for (output_index = 0; output_index < length; output_index++)
        {
          output_signal[output_index] = 0;
          for (filter_index = 0; filter_index < filter->length; filter_index++)
            {
              input_index1 = 
                QccFilterCalcSymmetricExtension(output_index + filter_index,
                                                length);
              
              output_signal[output_index] +=
                input_signal[input_index1] * 
                filter->coefficients[filter->length - 1 - filter_index];
            }
        }
      break;
      
    case QCCFILTER_SYMMETRIC:
      for (output_index = 0; output_index < length; output_index++)
        {
          output_signal[output_index] = 
            input_signal[output_index] * filter->coefficients[0];
          for (filter_index = 1; filter_index < filter->length; filter_index++)
            {
              input_index1 = 
                QccFilterCalcSymmetricExtension(output_index - filter_index,
                                                length);
              input_index2 = 
                QccFilterCalcSymmetricExtension(output_index + filter_index,
                                                length);
              
              output_signal[output_index] +=
                (input_signal[input_index1] + input_signal[input_index2]) * 
                filter->coefficients[filter_index];
            }
        }
      break;
      
    default:
      QccErrorAddMessage("(QccFilterVectorSymmetricExtension): Undefined filter causality (%d)",
                         filter->causality);
      return(1);
    }
  
  return(0);
}

int QccFilterVector(const QccVector input_signal,
                    QccVector output_signal,
                    int length,
                    const QccFilter *filter,
                    int boundary_extension)
{
  if (input_signal == NULL)
    return(0);
  if (output_signal == NULL)
    return(0);
  if (filter == NULL)
    return(0);
  if (!(filter->length) || (filter->coefficients == NULL))
    return(0);
  
  switch (boundary_extension)
    {
    case QCCFILTER_SYMMETRIC_EXTENSION:
      if (QccFilterVectorSymmetricExtension(input_signal,
                                            output_signal,
                                            length,
                                            filter))
        {
          QccErrorAddMessage("(QccFilterVector): Error calling QccFilterVectorPeriodicExtension()");
          return(1);
        }
      break;
      
    case QCCFILTER_PERIODIC_EXTENSION:
      if (QccFilterVectorPeriodicExtension(input_signal,
                                           output_signal,
                                           length,
                                           filter))
        {
          QccErrorAddMessage("(QccFilterVector): Error calling QccFilterVectorSymmetricExtension()");
          return(1);
        }
      break;
      
    default:
      QccErrorAddMessage("(QccFilterVector): Undefined boundary extension (%d)",
                         boundary_extension);
      return(1);
    }
  
  return(0);
}

int QccFilterMultiRateFilterVector(const QccVector input_signal,
                                   int input_length,
                                   QccVector output_signal,
                                   int output_length,
                                   const QccFilter *filter,
                                   int input_sampling,
                                   int output_sampling,
                                   int boundary_extension)
{
  QccVector input_signal2 = NULL;
  QccVector output_signal2 = NULL;
  int input_length2;
  int output_length2;
  int input_allocated = 0;
  int output_allocated = 0;
  int return_value;
  
  if (input_signal == NULL)
    return(0);
  if (output_signal == NULL)
    return(0);
  if (filter == NULL)
    return(0);
  if (!(filter->length) || (filter->coefficients == NULL))
    return(0);

  switch (input_sampling)
    {
    case QCCFILTER_SAMESAMPLING:
      input_length2 = input_length;
      input_signal2 = input_signal;
      input_allocated = 0;
      break;
      
    case QCCFILTER_SUBSAMPLEEVEN:
      input_length2 = (int)ceil((double)input_length / 2);
      if ((input_signal2 = QccVectorAlloc(input_length2)) == NULL)
        {
          QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccVectorAlloc()");
          goto QccError;
        }
      input_allocated = 1;
      if (QccVectorSubsample(input_signal,
                             input_length,
                             input_signal2,
                             input_length2,
                             QCCVECTOR_EVEN))
        {
          QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccVectorSubsample()");
          goto QccError;
        }
      break;

    case QCCFILTER_SUBSAMPLEODD:
      input_length2 = (int)floor((double)input_length / 2);
      if ((input_signal2 = QccVectorAlloc(input_length2)) == NULL)
        {
          QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccVectorAlloc()");
          goto QccError;
        }
      input_allocated = 1;
      if (QccVectorSubsample(input_signal,
                             input_length,
                             input_signal2,
                             input_length2,
                             QCCVECTOR_ODD))
        {
          QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccVectorSubsample()");
          goto QccError;
        }
      break;
      
    case QCCFILTER_UPSAMPLEEVEN:
      input_length2 = input_length * 2;
      if ((input_signal2 = QccVectorAlloc(input_length2)) == NULL)
        {
          QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccVectorAlloc()");
          goto QccError;
        }
      input_allocated = 1;
      if (QccVectorUpsample(input_signal,
                            input_length,
                            input_signal2,
                            input_length2,
                            ((input_sampling == QCCFILTER_UPSAMPLEEVEN) ?
                             QCCVECTOR_EVEN : QCCVECTOR_ODD)))
        {
          QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccVectorUpsample()");
          goto QccError;
        }
      break;
      
    case QCCFILTER_UPSAMPLEODD:
      input_length2 = input_length * 2 + 1;
      if ((input_signal2 = QccVectorAlloc(input_length2)) == NULL)
        {
          QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccVectorAlloc()");
          goto QccError;
        }
      input_allocated = 1;
      if (QccVectorUpsample(input_signal,
                            input_length,
                            input_signal2,
                            input_length2,
                            ((input_sampling == QCCFILTER_UPSAMPLEEVEN) ?
                             QCCVECTOR_EVEN : QCCVECTOR_ODD)))
        {
          QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccVectorUpsample()");
          goto QccError;
        }
      break;
      
    default:
      QccErrorAddMessage("(QccFilterMultiRateFilterVector): Undefined input sampling (%d)",
                         input_sampling);
      goto QccError;
    }
  
  switch (output_sampling)
    {
    case QCCFILTER_SAMESAMPLING:
      output_length2 = QccMathMin(input_length2, output_length);
      output_signal2 = output_signal;
      output_allocated = 0;
      break;
    case QCCFILTER_SUBSAMPLEEVEN:
    case QCCFILTER_SUBSAMPLEODD:
      output_length2 = input_length2;
      if ((output_signal2 = QccVectorAlloc(output_length2)) == NULL)
        {
          QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccVectorAlloc()");
          goto QccError;
        }
      output_allocated = 1;
      break;
    case QCCFILTER_UPSAMPLEEVEN:
    case QCCFILTER_UPSAMPLEODD:
      output_length2 = input_length2;
      if ((output_signal2 = QccVectorAlloc(output_length2)) == NULL)
        {
          QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccVectorAlloc()");
          goto QccError;
        }
      output_allocated = 1;
      break;
    default:
      QccErrorAddMessage("(QccFilterMultiRateFilterVector): Undefined output sampling (%d)",
                         output_sampling);
      goto QccError;
    }
  
  if (QccFilterVector(input_signal2,
                      output_signal2,
                      output_length2,
                      filter,
                      boundary_extension))
    {
      QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccFilterVector()");
      goto QccError;
    }
  
  switch (output_sampling)
    {
    case QCCFILTER_SUBSAMPLEEVEN:
    case QCCFILTER_SUBSAMPLEODD:
      if (QccVectorSubsample(output_signal2,
                             output_length2,
                             output_signal,
                             output_length,
                             ((output_sampling == QCCFILTER_SUBSAMPLEEVEN) ?
                              QCCVECTOR_EVEN : QCCVECTOR_ODD)))
        {
          QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccVectorSubsample()");
          goto QccError;
        }
      break;
    case QCCFILTER_UPSAMPLEEVEN:
    case QCCFILTER_UPSAMPLEODD:
      if (QccVectorUpsample(output_signal2,
                            output_length2,
                            output_signal,
                            output_length,
                            ((output_sampling == QCCFILTER_UPSAMPLEEVEN) ?
                             QCCVECTOR_EVEN : QCCVECTOR_ODD)))
        {
          QccErrorAddMessage("(QccFilterMultiRateFilterVector): Error calling QccVectorUpsample()");
          goto QccError;
        }
      break;
    }
  
  return_value = 0;
  goto QccReturn;
 QccError:
  return_value = 1;
 QccReturn:
  if (input_allocated)
    QccVectorFree(input_signal2);
  if (output_allocated)
    QccVectorFree(output_signal2);
  return(return_value);
}