swish-e/src/ramdisk.c

/*
**
** This program and library is free software; you can redistribute it and/or
** modify it under the terms of the GNU (Library) General Public License
** as published by the Free Software Foundation; either version 2
** of the License, or any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU (Library) General Public License for more details.
**
** You should have received a copy of the GNU (Library) General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
**
**
** 2001-06-21 jmruiz ramdisk module or "poor man ramdisk" - Initial coding
**                   to test with LOCATIONS but it can be used with other
**                   things.
**                   Writes: Only sequential write is allowed
**                   Reads: Direct and sequential reads are allowed
**                   Routines and its equivalents:
**                   
**                         ramdisk_create                         fopen
**                         ramdisk_tell                           ftell
**                         ramdisk_write                          fwrite
**                         ramdisk_read                           fwrite
**                         ramdisk_seek                           fseek
**                         ramdisk_close                          fclose
**
**
*/


#include "swish.h"
#include "mem.h"
#include "ramdisk.h"

/* 06/2001 Jose Ruiz
** Routines to store/extract location data in memory incontigous positions to sa
ve
** memory.
** The data has been compressed previously in memory.
** Returns the pointer to the memory.
*/

struct ramdisk
{
   unsigned long cur_pos;
   unsigned long end_pos;
   unsigned int n_buffers;
   unsigned int buf_size;
   unsigned char **buffer;
   MEM_ZONE *zone;
};


/* Create a new ramdisk - The size of the internal buffers is buf_size */
struct ramdisk *ramdisk_create(char *name, int buf_size)
{
struct ramdisk *rd;

        rd = (struct ramdisk *) emalloc(sizeof(struct ramdisk));
        rd->zone = Mem_ZoneCreate(name, buf_size, 0);
        rd->cur_pos = 0;
        rd->end_pos =0;
        rd->n_buffers = 1;
        rd->buf_size = buf_size;
        rd->buffer = (unsigned char **)emalloc(sizeof(unsigned char *));
        rd->buffer[0] = (unsigned char *)Mem_ZoneAlloc(rd->zone, buf_size);
        return rd;
}

/* Closes / frees the memory used by the ramdisk */
int ramdisk_close(FILE *fp)
{
struct ramdisk *rd = (struct ramdisk *)fp;

        Mem_ZoneFree(&rd->zone);
        efree(rd->buffer);
        efree(rd);
    return 0;
}

void add_buffer_ramdisk(struct ramdisk *rd)
{
        rd->buffer = (unsigned char **)erealloc(rd->buffer,(rd->n_buffers + 1) * sizeof(unsigned char *));
        rd->buffer[rd->n_buffers++] = (unsigned char *)Mem_ZoneAlloc(rd->zone, rd->buf_size);
}

/* Equivalent to ftell to get the position while writing to the ramdisk */
long ramdisk_tell(FILE *fp)
{
struct ramdisk *rd = (struct ramdisk *)fp;

    return rd->cur_pos;
}


/* Writes to the ramdisk - The parameters are identical to those in fwrite */
size_t ramdisk_write(const void *buffer,size_t sz1, size_t sz2, FILE *fp)
{
unsigned int lenbuf=(unsigned int)(sz1 *sz2);
struct ramdisk *rd = (struct ramdisk *)fp;
unsigned char *buf = (unsigned char *)buffer;
unsigned int num_buffer,start_pos,tmplenbuf = lenbuf;
unsigned int avail;

    num_buffer = rd->cur_pos / rd->buf_size;
    start_pos = rd->cur_pos % rd->buf_size;

    avail = rd->buf_size - start_pos;
    while(avail<=(unsigned int)lenbuf)
    {
        if(avail)
            memcpy(rd->buffer[num_buffer]+start_pos,buf,avail);
        lenbuf -= avail;
        rd->cur_pos += avail;
        buf += avail;
        add_buffer_ramdisk(rd);
        avail = rd->buf_size;
        start_pos = 0;
        num_buffer++;
    }
    if(lenbuf)
    {
        memcpy(rd->buffer[num_buffer]+start_pos,buf,lenbuf);
        rd->cur_pos += lenbuf;
    }
    if(rd->cur_pos > rd->end_pos)
        rd->end_pos = rd->cur_pos;
    return (int) tmplenbuf;
}

/* Equivalent to fseek */
int ramdisk_seek(FILE *fp,long pos, int set)
{
struct ramdisk *rd = (struct ramdisk *)fp;

    switch(set)
    {
    case SEEK_CUR:
        pos += rd->cur_pos;
        break;
    case SEEK_END:
        pos += rd->end_pos;
        break;
    }
    if( pos > rd->end_pos )
    {
        while(rd->end_pos < pos)
        {
            ramdisk_putc(0, (FILE *)rd);
        }
    } 
    else
    {
        rd->cur_pos = pos;
    }
    return 0;
}


/* Reads from the ramdisk - The parameters are identical to those in fread */
size_t ramdisk_read(void *buf, size_t sz1, size_t sz2, FILE *fp)
{
struct ramdisk *rd = (struct ramdisk *)fp;
unsigned int len = (unsigned int) (sz1 *sz2);
unsigned char *buffer = (unsigned char *)buf;
unsigned int avail, num_buffer, start_pos, buffer_offset;

    if(rd->cur_pos >= rd->end_pos)
    return 0;
    if((rd->cur_pos + len) > rd->end_pos)
    {
        len = rd->end_pos - rd->cur_pos;
    }
    num_buffer = rd->cur_pos / rd->buf_size;
    start_pos = rd->cur_pos % rd->buf_size;

    buffer_offset = 0;

    avail = rd->buf_size - start_pos;
    while(avail < (unsigned int)len)
    {
        memcpy(buffer+buffer_offset,rd->buffer[num_buffer]+start_pos,avail);
        buffer_offset += avail;
        rd->cur_pos += avail;
        len -= avail;
        num_buffer++;
        start_pos=0;
        avail = rd->buf_size;
        if(num_buffer == rd->n_buffers)
            return buffer_offset;
    }
    memcpy(buffer+buffer_offset,rd->buffer[num_buffer]+start_pos,len);
    rd->cur_pos += len;
    buffer_offset += len;
    return buffer_offset;
}

int ramdisk_getc(FILE *fp)
{
unsigned char c;

    ramdisk_read((void *)&c, 1, 1, fp);
    return (int) ((unsigned char)c);
}

int ramdisk_putc(int c, FILE *fp)
{
unsigned char tmp = (unsigned char)c;

    ramdisk_write((const void *)&tmp,1, 1, fp);
    return 1;
}
1	adcroft	1.1	/*
2			**
3			** This program and library is free software; you can redistribute it and/or
4			** modify it under the terms of the GNU (Library) General Public License
5			** as published by the Free Software Foundation; either version 2
6			** of the License, or any later version.
7			**
8			** This program is distributed in the hope that it will be useful,
9			** but WITHOUT ANY WARRANTY; without even the implied warranty of
10			** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11			** GNU (Library) General Public License for more details.
12			**
13			** You should have received a copy of the GNU (Library) General Public License
14			** along with this program; if not, write to the Free Software
15			** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
16			**
17			**
18			** 2001-06-21 jmruiz ramdisk module or "poor man ramdisk" - Initial coding
19			** to test with LOCATIONS but it can be used with other
20			** things.
21			** Writes: Only sequential write is allowed
22			** Reads: Direct and sequential reads are allowed
23			** Routines and its equivalents:
24			**
25			** ramdisk_create fopen
26			** ramdisk_tell ftell
27			** ramdisk_write fwrite
28			** ramdisk_read fwrite
29			** ramdisk_seek fseek
30			** ramdisk_close fclose
31			**
32			**
33			*/
34
35
36			#include "swish.h"
37			#include "mem.h"
38			#include "ramdisk.h"
39
40			/* 06/2001 Jose Ruiz
41			** Routines to store/extract location data in memory incontigous positions to sa
42			ve
43			** memory.
44			** The data has been compressed previously in memory.
45			** Returns the pointer to the memory.
46			*/
47
48			struct ramdisk
49			{
50			unsigned long cur_pos;
51			unsigned long end_pos;
52			unsigned int n_buffers;
53			unsigned int buf_size;
54			unsigned char **buffer;
55			MEM_ZONE *zone;
56			};
57
58
59			/* Create a new ramdisk - The size of the internal buffers is buf_size */
60			struct ramdisk ramdisk_create(char name, int buf_size)
61			{
62			struct ramdisk *rd;
63
64			rd = (struct ramdisk *) emalloc(sizeof(struct ramdisk));
65			rd->zone = Mem_ZoneCreate(name, buf_size, 0);
66			rd->cur_pos = 0;
67			rd->end_pos =0;
68			rd->n_buffers = 1;
69			rd->buf_size = buf_size;
70			rd->buffer = (unsigned char *)emalloc(sizeof(unsigned char ));
71			rd->buffer[0] = (unsigned char *)Mem_ZoneAlloc(rd->zone, buf_size);
72			return rd;
73			}
74
75			/* Closes / frees the memory used by the ramdisk */
76			int ramdisk_close(FILE *fp)
77			{
78			struct ramdisk rd = (struct ramdisk )fp;
79
80			Mem_ZoneFree(&rd->zone);
81			efree(rd->buffer);
82			efree(rd);
83			return 0;
84			}
85
86			void add_buffer_ramdisk(struct ramdisk *rd)
87			{
88			rd->buffer = (unsigned char *)erealloc(rd->buffer,(rd->n_buffers + 1) sizeof(unsigned char *));
89			rd->buffer[rd->n_buffers++] = (unsigned char *)Mem_ZoneAlloc(rd->zone, rd->buf_size);
90			}
91
92			/* Equivalent to ftell to get the position while writing to the ramdisk */
93			long ramdisk_tell(FILE *fp)
94			{
95			struct ramdisk rd = (struct ramdisk )fp;
96
97			return rd->cur_pos;
98			}
99
100
101			/* Writes to the ramdisk - The parameters are identical to those in fwrite */
102			size_t ramdisk_write(const void buffer,size_t sz1, size_t sz2, FILE fp)
103			{
104			unsigned int lenbuf=(unsigned int)(sz1 *sz2);
105			struct ramdisk rd = (struct ramdisk )fp;
106			unsigned char buf = (unsigned char )buffer;
107			unsigned int num_buffer,start_pos,tmplenbuf = lenbuf;
108			unsigned int avail;
109
110			num_buffer = rd->cur_pos / rd->buf_size;
111			start_pos = rd->cur_pos % rd->buf_size;
112
113			avail = rd->buf_size - start_pos;
114			while(avail<=(unsigned int)lenbuf)
115			{
116			if(avail)
117			memcpy(rd->buffer[num_buffer]+start_pos,buf,avail);
118			lenbuf -= avail;
119			rd->cur_pos += avail;
120			buf += avail;
121			add_buffer_ramdisk(rd);
122			avail = rd->buf_size;
123			start_pos = 0;
124			num_buffer++;
125			}
126			if(lenbuf)
127			{
128			memcpy(rd->buffer[num_buffer]+start_pos,buf,lenbuf);
129			rd->cur_pos += lenbuf;
130			}
131			if(rd->cur_pos > rd->end_pos)
132			rd->end_pos = rd->cur_pos;
133			return (int) tmplenbuf;
134			}
135
136			/* Equivalent to fseek */
137			int ramdisk_seek(FILE *fp,long pos, int set)
138			{
139			struct ramdisk rd = (struct ramdisk )fp;
140
141			switch(set)
142			{
143			case SEEK_CUR:
144			pos += rd->cur_pos;
145			break;
146			case SEEK_END:
147			pos += rd->end_pos;
148			break;
149			}
150			if( pos > rd->end_pos )
151			{
152			while(rd->end_pos < pos)
153			{
154			ramdisk_putc(0, (FILE *)rd);
155			}
156			}
157			else
158			{
159			rd->cur_pos = pos;
160			}
161			return 0;
162			}
163
164
165			/* Reads from the ramdisk - The parameters are identical to those in fread */
166			size_t ramdisk_read(void buf, size_t sz1, size_t sz2, FILE fp)
167			{
168			struct ramdisk rd = (struct ramdisk )fp;
169			unsigned int len = (unsigned int) (sz1 *sz2);
170			unsigned char buffer = (unsigned char )buf;
171			unsigned int avail, num_buffer, start_pos, buffer_offset;
172
173			if(rd->cur_pos >= rd->end_pos)
174			return 0;
175			if((rd->cur_pos + len) > rd->end_pos)
176			{
177			len = rd->end_pos - rd->cur_pos;
178			}
179			num_buffer = rd->cur_pos / rd->buf_size;
180			start_pos = rd->cur_pos % rd->buf_size;
181
182			buffer_offset = 0;
183
184			avail = rd->buf_size - start_pos;
185			while(avail < (unsigned int)len)
186			{
187			memcpy(buffer+buffer_offset,rd->buffer[num_buffer]+start_pos,avail);
188			buffer_offset += avail;
189			rd->cur_pos += avail;
190			len -= avail;
191			num_buffer++;
192			start_pos=0;
193			avail = rd->buf_size;
194			if(num_buffer == rd->n_buffers)
195			return buffer_offset;
196			}
197			memcpy(buffer+buffer_offset,rd->buffer[num_buffer]+start_pos,len);
198			rd->cur_pos += len;
199			buffer_offset += len;
200			return buffer_offset;
201			}
202
203			int ramdisk_getc(FILE *fp)
204			{
205			unsigned char c;
206
207			ramdisk_read((void *)&c, 1, 1, fp);
208			return (int) ((unsigned char)c);
209			}
210
211			int ramdisk_putc(int c, FILE *fp)
212			{
213			unsigned char tmp = (unsigned char)c;
214
215			ramdisk_write((const void *)&tmp,1, 1, fp);
216			return 1;
217			}