Home
80's & Games
Javanoïd | Pang
PooPooDream
AmiGames
 
Galleries
Marilyn | Ban
 
Amiga Oldies
modules | Goodies
 
Humour
Gallery | Goodies
 
Bibliothèque
Sci-Fi | Fantasy
Thriller Polar
Divers | Doc
 
Links
GuestBook
Wanted








1. Rip a custom module and Make a deliplayer version
2. Rip and Convert Devils Colors modules
3. Titanics player routine for ripping and converting
4. MegaTraxx
5. NoisePakker asm to C
..= #1 - Rip and Make a custom module =..
how to rip and make a custom module for deliplayer

 Amiga Tutos

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  

..= #2 - Rip and Convert Devils Colors modules =..
how to rip and convert the modules from Colors/Devils

 Amiga Tutos
I no more found the rip of the modules of Colors/Devils demo (by Hydra & Nuno)
The Deliplayer adaptation was done by Shd

----------------------------------------------------------------------------------
How To Convert modules from modified NT2 format
----------------------------------------------------------------------------------
these mods are NoiseTracker 2 module modified

modifications :
- Patterns crypted
- Pattern size : 192 bytes (normal 1024)
- second part of pattern @ end of file

structure:
$3B6 - 1 : songlen : $f
$3B7 - 1 : repeat pos : $7f (constante)
$3B8 - 128 : songpos : table of patterns
$438 - 4 : "M.K."
$43c - $400 : Data Pattern (1 ligne = 4 bytes)

the files (deliplayer custom module, custom source, original module, converted module, converter source)
Deliplayer Custom module Music+Converted module - Deliplayer Custom module Music+Converted module - Deliplayer Custom module Music+Converted module

..= #3 - the Titanics Player Routine =..
Understand the Titanics player routine for ripping and converting mods

 Amiga Tutos
The rip of Titanics demos modules was never done until Asle want to start this quest. See this topic on Exotica forum.

----------------------------------------------------------------------------------
the Titanics Player and his format
----------------------------------------------------------------------------------
The first time, the routine seems to be the MasterSoundtracker 1.0, but not so simple :/
To understand the format, only one thing to do : resource original player from a demo and compare with Soundtracker player.
- 15 samples stored on 12 bytes each
- smp addy (dword)
- smp size/2 (word)
- fine ? (byte)
- vol (byte)
- loopstart/2 (word)
- loopsize/2 (word)
- pattern list which is a lot of words being addys of patterns. It ends with 0xFFFF
- pattern data. That's where got problems. Seems each value is one dword. The patterns seem to end if value[0]&0x80 == 0x80.
The last 12 bits are the FX+FXVal like STK.
Note that C is set volume and its value can be up to 0x64 (why? later...)
Remains to identify the notes and sample number and empty notes.
The size of each pattern is not fixed, so there's a way to bypass or repeat a given note.

..= #4 - Megatraxx format convert =..
the MegaTraxx format for converting mods

 Amiga Tutos
MegaTraxx format :
mt_sampleinfo: <=> mt_data <=> mt_module = SOUNDTRACKER 1-15 samples

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


..= #5 - Atari NoisePakker format convert =..
NoisePakker asm to C depacker

 Amiga Tutos

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
}