static void *open_js_write(const char *path, const char *filetype, int natoms) {
jshandle *js;
js = (jshandle *)malloc(sizeof(jshandle));
memset(js, 0, sizeof(jshandle));
if (fio_open(path, FIO_WRITE, &js->fd) < 0) {
printf("jsplugin) Could not open file %s for writing\n", path);
free(js);
return NULL;
}
js->natoms = natoms;
js->with_unitcell = 1;
/* emit header information */
fio_write_str(js->fd, JSHEADERSTRING);
fio_write_int32(js->fd, JSMAGICNUMBER);
fio_write_int32(js->fd, JSENDIANISM);
fio_write_int32(js->fd, JSMAJORVERSION);
fio_write_int32(js->fd, JSMINORVERSION);
/* write number of atoms */
fio_write_int32(js->fd, natoms);
/* write number of frames, to be updated later */
js->nframes = 0;
fio_write_int32(js->fd, js->nframes);
return js;
}
static void *open_dcd_write(const char *path, const char *filetype,
int natoms) {
dcdhandle *dcd;
fio_fd fd;
int rc;
int istart, nsavc;
double delta;
int with_unitcell;
int charmm;
if (fio_open(path, FIO_WRITE, &fd) < 0) {
printf("dcdplugin) Could not open file '%s' for writing\n", path);
return NULL;
}
dcd = (dcdhandle *)malloc(sizeof(dcdhandle));
memset(dcd, 0, sizeof(dcdhandle));
dcd->fd = fd;
istart = 0; /* starting timestep of DCD file */
nsavc = 1; /* number of timesteps between written DCD frames */
delta = 1.0; /* length of a timestep */
if (getenv("VMDDCDWRITEXPLORFORMAT") != NULL) {
with_unitcell = 0; /* no unit cell info */
charmm = DCD_IS_XPLOR; /* X-PLOR format */
printf("dcdplugin) WARNING: Writing DCD file in X-PLOR format, \n");
printf("dcdplugin) WARNING: unit cell information will be lost!\n");
} else {
with_unitcell = 1; /* contains unit cell infor (Charmm format) */
charmm = DCD_IS_CHARMM; /* charmm-formatted DCD file */
if (with_unitcell)
charmm |= DCD_HAS_EXTRA_BLOCK;
}
rc = write_dcdheader(dcd->fd, "Created by DCD plugin", natoms,
istart, nsavc, delta, with_unitcell, charmm);
if (rc < 0) {
print_dcderror("write_dcdheader", rc);
fio_fclose(dcd->fd);
free(dcd);
return NULL;
}
dcd->natoms = natoms;
dcd->nsets = 0;
dcd->istart = istart;
dcd->nsavc = nsavc;
dcd->with_unitcell = with_unitcell;
dcd->charmm = charmm;
dcd->x = (float *)malloc(natoms * sizeof(float));
dcd->y = (float *)malloc(natoms * sizeof(float));
dcd->z = (float *)malloc(natoms * sizeof(float));
return dcd;
}
static int devfs_open(void * opaque, const char * path, int flags, int mode) {
uint32_t h = hash_djb2((const uint8_t *) path, -1);
// DBGOUT("devfs_open(%p, \"%s\", %i, %i)\r\n", opaque, path, flags, mode);
switch (h) {
case stdin_hash:
if (flags & (O_WRONLY | O_RDWR))
return -1;
return fio_open(stdin_read, NULL, NULL, NULL, NULL);
break;
case stdout_hash:
if (flags & O_RDONLY)
return -1;
return fio_open(NULL, stdout_write, NULL, NULL, NULL);
break;
case stderr_hash:
if (flags & O_RDONLY)
return -1;
return fio_open(NULL, stdout_write, NULL, NULL, NULL);
break;
}
return -1;
}
static int romfs_open(void * opaque, const char * path, int flags, int mode) {
uint32_t h = hash_djb2((const uint8_t *) path, -1);
const uint8_t * romfs = (const uint8_t *) opaque;
const uint8_t * file;
int r = -1;
file = romfs_get_file_by_hash(romfs, h, NULL);
if (file) {
r = fio_open(romfs_read, NULL, romfs_seek, NULL, NULL);
if (r > 0) {
romfs_fds[r].file = file;
romfs_fds[r].cursor = 0;
fio_set_opaque(r, romfs_fds + r);
}
}
return r;
}
static int romfs_open(void * opaque, const char * path, int flags, int mode) {
uint32_t h = hash_djb2((const uint8_t *) path, -1);
const uint8_t * romfs = (const uint8_t *) opaque;
const uint8_t * file;
int r = -1;
file = romfs_get_file_by_hash(romfs, h, NULL);
if (file) {
r = fio_open(romfs_read, NULL, romfs_seek, NULL, NULL);
if (r > 0) {
uint32_t size = get_unaligned(file - 8);
const uint8_t *filestart = file;
while(*filestart) ++filestart;
++filestart;
size -= filestart - file;
romfs_fds[r].file = filestart;
romfs_fds[r].cursor = 0;
romfs_fds[r].size = size;
fio_set_opaque(r, romfs_fds + r);
}
}
return r;
}
static void *open_dcd_read(const char *path, const char *filetype,
int *natoms) {
dcdhandle *dcd;
fio_fd fd;
int rc;
struct stat stbuf;
if (!path) return NULL;
/* See if the file exists, and get its size */
memset(&stbuf, 0, sizeof(struct stat));
if (stat(path, &stbuf)) {
printf("dcdplugin) Could not access file '%s'.\n", path);
return NULL;
}
if (fio_open(path, FIO_READ, &fd) < 0) {
printf("dcdplugin) Could not open file '%s' for reading.\n", path);
return NULL;
}
dcd = (dcdhandle *)malloc(sizeof(dcdhandle));
memset(dcd, 0, sizeof(dcdhandle));
dcd->fd = fd;
if ((rc = read_dcdheader(dcd->fd, &dcd->natoms, &dcd->nsets, &dcd->istart,
&dcd->nsavc, &dcd->delta, &dcd->nfixed, &dcd->freeind,
&dcd->fixedcoords, &dcd->reverse, &dcd->charmm))) {
print_dcderror("read_dcdheader", rc);
fio_fclose(dcd->fd);
free(dcd);
return NULL;
}
/*
* Check that the file is big enough to really hold the number of sets
* it claims to have. Then we'll use nsets to keep track of where EOF
* should be.
*/
{
fio_size_t ndims, firstframesize, framesize, extrablocksize;
fio_size_t trjsize, filesize, curpos;
int newnsets;
extrablocksize = dcd->charmm & DCD_HAS_EXTRA_BLOCK ? 48 + 8 : 0;
ndims = dcd->charmm & DCD_HAS_4DIMS ? 4 : 3;
firstframesize = (dcd->natoms+2) * ndims * sizeof(float) + extrablocksize;
framesize = (dcd->natoms-dcd->nfixed+2) * ndims * sizeof(float)
+ extrablocksize;
/*
* It's safe to use ftell, even though ftell returns a long, because the
* header size is < 4GB.
*/
curpos = fio_ftell(dcd->fd); /* save current offset (end of header) */
#if defined(_MSC_VER) && defined(FASTIO_NATIVEWIN32)
/* the stat() call is not 64-bit savvy on Windows */
/* so we have to use the fastio fseek/ftell routines for this */
/* until we add a portable filesize routine for this purpose */
fio_fseek(dcd->fd, 0, FIO_SEEK_END); /* seek to end of file */
filesize = fio_ftell(dcd->fd);
fio_fseek(dcd->fd, curpos, FIO_SEEK_SET); /* return to end of header */
#else
filesize = stbuf.st_size; /* this works ok on Unix machines */
#endif
trjsize = filesize - curpos - firstframesize;
if (trjsize < 0) {
printf("dcdplugin) file '%s' appears to contain no timesteps.\n", path);
fio_fclose(dcd->fd);
free(dcd);
return NULL;
}
newnsets = trjsize / framesize + 1;
if (dcd->nsets > 0 && newnsets != dcd->nsets) {
printf("dcdplugin) Warning: DCD header claims %d frames, file size indicates there are actually %d frames\n", dcd->nsets, newnsets);
}
dcd->nsets = newnsets;
dcd->setsread = 0;
}
dcd->first = 1;
dcd->x = (float *)malloc(dcd->natoms * sizeof(float));
dcd->y = (float *)malloc(dcd->natoms * sizeof(float));
dcd->z = (float *)malloc(dcd->natoms * sizeof(float));
if (!dcd->x || !dcd->y || !dcd->z) {
printf("dcdplugin) Unable to allocate space for %d atoms.\n", dcd->natoms);
if (dcd->x)
free(dcd->x);
if (dcd->y)
free(dcd->y);
if (dcd->z)
free(dcd->z);
fio_fclose(dcd->fd);
free(dcd);
return NULL;
}
*natoms = dcd->natoms;
return dcd;
}
static void *open_js_read(const char *path, const char *filetype, int *natoms) {
jshandle *js;
int jsmagicnumber, jsendianism, jsmajorversion, jsminorversion;
struct stat stbuf;
char strbuf[1024];
int rc = 0;
if (!path) return NULL;
/* See if the file exists, and get its size */
memset(&stbuf, 0, sizeof(struct stat));
if (stat(path, &stbuf)) {
printf("jsplugin) Could not access file '%s'.\n", path);
return NULL;
}
js = (jshandle *)malloc(sizeof(jshandle));
memset(js, 0, sizeof(jshandle));
if (fio_open(path, FIO_READ, &js->fd) < 0) {
printf("jsplugin) Could not open file '%s' for reading.\n", path);
free(js);
return NULL;
}
/* emit header information */
fio_fread(strbuf, strlen(JSHEADERSTRING), 1, js->fd);
strbuf[strlen(JSHEADERSTRING)] = '\0';
if (strcmp(strbuf, JSHEADERSTRING)) {
printf("jsplugin) Bad trajectory header!\n");
printf("jsplugin) Read string: %s\n", strbuf);
return NULL;
}
fio_read_int32(js->fd, &jsmagicnumber);
fio_read_int32(js->fd, &jsendianism);
fio_read_int32(js->fd, &jsmajorversion);
fio_read_int32(js->fd, &jsminorversion);
fio_read_int32(js->fd, &js->natoms);
fio_read_int32(js->fd, &js->nframes);
if ((jsmagicnumber != JSMAGICNUMBER) || (jsendianism != JSENDIANISM)) {
printf("jsplugin) opposite endianism file, enabling byte swapping\n");
js->reverseendian = 1;
swap4_aligned(&jsmagicnumber, 1);
swap4_aligned(&jsendianism, 1);
swap4_aligned(&jsmajorversion, 1);
swap4_aligned(&jsminorversion, 1);
swap4_aligned(&js->natoms, 1);
swap4_aligned(&js->nframes, 1);
} else {
printf("jsplugin) native endianism file\n");
}
if ((jsmagicnumber != JSMAGICNUMBER) || (jsendianism != JSENDIANISM)) {
printf("jsplugin) read_jsreader returned %d\n", rc);
fio_fclose(js->fd);
free(js);
return NULL;
}
if (jsmajorversion != JSMAJORVERSION) {
printf("jsplugin) major version mismatch\n");
printf("jsplugin) file version: %d\n", jsmajorversion);
printf("jsplugin) plugin version: %d\n", JSMAJORVERSION);
fio_fclose(js->fd);
free(js);
return NULL;
}
*natoms = js->natoms;
return js;
}
int main()
{
int whichdrawbuf = 0;
int s;
char *buffer;
int i;
int size;
int rc;
int fd;
// Initialise RPC system.
sif_rpc_init(0);
// Setup the Video.
DmaReset();
initGraph(3);
SetVideoMode();
//install_VRstart_handler();
// Setup the double buffers.
// SetDrawFrameBuffer(1);
// SetDrawFrameBuffer(0);
// SetCrtFrameBuffer(1);
// Load the modules!
loadModules();
// Loaded the modules.. now try ps2ip now..
if(ps2ip_init()<0)
{
printf("ERROR: ps2ip_init failed2");
k_SleepThread();
}
//put here your file path
fd=fio_open("ps2vfs:\\primer\\segun\\mio.txt",O_RDONLY);
if (fd>0)
{
printf("file id kernel is %d \n");
size=fio_lseek(fd,0,SEEK_END);
i=fio_lseek(fd,0,SEEK_SET);
buffer=(char *)malloc(sizeof(char)*size);
i=fio_read(fd,buffer,size);
printf("receive size: %d \n",i);
printf("receive: buffer= %s \n",buffer);
fio_close(fd);
}
while ( 1 )
{
//WaitForNextVRstart(1);
//ClearVRcount();
//SetCrtFrameBuffer(whichdrawbuf);
//whichdrawbuf ^= 1;
//SetDrawFrameBuffer(whichdrawbuf);
// scr_printf( "t" );
}
// We shouldn't get here.. but just in case.
k_SleepThread();
}
