file.c

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

int QccFileFlush(FILE *fileptr)
{
  if (fflush(fileptr))
    {
      QccErrorAddMessage("(QccFileFlush): Error flushing file");
      return(1);
    }

  return(0);
}


int QccFileRemove(const QccString filename)
{
  if (filename == NULL)
    return(0);

  if (remove(filename) < 0)
    {
      QccErrorAddMessage("(QccFileRemove): Error removing %s", filename);
      return(1);
    }

  return(0);
}


int QccFileGetSize(const QccString filename, FILE *fileptr,
                   long *filesize)
{
  struct stat statbuf;

  if ((filename == NULL) && (fileptr == NULL))
    return(0);
  if (filesize == NULL)
    return(0);

  if (filename == NULL)
    {
      if (QccFileGetPipeType(fileptr) == QCCFILE_PIPETRUE)
        {
          QccErrorAddMessage("(QccFileGetSize): cannot determine size of compressed file from fileptr");
          return(1);
        }
      if (fstat(fileno(fileptr), &statbuf))
        {
          QccErrorAddMessage("(QccFileGetSize): file not found");
          return(1);
        }
    }
  else
    if (stat(filename, &statbuf))
      {
        QccErrorAddMessage("(QccFileGetSize): file %s not found", filename);
        return(1);
      }
  
  *filesize = statbuf.st_size;

  return(0);
}


int QccFileGetModTime(const QccString filename, FILE *fileptr,
                      long *modtime)
{
  struct stat statbuf;

  if ((filename == NULL) && (fileptr == NULL))
    return(0);
  if (modtime == NULL)
    return(0);

  if (filename == NULL)
    {
      if (QccFileGetPipeType(fileptr) == QCCFILE_PIPETRUE)
        {
          QccErrorAddMessage("(QccFileGetModTime): cannot determine modtime of compressed file from fileptr");
          return(1);
        }
      if (fstat(fileno(fileptr), &statbuf))
        {
          QccErrorAddMessage("(QccFileGetModTime): file not found");
          return(1);
        }
    }
  else
    if (stat(filename, &statbuf))
      {
        QccErrorAddMessage("(QccFileGetModTime): file %s not found", filename);
        return(1);
      }
  
  *modtime = statbuf.st_mtime;

  return(0);
}


int QccFileGetCurrentPosition(FILE *infile, long *current_position)
{
  if (infile == NULL)
    return(0);
  if (current_position == NULL)
    return(0);

  if (QccFileGetPipeType(infile) == QCCFILE_PIPETRUE)
    {
      QccErrorAddMessage("(QccFileGetCurrentPosition): cannot determine position of compressed file");
      return(1);
    }

  *current_position = ftell(infile);
  if (ferror(infile))
    {
      QccErrorAddMessage("(QccFileGetCurrentPosition): error accessing file");
      return(1);
    }

  return(0);
}


int QccFileReadChar(FILE *infile, char *val)
{
  int read_val;

  if (infile == NULL)
    return(0);

  read_val = fgetc(infile);
  if (val != NULL)
    *val = (char)read_val;

  return(ferror(infile) || feof(infile));
}


int QccFileWriteChar(FILE *outfile, char val)
{
  if (outfile == NULL)
    return(0);

  fputc((int)val, outfile);
  return(ferror(outfile));
}


int QccFileReadInt(FILE *infile, int *val)
{
  unsigned char ch[QCC_INT_SIZE];

  if (infile == NULL)
    return(0);

  fread(ch, 1, QCC_INT_SIZE, infile);
  if (ferror(infile) || feof(infile))
    return(1);

  if (val != NULL)
    QccBinaryCharToInt(ch, (unsigned int *)val);

  return(0);
}


int QccFileWriteInt(FILE *outfile, int val)
{
  unsigned char ch[QCC_INT_SIZE];

  if (outfile == NULL)
    return(0);

  QccBinaryIntToChar((unsigned int)val, ch);

  fwrite(ch, 1, QCC_INT_SIZE, outfile);

  return(ferror(outfile));
}


int QccFileReadDouble(FILE *infile, double *val)
{
  unsigned char ch[QCC_INT_SIZE];
  float tmp;

  if (infile == NULL)
    return(0);

  fread(ch, 1, QCC_INT_SIZE, infile);
  if (ferror(infile) || feof(infile))
    return(1);

  if (val != NULL)
    {
      QccBinaryCharToFloat(ch, &tmp);
      
      if (val != NULL)
        *val = tmp;
    }

  return(0);
}


int QccFileWriteDouble(FILE *outfile, double val)
{
  unsigned char ch[QCC_INT_SIZE];
  float tmp;

  if (outfile == NULL)
    return(0);

  tmp = val;
  QccBinaryFloatToChar(tmp, ch);
  fwrite(ch, 1, QCC_INT_SIZE, outfile);
  return(ferror(outfile));

}


int QccFileReadString(FILE *infile, QccString s)
{
  QccString cmd;

  if (infile == NULL)
    return(0);

  if (s == NULL)
    return(0);

  QccStringSprintf(cmd, "%%%ds", QCCSTRINGLEN);
  fscanf(infile, cmd, s);

  return(ferror(infile) || feof(infile));
}


int QccFileWriteString(FILE *outfile, const QccString s)
{
  if (outfile == NULL)
    return(0);

  if (s == NULL)
    return(0);

  fprintf(outfile, "%s", s);

  return(ferror(outfile));
}


static int QccFileSkipComment(FILE *infile)
{
  unsigned char ch;

  if (infile == NULL)
    return(0);

  do
    {
      ch = fgetc(infile);
      if (ferror(infile))
        return(1);
    }
  while (ch != '\n');

  ungetc(ch, infile);

  return(0);
}


int QccFileSkipWhiteSpace(FILE *infile, int skip_comments_flag)
{
  unsigned char ch;

  if (infile == NULL)
    return(0);

  do
    {
      ch = fgetc(infile);
      if (ferror(infile))
        return(1);

      if (((ch == '#') || (ch == '*') || (ch == '/'))
          && skip_comments_flag)
        {
          if (QccFileSkipComment(infile))
            return(1);
          ch = fgetc(infile);
          if (ferror(infile))
            return(1);
        }
    }
  while ((ch == ' ') || (ch == '\n') || (ch == '\t') || (ch == '\r'));

  ungetc(ch, infile);
  return(0);

}


int QccFileReadMagicNumber(FILE *infile, QccString magic_num,
                           int *major_version_number,
                           int *minor_version_number)
{
  QccString header_value;
  int major, minor;

  if (infile == NULL)
    return(0);

  if (magic_num == NULL)
    return(1);

  if (QccFileReadString(infile, header_value))
    return(1);
  if (QccFileSkipWhiteSpace(infile, 1))
    return(1);

  sscanf(header_value, "%[^0-9]%d.%d", magic_num, &major, &minor);

  if (major_version_number != NULL)
    *major_version_number = major;
  if (minor_version_number != NULL)
    *minor_version_number = minor;

  return(0);
}


int QccFileWriteMagicNumber(FILE *outfile, const QccString magic_num)
{
  QccString header_value;
  int major;
  int minor;

  if (outfile == NULL)
    return(0);

  QccGetQccPackVersion(&major, &minor, NULL);

  QccStringSprintf(header_value, "%s%d.%d\n",
          magic_num, major, minor);

  if (QccFileWriteString(outfile, header_value))
    {
      QccErrorAddMessage("(QccFileWriteMagicNumber): Error writing magic number");
      goto QccErr;
    }

  return(0);

 QccErr:
  return(1);
}


int QccFileGetMagicNumber(const QccString filename, QccString magic_num)
{
  FILE *infile;

  if (filename == NULL)
    return(0);
  if (magic_num == NULL)
    return (0);

  if ((infile = QccFileOpen(filename, "r")) == NULL)
    {
      QccErrorAddMessage("(QccFileGetMagicNumber): Error opening %s for reading",
                         filename);
      return(1);
    }
  
  if (QccFileReadMagicNumber(infile, magic_num,
                             NULL, NULL))
    {
      QccErrorAddMessage("(QccFileGetMagicNumber): Error reading magic number of %s",
                         filename);
      return(1);
    }
  
  QccFileClose(infile);
  
  return(0);
}


int QccFilePrintFileInfo(const QccString filename,
                         const QccString magic_num,
                         int major_version,
                         int minor_version)
{
  long filesize, modtime;
  char *modtime_string;

  printf("---------------------------------------------------------------------------\n\n");

  if (filename != NULL)
    if (strlen(filename))
      printf("   File: %s\n", filename);

  if (magic_num != NULL)
    if (strlen(magic_num))
      {
        printf("   Format: %s (", magic_num);

        if (!strcmp(magic_num, QCCDATASET_MAGICNUM))
          printf("dataset");
        else if (!strcmp(magic_num, QCCCHANNEL_MAGICNUM))
          printf("channel");
        else if (!strcmp(magic_num, QCCSQSCALARQUANTIZER_MAGICNUM))
          printf("scalar quantizer");
        else if (!strcmp(magic_num, QCCVQCODEBOOK_MAGICNUM))
          printf("VQ codebook");
        else if (!strcmp(magic_num, QCCVQMULTISTAGECODEBOOK_MAGICNUM))
          printf("Multistage/Residual VQ codebook");
        else if (!strcmp(magic_num, QCCAVQSIDEINFO_MAGICNUM))
          printf("side information");
        else if (!strcmp(magic_num, QCCIMGIMAGECOMPONENT_MAGICNUM))
          printf("image component");
        else if (!strcmp(magic_num, QCCIMGIMAGECUBE_MAGICNUM))
          printf("3D image cube");
        else if (!strcmp(magic_num, QCCWAVFILTERBANK_MAGICNUM))
          printf("wavelet filter bank");
        else if (!strcmp(magic_num, QCCWAVVECTORFILTERBANK_MAGICNUM))
          printf("vector wavelet filter bank");
        else if (!strcmp(magic_num, QCCWAVLIFTINGSCHEME_MAGICNUM))
          printf("wavelet lifting scheme");
        else if (!strcmp(magic_num, QCCWAVPERCEPTUALWEIGHTS_MAGICNUM))
          printf("perceptual weights");
        else if (!strcmp(magic_num, QCCWAVSUBBANDPYRAMID_MAGICNUM))
          printf("subband pyramid");
        else if (!strcmp(magic_num, QCCWAVSUBBANDPYRAMIDINT_MAGICNUM))
          printf("integer-valued subband pyramid");
        else if (!strcmp(magic_num, QCCWAVSUBBANDPYRAMID3D_MAGICNUM))
          printf("3D subband pyramid");
        else if (!strcmp(magic_num, QCCWAVSUBBANDPYRAMID3DINT_MAGICNUM))
          printf("integer-valued 3D subband pyramid");
        else if (!strcmp(magic_num, QCCWAVZEROTREE_MAGICNUM))
          printf("zerotree");
        else if (!strcmp(magic_num, QCCHYPKLT_MAGICNUM))
          printf("KLT transform matrix");
        else
          printf("?");

        printf(")\n");
      }

  if ((major_version >= 0) && (minor_version >= 0))
    printf("   Created by: QccPack Version %d.%d\n",
           major_version, minor_version);

  if (QccFileExists(filename))
    {
      QccFileGetSize(filename, NULL, &filesize);
      QccFileGetModTime(filename, NULL, &modtime);
      modtime_string = ctime((time_t *)(&modtime));
      printf("   Time: %s", modtime_string);
      printf("   Size: %ld bytes\n", filesize);
    }

  printf("\n---------------------------------------------------------------------------\n\n");

  return(0);
}