RolandArrangerTypes.bt

//------------------------------------------------
//--- 010 Editor v12.0 Binary Template
//
//      File: RolandArrangerTypes.bt
//   Authors: Daniel Stien <daniel@stien.org>
//   Version: 
//   Purpose: Common types used in Roland arranger ROM images.
//  Category: Misc
// File Mask: 
//  ID Bytes: 
//   History: 
//------------------------------------------------
#define TICKS_PER_BEAT 24
#define PHRASES 6
#define CHORD_MODES 3
#define END_OF_TRACK 0x3F

typedef struct (int length)
{
    if (length == -1) {
        ubyte SpecifiedLength;
        length = SpecifiedLength;
    }
    char Value[length];
} Label <optimize=false,read=Str("%s", Value)>;

typedef struct
{
    char  Name[12];
    char  Data0[23];
    ubyte Sample;
    char  Data[180];
} Instrument <read=Str("%s (%i)", Name, Sample)>;

typedef struct
{
    char Name[12];
    char Data[48];
} Sample <read=Str("%s", Name)>;

typedef struct
{
    char Name[12];
    char Data[204];
} DrumSample <read=Str("%s", Name)>;

typedef struct
{
    char Data[1152];
    char Name[12];
} Drumset <read=Str("%s", Name)>;

typedef struct
{
    char Header[25];
    byte TitleLength;
    char Title[TitleLength];
} Smf <read=Str("%s", Title)>;

// GS Init?
typedef struct
{
    uint16 Unknown0[4];
    char   Frustration[16];
    uchar  Unknown1[48];
    struct
    {
        uint32 Data0;
        uchar  Channel;
        uchar  Data1[107];
    } Channel[16];
    char Version[32];
} GsInit;

typedef enum
{
    // E-20 gen, TN-SC1
    EventVersion0,
    // GS, TN-SC2
    EventVersion1,
} EventVersion;

typedef enum
{
    EventNote,
    EventProgramChange,
    EventUnknown,
    EventEnd
} EventType;

string ReadNoteValue(byte &n)
{
    local string name;
    switch (n % 12) {
        case  0: name = "C";  break;
        case  1: name = "C#"; break;
        case  2: name = "D";  break;
        case  3: name = "D#"; break;
        case  4: name = "E";  break;
        case  5: name = "F";  break;
        case  6: name = "F#"; break;
        case  7: name = "G";  break;
        case  8: name = "G#"; break;
        case 10: name = "A";  break;
        case 11: name = "A#"; break;
        case 12: name = "B";  break;
    }

    // TODO: Range offset varies by part type
    local int octave = (n / 12) + 3;

    return Str("%s%d (%d)", name, octave, n);
}

string ReadVelocityValue(byte &v)
{
    if (v > 0) {
        return Str("%d (%d)", (v + 1 << 3) - 1, v);
    }
    else {
        return "0";
    }
}

// New hypothesis for E-20/TN-SC1-nn - oct 2024
// 1 bit: is program change
//     1: 7-bit program
//     0: 1 bit is controller or delta?
//        1: 6-bit value
//            Multiple bytes or other event types?
//        0: 6-bit value:
//            0x3F (all bits set): end of track
//            Else:
//                Note
//                4-bit velocity
//                4-bit delta

typedef struct
{
    local EventType Type;

    byte IsProgramChange : 1;
    if (IsProgramChange) {
        Type = EventProgramChange;
        byte Program : 7;
    }
    else {
        byte IsElse : 1;
        local byte Value = ReadByte() & 0x3F;
        if (IsElse) {
            Type = EventUnknown;
            byte unknown0 : 6;
            //byte unknown1;
            //byte unknown2;
            //byte unknown3;
        }
        else if (Value == END_OF_TRACK) {
            Type = EventEnd;
            byte EndOfTrack : 6;
        }
        else {
            Type = EventNote;
            byte Note : 6 <read=ReadNoteValue>;
            byte Velocity : 4 <read=ReadVelocityValue>;
            byte Delta : 4;
        }
    }
} EventV0 <read=ReadEventV0,optimize=false>;

string ReadEventV0(EventV0 &e)
{
    local string type = EnumToString(e.Type);

    switch (e.Type) {
        case EventProgramChange:
            return Str("%s: %d", type, e.Program);
        case EventUnknown:
            return Str("%s: %d ...", type, e.unknown0);
        case EventNote:
            return Str("%s: %s vel: %s del: %d", type, ReadNoteValue(e.Note), ReadVelocityValue(e.Velocity), e.Length);
        case EventEnd:
            return type;
    }
}

// Chunk of custom coded MIDI messages
typedef struct (EventVersion ver)
{
    switch (ver) {
        case EventVersion0:
            local int i = 0;
            while (true) {
                EventV0 Events;
                if (Events.Type == EventEnd || i++ > 50) break;
            }
            break;
        case EventVersion1:
            EventV0 Events[5];
            break;
    }
} Chunk <read=ReadChunk,optimize=false>;

string ReadChunk(Chunk &c)
{
    return "...";
}

typedef struct (int count)
{
    BitfieldDisablePadding();
    int Unknown : 24;
    Chunk Chunks(EventVersion0)[count];
} ChunkCollection <comment=Str("%d", Unknown),optimize=false>;

typedef struct (byte segment, int64 styleSegments[])
{
    local byte Segment = segment;
    ushort Offset;
    local int64 Full = styleSegments[segment - 1] + Offset;
} Ptr <read=Str("%X:%04X (%06X)", Segment, Offset, Full)>;

// TODO: Figure out how the segments are mapped. Endianess change? Interleaving?
local int segmap[18];
segmap[ 0] = 1;
segmap[ 1] = 0;
segmap[ 2] = 3;
//segmap[ 3] = 4; // !!
segmap[ 3] = 2;
segmap[ 4] = 5;
//segmap[ 5] = 2; // !!
segmap[ 5] = 4;
segmap[ 6] = 7;
segmap[ 7] = 6;
segmap[ 8] = 9;
segmap[ 9] = 8;
segmap[10] = 11;
segmap[11] = 10;
segmap[12] = 13;
segmap[13] = 12;
segmap[14] = 15;
segmap[15] = 17; // !!
segmap[16] = 16; // !!
segmap[17] = 14;

typedef struct (int count, int64 styleSegments[], EventVersion ver)
{
    struct (int count, int64 styleSegments[]) {
        local int i;
        for (i = 0; i < count; i++) {
            byte Segments : 4;
        }

        for (i = 0; i < count; i++) {
            Ptr Offsets(Segments[segmap[i]], styleSegments);
        }
    } Ptrs(count, styleSegments);

    local int64 pos <hidden=true> = FTell();
    local int i;
    for (i = 0; i < count; i++) {
        FSeek(Ptrs.Offsets[i].Full);
        Chunk Data(ver);
    }
    FSeek(pos);
} ChunkRefs <optimize=false>;

typedef struct (char name[], int64 styleSegments[], EventVersion ver)
{
    local string Name = name;
    ChunkRefs DrumChunks(PHRASES, styleSegments, ver);
    ubyte  TicksPerBar;
    ubyte  Tempo;
    // Current hypothesis:
    // 4 (Bass, Accomp1, Accomp2, Accomp3) * 18 (3 chord variants (major, minor, seventh) * 6 phrases (Intro, Original, Variation, ToOriginal, ToVariation, Ending))
    ChunkRefs BassChunks(PHRASES * CHORD_MODES, styleSegments, ver);
    ChunkRefs Part2Chunks(PHRASES * CHORD_MODES, styleSegments, ver);
    ChunkRefs Part3Chunks(PHRASES * CHORD_MODES, styleSegments, ver);
    ChunkRefs Part4Chunks(PHRASES * CHORD_MODES, styleSegments, ver);
} StyleHeader <read=Str("%s %d/4 @ %d BPM", Name, TicksPerBar / TICKS_PER_BEAT, Tempo)>;