file_io.c

VQ压缩算法

#include <stdio.h>
#include <stdlib.h>
#include "vq_model.h"
#define MaxLen 2048        /* temp buffer length */

/*-------------------------------------------------------------*/
int scan_file(FILE *datafile, Info_Type *DataInfo) {

   int Len, Class, Dim;
   int VecCnt, Cnt;
   int FindFlag, TotalClass = 0;
   char Vector[MaxLen], Ch;

   do {

       fscanf(datafile, "%d %d %d\n", &Len, &Class, &Dim);

       /*---------------------*/
       /* find existing class */
       /*---------------------*/
       FindFlag = 0;
       for (Cnt=0; Cnt<TotalClass; Cnt++)
	  if (DataInfo[Cnt].ID == Class) {
	     FindFlag = 1;
	     break;
	  }

       if (FindFlag) {
	  if (DataInfo[Cnt].VecDim != Dim) {
	     fprintf (stderr, "inconsistent dimension in data file\n");
	     exit(-1);
	  }
	  DataInfo[Cnt].VecNum += Len;
       }
       else {                           /* new class */
	  DataInfo[TotalClass].VecNum = Len;
	  DataInfo[TotalClass].VecDim = Dim;
	  DataInfo[TotalClass].ID = Class;
	  TotalClass++;
       }

       /*-----------------------------*/
       /* ignore following vectors    */
       /*-----------------------------*/
       for (VecCnt=0; VecCnt<Len; VecCnt++) {
	 fgets(Vector, MaxLen, datafile);
       }

       Ch = fgetc(datafile);
       ungetc(Ch, datafile);
   } while (!feof(datafile) );

   return (TotalClass);
};

/*-------------------------------------------------------------*/
int load_data(FILE *datafile, DType *DataHead, int TotalClass) {

   int TotalVector=0;
   int ClassCnt, VecCnt, DimCnt;
   int Len, Class, Dim;
   int *CurrLen;
   float TmpFloat;
   char Ch;

   MArray_1D(CurrLen, TotalClass, int, "CurrLen");

   do {

       fscanf(datafile, "%d %d %d\n", &Len, &Class, &Dim);
       TotalVector += Len;

       /*---------------------*/
       /* find existing class */
       /*---------------------*/
       for (ClassCnt=0; ClassCnt<TotalClass; ClassCnt++)
	  if (DataHead[ClassCnt].ID == Class) break;

       if (ClassCnt == TotalClass) {
	 fprintf (stderr, "ERROR: wrong data/code file!\n");
	 exit(-1);
       }
       /*----------------------------*/
       /* load data of this pattern  */
       /*----------------------------*/
       for (VecCnt=0; VecCnt<Len; VecCnt++) {
	 for (DimCnt=0; DimCnt<Dim; DimCnt++) {
	   fscanf(datafile, "%f ", &TmpFloat);
	   DataHead[ClassCnt].Mat[ CurrLen[ClassCnt] ][DimCnt] = TmpFloat;
	 }
	 fscanf(datafile, "\n");

	 CurrLen[ClassCnt]++;
       }      /* for (VecCnt) */

       Ch = fgetc(datafile);
       ungetc(Ch, datafile);
   } while (!feof(datafile) );


   /*----------------------------------------*/
   /* verifying the number of loaded vectors */
   /*----------------------------------------*/
   for (ClassCnt=0; ClassCnt<TotalClass; ClassCnt++) {
     if (CurrLen[ClassCnt] != DataHead[ClassCnt].VecNum)
	fprintf (stderr, "Warning: not all data loaded!\n");
   }

   MFree_1D(CurrLen);
   return(TotalVector);

};


/*-------------------------------------------------------------*/
void save_code(FILE *codefile, DType *CodeHead, int TotalClass) {

   int ClassCnt, VecCnt, DimCnt;

   for (ClassCnt=0; ClassCnt<TotalClass; ClassCnt++) {

       fprintf(codefile, "%d %d %d\n", CodeHead[ClassCnt].VecNum,
	   CodeHead[ClassCnt].ID, CodeHead[ClassCnt].VecDim);

       for (VecCnt=0; VecCnt<CodeHead[ClassCnt].VecNum; VecCnt++) {
	 for (DimCnt=0; DimCnt<CodeHead[ClassCnt].VecDim; DimCnt++)
	   fprintf(codefile, "%7.4f ", CodeHead[ClassCnt].Mat[VecCnt][DimCnt]);

	 fprintf(codefile, "\n");
       }      /* for (VecCnt) */

   }          /* for (ClassCnt) */

};


/*-------------------------------------------------------------*/
DType *load_codebook(FILE *codefile) {

    DType *CodeHead = NULL, *CodeCurr, *CodeEnd;
    int Len, ClassID, Dim;
    int VecCnt, DimCnt;
    float TmpFloat;
    char Ch;


    do {

       fscanf(codefile, "%d %d %d\n", &Len, &ClassID, &Dim);
       MArray_1D(CodeCurr, 1, DType, "CodeCurr");
       CodeCurr->ID     = ClassID;
       CodeCurr->VecNum = Len;
       CodeCurr->VecDim = Dim;
       CodeCurr->Next   = NULL;
       MArray_2D(CodeCurr->Mat, Len, Dim, float, "CodeCurr->Mat");

       /*----------------------------*/
       /* load data of this pattern  */
       /*----------------------------*/
       for (VecCnt=0; VecCnt<Len; VecCnt++) {
	 for (DimCnt=0; DimCnt<Dim; DimCnt++) {
	   fscanf(codefile, "%f ", &TmpFloat);
	   CodeCurr->Mat[VecCnt][DimCnt] = TmpFloat;
	 }
	 fscanf(codefile, "\n");
       }      /* for (VecCnt) */

       /*------------------------------------------*/
       /* Link this model to the list              */
       /*------------------------------------------*/
       if (CodeHead == NULL) {          /* first model */
	  CodeHead   = CodeCurr;
	  CodeEnd    = CodeCurr;
       }
       else {         /* add pattern to the link list */
	  CodeEnd->Next  = CodeCurr;
	  CodeEnd        = CodeCurr;
       }

       Ch = fgetc(codefile);
       ungetc(Ch, codefile);
   } while (!feof(codefile) );

   return (CodeHead);
}