diff options
author | Solomon Peachy <pizza@shaftnet.org> | 2020-08-08 21:56:15 -0400 |
---|---|---|
committer | Solomon Peachy <pizza@shaftnet.org> | 2020-08-11 03:29:12 +0000 |
commit | b4e70422a3455e327433a7471c929ef100ef3b10 (patch) | |
tree | e96c5431a1b22af1fcbc628322b79fb8c3162427 /apps/plugins/mikmod/mmio.c | |
parent | 8c7780bafc9eabac6b92cfe5a5a00831c3d5fd9d (diff) | |
download | rockbox-b4e70422a3455e327433a7471c929ef100ef3b10.tar.gz rockbox-b4e70422a3455e327433a7471c929ef100ef3b10.zip |
mikmod: Upgrade mikmod core from v3.2.0 to v3.3.11
* Get rid of the non-functional GT2 loader
* Add the UMX loader
* Add HQ mixer routines (and make it configurable)
* Allow samplerate to be configured at run/playtime
* Support >64KHz mixing/playback
* Correctly restore non-boost status
(The diff to upstream is much smaller now too!)
Change-Id: Iaa4ac901ba9cd4123bb225656976e78271353a72
Diffstat (limited to 'apps/plugins/mikmod/mmio.c')
-rw-r--r-- | apps/plugins/mikmod/mmio.c | 304 |
1 files changed, 173 insertions, 131 deletions
diff --git a/apps/plugins/mikmod/mmio.c b/apps/plugins/mikmod/mmio.c index 0ffecffd2f..023c56baef 100644 --- a/apps/plugins/mikmod/mmio.c +++ b/apps/plugins/mikmod/mmio.c | |||
@@ -6,12 +6,12 @@ | |||
6 | it under the terms of the GNU Library General Public License as | 6 | it under the terms of the GNU Library General Public License as |
7 | published by the Free Software Foundation; either version 2 of | 7 | published by the Free Software Foundation; either version 2 of |
8 | the License, or (at your option) any later version. | 8 | the License, or (at your option) any later version. |
9 | 9 | ||
10 | This program is distributed in the hope that it will be useful, | 10 | This program is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
13 | GNU Library General Public License for more details. | 13 | GNU Library General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Library General Public | 15 | You should have received a copy of the GNU Library General Public |
16 | License along with this library; if not, write to the Free Software | 16 | License along with this library; if not, write to the Free Software |
17 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA | 17 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA |
@@ -20,8 +20,6 @@ | |||
20 | 20 | ||
21 | /*============================================================================== | 21 | /*============================================================================== |
22 | 22 | ||
23 | $Id: mmio.c,v 1.3 2005/03/30 19:10:58 realtech Exp $ | ||
24 | |||
25 | Portable file I/O routines | 23 | Portable file I/O routines |
26 | 24 | ||
27 | ==============================================================================*/ | 25 | ==============================================================================*/ |
@@ -51,10 +49,14 @@ | |||
51 | #include <unistd.h> | 49 | #include <unistd.h> |
52 | #endif | 50 | #endif |
53 | 51 | ||
52 | #ifdef HAVE_LIMITS_H | ||
53 | #include <limits.h> | ||
54 | #endif | ||
55 | |||
54 | #include <stdio.h> | 56 | #include <stdio.h> |
55 | #include <string.h> | 57 | #include <string.h> |
58 | #include <limits.h> | ||
56 | 59 | ||
57 | #include "mikmod.h" | ||
58 | #include "mikmod_internals.h" | 60 | #include "mikmod_internals.h" |
59 | 61 | ||
60 | #ifdef SUNOS | 62 | #ifdef SUNOS |
@@ -66,8 +68,6 @@ extern int fseek(FILE *, long, int); | |||
66 | extern size_t fwrite(const void *, size_t, size_t, FILE *); | 68 | extern size_t fwrite(const void *, size_t, size_t, FILE *); |
67 | #endif | 69 | #endif |
68 | 70 | ||
69 | #define COPY_BUFSIZE 1024 | ||
70 | |||
71 | /* some prototypes */ | 71 | /* some prototypes */ |
72 | static int _mm_MemReader_Eof(MREADER* reader); | 72 | static int _mm_MemReader_Eof(MREADER* reader); |
73 | static int _mm_MemReader_Read(MREADER* reader,void* ptr,size_t size); | 73 | static int _mm_MemReader_Read(MREADER* reader,void* ptr,size_t size); |
@@ -75,16 +75,13 @@ static int _mm_MemReader_Get(MREADER* reader); | |||
75 | static int _mm_MemReader_Seek(MREADER* reader,long offset,int whence); | 75 | static int _mm_MemReader_Seek(MREADER* reader,long offset,int whence); |
76 | static long _mm_MemReader_Tell(MREADER* reader); | 76 | static long _mm_MemReader_Tell(MREADER* reader); |
77 | 77 | ||
78 | //static long _mm_iobase=0,temp_iobase=0; | 78 | int _mm_fopen(const CHAR* fname, const CHAR* attrib) |
79 | |||
80 | int _mm_fopen(CHAR* fname,CHAR* attrib) | ||
81 | { | 79 | { |
82 | int fp; | 80 | int fp; |
83 | (void)attrib; | 81 | (void)attrib; |
84 | |||
85 | //if(!(fp=fopen(fname,attrib))) { | 82 | //if(!(fp=fopen(fname,attrib))) { |
86 | // _mm_errno = MMERR_OPENING_FILE; | 83 | // _mm_errno = MMERR_OPENING_FILE; |
87 | // if(_mm_errorhandler) _mm_errorhandler(); | 84 | // if(_mm_errorhandler) _mm_errorhandler(); |
88 | //} | 85 | //} |
89 | fp = open(fname, O_RDONLY); | 86 | fp = open(fname, O_RDONLY); |
90 | if( fp < 0 ) { | 87 | if( fp < 0 ) { |
@@ -94,7 +91,7 @@ int _mm_fopen(CHAR* fname,CHAR* attrib) | |||
94 | return fp; | 91 | return fp; |
95 | } | 92 | } |
96 | 93 | ||
97 | int _mm_FileExists(CHAR* fname) | 94 | int _mm_FileExists(const CHAR* fname) |
98 | { | 95 | { |
99 | int fp; | 96 | int fp; |
100 | 97 | ||
@@ -103,7 +100,7 @@ int _mm_FileExists(CHAR* fname) | |||
103 | fp = open(fname, O_RDONLY); | 100 | fp = open(fname, O_RDONLY); |
104 | if ( fp < 0 ) return 0; | 101 | if ( fp < 0 ) return 0; |
105 | close(fp); | 102 | close(fp); |
106 | 103 | ||
107 | return 1; | 104 | return 1; |
108 | } | 105 | } |
109 | 106 | ||
@@ -130,12 +127,12 @@ void _mm_iobase_revert(MREADER* reader) | |||
130 | 127 | ||
131 | typedef struct MFILEREADER { | 128 | typedef struct MFILEREADER { |
132 | MREADER core; | 129 | MREADER core; |
133 | int file; | 130 | int file; |
134 | } MFILEREADER; | 131 | } MFILEREADER; |
135 | 132 | ||
136 | static int _mm_FileReader_Eof(MREADER* reader) | 133 | static int _mm_FileReader_Eof(MREADER* reader) |
137 | { | 134 | { |
138 | //return feof(((MFILEREADER*)reader)->file); | 135 | //return feof(((MFILEREADER*)reader)->file); |
139 | int size = filesize(((MFILEREADER*)reader)->file); | 136 | int size = filesize(((MFILEREADER*)reader)->file); |
140 | int offset = lseek(((MFILEREADER*)reader)->file, 0, SEEK_CUR); | 137 | int offset = lseek(((MFILEREADER*)reader)->file, 0, SEEK_CUR); |
141 | return (size <= 0 || offset < 0 || offset >= size) ? 1 : 0; | 138 | return (size <= 0 || offset < 0 || offset >= size) ? 1 : 0; |
@@ -143,8 +140,8 @@ static int _mm_FileReader_Eof(MREADER* reader) | |||
143 | 140 | ||
144 | static int _mm_FileReader_Read(MREADER* reader,void* ptr,size_t size) | 141 | static int _mm_FileReader_Read(MREADER* reader,void* ptr,size_t size) |
145 | { | 142 | { |
146 | //return !!fread(ptr,size,1,((MFILEREADER*)reader)->file); | ||
147 | return read(((MFILEREADER*)reader)->file, ptr, size); | 143 | return read(((MFILEREADER*)reader)->file, ptr, size); |
144 | //return !!fread(ptr,size,1,((MFILEREADER*)reader)->file); | ||
148 | } | 145 | } |
149 | 146 | ||
150 | static int _mm_FileReader_Get(MREADER* reader) | 147 | static int _mm_FileReader_Get(MREADER* reader) |
@@ -160,7 +157,7 @@ static int _mm_FileReader_Get(MREADER* reader) | |||
160 | static int _mm_FileReader_Seek(MREADER* reader,long offset,int whence) | 157 | static int _mm_FileReader_Seek(MREADER* reader,long offset,int whence) |
161 | { | 158 | { |
162 | //return fseek(((MFILEREADER*)reader)->file, | 159 | //return fseek(((MFILEREADER*)reader)->file, |
163 | // (whence==SEEK_SET)?offset+reader->iobase:offset,whence); | 160 | // (whence==SEEK_SET)?offset+reader->iobase:offset,whence); |
164 | return lseek(((MFILEREADER*)reader)->file, | 161 | return lseek(((MFILEREADER*)reader)->file, |
165 | (whence==SEEK_SET)?offset+reader->iobase:offset,whence); | 162 | (whence==SEEK_SET)?offset+reader->iobase:offset,whence); |
166 | } | 163 | } |
@@ -173,7 +170,7 @@ static long _mm_FileReader_Tell(MREADER* reader) | |||
173 | 170 | ||
174 | MREADER *_mm_new_file_reader(int fp) | 171 | MREADER *_mm_new_file_reader(int fp) |
175 | { | 172 | { |
176 | MFILEREADER* reader=(MFILEREADER*)MikMod_malloc(sizeof(MFILEREADER)); | 173 | MFILEREADER* reader=(MFILEREADER*)MikMod_calloc(1,sizeof(MFILEREADER)); |
177 | if (reader) { | 174 | if (reader) { |
178 | reader->core.Eof =&_mm_FileReader_Eof; | 175 | reader->core.Eof =&_mm_FileReader_Eof; |
179 | reader->core.Read=&_mm_FileReader_Read; | 176 | reader->core.Read=&_mm_FileReader_Read; |
@@ -187,14 +184,14 @@ MREADER *_mm_new_file_reader(int fp) | |||
187 | 184 | ||
188 | void _mm_delete_file_reader (MREADER* reader) | 185 | void _mm_delete_file_reader (MREADER* reader) |
189 | { | 186 | { |
190 | if(reader) MikMod_free(reader); | 187 | MikMod_free(reader); |
191 | } | 188 | } |
192 | 189 | ||
193 | /*========== File Writer */ | 190 | /*========== File Writer */ |
194 | 191 | ||
195 | typedef struct MFILEWRITER { | 192 | typedef struct MFILEWRITER { |
196 | MWRITER core; | 193 | MWRITER core; |
197 | int file; | 194 | int file; |
198 | } MFILEWRITER; | 195 | } MFILEWRITER; |
199 | 196 | ||
200 | static int _mm_FileWriter_Seek(MWRITER* writer,long offset,int whence) | 197 | static int _mm_FileWriter_Seek(MWRITER* writer,long offset,int whence) |
@@ -209,27 +206,26 @@ static long _mm_FileWriter_Tell(MWRITER* writer) | |||
209 | return lseek(((MFILEWRITER*)writer)->file, 0, SEEK_CUR); | 206 | return lseek(((MFILEWRITER*)writer)->file, 0, SEEK_CUR); |
210 | } | 207 | } |
211 | 208 | ||
212 | static int _mm_FileWriter_Write(MWRITER* writer,void* ptr,size_t size) | 209 | static int _mm_FileWriter_Write(MWRITER* writer, const void* ptr, size_t size) |
213 | { | 210 | { |
214 | //return (fwrite(ptr,size,1,((MFILEWRITER*)writer)->file)==size); | 211 | //return (fwrite(ptr,size,1,((MFILEWRITER*)writer)->file)==size); |
215 | //return (write(ptr,size,((MFILEWRITER*)writer)->file)==(int)size); | 212 | (void)writer; |
216 | (void)writer; | 213 | (void)ptr; |
217 | (void)ptr; | 214 | (void)size; |
218 | (void)size; | 215 | return 0; |
219 | return 0; | ||
220 | } | 216 | } |
221 | 217 | ||
222 | static int _mm_FileWriter_Put(MWRITER* writer,int value) | 218 | static int _mm_FileWriter_Put(MWRITER* writer,int value) |
223 | { | 219 | { |
224 | (void)writer; | 220 | (void)writer; |
225 | (void)value; | 221 | (void)value; |
226 | //return fputc(value,((MFILEWRITER*)writer)->file); | 222 | //return fputc(value,((MFILEWRITER*)writer)->file); |
227 | return 1; // TODO | 223 | return 1; // TODO |
228 | } | 224 | } |
229 | 225 | ||
230 | MWRITER *_mm_new_file_writer(int fp) | 226 | MWRITER *_mm_new_file_writer(int fp) |
231 | { | 227 | { |
232 | MFILEWRITER* writer=(MFILEWRITER*)MikMod_malloc(sizeof(MFILEWRITER)); | 228 | MFILEWRITER* writer=(MFILEWRITER*)MikMod_calloc(1,sizeof(MFILEWRITER)); |
233 | if (writer) { | 229 | if (writer) { |
234 | writer->core.Seek =&_mm_FileWriter_Seek; | 230 | writer->core.Seek =&_mm_FileWriter_Seek; |
235 | writer->core.Tell =&_mm_FileWriter_Tell; | 231 | writer->core.Tell =&_mm_FileWriter_Tell; |
@@ -242,12 +238,11 @@ MWRITER *_mm_new_file_writer(int fp) | |||
242 | 238 | ||
243 | void _mm_delete_file_writer (MWRITER* writer) | 239 | void _mm_delete_file_writer (MWRITER* writer) |
244 | { | 240 | { |
245 | if(writer) MikMod_free (writer); | 241 | MikMod_free (writer); |
246 | } | 242 | } |
247 | 243 | ||
248 | /*========== Memory Reader */ | 244 | /*========== Memory Reader */ |
249 | 245 | ||
250 | |||
251 | typedef struct MMEMREADER { | 246 | typedef struct MMEMREADER { |
252 | MREADER core; | 247 | MREADER core; |
253 | const void *buffer; | 248 | const void *buffer; |
@@ -257,12 +252,12 @@ typedef struct MMEMREADER { | |||
257 | 252 | ||
258 | void _mm_delete_mem_reader(MREADER* reader) | 253 | void _mm_delete_mem_reader(MREADER* reader) |
259 | { | 254 | { |
260 | if (reader) { MikMod_free(reader); } | 255 | MikMod_free(reader); |
261 | } | 256 | } |
262 | 257 | ||
263 | MREADER *_mm_new_mem_reader(const void *buffer, int len) | 258 | MREADER *_mm_new_mem_reader(const void *buffer, long len) |
264 | { | 259 | { |
265 | MMEMREADER* reader=(MMEMREADER*)MikMod_malloc(sizeof(MMEMREADER)); | 260 | MMEMREADER* reader=(MMEMREADER*)MikMod_calloc(1,sizeof(MMEMREADER)); |
266 | if (reader) | 261 | if (reader) |
267 | { | 262 | { |
268 | reader->core.Eof =&_mm_MemReader_Eof; | 263 | reader->core.Eof =&_mm_MemReader_Eof; |
@@ -279,74 +274,86 @@ MREADER *_mm_new_mem_reader(const void *buffer, int len) | |||
279 | 274 | ||
280 | static int _mm_MemReader_Eof(MREADER* reader) | 275 | static int _mm_MemReader_Eof(MREADER* reader) |
281 | { | 276 | { |
282 | if (!reader) { return 1; } | 277 | MMEMREADER* mr = (MMEMREADER*) reader; |
283 | if ( ((MMEMREADER*)reader)->pos > ((MMEMREADER*)reader)->len ) { | 278 | if (!mr) return 1; |
284 | return 1; | 279 | if (mr->pos >= mr->len) return 1; |
285 | } | ||
286 | return 0; | 280 | return 0; |
287 | } | 281 | } |
288 | 282 | ||
289 | static int _mm_MemReader_Read(MREADER* reader,void* ptr,size_t size) | 283 | static int _mm_MemReader_Read(MREADER* reader,void* ptr,size_t size) |
290 | { | 284 | { |
291 | unsigned char *d=ptr; | 285 | unsigned char *d; |
292 | const unsigned char *s; | 286 | const unsigned char *s; |
293 | 287 | MMEMREADER* mr; | |
294 | if (!reader) { return 0; } | 288 | long siz; |
295 | 289 | int ret; | |
296 | if (reader->Eof(reader)) { return 0; } | 290 | |
297 | 291 | if (!reader || !size || (size > (size_t) LONG_MAX)) | |
298 | s = ((MMEMREADER*)reader)->buffer; | 292 | return 0; |
299 | s += ((MMEMREADER*)reader)->pos; | 293 | |
300 | 294 | mr = (MMEMREADER*) reader; | |
301 | if ( ((MMEMREADER*)reader)->pos + (long)size > ((MMEMREADER*)reader)->len) | 295 | siz = (long) size; |
302 | { | 296 | if (mr->pos >= mr->len) return 0; /* @ eof */ |
303 | ((MMEMREADER*)reader)->pos = ((MMEMREADER*)reader)->len; | 297 | if (mr->pos + siz > mr->len) { |
304 | return 0; /* not enough remaining bytes */ | 298 | siz = mr->len - mr->pos; |
299 | ret = 0; /* not enough remaining bytes */ | ||
300 | } | ||
301 | else { | ||
302 | ret = 1; | ||
305 | } | 303 | } |
306 | 304 | ||
307 | ((MMEMREADER*)reader)->pos += (long)size; | 305 | s = (const unsigned char *) mr->buffer; |
306 | s += mr->pos; | ||
307 | mr->pos += siz; | ||
308 | d = (unsigned char *) ptr; | ||
308 | 309 | ||
309 | while (size--) | 310 | while (siz) { |
310 | { | 311 | *d++ = *s++; |
311 | *d = *s; | 312 | siz--; |
312 | s++; | ||
313 | d++; | ||
314 | } | 313 | } |
315 | 314 | ||
316 | return 1; | 315 | return ret; |
317 | } | 316 | } |
318 | 317 | ||
319 | static int _mm_MemReader_Get(MREADER* reader) | 318 | static int _mm_MemReader_Get(MREADER* reader) |
320 | { | 319 | { |
321 | int pos; | 320 | MMEMREADER* mr; |
321 | int c; | ||
322 | 322 | ||
323 | if (reader->Eof(reader)) { return 0; } | 323 | mr = (MMEMREADER*) reader; |
324 | 324 | if (mr->pos >= mr->len) return EOF; | |
325 | pos = ((MMEMREADER*)reader)->pos; | 325 | c = ((const unsigned char*) mr->buffer)[mr->pos]; |
326 | ((MMEMREADER*)reader)->pos++; | 326 | mr->pos++; |
327 | 327 | ||
328 | return ((unsigned char*)(((MMEMREADER*)reader)->buffer))[pos]; | 328 | return c; |
329 | } | 329 | } |
330 | 330 | ||
331 | static int _mm_MemReader_Seek(MREADER* reader,long offset,int whence) | 331 | static int _mm_MemReader_Seek(MREADER* reader,long offset,int whence) |
332 | { | 332 | { |
333 | if (!reader) { return -1; } | 333 | MMEMREADER* mr; |
334 | 334 | ||
335 | if (!reader) return -1; | ||
336 | mr = (MMEMREADER*) reader; | ||
335 | switch(whence) | 337 | switch(whence) |
336 | { | 338 | { |
337 | case SEEK_CUR: | 339 | case SEEK_CUR: |
338 | ((MMEMREADER*)reader)->pos += offset; | 340 | mr->pos += offset; |
339 | break; | 341 | break; |
340 | case SEEK_SET: | 342 | case SEEK_SET: |
341 | ((MMEMREADER*)reader)->pos = offset; | 343 | mr->pos = reader->iobase + offset; |
342 | break; | 344 | break; |
343 | case SEEK_END: | 345 | case SEEK_END: |
344 | ((MMEMREADER*)reader)->pos = ((MMEMREADER*)reader)->len - offset - 1; | 346 | mr->pos = mr->len + offset; |
345 | break; | 347 | break; |
348 | default: /* invalid */ | ||
349 | return -1; | ||
346 | } | 350 | } |
347 | if ( ((MMEMREADER*)reader)->pos < 0) { ((MMEMREADER*)reader)->pos = 0; } | 351 | if (mr->pos < reader->iobase) { |
348 | if ( ((MMEMREADER*)reader)->pos > ((MMEMREADER*)reader)->len ) { | 352 | mr->pos = mr->core.iobase; |
349 | ((MMEMREADER*)reader)->pos = ((MMEMREADER*)reader)->len; | 353 | return -1; |
354 | } | ||
355 | if (mr->pos > mr->len) { | ||
356 | mr->pos = mr->len; | ||
350 | } | 357 | } |
351 | return 0; | 358 | return 0; |
352 | } | 359 | } |
@@ -354,13 +361,14 @@ static int _mm_MemReader_Seek(MREADER* reader,long offset,int whence) | |||
354 | static long _mm_MemReader_Tell(MREADER* reader) | 361 | static long _mm_MemReader_Tell(MREADER* reader) |
355 | { | 362 | { |
356 | if (reader) { | 363 | if (reader) { |
357 | return ((MMEMREADER*)reader)->pos; | 364 | return ((MMEMREADER*)reader)->pos - reader->iobase; |
358 | } | 365 | } |
359 | return 0; | 366 | return 0; |
360 | } | 367 | } |
361 | 368 | ||
362 | /*========== Write functions */ | 369 | /*========== Write functions */ |
363 | void _mm_write_string(CHAR* data,MWRITER* writer) | 370 | |
371 | void _mm_write_string(const CHAR* data,MWRITER* writer) | ||
364 | { | 372 | { |
365 | if(data) | 373 | if(data) |
366 | _mm_write_UBYTES(data,strlen(data),writer); | 374 | _mm_write_UBYTES(data,strlen(data),writer); |
@@ -410,37 +418,51 @@ void _mm_write_I_SLONG(SLONG data,MWRITER* writer) | |||
410 | _mm_write_I_ULONG((ULONG)data,writer); | 418 | _mm_write_I_ULONG((ULONG)data,writer); |
411 | } | 419 | } |
412 | 420 | ||
413 | #if defined __STDC__ || defined _MSC_VER || defined MPW_C | 421 | void _mm_write_M_SWORDS(SWORD *buffer,int cnt,MWRITER* writer) |
414 | #define DEFINE_MULTIPLE_WRITE_FUNCTION(type_name,type) \ | 422 | { |
415 | void _mm_write_##type_name##S (type *buffer,int number,MWRITER* writer) \ | 423 | while(cnt-- > 0) _mm_write_M_SWORD(*(buffer++),writer); |
416 | { \ | ||
417 | while(number-->0) \ | ||
418 | _mm_write_##type_name(*(buffer++),writer); \ | ||
419 | } | 424 | } |
420 | #else | 425 | |
421 | #define DEFINE_MULTIPLE_WRITE_FUNCTION(type_name,type) \ | 426 | void _mm_write_M_UWORDS(UWORD *buffer,int cnt,MWRITER* writer) |
422 | void _mm_write_/**/type_name/**/S (type *buffer,int number,MWRITER* writer) \ | 427 | { |
423 | { \ | 428 | while(cnt-- > 0) _mm_write_M_UWORD(*(buffer++),writer); |
424 | while(number-->0) \ | ||
425 | _mm_write_/**/type_name(*(buffer++),writer); \ | ||
426 | } | 429 | } |
427 | #endif | ||
428 | 430 | ||
429 | DEFINE_MULTIPLE_WRITE_FUNCTION(M_SWORD,SWORD) | 431 | void _mm_write_I_SWORDS(SWORD *buffer,int cnt,MWRITER* writer) |
430 | DEFINE_MULTIPLE_WRITE_FUNCTION(M_UWORD,UWORD) | 432 | { |
431 | DEFINE_MULTIPLE_WRITE_FUNCTION(I_SWORD,SWORD) | 433 | while(cnt-- > 0) _mm_write_I_SWORD(*(buffer++),writer); |
432 | DEFINE_MULTIPLE_WRITE_FUNCTION(I_UWORD,UWORD) | 434 | } |
433 | 435 | ||
434 | DEFINE_MULTIPLE_WRITE_FUNCTION(M_SLONG,SLONG) | 436 | void _mm_write_I_UWORDS(UWORD *buffer,int cnt,MWRITER* writer) |
435 | DEFINE_MULTIPLE_WRITE_FUNCTION(M_ULONG,ULONG) | 437 | { |
436 | DEFINE_MULTIPLE_WRITE_FUNCTION(I_SLONG,SLONG) | 438 | while(cnt-- > 0) _mm_write_I_UWORD(*(buffer++),writer); |
437 | DEFINE_MULTIPLE_WRITE_FUNCTION(I_ULONG,ULONG) | 439 | } |
440 | |||
441 | void _mm_write_M_SLONGS(SLONG *buffer,int cnt,MWRITER* writer) | ||
442 | { | ||
443 | while(cnt-- > 0) _mm_write_M_SLONG(*(buffer++),writer); | ||
444 | } | ||
445 | |||
446 | void _mm_write_M_ULONGS(ULONG *buffer,int cnt,MWRITER* writer) | ||
447 | { | ||
448 | while(cnt-- > 0) _mm_write_M_ULONG(*(buffer++),writer); | ||
449 | } | ||
450 | |||
451 | void _mm_write_I_SLONGS(SLONG *buffer,int cnt,MWRITER* writer) | ||
452 | { | ||
453 | while(cnt-- > 0) _mm_write_I_SLONG(*(buffer++),writer); | ||
454 | } | ||
455 | |||
456 | void _mm_write_I_ULONGS(ULONG *buffer,int cnt,MWRITER* writer) | ||
457 | { | ||
458 | while(cnt-- > 0) _mm_write_I_ULONG(*(buffer++),writer); | ||
459 | } | ||
438 | 460 | ||
439 | /*========== Read functions */ | 461 | /*========== Read functions */ |
440 | 462 | ||
441 | int _mm_read_string(CHAR* buffer,int number,MREADER* reader) | 463 | int _mm_read_string(CHAR* buffer,int cnt,MREADER* reader) |
442 | { | 464 | { |
443 | return reader->Read(reader,buffer,number); | 465 | return reader->Read(reader,buffer,cnt); |
444 | } | 466 | } |
445 | 467 | ||
446 | UWORD _mm_read_M_UWORD(MREADER* reader) | 468 | UWORD _mm_read_M_UWORD(MREADER* reader) |
@@ -491,32 +513,52 @@ SLONG _mm_read_I_SLONG(MREADER* reader) | |||
491 | return((SLONG)_mm_read_I_ULONG(reader)); | 513 | return((SLONG)_mm_read_I_ULONG(reader)); |
492 | } | 514 | } |
493 | 515 | ||
494 | #if defined __STDC__ || defined _MSC_VER || defined MPW_C | 516 | int _mm_read_M_SWORDS(SWORD *buffer,int cnt,MREADER* reader) |
495 | #define DEFINE_MULTIPLE_READ_FUNCTION(type_name,type) \ | 517 | { |
496 | int _mm_read_##type_name##S (type *buffer,int number,MREADER* reader) \ | 518 | while(cnt-- > 0) *(buffer++)=_mm_read_M_SWORD(reader); |
497 | { \ | 519 | return !reader->Eof(reader); |
498 | while(number-->0) \ | ||
499 | *(buffer++)=_mm_read_##type_name(reader); \ | ||
500 | return !reader->Eof(reader); \ | ||
501 | } | 520 | } |
502 | #else | 521 | |
503 | #define DEFINE_MULTIPLE_READ_FUNCTION(type_name,type) \ | 522 | int _mm_read_M_UWORDS(UWORD *buffer,int cnt,MREADER* reader) |
504 | int _mm_read_/**/type_name/**/S (type *buffer,int number,MREADER* reader) \ | 523 | { |
505 | { \ | 524 | while(cnt-- > 0) *(buffer++)=_mm_read_M_UWORD(reader); |
506 | while(number-->0) \ | 525 | return !reader->Eof(reader); |
507 | *(buffer++)=_mm_read_/**/type_name(reader); \ | ||
508 | return !reader->Eof(reader); \ | ||
509 | } | 526 | } |
510 | #endif | ||
511 | 527 | ||
512 | DEFINE_MULTIPLE_READ_FUNCTION(M_SWORD,SWORD) | 528 | int _mm_read_I_SWORDS(SWORD *buffer,int cnt,MREADER* reader) |
513 | DEFINE_MULTIPLE_READ_FUNCTION(M_UWORD,UWORD) | 529 | { |
514 | DEFINE_MULTIPLE_READ_FUNCTION(I_SWORD,SWORD) | 530 | while(cnt-- > 0) *(buffer++)=_mm_read_I_SWORD(reader); |
515 | DEFINE_MULTIPLE_READ_FUNCTION(I_UWORD,UWORD) | 531 | return !reader->Eof(reader); |
532 | } | ||
533 | |||
534 | int _mm_read_I_UWORDS(UWORD *buffer,int cnt,MREADER* reader) | ||
535 | { | ||
536 | while(cnt-- > 0) *(buffer++)=_mm_read_I_UWORD(reader); | ||
537 | return !reader->Eof(reader); | ||
538 | } | ||
539 | |||
540 | int _mm_read_M_SLONGS(SLONG *buffer,int cnt,MREADER* reader) | ||
541 | { | ||
542 | while(cnt-- > 0) *(buffer++)=_mm_read_M_SLONG(reader); | ||
543 | return !reader->Eof(reader); | ||
544 | } | ||
516 | 545 | ||
517 | DEFINE_MULTIPLE_READ_FUNCTION(M_SLONG,SLONG) | 546 | int _mm_read_M_ULONGS(ULONG *buffer,int cnt,MREADER* reader) |
518 | DEFINE_MULTIPLE_READ_FUNCTION(M_ULONG,ULONG) | 547 | { |
519 | DEFINE_MULTIPLE_READ_FUNCTION(I_SLONG,SLONG) | 548 | while(cnt-- > 0) *(buffer++)=_mm_read_M_ULONG(reader); |
520 | DEFINE_MULTIPLE_READ_FUNCTION(I_ULONG,ULONG) | 549 | return !reader->Eof(reader); |
550 | } | ||
551 | |||
552 | int _mm_read_I_SLONGS(SLONG *buffer,int cnt,MREADER* reader) | ||
553 | { | ||
554 | while(cnt-- > 0) *(buffer++)=_mm_read_I_SLONG(reader); | ||
555 | return !reader->Eof(reader); | ||
556 | } | ||
557 | |||
558 | int _mm_read_I_ULONGS(ULONG *buffer,int cnt,MREADER* reader) | ||
559 | { | ||
560 | while(cnt-- > 0) *(buffer++)=_mm_read_I_ULONG(reader); | ||
561 | return !reader->Eof(reader); | ||
562 | } | ||
521 | 563 | ||
522 | /* ex:set ts=4: */ | 564 | /* ex:set ts=4: */ |