vm_file_win.c

audio-video-codecs.rar语音编解码器

    LOCK;
    CloseHandle(fd[0].fd);
    UNLOCK;
    /* delete file if temporary file is being closed (according to IEC/ISO specification) */
    if (fd[0].ftemp == VM_TEMPORARY_PREFIX)
        tempfile_delete_by_handle(fd);
    /* return memory, allocated in CreateFile */
    DELETE_VM_FILE(fd);
    rtv = 1;
    }
    return rtv;
  };

Ipp32s vm_file_feof(vm_file* fd) {
  Ipp32s rtv = 0;
  if ((fd != NULL) && (fd[0].fd != INVALID_HANDLE_VALUE)) {
    Ipp64u pos = vm_file_ftell(fd);
    if (pos >= fd[0].fsize)
      rtv = 1;
    }
  return rtv;
  };

Ipp32s vm_file_getinfo(const vm_char *filename, Ipp64u *file_size, Ipp32u *file_attr) {
  Ipp32s rtv = 0;
  WIN32_FILE_ATTRIBUTE_DATA ffi;
  Ipp32s needsize = (file_size != NULL);
  Ipp32s needattr = (file_attr != NULL);
  if (filename && (needsize || needattr)) {
    if (GetFileAttributesEx(filename, GetFileExInfoStandard, &ffi) != 0) {
      if (needattr) {
        file_attr[0]+=(ffi.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) ? VM_FILE_ATTR_HIDDEN : 0;
        file_attr[0]+=(ffi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? VM_FILE_ATTR_DIRECTORY : 0;
        file_attr[0]+=(ffi.dwFileAttributes & FILE_ATTRIBUTE_NORMAL) ? VM_FILE_ATTR_FILE : 0;
        }
      if (needsize) {
        file_size[0] = ffi.nFileSizeHigh; // two steps to avoid 32 to 32 shift problem
        file_size[0] = ffi.nFileSizeLow + ( file_size[0] << 32);
        }
      rtv = 1;
      }
    }
  return rtv;
  };

/*
 * binary file IO */
Ipp32s vm_file_fread(void *buf, Ipp32u itemsz, Ipp32s nitems, vm_file *fd) {
  DWORD nmbread = 0;
  Ipp32s rtv = 0;
  if ((fd != NULL) && (fd[0].fd != INVALID_HANDLE_VALUE)) {
    LOCK;
    rtv = (ReadFile(fd[0].fd, buf, nitems*itemsz, &nmbread, NULL)) ? (nmbread/itemsz) : 0;
    UNLOCK;
    }
  return rtv;
  }

Ipp32s vm_file_fwrite(void *buf, Ipp32u itemsz, Ipp32s nitems, vm_file *fd) {
  DWORD nmbread;
  Ipp32s rtv = 0;
  if ((fd != NULL) && (fd[0].fd != INVALID_HANDLE_VALUE)) {
    LOCK;
    rtv = (WriteFile(fd[0].fd, buf, nitems*itemsz, &nmbread, NULL)) ? (nmbread/itemsz) : 0;
    UNLOCK;
    }
  return rtv;
  }

/*
 * character (string) file IO */
/*
 * read characters from input file until newline found, null character found,
 * nchars rad or EOF reached */
vm_char *vm_file_fgets(vm_char *str, int nchar, vm_file *fd) {
  /* read up to VM_MAX_TEMP_LINE bytes from input file, try
   * to satisfy fgets conditions */
  Ipp64s fpos;
  Ipp32s rdchar, i, j = 0; // j - current position in the output string
  vm_char *rtv = NULL;
  if (fd == vm_stdin)
#ifdef _UNICODE
    return fgetws(str, nchar, stdin);
#else
    return fgets(str, nchar, stdin);
#endif
  else {
    str[0] = str[nchar-1] = 0;
    --nchar;
    if ((fd != NULL) && (fd[0].fd != INVALID_HANDLE_VALUE)) {
      while ((rdchar = vm_file_fread(fd[0].tbuf, 1, VM_MAX_TEMP_LINE, fd)) != 0) {
        for(i = 0; i < rdchar; ++i) {
          str[j] = fd[0].tbuf[i];
          if((str[j]==0) || (str[j]=='\n') || (j >= nchar))
            break;
          ++j;
          }
        if (i < rdchar) { /* one of EOS conditions found */
          if ((str[j] == '\n') && (j < nchar)) /* add null character if possible */
            str[++j] = 0;
          if (str[j-2]=='\r') { /* remove CR from end of line */
            str[j-2]='\n';
            str[j-1]='\0';
            }
          /* return file pointer to the first non-string character */
          ++i; // skip end of line character
          fpos = i - rdchar; // - -- because file pointer will move back
          if (fpos != 0)
            vm_file_fseek(fd, fpos, VM_FILE_SEEK_CUR);
          rtv = str;
          break; // leave while loop
          }
        }
      if((rtv == NULL) && (j != 0) && vm_file_feof(fd)) {
        rtv = str; // end of file during read - input string is valid
        if (j < nchar)
          str[++j] = 0;
        }
      }
    }
  return rtv;
  }

#ifdef _UNICODE
# define FPUTS fputws
#else
# define FPUTS fputs
#endif

Ipp32s vm_file_fputs(vm_char *str, vm_file *fd) {
  if ( fd == vm_stdout )
    return FPUTS(str, stdout);
  else
    if (fd == vm_stderr)
      return FPUTS(str, stderr);
  else
    return (vm_file_fwrite((void *)str, 1, vm_string_strlen(str), fd)==(Ipp32s)vm_string_strlen(str)) ? 1 : -1;
  }

/* parse line, return total number of format specifiers */
Ipp32s fmtline_spcnmb( vm_char *s ) {
  Ipp32s rtv = 0;
  while ( *s )
    if ((*s++ == '%') && (*s != '%'))
      ++rtv;
  return rtv;
  }

Ipp32s vm_file_fscanf(vm_file *fd, vm_char *format, ...) {
  BOOL eol = FALSE;
  Ipp32s rtv = 0;
  Ipp32s nsize = VM_MAX_TEMP_LINE;
  Ipp32s lnoffset = 0;
  vm_char *s = NULL;
  Ipp32s items = 0;
  vm_char *fpt = NULL;
  vm_char *bpt = NULL;
  vm_char *ws = NULL;
  va_list args;
  vm_char tmp = '\0';
  Ipp32u i = 0;
  if ((fd != NULL) && (fd[0].fd != INVALID_HANDLE_VALUE)) {
    /* fscanf always deals with one text line */
    /* text line length is not limited so we have to be ready
     * to receive huge line */
    s = (vm_char *)malloc(VM_MAX_TEMP_LINE);
    do {
      if (s != NULL) {
        if (fd == vm_stdin)
#ifdef _UNICODE
          ws = fgetws(&s[lnoffset], VM_MAX_TEMP_LINE, stdin);
#else
          ws = fgets(&s[lnoffset], VM_MAX_TEMP_LINE, stdin);
#endif
        else
          ws = vm_file_fgets(&s[lnoffset], VM_MAX_TEMP_LINE, fd);
        if ( ws != NULL) {
          if ( (vm_string_strchr((const vm_char *)s, 0) != NULL) ||
              (vm_string_strchr((const vm_char *)s, '\n') != NULL)) {
            /* line complete and ready to scanf */
            items = fmtline_spcnmb( format );
            ws = vm_string_strtok(s, VM_STRING(" ,"));
            /* try to convert all parameters on the step by step basis */
            bpt = fpt = (vm_char *)malloc(vm_string_strlen(format)+16);
            vm_string_strcpy(fpt,format);
            va_start( args, format );
            while(items--) {
              while((*fpt != '%') && (*fpt)) ++fpt;
              tmp = '\0';
              if( items > 0) {
                for(i = 1; (fpt[i] != '\0' && fpt[i] != '\n' &&
                 fpt[i] != ' ' && fpt[i] != '%' && fpt[i] != ','); ++i ) ;
                if ((fpt[i] != '\0') && (fpt[i]!='\n')) {
                  tmp = fpt[i];
                  fpt[i] = '\0';
                  }
                }
              if (*fpt)
                rtv += _stscanf(ws, fpt, va_arg(args, void *));
              else
                items = 0;
              if (items > 0) {
                ws = vm_string_strtok(NULL, VM_STRING(" ,"));
                fpt[i] = tmp;
                ++fpt;
                }
              }
              va_end( args );
            eol = TRUE;
            free(bpt);
            }
          else {
            nsize += VM_MAX_TEMP_LINE;
            lnoffset += VM_MAX_TEMP_LINE;
            s = realloc(s, nsize);
            }
          } else
            eol = TRUE; // read from file problem ?
        }
      } while (!eol);
    free(s);
    }
  return rtv;
  }

/*
 * Error may occur if output string becomes longer than VM_MAX_TEMP_LINE */
Ipp32s vm_file_fprintf(vm_file *fd, vm_char *format, ...) {
  DWORD nmbread;
  Ipp32s rtv = 0;
  va_list args;
  va_start( args, format );
  if (fd == vm_stdout)
    rtv = _vftprintf(stdout, format, args);
   else
    if (fd == vm_stderr)
     rtv = _vftprintf(stderr, format, args);
    else
      if ((fd != NULL) && (fd[0].fd != INVALID_HANDLE_VALUE)) {
        vm_string_vsprintf( fd[0].tbuf, format, args );
        LOCK;
        rtv = (WriteFile(fd[0].fd, fd[0].tbuf, vm_string_strlen(fd[0].tbuf), &nmbread, NULL)) ? nmbread : 0;
        UNLOCK;
        va_end( args );
    }
  return rtv;
  }

Ipp32s vm_file_vfprintf(vm_file *fd, vm_char *format,  va_list argptr) {
  DWORD nmbread;
  Ipp32s rtv = 0;
  if (fd == vm_stdout)
    _vftprintf(stdout, format, argptr);
  else
    if (fd == vm_stderr)
      _vftprintf(stderr, format, argptr);
    else
      if ((fd != NULL) && (fd[0].fd != INVALID_HANDLE_VALUE)) {
        vm_string_vsprintf( fd[0].tbuf, format, argptr );
        LOCK;
        rtv = (WriteFile(fd[0].fd, fd[0].tbuf, vm_string_strlen(fd[0].tbuf), &nmbread, NULL)) ? nmbread : 0;
        UNLOCK;
        }
  return rtv;
  }


/* Directory manipulations */

Ipp32s vm_dir_remove(vm_char *path) {
  Ipp32s rtv = 1;
   if (!RemoveDirectory(path))
      rtv = DeleteFile(path);
   return rtv;
}

Ipp32s vm_dir_mkdir(vm_char *path) {
   return CreateDirectory(path, NULL);
}

Ipp32s vm_dir_open(vm_dir **dd, vm_char *path) {
  Ipp32s rtv = 0;
  vm_dir *td = (vm_dir *)malloc(sizeof(vm_dir));
  if (td != NULL) {
    td->handle=FindFirstFile(path, &td->ent);
    *dd = td;
    if (td->handle != INVALID_HANDLE_VALUE)
      rtv = 1;
    }
  return rtv;
}

Ipp32s vm_dir_read(vm_dir *dd, vm_char *filename,int nchars) {
  Ipp32s rtv = 0;
  if (dd->handle != INVALID_HANDLE_VALUE) {
    vm_string_strncpy(filename,dd->ent.cFileName,min(nchars,MAX_PATH));
    if (FindNextFile(dd->handle,&dd->ent))
      rtv = 1;
    else {
      FindClose(dd->handle);
      dd->handle=INVALID_HANDLE_VALUE;
      }
    }
   return rtv;
}

void vm_dir_close(vm_dir *dd) {
  if (dd->handle!=INVALID_HANDLE_VALUE) {
      FindClose(dd->handle);
      free(dd);
    }
}

Ipp64u vm_dir_get_free_disk_space( void ) {
  ULARGE_INTEGER freebytes[3];
  GetDiskFreeSpaceEx(VM_STRING("."), &freebytes[0], &freebytes[1], &freebytes[2]);
  return freebytes[0].QuadPart; /* return total number of available free bytes on disk */
  }

#endif // Windows is not Unix