diff options
Diffstat (limited to 'apps/codecs/dumb/src/it/reads3m.c')
-rw-r--r-- | apps/codecs/dumb/src/it/reads3m.c | 668 |
1 files changed, 668 insertions, 0 deletions
diff --git a/apps/codecs/dumb/src/it/reads3m.c b/apps/codecs/dumb/src/it/reads3m.c new file mode 100644 index 0000000000..6a8b84dd55 --- /dev/null +++ b/apps/codecs/dumb/src/it/reads3m.c | |||
@@ -0,0 +1,668 @@ | |||
1 | /* _______ ____ __ ___ ___ | ||
2 | * \ _ \ \ / \ / \ \ / / ' ' ' | ||
3 | * | | \ \ | | || | \/ | . . | ||
4 | * | | | | | | || ||\ /| | | ||
5 | * | | | | | | || || \/ | | ' ' ' | ||
6 | * | | | | | | || || | | . . | ||
7 | * | |_/ / \ \__// || | | | ||
8 | * /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque | ||
9 | * / \ | ||
10 | * / . \ | ||
11 | * reads3m.c - Code to read a ScreamTracker 3 / / \ \ | ||
12 | * module from an open file. | < / \_ | ||
13 | * | \/ /\ / | ||
14 | * By entheh. \_ / > / | ||
15 | * | \ / / | ||
16 | * | ' / | ||
17 | * \__/ | ||
18 | */ | ||
19 | |||
20 | // IT_STEREO... :o | ||
21 | #include <stdlib.h> | ||
22 | #include <string.h> | ||
23 | |||
24 | #include "dumb.h" | ||
25 | #include "internal/it.h" | ||
26 | |||
27 | |||
28 | |||
29 | /** WARNING: this is duplicated in itread.c */ | ||
30 | static int it_seek(DUMBFILE *f, long offset) | ||
31 | { | ||
32 | long pos = dumbfile_pos(f); | ||
33 | |||
34 | if (pos > offset) | ||
35 | return -1; | ||
36 | |||
37 | if (pos < offset) | ||
38 | if (dumbfile_skip(f, offset - pos)) | ||
39 | return -1; | ||
40 | |||
41 | return 0; | ||
42 | } | ||
43 | |||
44 | |||
45 | |||
46 | static int it_s3m_read_sample_header(IT_SAMPLE *sample, long *offset, DUMBFILE *f) | ||
47 | { | ||
48 | unsigned char type; | ||
49 | int flags; | ||
50 | |||
51 | type = dumbfile_getc(f); | ||
52 | |||
53 | if (type > 1) { | ||
54 | /** WARNING: no adlib support */ | ||
55 | } | ||
56 | |||
57 | /* Skip DOS Filename */ | ||
58 | dumbfile_skip(f, 13); | ||
59 | |||
60 | *offset = dumbfile_igetw(f) << 4; | ||
61 | |||
62 | sample->length = dumbfile_igetl(f); | ||
63 | sample->loop_start = dumbfile_igetl(f); | ||
64 | sample->loop_end = dumbfile_igetl(f); | ||
65 | |||
66 | sample->default_volume = dumbfile_getc(f); | ||
67 | |||
68 | dumbfile_skip(f, 1); | ||
69 | |||
70 | if (dumbfile_getc(f) != 0) | ||
71 | /* Sample is packed apparently (or error reading from file). We don't | ||
72 | * know how to read packed samples. | ||
73 | */ | ||
74 | return -1; | ||
75 | |||
76 | flags = dumbfile_getc(f); | ||
77 | |||
78 | sample->C5_speed = dumbfile_igetl(f) << 1; | ||
79 | |||
80 | /* Skip four unused bytes, three internal variables and sample name. */ | ||
81 | dumbfile_skip(f, 4+2+2+4+28); | ||
82 | |||
83 | if (type == 0) { | ||
84 | /* Looks like no-existy. Anyway, there's for sure no 'SCRS'... */ | ||
85 | sample->flags &= ~IT_SAMPLE_EXISTS; | ||
86 | return dumbfile_error(f); | ||
87 | } | ||
88 | |||
89 | if (dumbfile_mgetl(f) != DUMB_ID('S','C','R','S')) | ||
90 | return -1; | ||
91 | |||
92 | sample->global_volume = 64; | ||
93 | |||
94 | sample->flags = IT_SAMPLE_EXISTS; | ||
95 | if (flags & 1) sample->flags |= IT_SAMPLE_LOOP; | ||
96 | if (flags & 2) sample->flags |= IT_SAMPLE_STEREO; | ||
97 | if (flags & 4) sample->flags |= IT_SAMPLE_16BIT; | ||
98 | |||
99 | sample->default_pan = 0; // 0 = don't use, or 160 = centre? | ||
100 | |||
101 | if (sample->length <= 0) | ||
102 | sample->flags &= ~IT_SAMPLE_EXISTS; | ||
103 | else if (sample->flags & IT_SAMPLE_LOOP) { | ||
104 | if ((unsigned int)sample->loop_end > (unsigned int)sample->length) | ||
105 | sample->flags &= ~IT_SAMPLE_LOOP; | ||
106 | else if ((unsigned int)sample->loop_start >= (unsigned int)sample->loop_end) | ||
107 | sample->flags &= ~IT_SAMPLE_LOOP; | ||
108 | else | ||
109 | /* ScreamTracker seems not to save what comes after the loop end | ||
110 | * point, but rather to assume it is a duplicate of what comes at | ||
111 | * the loop start point. I am not completely sure of this though. | ||
112 | * It is easy to evade; simply truncate the sample. | ||
113 | */ | ||
114 | sample->length = sample->loop_end; | ||
115 | } | ||
116 | |||
117 | |||
118 | //Do we need to set all these? | ||
119 | sample->vibrato_speed = 0; | ||
120 | sample->vibrato_depth = 0; | ||
121 | sample->vibrato_rate = 0; | ||
122 | sample->vibrato_waveform = IT_VIBRATO_SINE; | ||
123 | |||
124 | return dumbfile_error(f); | ||
125 | } | ||
126 | |||
127 | |||
128 | |||
129 | static int it_s3m_read_sample_data(IT_SAMPLE *sample, int ffi, DUMBFILE *f) | ||
130 | { | ||
131 | long n; | ||
132 | |||
133 | sample->left = malloc(sample->length * sizeof(*sample->left)); | ||
134 | if (!sample->left) | ||
135 | return -1; | ||
136 | |||
137 | if (sample->flags & IT_SAMPLE_STEREO) { | ||
138 | sample->right = malloc(sample->length * sizeof(*sample->right)); | ||
139 | if (!sample->right) | ||
140 | return -1; | ||
141 | } | ||
142 | |||
143 | if (sample->flags & IT_SAMPLE_STEREO) { | ||
144 | if (sample->flags & IT_SAMPLE_16BIT) { | ||
145 | for (n = 0; n < sample->length; n++) | ||
146 | sample->left[n] = (int)(signed short)dumbfile_igetw(f) << 8; | ||
147 | for (n = 0; n < sample->length; n++) | ||
148 | sample->right[n] = (int)(signed short)dumbfile_igetw(f) << 8; | ||
149 | } else { | ||
150 | for (n = 0; n < sample->length; n++) | ||
151 | sample->left[n] = (int)(signed char)dumbfile_getc(f) << 16; | ||
152 | for (n = 0; n < sample->length; n++) | ||
153 | sample->right[n] = (int)(signed char)dumbfile_getc(f) << 16; | ||
154 | } | ||
155 | } else if (sample->flags & IT_SAMPLE_16BIT) | ||
156 | for (n = 0; n < sample->length; n++) | ||
157 | sample->left[n] = (int)(signed short)dumbfile_igetw(f) << 8; | ||
158 | else | ||
159 | for (n = 0; n < sample->length; n++) | ||
160 | sample->left[n] = (int)(signed char)dumbfile_getc(f) << 16; | ||
161 | |||
162 | if (dumbfile_error(f)) | ||
163 | return -1; | ||
164 | |||
165 | if (ffi != 1) { | ||
166 | /* Convert to signed. */ | ||
167 | for (n = 0; n < sample->length; n++) | ||
168 | sample->left[n] ^= 0xFF800000; | ||
169 | |||
170 | if (sample->right) | ||
171 | for (n = 0; n < sample->length; n++) | ||
172 | sample->right[n] ^= 0xFF800000; | ||
173 | } | ||
174 | |||
175 | return 0; | ||
176 | } | ||
177 | |||
178 | |||
179 | |||
180 | static int it_s3m_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer) | ||
181 | { | ||
182 | int buflen = 0; | ||
183 | int bufpos = 0; | ||
184 | |||
185 | IT_ENTRY *entry; | ||
186 | |||
187 | unsigned char channel; | ||
188 | |||
189 | /* Haha, this is hilarious! | ||
190 | * | ||
191 | * Well, after some experimentation, it seems that different S3M writers | ||
192 | * define the format in different ways. The S3M docs say that the first | ||
193 | * two bytes hold the "length of [the] packed pattern", and the packed | ||
194 | * pattern data follow. Judging by the contents of ARMANI.S3M, packaged | ||
195 | * with ScreamTracker itself, the measure of length _includes_ the two | ||
196 | * bytes used to store the length; in other words, we should read | ||
197 | * (length - 2) more bytes. However, aryx.s3m, packaged with ModPlug | ||
198 | * Tracker, excludes these two bytes, so (length) more bytes must be | ||
199 | * read. | ||
200 | * | ||
201 | * Call me crazy, but I just find it insanely funny that the format was | ||
202 | * misunderstood in this way :D | ||
203 | * | ||
204 | * Now we can't just risk reading two extra bytes, because then we | ||
205 | * overshoot, and DUMBFILEs don't support backward seeking (for a good | ||
206 | * reason). Luckily, there is a way. We can read the data little by | ||
207 | * little, and stop when we have 64 rows in memory. Provided we protect | ||
208 | * against buffer overflow, this method should work with all sensibly | ||
209 | * written S3M files. If you find one for which it does not work, please | ||
210 | * let me know at entheh@users.sf.net so I can look at it. | ||
211 | */ | ||
212 | |||
213 | /* Discard the length. */ | ||
214 | dumbfile_skip(f, 2); | ||
215 | |||
216 | if (dumbfile_error(f)) | ||
217 | return -1; | ||
218 | |||
219 | pattern->n_rows = 0; | ||
220 | pattern->n_entries = 0; | ||
221 | |||
222 | /* Read in the pattern data, little by little, and work out how many | ||
223 | * entries we need room for. Sorry, but this is just so funny... | ||
224 | */ | ||
225 | for (;;) { | ||
226 | unsigned char b = buffer[buflen++] = dumbfile_getc(f); | ||
227 | |||
228 | #if 1 | ||
229 | static const unsigned char used[8] = {0, 2, 1, 3, 2, 4, 3, 5}; | ||
230 | channel = b & 31; | ||
231 | b >>= 5; | ||
232 | pattern->n_entries++; | ||
233 | if (b) { | ||
234 | if (buflen + used[b] >= 65536) return -1; | ||
235 | dumbfile_getnc(buffer + buflen, used[b], f); | ||
236 | buflen += used[b]; | ||
237 | } else { | ||
238 | /* End of row */ | ||
239 | if (++pattern->n_rows == 64) break; | ||
240 | if (buflen >= 65536) return -1; | ||
241 | } | ||
242 | #else | ||
243 | if (b == 0) { | ||
244 | /* End of row */ | ||
245 | pattern->n_entries++; | ||
246 | if (++pattern->n_rows == 64) break; | ||
247 | if (buflen >= 65536) return -1; | ||
248 | } else { | ||
249 | static const unsigned char used[8] = {0, 2, 1, 3, 2, 4, 3, 5}; | ||
250 | channel = b & 31; | ||
251 | b >>= 5; | ||
252 | if (b) { | ||
253 | pattern->n_entries++; | ||
254 | if (buflen + used[b] >= 65536) return -1; | ||
255 | dumbfile_getnc(buffer + buflen, used[b], f); | ||
256 | buflen += used[b]; | ||
257 | } | ||
258 | } | ||
259 | #endif | ||
260 | |||
261 | /* We have ensured that buflen < 65536 at this point, so it is safe | ||
262 | * to iterate and read at least one more byte without checking. | ||
263 | * However, now would be a good time to check for errors reading from | ||
264 | * the file. | ||
265 | */ | ||
266 | |||
267 | if (dumbfile_error(f)) | ||
268 | return -1; | ||
269 | } | ||
270 | |||
271 | pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); | ||
272 | |||
273 | if (!pattern->entry) | ||
274 | return -1; | ||
275 | |||
276 | entry = pattern->entry; | ||
277 | |||
278 | while (bufpos < buflen) { | ||
279 | unsigned char b = buffer[bufpos++]; | ||
280 | |||
281 | #if 1 | ||
282 | if (!(b & ~31)) | ||
283 | #else | ||
284 | if (b == 0) | ||
285 | #endif | ||
286 | { | ||
287 | /* End of row */ | ||
288 | IT_SET_END_ROW(entry); | ||
289 | entry++; | ||
290 | continue; | ||
291 | } | ||
292 | |||
293 | channel = b & 31; | ||
294 | |||
295 | if (b & 224) { | ||
296 | entry->mask = 0; | ||
297 | entry->channel = channel; | ||
298 | |||
299 | if (b & 32) { | ||
300 | unsigned char n = buffer[bufpos++]; | ||
301 | if (n != 255) { | ||
302 | if (n == 254) | ||
303 | entry->note = IT_NOTE_CUT; | ||
304 | else | ||
305 | entry->note = (n >> 4) * 12 + (n & 15); | ||
306 | entry->mask |= IT_ENTRY_NOTE; | ||
307 | } | ||
308 | |||
309 | entry->instrument = buffer[bufpos++]; | ||
310 | if (entry->instrument) | ||
311 | entry->mask |= IT_ENTRY_INSTRUMENT; | ||
312 | } | ||
313 | |||
314 | if (b & 64) { | ||
315 | entry->volpan = buffer[bufpos++]; | ||
316 | if (entry->volpan != 255) | ||
317 | entry->mask |= IT_ENTRY_VOLPAN; | ||
318 | } | ||
319 | |||
320 | if (b & 128) { | ||
321 | entry->effect = buffer[bufpos++]; | ||
322 | entry->effectvalue = buffer[bufpos++]; | ||
323 | if (entry->effect != 255) { | ||
324 | entry->mask |= IT_ENTRY_EFFECT; | ||
325 | if (entry->effect == IT_BREAK_TO_ROW) | ||
326 | entry->effectvalue -= (entry->effectvalue >> 4) * 6; | ||
327 | } | ||
328 | /** WARNING: ARGH! CONVERT TEH EFFECTS!@~ */ | ||
329 | } | ||
330 | |||
331 | entry++; | ||
332 | } | ||
333 | } | ||
334 | |||
335 | ASSERT(entry == pattern->entry + pattern->n_entries); | ||
336 | |||
337 | return 0; | ||
338 | } | ||
339 | |||
340 | |||
341 | |||
342 | /** WARNING: this is duplicated in itread.c - also bad practice to use the same struct name unless they are unified in a header */ | ||
343 | /* Currently we assume the sample data are stored after the sample headers in | ||
344 | * module files. This assumption may be unjustified; let me know if you have | ||
345 | * trouble. | ||
346 | */ | ||
347 | |||
348 | #define IT_COMPONENT_INSTRUMENT 1 | ||
349 | #define IT_COMPONENT_PATTERN 2 | ||
350 | #define IT_COMPONENT_SAMPLE 3 | ||
351 | |||
352 | typedef struct IT_COMPONENT | ||
353 | { | ||
354 | unsigned char type; | ||
355 | unsigned char n; | ||
356 | long offset; | ||
357 | short sampfirst; /* component[sampfirst] = first sample data after this */ | ||
358 | short sampnext; /* sampnext is used to create linked lists of sample data */ | ||
359 | } | ||
360 | IT_COMPONENT; | ||
361 | |||
362 | |||
363 | |||
364 | static int it_component_compare(const void *e1, const void *e2) | ||
365 | { | ||
366 | return ((const IT_COMPONENT *)e1)->offset - | ||
367 | ((const IT_COMPONENT *)e2)->offset; | ||
368 | } | ||
369 | |||
370 | |||
371 | |||
372 | static DUMB_IT_SIGDATA *it_s3m_load_sigdata(DUMBFILE *f) | ||
373 | { | ||
374 | DUMB_IT_SIGDATA *sigdata; | ||
375 | |||
376 | int flags, cwtv, ffi; | ||
377 | int default_pan_present; | ||
378 | |||
379 | IT_COMPONENT *component; | ||
380 | int n_components = 0; | ||
381 | |||
382 | int n; | ||
383 | |||
384 | unsigned char *buffer; | ||
385 | |||
386 | /* Skip song name. */ | ||
387 | if (dumbfile_skip(f, 28)) return NULL; | ||
388 | |||
389 | if (dumbfile_getc(f) != 0x1A) return NULL; | ||
390 | if (dumbfile_getc(f) != 16) return NULL; | ||
391 | |||
392 | if (dumbfile_skip(f, 2)) return NULL; | ||
393 | |||
394 | sigdata = malloc(sizeof(*sigdata)); | ||
395 | |||
396 | if (!sigdata) | ||
397 | return NULL; | ||
398 | |||
399 | sigdata->order = NULL; | ||
400 | sigdata->instrument = NULL; | ||
401 | sigdata->sample = NULL; | ||
402 | sigdata->pattern = NULL; | ||
403 | sigdata->midi = NULL; | ||
404 | sigdata->checkpoint = NULL; | ||
405 | |||
406 | sigdata->n_orders = dumbfile_igetw(f); | ||
407 | sigdata->n_instruments = 0; | ||
408 | sigdata->n_samples = dumbfile_igetw(f); | ||
409 | sigdata->n_patterns = dumbfile_igetw(f); | ||
410 | |||
411 | if (dumbfile_error(f) || sigdata->n_orders <= 0 || sigdata->n_samples > 256 || sigdata->n_patterns > 256) { | ||
412 | _dumb_it_unload_sigdata(sigdata); | ||
413 | return NULL; | ||
414 | } | ||
415 | |||
416 | sigdata->order = malloc(sigdata->n_orders); | ||
417 | if (!sigdata->order) { | ||
418 | _dumb_it_unload_sigdata(sigdata); | ||
419 | return NULL; | ||
420 | } | ||
421 | |||
422 | if (sigdata->n_samples) { | ||
423 | sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); | ||
424 | if (!sigdata->sample) { | ||
425 | _dumb_it_unload_sigdata(sigdata); | ||
426 | return NULL; | ||
427 | } | ||
428 | for (n = 0; n < sigdata->n_samples; n++) | ||
429 | sigdata->sample[n].right = sigdata->sample[n].left = NULL; | ||
430 | } | ||
431 | |||
432 | if (sigdata->n_patterns) { | ||
433 | sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); | ||
434 | if (!sigdata->pattern) { | ||
435 | _dumb_it_unload_sigdata(sigdata); | ||
436 | return NULL; | ||
437 | } | ||
438 | for (n = 0; n < sigdata->n_patterns; n++) | ||
439 | sigdata->pattern[n].entry = NULL; | ||
440 | } | ||
441 | |||
442 | flags = dumbfile_igetw(f); | ||
443 | |||
444 | cwtv = dumbfile_igetw(f); | ||
445 | |||
446 | if (cwtv == 0x1300) { | ||
447 | /** WARNING: volume slides on every frame */ | ||
448 | } | ||
449 | |||
450 | ffi = dumbfile_igetw(f); | ||
451 | |||
452 | /** WARNING: which ones? */ | ||
453 | sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX; | ||
454 | |||
455 | if (dumbfile_mgetl(f) != DUMB_ID('S','C','R','M')) { | ||
456 | _dumb_it_unload_sigdata(sigdata); | ||
457 | return NULL; | ||
458 | } | ||
459 | |||
460 | sigdata->global_volume = dumbfile_getc(f) << 1; | ||
461 | sigdata->speed = dumbfile_getc(f); | ||
462 | if (sigdata->speed == 0) sigdata->speed = 6; // Should we? What about tempo? | ||
463 | sigdata->tempo = dumbfile_getc(f); | ||
464 | /*master_volume = */dumbfile_getc(f); // 7 bits; +128 for stereo | ||
465 | //what do we do with master_volume? it's not the same as mixing volume... | ||
466 | sigdata->mixing_volume = 48; | ||
467 | |||
468 | /* Skip GUS Ultra Click Removal byte. */ | ||
469 | dumbfile_getc(f); | ||
470 | |||
471 | default_pan_present = dumbfile_getc(f); | ||
472 | |||
473 | dumbfile_skip(f, 8); | ||
474 | |||
475 | /* Skip Special Custom Data Pointer. */ | ||
476 | /** WARNING: investigate this? */ | ||
477 | dumbfile_igetw(f); | ||
478 | |||
479 | /* Channel settings for 32 channels, 255=unused, +128=disabled */ | ||
480 | { | ||
481 | int i; | ||
482 | for (i = 0; i < 32; i++) { | ||
483 | int c = dumbfile_getc(f); | ||
484 | if (!(c & (128 | 16))) { /* +128=disabled, +16=Adlib */ | ||
485 | sigdata->channel_volume[i] = 64; | ||
486 | sigdata->channel_pan[i] = c & 8 ? 12 : 3; | ||
487 | /** WARNING: ah, but it should be 7 for mono... */ | ||
488 | } else { | ||
489 | /** WARNING: this could be improved if we support channel muting... */ | ||
490 | sigdata->channel_volume[i] = 0; | ||
491 | sigdata->channel_pan[i] = 7; | ||
492 | } | ||
493 | } | ||
494 | } | ||
495 | |||
496 | /* Orders, byte each, length = sigdata->n_orders (should be even) */ | ||
497 | dumbfile_getnc(sigdata->order, sigdata->n_orders, f); | ||
498 | sigdata->restart_position = 0; | ||
499 | |||
500 | component = malloc(768*sizeof(*component)); | ||
501 | if (!component) { | ||
502 | _dumb_it_unload_sigdata(sigdata); | ||
503 | return NULL; | ||
504 | } | ||
505 | |||
506 | for (n = 0; n < sigdata->n_samples; n++) { | ||
507 | component[n_components].type = IT_COMPONENT_SAMPLE; | ||
508 | component[n_components].n = n; | ||
509 | component[n_components].offset = dumbfile_igetw(f) << 4; | ||
510 | component[n_components].sampfirst = -1; | ||
511 | n_components++; | ||
512 | } | ||
513 | |||
514 | for (n = 0; n < sigdata->n_patterns; n++) { | ||
515 | long offset = dumbfile_igetw(f) << 4; | ||
516 | if (offset) { | ||
517 | component[n_components].type = IT_COMPONENT_PATTERN; | ||
518 | component[n_components].n = n; | ||
519 | component[n_components].offset = offset; | ||
520 | component[n_components].sampfirst = -1; | ||
521 | n_components++; | ||
522 | } else { | ||
523 | /** WARNING: Empty 64-row pattern ... ? (this does happen!) */ | ||
524 | sigdata->pattern[n].n_rows = 64; | ||
525 | sigdata->pattern[n].n_entries = 0; | ||
526 | } | ||
527 | } | ||
528 | |||
529 | qsort(component, n_components, sizeof(IT_COMPONENT), &it_component_compare); | ||
530 | |||
531 | /* I found a really dumb S3M file that claimed to contain default pan | ||
532 | * data but didn't contain any. Programs would load it by reading part of | ||
533 | * the first instrument header, assuming the data to be default pan | ||
534 | * positions, and then rereading the instrument module. We cannot do this | ||
535 | * without obfuscating the file input model, so we insert an extra check | ||
536 | * here that we won't overrun the start of the first component. | ||
537 | */ | ||
538 | if (default_pan_present == 252 && component[0].offset >= dumbfile_pos(f) + 32) { | ||
539 | /* Channel default pan positions */ | ||
540 | int i; | ||
541 | for (i = 0; i < 32; i++) { | ||
542 | int c = dumbfile_getc(f); | ||
543 | if (c & 32) | ||
544 | sigdata->channel_pan[i] = c & 15; | ||
545 | } | ||
546 | } | ||
547 | |||
548 | { | ||
549 | int i; | ||
550 | for (i = 0; i < 32; i++) { | ||
551 | sigdata->channel_pan[i] -= (sigdata->channel_pan[i] & 8) >> 3; | ||
552 | sigdata->channel_pan[i] = ((int)sigdata->channel_pan[i] << 5) / 7; | ||
553 | } | ||
554 | } | ||
555 | |||
556 | /** WARNING: is this right? */ | ||
557 | sigdata->pan_separation = 64; | ||
558 | |||
559 | if (dumbfile_error(f)) { | ||
560 | free(component); | ||
561 | _dumb_it_unload_sigdata(sigdata); | ||
562 | return NULL; | ||
563 | } | ||
564 | |||
565 | buffer = malloc(65536); | ||
566 | if (!buffer) { | ||
567 | free(component); | ||
568 | _dumb_it_unload_sigdata(sigdata); | ||
569 | return NULL; | ||
570 | } | ||
571 | |||
572 | for (n = 0; n < n_components; n++) { | ||
573 | long offset; | ||
574 | int m; | ||
575 | |||
576 | if (it_seek(f, component[n].offset)) { | ||
577 | free(buffer); | ||
578 | free(component); | ||
579 | _dumb_it_unload_sigdata(sigdata); | ||
580 | return NULL; | ||
581 | } | ||
582 | |||
583 | switch (component[n].type) { | ||
584 | |||
585 | case IT_COMPONENT_PATTERN: | ||
586 | if (it_s3m_read_pattern(&sigdata->pattern[component[n].n], f, buffer)) { | ||
587 | free(buffer); | ||
588 | free(component); | ||
589 | _dumb_it_unload_sigdata(sigdata); | ||
590 | return NULL; | ||
591 | } | ||
592 | break; | ||
593 | |||
594 | case IT_COMPONENT_SAMPLE: | ||
595 | if (it_s3m_read_sample_header(&sigdata->sample[component[n].n], &offset, f)) { | ||
596 | free(buffer); | ||
597 | free(component); | ||
598 | _dumb_it_unload_sigdata(sigdata); | ||
599 | return NULL; | ||
600 | } | ||
601 | |||
602 | if (sigdata->sample[component[n].n].flags & IT_SAMPLE_EXISTS) { | ||
603 | short *sample; | ||
604 | |||
605 | for (m = n + 1; m < n_components; m++) | ||
606 | if (component[m].offset > offset) | ||
607 | break; | ||
608 | m--; | ||
609 | |||
610 | sample = &component[m].sampfirst; | ||
611 | |||
612 | while (*sample >= 0 && component[*sample].offset <= offset) | ||
613 | sample = &component[*sample].sampnext; | ||
614 | |||
615 | component[n].sampnext = *sample; | ||
616 | *sample = n; | ||
617 | |||
618 | component[n].offset = offset; | ||
619 | } | ||
620 | } | ||
621 | |||
622 | m = component[n].sampfirst; | ||
623 | |||
624 | while (m >= 0) { | ||
625 | if (it_seek(f, component[m].offset)) { | ||
626 | free(buffer); | ||
627 | free(component); | ||
628 | _dumb_it_unload_sigdata(sigdata); | ||
629 | return NULL; | ||
630 | } | ||
631 | |||
632 | if (it_s3m_read_sample_data(&sigdata->sample[component[m].n], ffi, f)) { | ||
633 | free(buffer); | ||
634 | free(component); | ||
635 | _dumb_it_unload_sigdata(sigdata); | ||
636 | return NULL; | ||
637 | } | ||
638 | |||
639 | m = component[m].sampnext; | ||
640 | } | ||
641 | } | ||
642 | |||
643 | free(buffer); | ||
644 | free(component); | ||
645 | |||
646 | _dumb_it_fix_invalid_orders(sigdata); | ||
647 | |||
648 | return sigdata; | ||
649 | } | ||
650 | |||
651 | |||
652 | |||
653 | DUH *dumb_read_s3m(DUMBFILE *f) | ||
654 | { | ||
655 | sigdata_t *sigdata; | ||
656 | long length; | ||
657 | |||
658 | DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; | ||
659 | |||
660 | sigdata = it_s3m_load_sigdata(f); | ||
661 | |||
662 | if (!sigdata) | ||
663 | return NULL; | ||
664 | |||
665 | length = _dumb_it_build_checkpoints(sigdata); | ||
666 | |||
667 | return make_duh(length, 1, &descptr, &sigdata); | ||
668 | } | ||