libqccpack.h

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.
 * 
 */


#ifndef LIBQCCPACK_H
#define LIBQCCPACK_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include <sys/time.h>
#include <stdarg.h>
#include <unistd.h>
#include <glob.h>
#include <fcntl.h>
#ifdef QCC_USE_PTHREADS
#include <pthread.h>
#endif
#ifdef QCC_USE_MTRACE
#include <mcheck.h>
#endif
#ifdef QCC_USE_GSL
#define HAVE_INLINE
#include <gsl/gsl_linalg.h>
#include <gsl/gsl_blas.h>
#include <gsl/gsl_complex.h>
#include <gsl/gsl_complex_math.h>
#include <gsl/gsl_fft_complex.h>
#endif

#define TRUE 1
#define FALSE 0

#ifndef MAXINT
#define MAXINT 2147483647
#endif
#ifndef MAXDOUBLE
#define MAXDOUBLE 1.7976931348623157e+308
#endif
#ifndef MAXFLOAT
#define MAXFLOAT 3.40282347e+38F
#endif


/*  parse.c  */
int QccParseParametersVA(int argc, char *argv[], const char *format,
                         va_list ap);
int QccParseParameters(int argc, char *argv[], const char *format, ...);


/*  string.c  */
#define QCCSTRINGLEN 1200
typedef char QccString[QCCSTRINGLEN + 1];
void QccStringMakeNull(QccString qccstring);
int QccStringNull(const QccString qccstring);
void QccConvertToQccString(QccString qccstring, const char *str);
void QccStringCopy(QccString qccstring1, const QccString qccstring2);
void QccStringSprintf(QccString qccstring, const char *format, ...);


/*  init.c  */
#define QCCEXIT_NOERROR 0
#define QCCEXIT_ERROR 1
void QccExtractProgramName(const char *argv0);
int QccGetProgramName(QccString program_name);
void QccInit(int argc, char *argv[]);
#define QccExit exit(QCCEXIT_NOERROR)
#define QccFree(p) (p != NULL) ? free(p):(void)0, (p) = NULL


/*  env.c  */
int QccGetEnv(const char *environment_variable,
              QccString returned_value);
int QccSetEnv(const char *environment_variable,
              const char *value);


/*  version.c  */
void QccVersionInit();
void QccSetUserHeader(const QccString user_header);
void QccGetQccPackVersion(int *major, int *minor, QccString date);
int QccCompareQccPackVersions(int major1, int minor1,
                              int major2, int minor2);
void QccPrintQccPackVersion(FILE *outfile);


/*  time.c  */
void QccTimeInit();
int QccTimeTic();
int QccTimeToc(double *time);


/*  error.c  */
#define QCCERROR_OUTPUTLINELENGTH 80
#define QCCERROR_OUTPUTTABLENGTH 8
typedef struct
{
  QccString current_message;
  QccString *error_messages;
  int num_messages;
  int errcode;
} QccErrorStruct;
void QccErrorInit(void);
void QccErrorAddMessageVA(const char *format, va_list ap);
void QccErrorAddMessage(const char *format, ...);
void QccErrorWarningVA(const char *format, va_list ap);
void QccErrorWarning(const char *format, ...);
void QccErrorPrintMessages(void);
void QccErrorClearMessages(void);
void QccErrorExit(void);


/*  binary_values.c  */
#define QCC_INT_SIZE 4
int QccBinaryCharToInt(const unsigned char *ch, unsigned int *val);
int QccBinaryIntToChar(unsigned int val, unsigned char *ch);
int QccBinaryCharToFloat(const unsigned char *ch, float *val);
int QccBinaryFloatToChar(float val, unsigned char *ch);


/*  file.c  */
#define QCCMAKESTRING(s) QCCMAKESTRING2(s)
#define QCCMAKESTRING2(s) #s
#define QCCFILE_WHOLEFILE -1
void QccFileInit(void);
int QccFileExists(const QccString filename);
int QccFileGetExtension(const QccString filename, QccString extension);
FILE *QccFileOpen(const QccString filename, const QccString mode);
FILE *QccFileDescriptorOpen(int file_descriptor, const QccString mode);
int QccFileClose(FILE *fileptr);
int QccFileSeekable(FILE *fileptr);
int QccFileFlush(FILE *fileptr);
int QccFileRemove(const QccString filename);
int QccFileGetSize(const QccString filename, FILE *fileptr,
                   long *filesize);
int QccFileGetModTime(const QccString filename, FILE *fileptr,
                      long *time);
int QccFileGetCurrentPosition(FILE *infile, long *current_position);
int QccFileReadChar(FILE *infile, char *val);
int QccFileWriteChar(FILE *outfile, char val);
int QccFileReadInt(FILE *infile, int *val);
int QccFileWriteInt(FILE *outfile, int val);
int QccFileReadDouble(FILE *infile, double *val);
int QccFileWriteDouble(FILE *outfile, double val);
int QccFileReadString(FILE *infile, QccString s);
int QccFileWriteString(FILE *outfile, const QccString s);
int QccFileSkipWhiteSpace(FILE *infile, int skip_comments_flag);
int QccFileReadMagicNumber(FILE *infile, QccString magic_num,
                           int *major_version_number,
                           int *minor_version_number);
int QccFileWriteMagicNumber(FILE *outfile, const QccString magic_num);
int QccFileGetMagicNumber(const QccString filename, QccString magic_num);
int QccFilePrintFileInfo(const QccString filename,
                         const QccString magic_num,
                         int major_version,
                         int minor_version);


/*  file_path.c  */
int QccFilePathSearch(const QccString pathlist,
                      const QccString filename,
                      QccString found_pathname);
FILE *QccFilePathSearchOpenRead(QccString filename,
                                const char *environment_path_variable,
                                const char *default_path_list);


/*  math.c  */
#define QccMathMax(x, y) (((x) >= (y)) ? (x) : (y))
#define QccMathMin(x, y) (((x) <= (y)) ? (x) : (y))
#define QccMathPercent(x, y) ((y) ? ((double)(x)/(y))*100.0 : (double)0)
#define QccMathModulus(x, y) ((y)?((x)-(y)*((int)floor((double)(x)/(y)))):(x))
#define QccMathLog2(x) ((log(x) / M_LN2))
#define QccMathMedian(a, b, c) (((a) > (b)) ? (((b) > (c)) ? (b) : (((a) > (c)) ? (c) : (a))) : (((a) > (c)) ? (a) : (((b) > (c)) ? (c) : (b))))
#define QCCMATHEPS 3e-16
double QccMathRand(void);
double QccMathRandNormal(void);
typedef double (*QccMathProbabilityDensity)(double value,
                                            double variance,
                                            double mean);
double QccMathGaussianDensity(double x, double variance, double mean);
double QccMathLaplacianDensity(double x, double variance, double mean);


/*  alpha.c  */
#define QCCALPHA_TRANSPARENT 0.0
#define QCCALPHA_OPAQUE 1.0
#define QccAlphaOpaque(alpha) ((alpha) >= QCCALPHA_OPAQUE)
#define QccAlphaTransparent(alpha) ((alpha) <= QCCALPHA_TRANSPARENT)
#define QccAlphaTranslucent(alpha) (((alpha) < QCCALPHA_OPAQUE) && ((alpha) > QCCALPHA_TRANSPARENT))


/*  vector.c  */
#define QCCVECTOR_SORTASCENDING 1
#define QCCVECTOR_SORTDESCENDING 2
#define QCCVECTOR_EVEN 0
#define QCCVECTOR_ODD 1
typedef double *QccVector;
QccVector QccVectorAlloc(int vector_dimension);
void QccVectorFree(QccVector vector);
int QccVectorZero(QccVector vector,
                  int vector_dimension);
QccVector QccVectorResize(QccVector vector,
                          int vector_dimension,
                          int new_vector_dimension);
double QccVectorMean(const QccVector vector,
                     int vector_dimension);
double QccVectorVariance(const QccVector vector,
                         int vector_dimension);
int QccVectorAdd(QccVector vector1,
                 const QccVector vector2,
                 int vector_dimension);
int QccVectorSubtract(QccVector vector1,
                      const QccVector vector2,
                      int vector_dimension);
int QccVectorScalarMult(QccVector vector,
                        double s,
                        int vector_dimension);
int QccVectorCopy(QccVector vector1,
                  const QccVector vector2,
                  int vector_dimension);
double QccVectorNorm(const QccVector vector,
                     int vector_dimension);
void QccVectorNormalize(QccVector vector,
                        int vector_dimension);
double QccVectorDotProduct(const QccVector vector1,
                           const QccVector vector2,
                           int vector_dimension);
double QccVectorAngle(const QccVector vector1,
                      const QccVector vector2,
                      int vector_dimension,
                      int degrees);
double QccVectorSquareDistance(const QccVector vector1,
                               const QccVector vector2, 
                               int vector_dimension);
double QccVectorSumComponents(const QccVector vector,
                              int vector_dimension);
double QccVectorMaxValue(const QccVector vector,
                         int vector_dimension,
                         int *winner);
double QccVectorMinValue(const QccVector vector,
                         int vector_dimension,
                         int *winner);
int QccVectorPrint(const QccVector vector,
                   int vector_dimension);
int QccVectorSortComponents(const QccVector vector,
                            QccVector sorted_vector,
                            int vector_dimension,
                            int sort_direction,
                            int *auxiliary_list);
int QccVectorGetSymbolProbs(const int *symbol_list,
                            int symbol_list_length,
                            QccVector probs, 
                            int num_symbols);
int QccVectorMoveComponentToFront(QccVector vector,
                                  int vector_dimension,
                                  int index);
int QccVectorSubsample(const QccVector input_signal,
                       int input_length,
                       QccVector output_signal,
                       int output_length,
                       int sampling_flag);
int QccVectorUpsample(const QccVector input_signal,
                      int input_length,
                      QccVector output_signal,
                      int output_length,
                      int sampling_flag);
int QccVectorDCT(const QccVector input_signal,
                 QccVector output_signal,
                 int signal_length);
int QccVectorInverseDCT(const QccVector input_signal,
                        QccVector output_signal,
                        int signal_length);


/*  vector_int.c  */
#define QCCVECTORINT_SORTASCENDING 1
#define QCCVECTORINT_SORTDESCENDING 2
#define QCCVECTORINT_EVEN 0
#define QCCVECTORINT_ODD 1
typedef int *QccVectorInt;
QccVectorInt QccVectorIntAlloc(int vector_dimension);
void QccVectorIntFree(QccVectorInt vector);
int QccVectorIntZero(QccVectorInt vector,
                     int vector_dimension);
QccVectorInt QccVectorIntResize(QccVectorInt vector,
                                int vector_dimension,
                                int new_vector_dimension);
double QccVectorIntMean(const QccVectorInt vector,
                        int vector_dimension);
double QccVectorIntVariance(const QccVectorInt vector,
                            int vector_dimension);
int QccVectorIntAdd(QccVectorInt vector1,
                    const QccVectorInt vector2,
                    int vector_dimension);
int QccVectorIntSubtract(QccVectorInt vector1,
                         const QccVectorInt vector2,
                         int vector_dimension);
int QccVectorIntScalarMult(QccVectorInt vector,
                           int s,