codebook.c

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

    codebook->index_length = 
      (int)(log((double)codebook->num_codewords)/log(2.0) + 0.5);
  else
    codebook->index_length = 0;
  
  return(0);
}


int QccVQCodebookReadHeader(FILE *infile, QccVQCodebook *codebook)
{
  
  if ((infile == NULL) || (codebook == NULL))
    return(0);
  
  if (QccFileReadMagicNumber(infile,
                             codebook->magic_num,
                             &codebook->major_version,
                             &codebook->minor_version))
    {
      QccErrorAddMessage("(QccVQCodebookReadHeader): Error calling QccFileReadMagicNumber()");
      return(1);
    }
  
  if (strcmp(codebook->magic_num, QCCVQCODEBOOK_MAGICNUM))
    {
      QccErrorAddMessage("(QccVQCodebookReadHeader): %s is not of codebook (%s) type",
                         codebook->filename, QCCVQCODEBOOK_MAGICNUM);
      return(1);
    }
  
  fscanf(infile, "%d", &(codebook->num_codewords));
  if (ferror(infile) || feof(infile))
    {
      QccErrorAddMessage("(QccVQCodebookReadHeader): Error reading number of codewords in codebook %s",
                         codebook->filename);
      return(1);
    }
  
  if (QccFileSkipWhiteSpace(infile, 0))
    {
      QccErrorAddMessage("(QccVQCodebookReadHeader): Error reading codeword dimension in codebook %s",
                         codebook->filename);
      return(1);
    }
  fscanf(infile, "%d%*1[\n]", &(codebook->codeword_dimension));
  if (ferror(infile) || feof(infile))
    {
      QccErrorAddMessage("(QccVQCodebookReadHeader): Error reading codeword dimension in codebook %s",
                         codebook->filename);
      return(1);
    }
  
  return(0);
}


int QccVQCodebookReadData(FILE *infile, QccVQCodebook *codebook)
{
  int codeword, component;
  
  if ((infile == NULL) || (codebook == NULL))
    return(0);
  
  if (QccVQCodebookAlloc(codebook))
    {
      QccErrorAddMessage("(QccVQCodebookReadData): Error calling QccVQCodebookAlloc()");
      return(1);
    }

  QccVQCodebookSetIndexLength(codebook);

  for (codeword = 0; codeword < codebook->num_codewords; codeword++)
    for (component = 0; component < codebook->codeword_dimension; component++)
      if (QccFileReadDouble(infile,
                            &(codebook->codewords[codeword][component])))
        {
          QccErrorAddMessage("(QccVQCodebookReadData): Error calling QccFileReadDouble()");
          return(1);
        }
  for (codeword = 0; codeword < codebook->num_codewords; codeword++)
    if (QccFileReadDouble(infile,
                          &(codebook->codeword_probs[codeword])))
      {
        QccErrorAddMessage("(QccVQCodebookReadData): Error calling QccFileReadDouble()");
        return(1);
      }
  
  if (QccVQCodebookSetCodewordLengths(codebook))
    {
      QccErrorAddMessage("(QccVQCodebookReadData): Error calling QccVQCodebookSetCodewordLengths()");
      return(1);
    }
  
  return(0);
}


int QccVQCodebookRead(QccVQCodebook *codebook)
{
  FILE *infile = NULL;
  
  if (codebook == NULL)
    return(0);
  
  if ((infile = QccFileOpen(codebook->filename, "r")) == NULL)
    {
      QccErrorAddMessage("(QccVQCodebookRead): Error calling QccFileOpen()");
      return(1);
    }
  
  if (QccVQCodebookReadHeader(infile, codebook))
    {
      QccErrorAddMessage("(QccVQCodebookRead): Error calling QccVQCodebookReadHeader()");
      return(1);
    }
  
  if (QccVQCodebookReadData(infile, codebook))
    {
      QccErrorAddMessage("(QccVQCodebookRead): Error calling QccVQCodebookReadData()");
      return(1);
    }
  
  QccFileClose(infile);
  return(0);
}


int QccVQCodebookWriteHeader(FILE *outfile, const QccVQCodebook *codebook)
{
  if ((outfile == NULL) || (codebook == NULL))
    return(0);
  
  if (QccFileWriteMagicNumber(outfile, QCCVQCODEBOOK_MAGICNUM))
    goto Error;

  fprintf(outfile, "%d %d\n",
          codebook->num_codewords,
          codebook->codeword_dimension);
  if (ferror(outfile))
    goto Error;
  
  return(0);

 Error:
  QccErrorAddMessage("(QccVQCodebookWriteHeader): Error writing header to %s",
                     codebook->filename);
  return(1);
  
}


int QccVQCodebookWriteData(FILE *outfile, const QccVQCodebook *codebook)
{
  int codeword, component;
  
  if ((outfile == NULL) || (codebook == NULL))
    return(0);
  
  for (codeword = 0; codeword < codebook->num_codewords; codeword++)
    {
      for (component = 0; component < codebook->codeword_dimension; 
           component++)
        if (QccFileWriteDouble(outfile,
                               codebook->codewords[codeword][component]))
          {
            QccErrorAddMessage("(QccVQCodebookWriteData): Error writing data to %s",
                               codebook->filename);
            return(1);
          }
    }
  
  for (codeword = 0; codeword < codebook->num_codewords; codeword++)
    if (QccFileWriteDouble(outfile,
                           codebook->codeword_probs[codeword]))
      {
        QccErrorAddMessage("(QccVQCodebookWrite): Error writing data to %s",
                           codebook->filename);
        return(1);
      }
  
  return(0);
}


int QccVQCodebookWrite(const QccVQCodebook *codebook)
{
  FILE *outfile;
  
  if (codebook == NULL)
    return(0);
  
  if ((outfile = QccFileOpen(codebook->filename, "w")) == NULL)
    {
      QccErrorAddMessage("(QccVQCodebookWrite): Error calling QccFileOpen()");
      return(1);
    }
  
  if (QccVQCodebookWriteHeader(outfile, codebook))
    {
      QccErrorAddMessage("(QccVQCodebookWrite): Error calling QccVQCodebookWriteHeader()");
      return(1);
    }
  
  if (QccVQCodebookWriteData(outfile, codebook))
    {
      QccErrorAddMessage("(QccVQCodebookWrite): Error calling QccVQCodebookWriteData()");
      return(1);
    }
  
  QccFileClose(outfile);
  return(0);
}


int QccVQCodebookPrint(const QccVQCodebook *codebook)
{
  int component, codeword;
  
  if (codebook == NULL)
    return(0);
  
  if (QccFilePrintFileInfo(codebook->filename,
                           codebook->magic_num,
                           codebook->major_version,
                           codebook->minor_version))
    return(1);

  printf("Num of codewords: %d\n", codebook->num_codewords);
  printf("Codeword dimension: %d\n\n", codebook->codeword_dimension);
  
  if (!codebook->num_codewords)
    return(0);

  printf("Index\tProb\tCodeword\n\n");
  
  for (codeword = 0; codeword < codebook->num_codewords; codeword++)
    {
      printf("%4d\t%.3f\t", codeword, codebook->codeword_probs[codeword]);
      for (component = 0; component < codebook->codeword_dimension; 
           component++)
        printf("% 10.4f ", codebook->codewords[codeword][component]);
      printf("\n");
    }
  
  return(0);
}


int QccVQCodebookCreateRandomCodebook(QccVQCodebook *codebook, 
                                      double max, double min)
{
  int codeword, component;
  
  if (codebook == NULL)
    return(0);
  
  if (QccVQCodebookAlloc(codebook))
    {
      QccErrorAddMessage("(QccVQCodebookCreateRandomCodebook): Error calling QccVQCodebookAlloc()");
      return(1);
    }
  
  for (codeword = 0; codeword < codebook->num_codewords; codeword++)
    for (component = 0; component < codebook->codeword_dimension; component++)
      {
        codebook->codewords[codeword][component] =
          QccMathRand()*(max - min) + min;
        codebook->codeword_probs[codeword] = 
          1.0/(double)codebook->num_codewords;
      }
  
  if (QccVQCodebookSetCodewordLengths(codebook))
    {
      QccErrorAddMessage("(QccVQCodebookCreateRandomCodebook): Error calling QccVQCodebookSetCodewordLengths()");
      return(1);
    }
  
  return(0);
}


int QccVQCodebookAddCodeword(QccVQCodebook *codebook,
                             QccVQCodeword codeword)
{

  if (codebook == NULL)
    return(0);
  if (codeword == NULL)
    return(0);

  if (codebook->num_codewords > 0)
    {
      if (QccVQCodebookRealloc(codebook,
                               codebook->num_codewords + 1))
        {
          QccErrorAddMessage("(QccVQCodebookAddCodeword): Error calling QccVQCodebookRealloc()");
          return(1);
        }
    }
  else
    {
      codebook->num_codewords++;
      if (QccVQCodebookAlloc(codebook))
        {
          QccErrorAddMessage("(QccVQCodebookAddCodeword): Error calling QccVQCodebookAlloc()");
          return(1);
        }
      codebook->codeword_probs[codebook->num_codewords - 1] = 1.0;
    }

  QccVectorCopy((QccVector)codebook->codewords[codebook->num_codewords - 1],
                (QccVector)codeword, codebook->codeword_dimension);
  QccVQCodebookSetIndexLength(codebook);
  QccVQCodebookSetCodewordLengths(codebook);

  return(0);
}