fast_dct.c

spiht for linux this is used to decod and encode vedio i wich all enjoy

        {
          temp_value =
            gsl_complex_mul(gsl_complex_rect(0,
                                             -input_signal[length -
                                                           index - 1]),
                            transform->inverse_weights[index + 1]);
          transform->signal_workspace[2 * (index + length) + 2] =
            GSL_REAL(temp_value);
          transform->signal_workspace[2 * (index + length) + 3] =
            GSL_IMAG(temp_value);
        }

      if (gsl_fft_complex_inverse((gsl_complex_packed_array)
                                  transform->signal_workspace,
                                  1,
                                  length * 2,
                                  transform->wavetable,
                                  transform->workspace))
        {
          QccErrorAddMessage("(QccFastDCTInverseTransform1D): Error performing inverse fft");
          goto Error;
        }

      for (index = 0; index < length; index ++)
        output_signal[index] = transform->signal_workspace[2 * index];
    }
  else
    {
      if (QccVectorZero(transform->signal_workspace, length * 2))
        {
          QccErrorAddMessage("(QccFastDCTInverseTransform1D): Error calling QccVectorZero()");
          goto Error;
        }
      
      for (index = 0; index < length; index++)
        {
          temp_value =
            gsl_complex_mul(gsl_complex_rect(input_signal[index], 0),
                            transform->inverse_weights[index]);
          transform->signal_workspace[2 * index] = GSL_REAL(temp_value);
          transform->signal_workspace[2 * index + 1] = GSL_IMAG(temp_value);
        }
      
      if (gsl_fft_complex_inverse((gsl_complex_packed_array)
                                  transform->signal_workspace,
                                  1,
                                  length,
                                  transform->wavetable,
                                  transform->workspace))
        {
          QccErrorAddMessage("(QccFastDCTInverseTransform1D): Error performing inverse fft");
          goto Error;
        }
      
      for (index = 0; index < length; index += 2)
        {
          output_signal[index] = transform->signal_workspace[index];
          output_signal[index + 1] =
            transform->signal_workspace[2*length - index - 2];
        }
    }

  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);
}


int QccFastDCTForwardTransform2D(const QccMatrix input_block,
                                 QccMatrix output_block,
                                 int num_rows,
                                 int num_cols,
                                 const QccFastDCT *transform_horizontal,
                                 const QccFastDCT *transform_vertical)
{
  int return_value;
  QccVector col_vector1 = NULL;
  QccVector col_vector2 = NULL;
  int row, col;
  
  if ((input_block == NULL) ||
      (output_block == NULL))
    return(0);
  if ((transform_horizontal == NULL) ||
      (transform_vertical == NULL))
    return(0);

  if ((num_rows <= 0) || (num_cols <= 0))
    return(0);
  
  if ((num_rows != transform_vertical->length) ||
      (num_cols != transform_horizontal->length))
    {
      QccErrorAddMessage("(QccFastDCTForwardTransform2D): Transform lengths must match that of blocks both horizontally and vertically");
      goto Error;
    }

  if ((col_vector1 = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccFastDCTForwardTransform2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((col_vector2 = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccFastDCTForwardTransform2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  
  for (row = 0; row < num_rows; row++)
    if (QccFastDCTForwardTransform1D(input_block[row],
                                     output_block[row],
                                     num_cols,
                                     transform_horizontal))
      {
        QccErrorAddMessage("(QccFastDCTForwardTransform2D): Error calling QccFastDCTForwardTransform1D()");
        goto Error;
      }
  
  for (col = 0; col < num_cols; col++)
    {
      for (row = 0; row < num_rows; row++)
        col_vector1[row] = output_block[row][col];
      if (QccFastDCTForwardTransform1D(col_vector1,
                                       col_vector2,
                                       num_rows,
                                       transform_vertical))
        {
          QccErrorAddMessage("(QccFastDCTForwardTransform2D): Error calling QccFastDCTForwardTransform1D()");
          goto Error;
        }
      for (row = 0; row < num_rows; row++)
        output_block[row][col] = col_vector2[row];
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccVectorFree(col_vector1);
  QccVectorFree(col_vector2);
  return(return_value);
}


int QccFastDCTInverseTransform2D(const QccMatrix input_block,
                                 QccMatrix output_block,
                                 int num_rows,
                                 int num_cols,
                                 const QccFastDCT *transform_horizontal,
                                 const QccFastDCT *transform_vertical)
{
  int return_value;
  QccVector col_vector1 = NULL;
  QccVector col_vector2 = NULL;
  int row, col;
  
  if ((input_block == NULL) ||
      (output_block == NULL))
    return(0);
  if ((transform_horizontal == NULL) ||
      (transform_vertical == NULL))
    return(0);

  if ((num_rows <= 0) || (num_cols <= 0))
    return(0);
  
  if ((num_rows != transform_vertical->length) ||
      (num_cols != transform_horizontal->length))
    {
      QccErrorAddMessage("(QccFastDCTInverseTransform2D): Transform lengths must match that of blocks both horizontally and vertically");
      goto Error;
    }

  if ((col_vector1 = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccFastDCTInverseTransform2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((col_vector2 = QccVectorAlloc(num_rows)) == NULL)
    {
      QccErrorAddMessage("(QccFastDCTInverseTransform2D): Error calling QccVectorAlloc()");
      goto Error;
    }
  
  for (row = 0; row < num_rows; row++)
    if (QccFastDCTInverseTransform1D(input_block[row],
                                     output_block[row],
                                     num_cols,
                                     transform_horizontal))
      {
        QccErrorAddMessage("(QccFastDCTInverseTransform2D): Error calling QccFastDCTInverseTransform1D()");
        goto Error;
      }
  
  for (col = 0; col < num_cols; col++)
    {
      for (row = 0; row < num_rows; row++)
        col_vector1[row] = output_block[row][col];
      if (QccFastDCTInverseTransform1D(col_vector1,
                                       col_vector2,
                                       num_rows,
                                       transform_vertical))
        {
          QccErrorAddMessage("(QccFastDCTInverseTransform2D): Error calling QccFastDCTInverseTransform1D()");
          goto Error;
        }
      for (row = 0; row < num_rows; row++)
        output_block[row][col] = col_vector2[row];
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccVectorFree(col_vector1);
  QccVectorFree(col_vector2);
  return(return_value);
}


#else


int QccFastDCTInitialize(QccFastDCT *transform)
{
  QccErrorAddMessage("(QccFastDCTInitialize): GSL support is not available -- fast DCT is thus not supported");
  return(1);
}


int QccFastDCTCreate(QccFastDCT *transform,
                     int length)
{
  QccErrorAddMessage("(QccFastDCTCreate): GSL support is not available -- fast DCT is thus not supported");
  return(1);
}


void QccFastDCTFree(QccFastDCT *transform)
{
  QccErrorAddMessage("(QccFastDCTFree): GSL support is not available -- fast DCT is thus not supported");
}


int QccFastDCTForwardTransform1D(const QccVector input_signal,
                                 QccVector output_signal,
                                 int length,
                                 const QccFastDCT *transform)
{
  QccErrorAddMessage("(QccFastDCTForwardTransform1D): GSL support is not available -- fast DCT is thus not supported");
  return(1);
}


int QccFastDCTInverseTransform1D(const QccVector input_signal,
                                 QccVector output_signal,
                                 int length,
                                 const QccFastDCT *transform)
{
  QccErrorAddMessage("(QccFastDCTInverseTransform1D): GSL support is not available -- fast DCT is thus not supported");
  return(1);
}


int QccFastDCTForwardTransform2D(const QccMatrix input_block,
                                 QccMatrix output_block,
                                 int num_rows,
                                 int num_cols,
                                 const QccFastDCT *transform_horizontal,
                                 const QccFastDCT *transform_vertical)
{
  QccErrorAddMessage("(QccFastDCTForwardTransform2D): GSL support is not available -- fast DCT is thus not supported");
  return(1);
}


int QccFastDCTInverseTransform2D(const QccMatrix input_block,
                                 QccMatrix output_block,
                                 int num_rows,
                                 int num_cols,
                                 const QccFastDCT *transform_horizontal,
                                 const QccFastDCT *transform_vertical)
{
  QccErrorAddMessage("(QccFastDCTInverseTransform2D): GSL support is not available -- fast DCT is thus not supported");
  return(1);
}


#endif