I never found the rip of the module "Windsurf in C-Minor" from the slide Project Megaran/Reality (by Pete)

----------------------------------------------------------------------------------
How To Rip a Custom Module for a Deliplayer adaptation
----------------------------------------------------------------------------------

- The demo Reality Project Megaran
- The DeliTracker developer lib (Deliplayer.i) found in Delitracker232.lha (see on Aminet)
- assembler (Devpac - v3 for Includes "Utility")

if you try to rip the mod (with AR or other ripper),
the module is found : "WindSurf in C-Minor" by Pete/Enigma as a Soundtracker 32 mod
but when you try to listen it in your prefered player, it doesn't work

with ActionReplay, take a look at the bootblock : RT 0 1 40000

D 4000C

load "main loader" @ B000

quit (x), lets loading and decrunching

D B000



at B0B2, jump to B134
after loading & decrunching, return to B0E0, and Jump to 53000 (main code)

D B134



here is the 3 parts loading :
@17000 (start block 578 - len block 266)
@44000 (start block 1611 - len block 77)
@C10000 or @90000 (start block 844 - len block 767)

at B1DA, decrunch the datas 17000/44000 and "RTE" return to B0E0 to start

you can look the data at 17000, 44000 , 90000 :
n 17000 -> the Module ! (or use "Tracker" AR3 ripper)
n 44000 -> IFF file & code
n C10000/90000 -> IFF file

now, disassemble @ 53000

D 53000



search address of module :
FA 17000
: 054A4E, 054AFE, 054BB8

at 53012, 54A4E-5517A is moved to 7F000
here is the Player routine !

is time to save the player to disk
insert a blank floppy and save the data from 54A4E to 5517A

SM player,54A4E 5517A

save also the module : use tracker to find the size
tracker
F3

module total lenght : 289A8
F10 to exit ripper

SM mod.windsurf,17000 289A8

now search the init and play jump at 53000
D 53000

@530E0 :
JSR 7E000 (?! init)

@5311E :
LEA 531A6(pc),a0
move.l a0, $6c.s ; interrupt

D 531A6

@ 531a6:
move.w #10,$dff09c
JSR 7F0AC ; play
RTE

now quit AR/winuae or reset and use Devpac to make the custom player

use a Debugger (monam) to disassemble the player and get a clean source code
with label in a file : cust.windsurf.s

take a look to the code, the routine seem to be a NoiseTracker replay routine

use the Custom_NT.s code provided with DeliTracker developper archive

and replace the NT2 code by the cust.windsurf.s

set the Tag $VER with the name of the custom player
set the module name at the end of the source (mt_data: incbin "mod.windsurf" note: replace $17000 by mt_data)

and assemble

you get a cust.windsurf bin to use with Deliplayer, EaglerPlayer, Winamp with OldSkool plugin or XMplay with DeliX plugin.

the files (deliplayer custom module, custom source, original module, converted module, converter source)

---------------- Convertion to standard NT module

It's possible to convert the module as real NoiseTracker module. see the "simpleconverter.s" source based on Gryzor's DeliWizard converter.
the original player routine is NoiseTracker V.1.0 (not 2.0 !)

the module is a NT1, but with some modifications :
- Pattern Position : normal $3B8 -> $400
- constant MK offset : normal $7F -> $37 (offset 400-3B8=48 / 7F-48 = 37) : Repeat pos @ 2
- songlen : normal pattpos-2 = $3B6 -> $3FE
- Pattern Sequence Table moved forward of 72 bytes

No more differences. The conversion is possible to NT1 module.
-------------------------------
structure - offset / len
-------------------------------
00 - 20 : songname: WINDSURF IN c-MINOR,0
Samples-----------
Sample1: 30 octets (1e)
20 - 22 : smplname: (/) by pete of enigma,0
42 - 02 : smpllen : 4000 .w = 8000 .b = 32 ko
44 - 01 : finetune: 0
45 - 01 : volume : 40 (0-64)
46 - 02 : repeat point : 31e5 .w offset
48 - 02 : repeat lengt : 0e1b .w

Sample2:
50 : "" - 4000 - 0 - 40 - 308a - f56
Sample3:
80 : "" - 7f6 - 0 - 40 - 0 - 1

04: "" - 1bab - 0 - 2f - 0 - 1
05: "" - 0d00 - 0 - 21 - 0 - 1
06: "" - 0447 - 0 - 2e - 0 - 1
07: "" - 02fe - 0 - 40 - 0 - 1
08: "" - 2d1d - 0 - 36 - 06bd - 244b
09: "" - 3f5e - 0 - 40 - 0102 - 3e5c
10: "" - 0491 - 0 - 1f - 0 - 1
11: "" - 098f - 0 - 3d - 0 - 1
12: "" - 0c35 - 0 - 33 - 0 - 1
13: "" - 0000 - 0 - 0 - 0 - 1
14: "" - 0000 - 0 - 0 - 0 - 1
15: "" - 0000 - 0 - 0 - 0 - 1
16: "" - 0000 - 0 - 0 - 0 - 1
17: "" - 0000 - 0 - 0 - 0 - 1
18: "" -
...
31: "" - 000
--------------------------------
950 ($3b6) - 1 : songlen : $63 (99) (1-128)
951 ($3b7) - 1 : constante MK : normal $7f = ici 01
952 ($3b8) - 128 : song pos Table Pattern : 1,1,0,0,0 ...

$3FE - 1 : songlen : $1b
$3FF - 1 : 02

$400 - 56 : table pattern : 0,1,2,2,3,4,6,5,7,8,9,a,b,a,b,c,d,e,2,2,3,4,6,5,c,d,e
+28x0

normal : 1080 ($438) - 4 : "M.K."
move $3FE - $438 -> $3B6
modify $3B7 : $7F
clear $3D4 -> $438

module is now a NT1  

I no more found the rip of the modules of Colors/Devils demo (by Hydra & Nuno) or No Reality/Devils
The Deliplayer adaptation was done by Shd (2003-2004)

----------------------------------------------------------------------------------
How To Convert modules from modified NT2 format
- asm version and first conv by VrS (2004)
- C depacker and doc by Asle (2020)
----------------------------------------------------------------------------------
standard protracker header until 'M.K.' at 1080
1084 short size of pattern data [A]
1086 + [A] short size of reference table [B]
1086 + [A] short sample data
+ 2 + [B]

pattern data:
192 bytes per pattern
3 bytes per row:
0 byte : filter
1 short : address to read in reference table

Reference table:
contains rows of output unpacked notes - so up to 16 bytes.
depending of the filter, above, the blocks of word/short are stored
filter : abcd-efgh
output:
0000-0000 0000-0000 0000-0000 0000-0000
| | | | | | | | | | | | | | | |
\/ \/ \/ \/ \/ \/ \/ \/
a b c d e f g h
if the filter bit is set, the corresponding output is stored in the reference table.

the files (deliplayer custom module, custom source, original module, converted module, converter source)
- -

0 20.b music name = MOD

20 22.b sample1 name ; 22.b + 8.b = 30 bytes = 1 samples info = MOD
42 02.b length .w/2 ; 8.b = MOD (+ 1 b pour finetune)
44 02.b volume => 1.b MOD
46 02.b start = MOD
48 02.b repeat
= MOD
50 22.b sample2 name
...
80 sample 3
110 sample 4
140 sample 5
170 sample 6
200 sample 7
230 sample 8
260 sample 9
290 sample 10
320 sample 11
350 sample 12
380 sample 13
410 sample 14
440 sample 15 = 450 bytes+20=470

470 $172 02.b partinfo $2178 = .b maxpart + .b kn1 33,120 = MOD number of song pos/..
472 $174 128.b partitions table (1 -> 10) = MOD patterns table
(=> MOD 4.b "M.K." if 31 samples)
partitions datas...
600 $1f4 (4.b voice 1 wwww
4.b voice 2 xxxx
4.b voice 3 yyyy
4.b voice 4) zzzz 16 * 32 notes= 512 bytes/ partition => MOD 1024 (64) pattern data each pattern
616 part1 - 2nd pattern
...
1012 partition 2
...
n partitions = n*512 + 600

6744 start samples (with n=12)

How To Convert :
adding 16 empty samples (480 bytes)
adding M.K.
adding 508 empty bytes + 4 for the end pattern : 00 00 00 d0 (voice1) for each pattern (each 512 bytes) = 1024 bytes
copy samples

format is the same as standard Module. Only Samples are packed. The size of samples is the unpacked one.

original depacker source here

C version of Depack routines (analyze_module is from Prowiz by Asle) :

signed char power_bytes[16]={-128,-64,-32,-16,-8,-4,-2,-1,0,1,2,4,8,16,32,64};
signed char depack[256*2]; // depack_lo ds.b 256, depack_hi ds.b 256
unsigned char last_byte;
int in_size; // size of packed samples
int out_size = 0; // size of depacked samples
char *in_data; /* packed sample */
char *out_data; /* depacked sample */

/* Analyze_Module : from Prowiz - same as Noise/Protracker */

/* get highest pattern number */
...
/* pattern data starts at 1084 + highest_pattern*1024 */
in_size = filesize - 1084 - (highest_pattern*1024);

/* get output size of sample data */
... => out_size = sum of size samples

/* Init_Depack */

for (i=0; i<16; i++)
for (j=0;j<16;j++)
{
depack[(i*16) + j] = power_bytes[j]; // depack_lo
depack[256 + (i*16) + j] = power_bytes[i]; // depack_hi
}

/* Depack_Sample */

filesize -= 1;
k = out_size - 1;
for(last_byte=128,i=filesize; i>(filesize-in_size); i--)
{
/* k : address of end of depacked data, going backward */
/* i : address of end of packed file, going backward */
unsigned char d1;

d=in_data[i]; // get 2 distances

last_byte+=depack[256+d]; // last byte + depack_hi[d]
out_data[k]=last_byte; // 2nd byte depacked value

last_byte+=depack[d]; // last byte + depack_lo[d];
out_data[k-1]=last_byte; // 1st byte depacked value

k -= 2; // next word
}