libqccpack.h

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

} QccFastDCT;
int QccFastDCTInitialize(QccFastDCT *transform);
int QccFastDCTCreate(QccFastDCT *transform,
                     int length);
void QccFastDCTFree(QccFastDCT *transform);
int QccFastDCTForwardTransform1D(const QccVector input_signal,
                                 QccVector output_signal,
                                 int length,
                                 const QccFastDCT *transform);
int QccFastDCTInverseTransform1D(const QccVector input_signal,
                                 QccVector output_signal,
                                 int length,
                                 const QccFastDCT *transform);
int QccFastDCTForwardTransform2D(const QccMatrix input_block,
                                 QccMatrix output_block,
                                 int num_rows,
                                 int num_cols,
                                 const QccFastDCT *transform_horizontal,
                                 const QccFastDCT *transform_vertical);
int QccFastDCTInverseTransform2D(const QccMatrix input_block,
                                 QccMatrix output_block,
                                 int num_rows,
                                 int num_cols,
                                 const QccFastDCT *transform_horizontal,
                                 const QccFastDCT *transform_vertical);


/*  point.c  */
typedef struct
{
  double x;
  double y;
} QccPoint;
void QccPointPrint(const QccPoint *point);
void QccPointCopy(QccPoint *point1,
                  const QccPoint *point2);
void QccPointAffineTransform(const QccPoint *point1,
                             QccPoint *point2,
                             QccMatrix affine_transform);


/*  triangle.c  */
typedef struct
{
  QccPoint vertices[3];
} QccTriangle;
void QccTrianglePrint(const QccTriangle *triangle);
int QccTriangleBoundingBox(const QccTriangle *triangle,
                           QccPoint *box_max,
                           QccPoint *box_min);
int QccTrianglePointInside(const QccTriangle *triangle, const QccPoint *point);
int QccTriangleCreateAffineTransform(const QccTriangle *triangle1,
                                     const QccTriangle *triangle2,
                                     QccMatrix transform);


/*  regular_mesh.c  */
typedef struct
{
  int num_rows;
  int num_cols;
  QccPoint **vertices;
} QccRegularMesh;
void QccRegularMeshInitialize(QccRegularMesh *mesh);
int QccRegularMeshAlloc(QccRegularMesh *mesh);
void QccRegularMeshFree(QccRegularMesh *mesh);
int QccRegularMeshGenerate(QccRegularMesh *mesh,
                           const QccPoint *range_upper,
                           const QccPoint *range_lower);
int QccRegularMeshNumTriangles(const QccRegularMesh *mesh);
int QccRegularMeshToTriangles(const QccRegularMesh *mesh,
                              QccTriangle *triangles);


/*  filter.c  */
#define QCCFILTER_CAUSAL 0
#define QCCFILTER_ANTICAUSAL 1
#define QCCFILTER_SYMMETRICWHOLE 2
#define QCCFILTER_SYMMETRICHALF 3
#define QCCFILTER_SYMMETRIC_EXTENSION 0
#define QCCFILTER_PERIODIC_EXTENSION 1
#define QCCFILTER_SAMESAMPLING 0
#define QCCFILTER_SUBSAMPLEEVEN 1
#define QCCFILTER_SUBSAMPLEODD 2
#define QCCFILTER_UPSAMPLEEVEN 3
#define QCCFILTER_UPSAMPLEODD 4
typedef struct
{
  int causality;
  int length;
  QccVector coefficients;
} QccFilter;
int QccFilterInitialize(QccFilter *filter);
int QccFilterAlloc(QccFilter *filter);
void QccFilterFree(QccFilter *filter);
int QccFilterCopy(QccFilter *filter1,
                  const QccFilter *filter2);
int QccFilterReversal(const QccFilter *filter1,
                      QccFilter *filter2);
int QccFilterAlternateSignFlip(QccFilter *filter);
int QccFilterRead(FILE *infile,
                  QccFilter *filter);
int QccFilterWrite(FILE *outfile,
                   const QccFilter *filter);
int QccFilterPrint(const QccFilter *filter);
int QccFilterCalcSymmetricExtension(int index, int length, int symmetry);
int QccFilterVector(const QccVector input_signal,
                    QccVector output_signal,
                    int length,
                    const QccFilter *filter,
                    int boundary_extension);
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);
int QccFilterMatrixSeparable(const QccMatrix input_matrix,
                             QccMatrix output_matrix,
                             int num_rows,
                             int num_cols,
                             const QccFilter *horizontal_filter,
                             const QccFilter *vertical_filter,
                             int boundary_extension);


/*  linked_list.c  */
#define QCCLIST_SORTASCENDING 1
#define QCCLIST_SORTDESCENDING 2
typedef struct QccListNodeStruct
{
  int value_size;
  void *value;
  struct QccListNodeStruct *previous;
  struct QccListNodeStruct *next;
} QccListNode;
typedef struct
{
  QccListNode *start;
  QccListNode *end;
} QccList;
typedef void (*QccListPrintValueFunction)(const void *value);
typedef int (*QccListCompareValuesFunction)(const void *value1,
                                            const void *value2);
void QccListInitialize(QccList *list);
void QccListFreeNode(QccListNode *node);
void QccListFree(QccList *list);
QccListNode *QccListCreateNode(int value_size, const void *value);
QccListNode *QccListCopyNode(const QccListNode *node);
int QccListLength(const QccList *list);
int QccListAppendNode(QccList *list, QccListNode *node);
int QccListInsertNode(QccList *list,
                      QccListNode *insertion_point, 
                      QccListNode *node);
int QccListSortedInsertNode(QccList *list,
                            QccListNode *node,
                            int sort_direction,
                            QccListCompareValuesFunction);
int QccListRemoveNode(QccList *list, QccListNode *node);
int QccListDeleteNode(QccList *list, QccListNode *node);
int QccListMoveNode(QccList *list1, QccList *list2, QccListNode *node);
int QccListSort(QccList *list, int sort_direction,
                int (*compare_values)(const void *value1,
                                      const void *value2));
int QccListConcatenate(QccList *list1, QccList *list2);
int QccListPrint(QccList *list,
                 QccListPrintValueFunction);


/*  bit_buffer.c  */
#define QCCBITBUFFER_BLOCKSIZE 1024
#define QCCBITBUFFER_INPUT 0
#define QCCBITBUFFER_OUTPUT 1
typedef unsigned char QccBitBufferChar;
typedef struct
{
  QccString          filename;
  FILE               *fileptr;
  int                type;
  int                bit_cnt;
  int                byte_cnt;
  int                bits_to_go;
  QccBitBufferChar   buffer;
} QccBitBuffer;
int QccBitBufferInitialize(QccBitBuffer *bit_buffer);
int QccBitBufferStart(QccBitBuffer *bit_buffer);
int QccBitBufferEnd(QccBitBuffer *bit_buffer);
int QccBitBufferFlush(QccBitBuffer *bit_buffer);
int QccBitBufferCopy(QccBitBuffer *output_buffer,
                     QccBitBuffer *input_buffer,
                     int num_bits);
int QccBitBufferPutBit(QccBitBuffer *bit_buffer, int bit_value);
int QccBitBufferGetBit(QccBitBuffer *bit_buffer, int *bit_value);
int QccBitBufferPutBits(QccBitBuffer *bit_buffer, int val, int num_bits);
int QccBitBufferGetBits(QccBitBuffer *bit_buffer, int *val, int num_bits);
int QccBitBufferPutChar(QccBitBuffer *bit_buffer, unsigned char val);
int QccBitBufferGetChar(QccBitBuffer *bit_buffer, unsigned char *val);
int QccBitBufferPutInt(QccBitBuffer *bit_buffer, int val);
int QccBitBufferGetInt(QccBitBuffer *bit_buffer, int *val);
int QccBitBufferPutDouble(QccBitBuffer *bit_buffer, double val);
int QccBitBufferGetDouble(QccBitBuffer *bit_buffer, double *val);


/*  fifo.c  */
typedef struct
{
  QccBitBuffer output_buffer;
  QccBitBuffer input_buffer;
} QccFifo;
void QccFifoInitialize(QccFifo *fifo);
int QccFifoStart(QccFifo *fifo);
int QccFifoEnd(QccFifo *fifo);
int QccFifoFlush(QccFifo *fifo);
int QccFifoRestart(QccFifo *fifo);


/*  dataset.c  */
#define QCCDATASET_MAGICNUM "DAT"
#define QCCDATASET_ACCESSWHOLEFILE QCCFILE_WHOLEFILE
typedef struct
{
  QccString       filename;
  FILE            *fileptr;
  QccString       magic_num;
  int             major_version;
  int             minor_version;
  int             num_vectors;
  int             vector_dimension;
  int             access_block_size;
  int             num_blocks_accessed;
  double          min_val;
  double          max_val;
  QccMatrix       vectors;
} QccDataset;
int QccDatasetInitialize(QccDataset *dataset);
int QccDatasetAlloc(QccDataset *dataset);
void QccDatasetFree(QccDataset *dataset);
int QccDatasetGetBlockSize(const QccDataset *dataset);
int QccDatasetPrint(const QccDataset *dataset);
int QccDatasetCopy(QccDataset *dataset1, const QccDataset *dataset2);
int QccDatasetReadWholefile(QccDataset *dataset);
int QccDatasetReadHeader(QccDataset *dataset);
int QccDatasetStartRead(QccDataset *dataset);
int QccDatasetEndRead(QccDataset *dataset);
int QccDatasetReadBlock(QccDataset *dataset);
int QccDatasetReadSlidingBlock(QccDataset *dataset);
int QccDatasetWriteWholefile(QccDataset *dataset);
int QccDatasetWriteHeader(QccDataset *dataset);
int QccDatasetStartWrite(QccDataset *dataset);
int QccDatasetEndWrite(QccDataset *dataset);
int QccDatasetWriteBlock(QccDataset *dataset);
int QccDatasetSetMaxMinValues(QccDataset *dataset);
double QccDatasetMSE(const QccDataset *dataset1, const QccDataset *dataset2);
int QccDatasetMeanVector(const QccDataset *dataset, QccVector mean);
int QccDatasetCovarianceMatrix(const QccDataset *dataset,
                               QccMatrix covariance);
int QccDatasetCalcVectorPowers(const QccDataset *dataset, 
                               QccVector vector_power);


/*  channel.c  */
#define QCCCHANNEL_MAGICNUM "CHN"
#define QCCCHANNEL_ACCESSWHOLEFILE QCCFILE_WHOLEFILE
#define QCCCHANNEL_UNDEFINEDSIZE -1
#define QCCCHANNEL_NULLSYMBOL -1
typedef struct
{
  QccString    filename;
  FILE         *fileptr;
  QccString    magic_num;
  int          major_version;
  int          minor_version;
  int          channel_length;
  int          access_block_size;
  int          num_blocks_accessed;
  int          alphabet_size;
  int          *channel_symbols;
} QccChannel;
int QccChannelInitialize(QccChannel *channel);
int QccChannelAlloc(QccChannel *channel);
void QccChannelFree(QccChannel *channel);
int QccChannelGetBlockSize(const QccChannel *channel);
int QccChannelPrint(const QccChannel *channel);
int QccChannelReadWholefile(QccChannel *channel);
int QccChannelReadHeader(QccChannel *channel);
int QccChannelStartRead(QccChannel *channel);
int QccChannelEndRead(QccChannel *channel);
int QccChannelReadBlock(QccChannel *channel);
int QccChannelWriteWholefile(QccChannel *channel);
int QccChannelWriteHeader(QccChannel *channel);
int QccChannelStartWrite(QccChannel *channel);
int QccChannelEndWrite(QccChannel *channel);
int QccChannelWriteBlock(QccChannel *channel);
int QccChannelNormalize(QccChannel *channel);
int QccChannelDenormalize(QccChannel *channel);
int QccChannelGetNumNullSymbols(const QccChannel *channel);
int QccChannelRemoveNullSymbols(QccChannel *channel);
double QccChannelEntropy(const QccChannel *channel, int order);
int QccChannelAddSymbolToChannel(QccChannel *channel, int symbol);

/*  Link in other header files  */
#include "libQccPackENT.h"
#include "libQccPackECC.h"
#include "libQccPackSQ.h"
#include "libQccPackVQ.h"
#include "libQccPackAVQ.h"
#include "libQccPackIMG.h"
#include "libQccPackWAV.h"
#include "libQccPackVID.h"
#include "libQccPackHYP.h"

/*  Optional modules  */
#ifdef HAVE_SPIHT
#include "libQccPackSPIHT.h"
#endif
#ifdef HAVE_SPECK
#include "libQccPackSPECK.h"
#endif


#endif /* LIBQCCPACK_H */