libqccpackimg.h

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

int QccIMGImageCubeAlloc(QccIMGImageCube *image_cube);
void QccIMGImageCubeFree(QccIMGImageCube *image_cube);
int QccIMGImageCubePrint(const QccIMGImageCube *image_cube);
int QccIMGImageCubeSetMin(QccIMGImageCube *image_cube);
int QccIMGImageCubeSetMax(QccIMGImageCube *image_cube);
int QccIMGImageCubeSetMaxMin(QccIMGImageCube *image_cube);
int QccIMGImageCubeResize(QccIMGImageCube *image_cube,
                          int num_frames,
                          int num_rows,
                          int num_cols);
int QccIMGImageCubeRead(QccIMGImageCube *image_cube);
int QccIMGImageCubeWrite(const QccIMGImageCube *image_cube);
int QccIMGImageCubeClip(QccIMGImageCube *image_cube);
int QccIMGImageCubeNormalize(QccIMGImageCube *image_cube,
                             double upper_bound,
                             double lower_bound);
int QccIMGImageCubeAbsoluteValue(QccIMGImageCube *image_cube);
double QccIMGImageCubeMean(const QccIMGImageCube *image_cube);
double QccIMGImageCubeShapeAdaptiveMean(const QccIMGImageCube *image_cube,
                                        const QccIMGImageCube *alpha_mask);
double QccIMGImageCubeVariance(const QccIMGImageCube *image_cube);
double QccIMGImageCubeShapeAdaptiveVariance(const QccIMGImageCube *image_cube,
                                            const QccIMGImageCube *alpha_mask);
int QccIMGImageCubeSubtractMean(QccIMGImageCube *image_cube,
                                double *mean,
                                const QccSQScalarQuantizer *quantizer);
int QccIMGImageCubeAddMean(QccIMGImageCube *image_cube,
                           double mean);
double QccIMGImageCubeMSE(const QccIMGImageCube *image_cube1,
                          const QccIMGImageCube *image_cube2);
double QccIMGImageCubeShapeAdaptiveMSE(const QccIMGImageCube *image_cube1,
                                       const QccIMGImageCube *image_cube2,
                                       const QccIMGImageCube *alpha_mask);
double QccIMGImageCubeMAE(const QccIMGImageCube *image_cube1,
                          const QccIMGImageCube *image_cube2);
double QccIMGImageCubeShapeAdaptiveMAE(const QccIMGImageCube *image_cube1,
                                       const QccIMGImageCube *image_cube2,
                                       const QccIMGImageCube *alpha_mask);
int QccIMGImageCubeExtractBlock(const QccIMGImageCube *image_cube,
                                int image_frame,
                                int image_row,
                                int image_col,
                                QccVolume block,
                                int block_num_frames,
                                int block_num_rows,
                                int block_num_cols);
int QccIMGImageCubeInsertBlock(QccIMGImageCube *image_cube,
                               int image_frame,
                               int image_row,
                               int image_col,
                               const QccVolume block,
                               int block_num_frames,
                               int block_num_rows,
                               int block_num_cols);
int QccIMGImageCubeCopy(QccIMGImageCube *image_cube1,
                        const QccIMGImageCube *image_cube2);
int QccIMGImageCubeAdd(const QccIMGImageCube *image_cube1,
                       const QccIMGImageCube *image_cube2,
                       QccIMGImageCube *image_cube3);
int QccIMGImageCubeSubtract(const QccIMGImageCube *image_cube1,
                            const QccIMGImageCube *image_cube2,
                            QccIMGImageCube *image_cube3);
int QccIMGImageCubeExtractFrame(const QccIMGImageCube *image_cube,
                                int frame,
                                QccIMGImageComponent *image_component);


/*  image_sequence.c  */
typedef struct
{
  QccString filename;
  int start_frame_num;
  int end_frame_num;
  int current_frame_num;
  QccString current_filename;
  QccIMGImage current_frame;
} QccIMGImageSequence;
int QccIMGImageSequenceInitialize(QccIMGImageSequence *image_sequence);
int QccIMGImageSequenceAlloc(QccIMGImageSequence *image_sequence);
void QccIMGImageSequenceFree(QccIMGImageSequence *image_sequence);
int QccIMGImageSequenceLength(const QccIMGImageSequence *image_sequence);
int QccIMGImageSequenceSetCurrentFilename(QccIMGImageSequence *image_sequence);
int QccIMGImageSequenceIncrementFrameNum(QccIMGImageSequence *image_sequence);
int QccIMGImageSequenceFindFrameNums(QccIMGImageSequence *image_sequence);
int QccIMGImageSequenceReadFrame(QccIMGImageSequence *image_sequence);
int QccIMGImageSequenceWriteFrame(QccIMGImageSequence *image_sequence);
int QccIMGImageSequenceStartRead(QccIMGImageSequence *image_sequence);


/*  image_filter.c  */
int QccIMGImageComponentFilterSeparable(const
                                        QccIMGImageComponent *input_image,
                                        QccIMGImageComponent *output_image,
                                        const QccFilter *horizontal_filter,
                                        const QccFilter *vertical_filter,
                                        int boundary_extension);
int QccIMGImageFilterSeparable(const QccIMGImage *input_image,
                               QccIMGImage *output_image,
                               const QccFilter *horizontal_filter,
                               const QccFilter *vertical_filter,
                               int boundary_extension);
int QccIMGImageComponentFilter2D(const QccIMGImageComponent *input_image,
                                 QccIMGImageComponent *output_image,
                                 const QccIMGImageComponent *filter);
int QccIMGImageFilter2D(const QccIMGImage *input_image,
                        QccIMGImage *output_image,
                        const QccIMGImageComponent *filter);


/*  image_dpcm.c  */
#define QCCIMGPREDICTOR_NUMPREDICTORS 6
int QccIMGImageComponentDPCMEncode(const QccIMGImageComponent *image_component,
                                   const QccSQScalarQuantizer *quantizer,
                                   double out_of_bound_value,
                                   int predictor_code,
                                   QccIMGImageComponent *difference_image,
                                   QccChannel *channel);
int QccIMGImageComponentDPCMDecode(QccChannel *channel,
                                   const QccSQScalarQuantizer *quantizer,
                                   double out_of_bound_value,
                                   int predictor_code,
                                   QccIMGImageComponent *image_component);
int QccIMGImageDPCMEncode(const QccIMGImage *image,
                          const QccSQScalarQuantizer *quantizers,
                          const QccVector out_of_bound_values,
                          int predictor_code,
                          QccIMGImage *difference_image,
                          QccChannel *channels);
int QccIMGImageDPCMDecode(QccChannel *channels,
                          const QccSQScalarQuantizer *quantizers,
                          const QccVector out_of_bound_values,
                          int predictor_code,
                          QccIMGImage *image);


/*  image_sq.c  */
int QccIMGImageComponentScalarQuantize(const
                                       QccIMGImageComponent *image_component,
                                       const QccSQScalarQuantizer *quantizer,
                                       QccVector distortion,
                                       QccChannel *channel);
int QccIMGImageComponentInverseScalarQuantize(const QccChannel *channel,
                                              const
                                              QccSQScalarQuantizer *quantizer,
                                              QccIMGImageComponent 
                                              *image_component);
int QccIMGImageScalarQuantize(const QccIMGImage *image,
                              const QccSQScalarQuantizer *quantizers,
                              QccChannel *channels);
int QccIMGImageInverseScalarQuantize(const QccChannel *channels,
                                     const QccSQScalarQuantizer *quantizers,
                                     QccIMGImage *image);


/*  image_dct.c  */
int QccIMGImageComponentDCT(const QccIMGImageComponent *input_component,
                            QccIMGImageComponent *output_component,
                            int block_num_rows,
                            int block_num_cols);
int QccIMGImageComponentInverseDCT(const QccIMGImageComponent *input_component,
                                   QccIMGImageComponent *output_component,
                                   int block_num_rows,
                                   int block_num_cols);
int QccIMGImageDCT(const QccIMGImage *input_image,
                   QccIMGImage *output_image,
                   int block_num_rows,
                   int block_num_cols);
int QccIMGImageInverseDCT(const QccIMGImage *input_image,
                          QccIMGImage *output_image,
                          int block_num_rows,
                          int block_num_cols);


/*  image_lbt.c  */
int QccIMGImageComponentLBT(const QccIMGImageComponent *image1,
                            QccIMGImageComponent *image2,
                            int overlap_sample,
                            int block_size,
                            double smooth_factor);
int QccIMGImageComponentInverseLBT(const QccIMGImageComponent *image1,
                                   QccIMGImageComponent *image2,
                                   int overlap_sample,
                                   int block_size,
                                   double smooth_factor);


/*  icpdat.c  */
int QccIMGImageComponentToDataset(const QccIMGImageComponent *image_component, 
                                  QccDataset *dataset,
                                  int tile_num_rows, 
                                  int tile_num_cols);
int QccIMGDatasetToImageComponent(QccIMGImageComponent *image_component,
                                  const QccDataset *dataset,
                                  int tile_num_rows,
                                  int tile_num_cols);


/*  seqicb.c  */
int QccIMGImageSequenceToImageCube(QccIMGImageSequence *image_sequence,
                                   QccIMGImageCube *image_cube);
int QccIMGImageCubeToImageSequence(const QccIMGImageCube *image_cube,
                                   QccIMGImageSequence *image_sequence);


/*  image_deinterlace  */
int QccIMGImageComponentDeinterlace(const
                                    QccIMGImageComponent *input_component,
                                    QccIMGImageComponent *output_component1,
                                    QccIMGImageComponent *output_component2);
int QccIMGImageDeinterlace(const QccIMGImage *input_image, 
                           QccIMGImage *output_image1,
                           QccIMGImage *output_image2);
int QccIMGImageSequenceDeinterlace(QccIMGImageSequence *input_sequence,
                                   QccIMGImageSequence *output_sequence,
                                   int supersample);


#endif /* LIBQCCPACKIMG_H */