Unknown Fields

[ashduino101]

Describe the feature

Hello,

If you're interested, I've been working on a 010 editor binary template to help reverse engineer FLP event formats and data structures. I've already added some structures that haven't been implemented in this library yet, so this might be useful to you. The template is available as a GitHub gist.

What version of PyFLP are you using?

Latest source (v2.2.1+)

Screenshots, Additional info

Code of Conduct

• I agree to follow this project's Code of Conduct

[meint52]

Very nice! Im using ImHex since it's free, do you know if there is an easy way to use this template in there?

[demberto]

Nice work, I'll add info about this to the README. Just a small thing I noticed, note size wasn't always 24, I have found FLPs having Note event sizes of a multiple of 16.

Can you give some brief summary of which fields or events you have discovered not present in PyFLP? If its an entirely new event ID can you also add something about it in #34?

[ashduino101]

Very nice! Im using ImHex since it's free, do you know if there is an easy way to use this template in there?

I'm not sure if you can load 010 Editor templates into ImHex, but ImHex looks like it might be a better option for this research, so I might just port it to an ImHex pattern.

Can you give some brief summary of which fields or events you have discovered not present in PyFLP? If its an entirely new event ID can you also add something about it in #34?

Some things I've looked into that aren't in PyFLP:

• Automation -- though a lot of it is still unknown, I've found some of the additional properties as well as LFO
• Remote controllers -- only 1 unknown field left, though some may be mislabeled
• MIDI controllers -- though not in the template yet, I think I've written down some notes on the structure of such events
• Track data -- Completely discovered
• Channel parameters -- added more unknown fields, such as the sampler support for SimSynth and DrumSynth, and used the right type for sample start and end offsets (float64/double, in PyFLP, it's decoded as a couple of uint16s surrounded by unknown fields)
• A couple more wrapper properties -- position & mixer attributes (something that I haven't added to the template yet: bit 3 of the flags is if the window is maximized, which I'm surprised wasn't figured out sooner)

I've also looked into some plugin formats such as 3x OSC and Parametric EQ 2, which might be worth documenting.

In terms of additional events, I haven't really kept track between PyFLP and the template, but there are some additional fields such as Controller Formula (230) and a couple events related to layer channels.

[meint52]

Currently im working on an ImHex pattern. It detects all event fields but it does not ID them yet. Here's the file for it if you want to tinker with it. Just make sure to rename the extention to .hexpat.

flp_structure.txt

[meint52]

By the way, is there a table somewhere with all the known event ID's and what they do?

[ashduino101]

There's the switch-case statement near the top of the template, but not much more than that. I might make a repository to keep track of these things and store the research/templates.

[ashduino101]

I made a repository if you want to submit a pull request with the pattern. Feel free to also submit issues if you find any interesting fields or figure out any events.

[ashduino101]

I've been trying to reverse engineer a couple more plugins over the last couple of hours, and I found something a bit interesting -- Fruity Convolver uses the same structure for envelopes as points stored in regular automation clips. I assume this might be some common structure; if it's completely discovered, it will probably help with other various structures.

[ashduino101]

after two years I just spent 10 hours figuring out every single FL event up to FL 2025

//------------------------------------------------
//--- 010 Editor v14.0 Binary Template
//
//      File: FLP.bt
//   Authors: ashduino101
//   Version: 1.0
//   Purpose: Binary template for FL Studio project files
//  Category: Audio
// File Mask: *.flp
//  ID Bytes: 46 4C 68 64 (FLhd)
//   History: 
//     1.0 - Initial release
//------------------------------------------------
RequiresVersion(14);

typedef char FourCC[4];

const int S_BYTE = 0;
const int S_WORD = 64;
const int S_DWORD = 128;
const int S_DATA = 192;

LittleEndian();

typedef struct {
    FourCC magic <bgcolor=cGreen>;
    int32 headerSize <bgcolor=cPurple>;
    int16 fmt <bgcolor=cAqua>;
    int16 channelCount <bgcolor=cYellow>;
    int16 ppq <bgcolor=cRed>;
    FourCC dataMagic <bgcolor=cGreen>;
    int32 eventSize <bgcolor=cPurple>;
} FLPHeader;

FLPHeader header;

if (header.magic != "FLhd") {
    Warning("File is not a valid FLP file. Template stopped.");
    return -1;
}


if (header.dataMagic != "FLdt") {
    Warning("Invalid data segment magic. Template stopped.");
    return -1;
}

local uint16 build = 0;
local string version = "00.00";
local string currentPlugin;
local byte trialKey = 0;
local byte arrangementKey = 0;
local byte trackDelta = 0;

ubyte VersionGTE(string major) {
    // TODO wtf this is totally wrong
    return version[0] > major[0] || (version[0] == major[0] && version[1] >= major[1]);
}

ubyte VersionLT(string major) {
    return version[0] < major[0];
}

string EventNameFunc(ubyte &id) {
    switch (id) {
        case 0: return "Is Channel Enabled";
        case 2: return "Channel Volume (Byte)";
        case 3: return "Channel Panning (Byte)";
        case 9: return "Project Loop Active";
        case 10: return "Show Project Info";
        case 11: return "Rack Swing";
        case 12: return "Project Volume *";
        case 13: return "Fit Rack To Steps";
        case 15: return "Is Channel Zipped";
        case 17: return "Time Signature Numerator";
        case 18: return "Time Signature Denominator";
        case 20: return "Is Channel Ping Pong Loop Enabled";
        case 21: return "Channel Type";
        case 22: return "Channel Routed To";
        case 23: return "Project Pan Law";
        case 26: return "Pattern Looped";
        case 28: return "Project Licensed";
        case 29: return "Mixer Automatic Plugin Delay Compensation (APDC)";
        case 30: return "Patterns Should Play Truncated Notes";
        case 31: return "Performance Mode";
        case 32: return "Is Channel Locked";
        case 33: return "Time Signature Numerator";
        case 34: return "Time Signature Denominator";
        case 35: return "Time Signature Type";
        case 36: return "Arrangement Trial Lock";
        case 37: return "Trial Key";
        case 38: return "Master Visible";
        case 39: return "Mixer Compensate Automations";
        case 40: return "Fast Declick For Cut Groups";
        case 41: return "Use Custom Color";
        case 42: return "Use Legacy Display";  // it just makes the text brighter?? i don't know why
        case 43: return "Track Trial Lock";
        case 44: return "Automatic Crossfades";
        case 45: return "Key Signature Type";
        case 46: return "Key Signature Key";
        case 47: return "Copy Samples To Project Folder";
        case 48: return "Channel Truncate Swing Notes";
        case 49: return "Bypass Track Latency Compensation";
        case 50: return "Channel Trial Lock";
        case 51: return "Channel Trial Lock 2";
        case 64: return "New Channel";
        case 65: return "New Pattern";
        case 66: return "Project Coarse Tempo *";
        case 67: return "Currently Selected Patterns";
        case 69: return "Channel Frequency Tilt";
        case 70: return "Channel FX Flags";
        case 71: return "Channel Cutoff";
        case 72: return "Channel Volume (Word)";
        case 73: return "Channel Panning (Word)";
        case 74: return "Channel Preamp";
        case 75: return "Channel Fade Out";
        case 76: return "Channel Fade In";
        case 77: return "Dot Note *";
        case 78: return "Dot Pitch *";
        case 79: return "Dot Mix *";
        case 80: return "Project Global Pitch";
        case 83: return "Channel Resonance";
        case 84: return "Loop Bar *";
        case 85: return "Channel Stereo Delay";
        case 86: return "Channel Pogo";
        case 87: return "Dot Resonance *";
        case 88: return "Dot Cutoff *";
        case 89: return "Channel Time Shift";
        case 91: return "Dot *";
        case 92: return "Dot Shift *";
        case 93: return "Project Fine Tempo *";
        case 94: return "Channel Children";
        case 95: return "Insert Icon";
        case 96: return "Dot Release *";
        case 97: return "Channel Swing";
        case 98: return "Slot Index";
        case 99: return "New Arrangement";
        case 100: return "Current Arrangement";
        case 103: return "Mixer Insert Count";
        case 104: return "Target Mixer Track";
        case 128: return "Plugin Color";
        case 130: return "Channel Echo *";
        case 131: return "Channel Ring Modulation";
        case 132: return "Channel Cut Group";
        case 133: return "Rack Window Height";
        case 135: return "Channel Root Note";
        case 136: return "Channel Stretch Time";
        case 138: return "Channel Fine Tune";
        case 139: return "Sampler Flags";
        case 140: return "Layer Flags";
        case 141: return "Channel Group Number";
        case 143: return "Sample Flags";
        case 144: return "Layer Flags";
        case 145: return "Channel Filter Number";
        case 146: return "Current Group ID";
        case 147: return "Insert Output";
        case 148: return "Time Marker Position";
        case 149: return "Insert Color";
        case 150: return "Pattern Color";
        case 152: return "Arrangement Loop Position";
        case 153: return "AU Sample Rate";
        case 154: return "Insert Input";
        case 155: return "Plugin Icon";
        case 156: return "Project Tempo";
        case 159: return "FL Studio Build";
        case 160: return "Pattern Channel ID";
        case 161: return "Channel Loop";
        case 162: return "Pattern Loop";
        case 164: return "Pattern Length";
        case 165: return "Included In Recording";
        case 166: return "Monitor External Input";
        case 167: return "Data Folder Mode";
        case 168: return "Key Signature Mode";
        case 169: return "Compatibility Flags";
        case 170: return "Channel Trial Lock 3";
        case 192: return "Channel Name";
        case 193: return "Pattern Name";
        case 194: return "Project Title";
        case 195: return "Project Comments";
        case 196: return "Channel Sample Path";
        case 197: return "Project URL";
        case 198: return "RTF Comments *";
        case 199: return "FL Studio Version";
        case 200: return "Licensee";
        case 201: return "Plugin Internal Name";
        case 202: return "Project Data Path";
        case 203: return "Plugin Name";
        case 204: return "Insert Name";
        case 205: return "Time Marker Name";
        case 206: return "Project Genre";
        case 207: return "Project Artists";
        case 209: return "Channel Delay";
        case 212: return "Plugin Wrapper";
        case 213: return "Plugin Data";
        case 215: return "Channel Parameters";
        case 216: return "Initial Parameter Positions";
        case 217: return "Playlist Selection";
        case 218: return "Channel Envelope LFO";
        case 219: return "Channel Levels";
        case 220: return "Channel Filter *";
        case 221: return "Channel Polyphony";
        case 223: return "Pattern Controllers";
        case 224: return "Pattern Notes";
        case 225: return "Mixer Parameters";
        case 226: return "MIDI Controller";
        case 227: return "Remote Controller";
        case 228: return "Channel Tracking";
        case 229: return "Channel Level Adjusts";
        case 230: return "Controller Formula";
        case 231: return "Display Group Name";
        case 233: return "Arrangement Playlist";
        case 234: return "Channel Automation";
        case 235: return "Insert Routing";
        case 236: return "Insert Options";  // float trackLatency; u32 flags; float inputLatency  
        case 237: return "Project Timestamp";
        case 238: return "Track Data";
        case 239: return "Track Name";
        case 241: return "Arrangement Name";
        case 242: return "Playlist Zoom";
        case 243: return "Scale Highlighting";
        default:
            Printf("Unknown event %d!!!", id);
            return "";
    }
}

typedef struct {
    local int64 value = 0;
    local int32 i = 0;
    while (true) {
        ubyte b;
        value |= (b & 127) << (7 * i);
        if(!(b & 128)) {
            break;
        }
        i++;
    }
} VarInt;

typedef struct {
    ubyte red <bgcolor=0x0000ff>;
    ubyte green <bgcolor=0x00ff00>;
    ubyte blue <bgcolor=0xff0000>;
    ubyte alpha <hidden=true>;  // maybe unused
} Color;

typedef struct {
    double delta <bgcolor=0xbef23c>;
    double value <bgcolor=0xc9167b>;
    float tension <bgcolor=0x6fc1c6>;
    uint16 tensionType <bgcolor=0xba9771>;
    ubyte isSelected <bgcolor=0x0fc612>;
    byte tensionSign <bgcolor=0x9270aa>;  // 2 = t==0, 1 = t<0, -1 = t>0
} Point;

typedef struct {
    int32 u1;
    int32 u2;
    uint32 length;
    Point points[length];
    uint32 flags;
    int32 mode;
    int32 u3;
    int32 u4;
    int32 u5;
} PointCollection;

typedef struct {
    uint32 position <bgcolor=0x08d5e0>;
    uint16 flags <bgcolor=0x85448c>;
    uint16 rack <bgcolor=0xc93c6b>;
    uint32 duration <bgcolor=0x2f9dd8>;
    uint16 key <bgcolor=0xd36d37>;
    int16 group <bgcolor=0x35c44f>;
    int16 pitch <bgcolor=0x7225d1>;
    ubyte release <bgcolor=0xc3d34c>;
    ubyte midiChannel <bgcolor=0x3192aa>;
    ubyte pan <bgcolor=0xd6268d>;
    ubyte velocity <bgcolor=0x77d14b>;
    ubyte modX <bgcolor=0x2aea30>;
    ubyte modY <bgcolor=0x39e3ef>;
} Note;

typedef struct {
    int32 u1 <bgcolor=0x5e6360>;
    ubyte paramId <bgcolor=0xcce293>;
    ubyte u2 <bgcolor=0x5e6360>;
    uint16 slot : 6 <bgcolor=0xab27b5>;
    uint16 insert : 7 <bgcolor=0x5cabd6>;
    uint16 type : 3 <bgcolor=0xb75697>;
    uint32 data <bgcolor=0xb23556>;
} MixerParam;

typedef struct {
    uint32 u1;
    uint16 targetParam;
    uint16 generatorChannel;
    uint32 initialPosition;
} InitialPosition;

typedef struct {
    uint32 position;
    uint16 patternBase;
    uint16 itemIndex;
    int32 length;
    uint16 idx;
    uint16 group;
    uint16 u1;
    int16 flags;
    uint32 u2;
    if (itemIndex >= patternBase) {
        int32 startOffset;
        int32 endOffset;
    } else {
        float startOffset;
        float endOffset;
    }
    if (build >= 2964) {
        int32 id;  // increment by 1 for each item placed
        float fadeIn;
        float fadeInTension;
        float fadeOut;
        float fadeOutTension;
        float gain;
        ubyte shouldFadeIn : 1;
        ubyte shouldFadeOut : 1;
        ubyte flags : 6;
        ubyte fadeInTensionType : 4;
        ubyte fadeOutTensionType : 4;
        ubyte new[2];
    }
    if (VersionGTE("25")) {
        ubyte newer[20];
    }
} PlaylistItem;

typedef struct {
    ubyte id <bgcolor=cSilver>;
    if (id < S_WORD) {
        byte value <bgcolor=cBlue>;
        switch (id) {
            case 37:
                trialKey = value;
                break;
            case 36:
                arrangementKey = value;
                break;
            case 43:
                // just keeping this here because it seems to always be trialKey + 1 (except for the first iteration)
                // (it would make sense for it to be +1 because a trial key of 1 indicates a license)
                local byte delta = trackDelta - value;
                trackDelta = value;
                // Printf("d=%d\n", delta);
                break;
        }
    } else if (id < S_DWORD) {
        int16 value <bgcolor=cBlue>;
    } else if (id < S_DATA) {
        switch (id) {
            case 132:
                int16 cutGroup <bgcolor=0x2aea30>;
                int16 cutBy <bgcolor=0x39e3ef>;
                break;
            case 159:
                int32 value <bgcolor=cBlue>;
                build = value;
                break;
            default:
                int32 value <bgcolor=cBlue>;
                break;
        }
    } else {
        VarInt length <bgcolor=cLtBlue>;
        switch (id) {
            case 199:
                char value[length.value];
                version = value;
                break;
            case 200:
                if (VersionLT("11")) {
                    char value[length.value];
                } else {
                    wchar_t value[length.value / 2];
                }
                break;
            case 201:
                if (VersionLT("11")) {
                    char value[length.value];
                } else {
                    wchar_t value[length.value / 2];
                }
                currentPlugin = value;
                break;
            case 209:
                int32 feedback <bgcolor=0x77d14b>;
                int32 pan <bgcolor=0xd6268d>;
                int32 pitchShift <bgcolor=0x7225d1>;
                int32 echoes <bgcolor=0x2f9dd8>;
                int32 time <bgcolor=0x08d5e0>;
                break;
            case 212:
                int32 mixerInsert <bgcolor=0x5cabd6>;
                int32 mixerSlot <bgcolor=0xab27b5>;
                int32 u1 <bgcolor=0x5e6360>;
                int32 u2 <bgcolor=0x5e6360>;
                uint32 flags <bgcolor=0x85448c>;
                uint32 page <bgcolor=0x35c44f>;
                int32 u3 <bgcolor=0x5e6360>;
                int32 u4 <bgcolor=0x5e6360>;
                int32 u5 <bgcolor=0x5e6360>;
                int32 x <bgcolor=0x2aea30>;
                int32 y <bgcolor=0x39e3ef>;
                uint32 width <bgcolor=0xab27b5>;
                uint32 height <bgcolor=0xe2e224>;
                break;
            case 213:
                if (currentPlugin == "Fruity Convolver") {
                    uint16 u1;  // 3
                    uint16 version;  // 15
                    uint32 dryMix;
                    uint32 wetMix;
                    int32 dryStereoSeparation;
                    int32 wetStereoSeparation;
                    byte mode;
                    if (mode == 0) {
                        ubyte u3;  // 0
                        ubyte pathLen;
                        char path[pathLen];
                        uint32 sampleLen;
                        ubyte sample[sampleLen];
                    } else {
                        ubyte pathLen;
                        char path[pathLen];    
                    }
                    double startOffset;
                    double endOffset;
                    double sampleStart;
                    double sampleEnd;
                    float u4;  // 0.02
                    
                    PointCollection panEnvelope;
                    PointCollection volumeEnvelope;
                    PointCollection stereoEnvelope;
                    PointCollection allEnvelope;
                    
                    PointCollection impulseResponse;
                    
                    ubyte noAutoscroll;
                    ubyte keystrokePriority;  // 0
                    ubyte u7;  // 1
                    ubyte normalize;
                    if (version >= 15) {
                        uint32 latency;
                    }
                    int32 display;
                    int32 delay;
                    int32 selfConv;
                    int32 stretch;
                    int32 eq;
                    break;
                } else if (currentPlugin == "Fruity Delay Bank") {
                    int version;
                    int dryMix;
                    int wetMix;
                    int inLevel;
                    int feedbackLevel;
                    typedef struct {
                        int pan;
                        int volume;
                        int inFilterCut;
                        int inFilterRes;
                        int inFilterGain;
                        int feedbackPan;
                        int feedbackVolume;
                        int feedbackSep;
                        int feedbackTime;
                        int feedbackOffset;
                        int fbFilterCut;
                        int fbFilterRes;
                        int fbFilterGain;
                        int outPan;
                        int outVol;
                        int toNext;
                    } Params;
                    
                    Params modules[8];
                    int oversample;
                    
                    typedef struct {
                        int filterType;
                        int filterMode;
                        int fbFilterType;
                        int fbFilterMode;
                        uint8 filterPost;
                        int feedbackMode;
                        int grainDiv;
                        int grainShape;
                        uint8 enabled;
                        uint8 leaveFirstEcho;
                        uint8 tempoBasedTime;
                    } Params2;
                    
                    Params2 newParams[8];
                } else if (currentPlugin == "Fruity Delay 2") {
                    int inPan;
                    int inVol;
                    int dryVol;
                    int feedbackVol;
                    int feedbackTime;
                    int feedbackOffset;
                    int feedbackMode;
                    int feedbackCutoff;
                } else if (currentPlugin == "Fruity Delay") {
                    int version;
                    int input;
                    int feedback;
                    int cutoff;
                    int tempo;
                    int steps;
                    int mode;
                } else if (currentPlugin == "Fruity Reeverb") {
                    int version;
                    int lowCut;
                    int highCut;
                    int delay;
                    int roomSize;
                    int diff;
                    int color;
                    int decay;
                    int highDamp;
                    int dry;
                    int reverb;
                } else if (currentPlugin == "Fruity Blood Overdrive") {
                    int version;
                    int preBand;
                    int color;
                    int preAmp;
                    int x100;
                    int postFilter;
                    int postGain;
                    int theme;
                    int _unused;  // always written as 0
                } else if (currentPlugin == "Fruity Fast Dist") {
                    int pre;
                    int thresh;
                    int type;
                    int mix;
                    int post;
                } else if (currentPlugin == "Fruity Soft Clipper") {
                    int thresh;
                    int post;
                } else if (currentPlugin == "Fruity Squeeze") {
                    int version;
                    int gain;
                    int mix;
                    int squarizeAmount;
                    int filterEnabled;
                    int filterType;
                    int filterRes;
                    int filterCut;
                    int filterPos;
                    int puncherRel;
                    int puncherImpact;
                    int puncherPreserve;
                    int puncherAmount;
                } else if (currentPlugin == "Fruity Reeverb 2") {
                    int version;
                    int lowCut;
                    int highCut;
                    int delay;
                    int size;
                    int diff;
                    int decay;
                    int damp;
                    int bass;
                    int cross;
                    int sep;
                    int dry;
                    int er;
                    int wet;
                    if (version > 10000) {
                        int speed;
                        int mod;
                    }
                    uint8 tempo;
                    uint8 side;
                } else if (currentPlugin == "Fruity WaveShaper") {
                    int32 version;
                    int32 pre;
                    int32 mix;
                    int32 post;
                    uint8 bipolar;
                    uint8 center;
                    int32 oversampleMode;
                    PointCollection points;
                    if (version > 4) {
                        int32 showSettings;
                        uint8 highQuality;
                        uint8 oversample;
                    }
                } else if (currentPlugin == "Fruity Compressor") {
                    int version;
                    int threshold;
                    int ratio;
                    int gain;
                    int attack;
                    int release;
                    int type;
                    int reportLatency;
                    
                } else if (currentPlugin == "Fruity Limiter") {
                    int version;
                    
                    typedef struct {
                        int gain;
                        int sat;
                        int ceil;
                        int attack;
                        int attackCurve;
                        int release;
                        int releaseCurve;
                        int sustain;
                        int compThres;
                        int compRatio;
                        int compKnee;
                        int compAttack;
                        int compRelease;
                        int compCurve;
                        int compSustain;
                        int noiseGateGain;
                        int noiseGateThres;
                        int noiseGateRel;
                    } LimiterState;
                    
                    LimiterState mainState;
                    LimiterState spareState;
                    
                    int speed;
                    int activeWindow;
                    uint8 showInputPeaks;
                    uint8 showOutputPeaks;
                    uint8 showAnalysisAndGain;
                    uint8 showLevel;
                    int isPaused;
                    int compSidechain;
                    if (version > 6) {
                        uint8 unsafeHeadroom;
                    }
                } else if (currentPlugin == "Fruity Multiband Compressor") {
                    int version;
                    int gain;
                    int limiter;
                    int filterType;
                    
                    int highState;
                    int highFreq;
                    int highGain;
                    int highThres;
                    int highRatio;
                    int highAttack;
                    int highRelease;
                    int highKnee;
                    
                    int midState;
                    int midFreqH;
                    int midFreqL;
                    int midGain;
                    int midThres;
                    int midRatio;
                    int midAttack;
                    int midRelease;
                    int midKnee;
                    
                    int lowState;
                    int lowFreq;
                    int lowGain;
                    int lowThres;
                    int lowRatio;
                    int lowAttack;
                    int lowRelease;
                    int lowKnee;
                    
                    uint8 mainMonitorOut;
                    uint8 lowMonitorOut;
                    uint8 midMonitorOut;
                    uint8 highMonitorOut;
                    
                    int speed;
                } else if (currentPlugin == "Soundgoodizer") {
                    int version;
                    int mode;
                    int amount;
                } else if (currentPlugin == "Transient Processor") {
                    int version;
                    int attack;
                    int drive;
                    int release;
                    int gain;
                    int attackShape;
                    int releaseShape;
                    int splitFreq;
                    int splitBalance;
                    int effect;
                    ubyte viewFlags;  // input = 1, output = 2, curve = 4
                    int isPaused;
                    int speed;
                } else if (currentPlugin == "Frequency Splitter") {
                    int version;
                    int lowMidFreq;
                    int midHighFreq;
                    int lowMidSlope;
                    int midHighSlope;
                    int linearPhase;
                    int numBands;
                    int linPhaseQuality;
                    int linPhaseModSpeed;
                    int low;
                    int mid;
                    int high;
                    int lowGain;
                    int midGain;
                    int highGain;
                    
                    int lowSend;
                    int midSend;
                    int highSend;
                    int monitor;
                    int monitorMode;
                    int bandFlags;
                    int muteFlags;
                    uint8 basicFlags;
                    int monitorInput;
                    int pivotSlope;
                    int freqPrecision;
                    int timeSmoothing;
                    int range;
                    int heatmapPosition;
                } else if (currentPlugin == "Fruity Filter") {
                    int version;
                    int cutoff;
                    int res;
                    int lowPass;
                    int bandPass;
                    int highPass;
                    int x2;
                    uint8 center;
                } else if (currentPlugin == "Fruity Parametric EQ 2") {
                    int version;
                    
                    typedef struct {
                        int bandLevels[7];
                        int freqLevels[7];
                        int bandWidthLevels[7];
                        int bandTypes[7];
                        int bandOrder[7];
                        int mainLevel;
                    } EQState;
                    
                    EQState mainState;
                    EQState spareState;
                    
                    int highQuality;
                    int highHeatmapPrecision;
                    uint8 viewBandTokens;
                    int monitorMode;
                    if (version > 2) {
                        int reducedHeatmapFreq;
                        int linearPhase;
                        int linearPhaseModSpeed;
                        
                        uint8 flags;
                        int activeBands;
                        
                        int monitorInput;
                        int bandSoloOnShift;
                        int pivotSlope;
                        int freqPrecision;
                        int timeSmoothing;
                        int histogramRange;
                        int heatmapPosition;
                        int minPhaseModSpeed;
                    }
                } else if (currentPlugin == "Fruity Parametric EQ") {
                    int bandLevels[7];
                    int freqLevels[7];
                    int bandWidthLevels[7];
                    int bandTypes[7];
                    int mainLevel;
                } else if (currentPlugin == "Fruity Chorus") {
                    int version;
                    int delay;
                    int depth;
                    int stereo;
                    int lfo1Freq;
                    int lfo2Freq;
                    int lfo3Freq;
                    int lfo1Wave;
                    int lfo2Wave;
                    int lfo3Wave;
                    int crossType;
                    int crossCutoff;
                    int wetOnly;
                } else if (currentPlugin == "Fruity Flanger") {
                    int version;
                    int delay;
                    int depth;
                    int rate;
                    int phase;
                    int damp;
                    int shape;
                    int feed;
                    int invertFeedback;
                    int invertWet;
                    int dry;
                    int wet;
                    int cross;
                } else if (currentPlugin == "Fruity Flangus") {
                    int order;
                    int depth;
                    int speed;
                    int delay;
                    int spread;
                    int cross;
                    int dry;
                    int wet;
                } else if (currentPlugin == "Fruity Phaser") {
                    int version;
                    int sweepFreq;
                    int minDepth;
                    int maxDepth;
                    int freqRange;
                    int stereo;
                    int numStages;
                    int feedback;
                    int dryWet;
                    int outGain;
                } else if (currentPlugin == "Fruity Balance") {
                    int balance;
                    int volume;
                } else if (currentPlugin == "Fruity PanOMatic") {
                    int panning;
                    int volume;
                    int lfoShape;
                    int lfoTarget;
                    int lfoAmount;
                    int lfoSpeed;
                } else if (currentPlugin == "Fruity Send") {
                    int pan;
                    int volume;
                    int dry;
                    int sendTo;
                } else if (currentPlugin == "Fruity Stereo Enhancer") {
                    int pan;
                    int volume;
                    int stereoSeparation;
                    int phaseOffset;
                    int phasePosition;
                    int phaseInversion;
                } else if (currentPlugin == "Fruity Stereo Shaper") {
                    int version;
                    int rightIntoLeft;
                    int left;
                    int right;
                    int leftIntoRight;
                    int delay;
                    int phase;
                    int inOutDifference;
                    int effectPosition;
                } else if (currentPlugin == "Frequency Shifter") {
                    int version;
                    int mix;
                    int type;
                    int frequency;
                    int lrPhase;
                    int leftShape;
                    int rightShape;
                    int feedback;
                    int stereo;
                    int freqType;
                    int startPhase;
                    int unused;  // always written as 0
                    int sidechain;
                } else if (currentPlugin == "Fruity Scratcher") {
                    int version;
                    float wavePos;
                    float finalVol;
                    float speed;
                    float accel;
                    float pan;
                    float vol;
                    float hold;
                    float sensitivity;
                    float transport;
                    float smooth1;
                    float smooth2;
                    float smooth3;
                    float smooth4;
                    float rotations;
                    int pathLen;
                    char path[pathLen];
                    byte viewMode;
                    int timecodeType;
                    uint8 riaaPreamp;
                } else if (currentPlugin == "Hyper Chorus") {
                    int version;
                    int delay;
                    int feedback;
                    int modRate;
                    int modAmount;
                    int moveAmount;
                    int movementRate;
                    int delayLines;
                    int lowPass;
                    int highPass;
                    int mix;
                    int lfoPhaseDiff;
                    int displayScaling;
                } else if (currentPlugin == "Spreader") {
                    int version;
                    int spread;
                    int stereoSeparation;
                    int lowFreqBypass;
                    int mono;
                    int enabled;
                    int theme;
                    uint8 preFX;
                    uint8 postFX;
                } else if (currentPlugin == "Fruity Big Clock") {
                    uint8 version;
                    uint8 beat;  // step = 0, beat = 1
                    int color;
                } else if (currentPlugin == "Fruity HTML NoteBook") {
                    int version;
                    uint8 pathLen;
                    if (pathLen == 0xFF) {
                        uint32 pathLen;
                    }
                    char path[pathLen];
                } else if (currentPlugin == "Fruity NoteBook 2" || currentPlugin == "Fruity NoteBook") {
                    int version;
                    int currentPage;
                    
                    if (currentPlugin == "Fruity NoteBook") {
                        typedef struct {
                            int length;
                            char content[length];
                        } NoteBook1Page;
                        
                        while (true) {
                            int pageIndex;
                            if (pageIndex == -1) break;
                            NoteBook1Page page;
                        }
                    } else {
                        typedef struct {
                            VarInt length;
                            wchar_t content[length.value];
                        } NoteBook2Page;
                        
                        while (true) {
                            int pageIndex;
                            if (pageIndex == -1) break;
                            NoteBook2Page page;
                        }
                    }
                    
                    uint8 canEdit;
                } else if (currentPlugin == "Fruity Spectroman") {
                    int version;
                    int outputMode;
                    int amp;
                    int scale;
                    uint8 windowing;
                    uint8 showPeaks;
                    uint8 stereo;
                } else if (currentPlugin == "Razer Chroma") {
                    int version;
                    int amplitude;
                    int outMode;
                    int decay;
                    int colorMode;
                    int keyboardEnabled;
                    int chromaLinkEnabled;
                    int headsetEnabled;
                    int mouseEnabled;
                    int mouseMatEnabled;
                    int keypadEnabled;
                } else if (currentPlugin == "Tuner") {
                    int version;
                    int reference;
                    int reactivity;
                    int bassMode;
                    int displayMode;
                } else if (currentPlugin == "ZGameEditor Visualizer") {
                    int length;
                    char project[length];
                } else if (currentPlugin == "3x Osc") {
                    typedef struct {
                        int32 pan;
                        int32 shape;
                        int32 coarsePitch;
                        int32 finePitch;
                        int32 phaseOffset;
                        int32 detune;
                    } Osc;
                    
                    typedef struct {
                        int32 flags <bgcolor=0x85448c>;
                        int32 envelopeEnabled <bgcolor=0x2aea30>;
                        int32 envelopePredelay <bgcolor=0xc93c6b>;
                        int32 envelopeAttack <bgcolor=0x7225d1>;
                        int32 envelopeHold <bgcolor=0x2f9dd8>;
                        int32 envelopeDecay <bgcolor=0xcce293>;
                        int32 envelopeSustain <bgcolor=0x3192aa>;
                        int32 envelopeRelease <bgcolor=0x9270aa>;
                        int32 envelopeAmount <bgcolor=0x08d5e0>;
                        int32 lfoPredelay <bgcolor=0xc93c6b>;
                        int32 lfoAttack <bgcolor=0x7225d1>;
                        int32 lfoAmount <bgcolor=0x08d5e0>;
                        int32 lfoSpeed <bgcolor=0xba9771>;
                        int32 lfoShape <bgcolor=0xb23556>;
                        int32 envelopeAttackTension <bgcolor=0xdda640>;
                        int32 envelopeDecayTension <bgcolor=0x77d14b>;
                        int32 envelopeReleaseTension <bgcolor=0x7225d1>;
                    } Env;
                    
                    int32 version;
                    
                    Osc osc1;
                    int32 osc2mix;
                    Osc osc2;
                    int32 osc3mix;
                    Osc osc3;
                    
                    int32 phaseRand;
                    ubyte invOsc1;
                    ubyte invOsc2;
                    ubyte invOsc3;
                    ubyte amOsc3;
                    if (version < 14) {
                        ubyte hq;
                        if (version < 13) {
                            ubyte old1;
                        }
                    } else {
                        int32 hq;
                        Env panEnv;
                        Env volEnv;
                        Env modXEnv;
                        Env modYEnv;
                        Env pitchEnv;
                        int32 _ustdPan;
                        int32 _ustdVolume;
                        int32 modX;
                        int32 modY;
                        int32 _ustdPitch;
                        int32 filterType;
                    }
                } else if (currentPlugin == "FL Keys") {
                    int version;
                    byte presetLength;
                    char presetName[presetLength];
                    int decay;
                    int release;
                    int hardness;
                    int velToHardness;
                    int muffle;
                    int velToMuffle;
                    int sensitivity;
                    int stereo;
                    int tune;
                    int detune;
                    int stretch;
                    int treble;
                    int pan;
                    int lfo;
                    int overdrive;
                } else if (currentPlugin == "BooBass") {
                    int version;
                    int bass;
                    int mid;
                    int treble;
                } else if (currentPlugin == "!") {

                } else {
                    Printf("Unknown plugin format for %s\n", currentPlugin);
                    ubyte data[length.value];
                }
                break;
            case 215:
                if (VersionLT("20")) {
                       ubyte data[length.value];  // idk
                       break;
                }
                int32 simSynthTempo <bgcolor=0x2f9dd8>;
                ubyte spectrumView <bgcolor=0x7225d1>;
                ubyte multiChannelWaveformView <bgcolor=0xcce293>;
                int16 u1 <bgcolor=0x5e6360>;
                ubyte useRiff <bgcolor=0xba9771>;
                ubyte removeDc <bgcolor=0xcce293>;
                ubyte delayFlags <bgcolor=0x85448c>;
                ubyte keyboardPitch <bgcolor=0x7225d1>;
                int32 simSynthKeyboardPitch <bgcolor=0x77d14b>;
                int32 drumSynthKeyboardPitch <bgcolor=0x77d14b>;
                float tone <bgcolor=0x35c44f>;
                float overtone <bgcolor=0xc93c6b>;
                float noise <bgcolor=0x7225d1>;
                float noiseBand <bgcolor=0x2f9dd8>;
                float timeStretch <bgcolor=0xcce293>;
                int32 arpDirection <bgcolor=0x35c44f>;
                int32 arpRange <bgcolor=0xc93c6b>;
                int32 arpChord <bgcolor=0x7225d1>;
                int32 arpTime <bgcolor=0x2f9dd8>;
                int32 arpGate <bgcolor=0xcce293>;
                ubyte arpSlide <bgcolor=0x3192aa>;
                ubyte u2 <bgcolor=0x5e6360>;
                ubyte fullPorta <bgcolor=0xbef23c>;
                ubyte addRoot <bgcolor=0x9270aa>;
                int16 timeGate <bgcolor=0x39e3ef>;
                int16 u3 <bgcolor=0x5e6360>;
                int32 keyRegionMin <bgcolor=0x35c44f>;
                int32 keyRegionMax <bgcolor=0x35c44f>;
                int32 layerCrossfade <bgcolor=0xc9167b>;
                ubyte normalize <bgcolor=0x77d14b>;
                ubyte inverted <bgcolor=0xc3d34c>;
                ubyte u4 <bgcolor=0x5e6360>;
                ubyte declickMode <bgcolor=0x0fc612>;
                int32 crossfade <bgcolor=0xc9167b>;
                int32 trim <bgcolor=0xab27b5>;
                int32 arpRepeat <bgcolor=0x77d14b>;
                int32 stretchTime <bgcolor=0x08d5e0>;
                int32 stretchPitch <bgcolor=0x7225d1>;
                int32 stretchMultiplier <bgcolor=0xba9771>;
                int32 stretchMode <bgcolor=0xb23556>;
                int32 pitchRange <bgcolor=0x7225d1>;
                int32 receiveNotesInput <bgcolor=0x5e6360>;
                int32 receiveNotesChannel <bgcolor=0x5e6360>;
                ubyte midiChannelThrough;
                if (VersionGTE("20")) {
                    ubyte u7[3];
                    double fxStart <bgcolor=0x2aea30>;
                    double fxEnd <bgcolor=0x39e3ef>;
                    int32 u8 <bgcolor=0x5e6360>;
                    float playbackStart <bgcolor=0x08d5e0>;
                    int32 u9 <bgcolor=0x5e6360>;
                    ubyte reverseRegions <bgcolor=0x39e3ef>;
                    ubyte fixTrim <bgcolor=0xdda640>;
                    int16 u10 <bgcolor=0x5e6360>;
                    double formantShift <bgcolor=0x77d14b>;
                }
                break;
            case 216:
                InitialPosition positions[length.value / 12];
                break;
            case 218:
                int32 flags <bgcolor=0x85448c>;
                int32 envelopeEnabled <bgcolor=0x2aea30>;
                int32 envelopePredelay <bgcolor=0xc93c6b>;
                int32 envelopeAttack <bgcolor=0x7225d1>;
                int32 envelopeHold <bgcolor=0x2f9dd8>;
                int32 envelopeDecay <bgcolor=0xcce293>;
                int32 envelopeSustain <bgcolor=0x3192aa>;
                int32 envelopeRelease <bgcolor=0x9270aa>;
                int32 envelopeAmount <bgcolor=0x08d5e0>;
                int32 lfoPredelay <bgcolor=0xc93c6b>;
                int32 lfoAttack <bgcolor=0x7225d1>;
                int32 lfoAmount <bgcolor=0x08d5e0>;
                int32 lfoSpeed <bgcolor=0xba9771>;
                int32 lfoShape <bgcolor=0xb23556>;
                int32 envelopeAttackTension <bgcolor=0xdda640>;
                int32 envelopeDecayTension <bgcolor=0x77d14b>;
                int32 envelopeReleaseTension <bgcolor=0x7225d1>;
                break;
            case 219:
                int32 pan <bgcolor=0xd6268d>;
                int32 volume <bgcolor=0xdda640>;
                int32 pitch <bgcolor=0x7225d1>;
                int32 modX <bgcolor=0x2aea30>;
                int32 modY <bgcolor=0x39e3ef>;
                int32 filterType <bgcolor=0xb75697>;
                break;
            case 221:
                int32 max <bgcolor=0x77d14b>;
                int32 slide <bgcolor=0x7225d1>;
                enum<ubyte> {None=0, Mono=1, Porta=2} type <bgcolor=0x85448c>;
                break;
            case 224:
                Note notes[length.value / 24];
                break;
            case 225:
                MixerParam params[length.value / 12];
                break;
            case 227:
                uint16 internalParam <bgcolor=0xcce293>;
                int16 automationChannel <bgcolor=0x2e69e8>;
                uint32 u1 <bgcolor=0x5e6360>;
                uint16 targetParam <bgcolor=0xbfe82e>;
                uint16 generatorChannel <bgcolor=0xc73ce0>;
                uint32 params <bgcolor=0xb23556>;
                uint32 smoothingFactor <bgcolor=0xe0bf3a>;
                break;
            case 228:
                int32 mid <bgcolor=0x2f9dd8>;
                int32 pan <bgcolor=0xd6268d>;
                int32 modX <bgcolor=0x2aea30>;
                int32 modY <bgcolor=0x39e3ef>;
                break;
            case 229:
                int32 pan <bgcolor=0xd6268d>;
                int32 volume <bgcolor=0xdda640>;
                int32 pitch <bgcolor=0x7225d1>;
                int32 modX <bgcolor=0x2aea30>;
                int32 modY <bgcolor=0x39e3ef>;
                break;
            case 233:
                if (build < 2964) {
                    PlaylistItem items[length.value / 32] <optimize=false>;
                } else if (VersionGTE("25")) {
                    PlaylistItem items[length.value / 80] <optimize=false>;
                } else {
                    PlaylistItem items[length.value / 60] <optimize=false>;
                }
                break;
            case 234:
                int32 version <bgcolor=0x22f9e0>;
                int32 lfoAmount <bgcolor=0xe2e224>;
                ubyte dontMultiplyEnvelopeLevel <bgcolor=0x2467e2>;
                PointCollection points;
                
                ubyte unknown1[16] <bgcolor=0x777761>;
                
                PointCollection lfoPoints;
                
                int32 lfoSpeed <bgcolor=0x5fdd6c>;
                int32 lfoTension <bgcolor=0x8bc643>;
                int32 lfoSkew <bgcolor=0x5cabd6>;
                int32 lfoPulseWidth <bgcolor=0xab27b5>;
                float lfoOffset <bgcolor=0x81539e>;
                break;
            case 235:
                uchar routes[length.value];  // should always be 127 bytes long
                break;
            case 238:
                int32 idx <bgcolor=0x35c44f>;
                Color color <bgcolor=0x7225d1>;
                int32 icon <bgcolor=0xbfe82e>;
                ubyte enabled <bgcolor=0x0fc612>;
                float height <bgcolor=0xe2e224>;
                int32 lockedHeight <bgcolor=0x39e3ef>;
                ubyte contentLocked <bgcolor=0x5cabd6>;
                int32 motion <bgcolor=0x85448c>;
                int32 press <bgcolor=0x81539e>;
                int32 triggerSync <bgcolor=0xab27b5>;
                uint32 queued <bgcolor=0x5cabd6>;
                uint32 tolerant <bgcolor=0x8bc643>;
                int32 positionSync <bgcolor=0x5cabd6>;
                ubyte grouped <bgcolor=0x35c44f>;
                if (VersionGTE("12")) {
                    ubyte locked <bgcolor=0x0f12c6>;
                    ubyte solo <bgcolor=0x0fc612>;
                }
                if (VersionGTE("20")) {
                    int32 trackMode <bgcolor=0xb75697>;
                    int32 targetAudioChannel <bgcolor=0x2e69e8>;
                    int32 targetInstChannel <bgcolor=0xc73ce0>;
                    ubyte expanded <bgcolor=0xe0bf3a>;
                    int32 instTrackEditMode <bgcolor=0xb23556>;
                }
                if (VersionGTE("25")) {
                    int32 showGhostNotes;
                }
                break;
            case 242:
                uint32 u1;
                double xPan;
                double xZoom;
                uint32 yPan;
                uint32 yZoom;
                break;
            default:
                uchar data[length.value] <bgcolor=cBlue>;
                break;
        }
    }
} Event;
        

while(!FEof()) {
    Event event <comment=EventNameFunc(this.id)>;
}
// Printf("Trial data: %d %d %d\n", trialKey, arrangementKey, trackDelta);

https://github.com/ashduino101/FLPFormats/blob/main/FLP.bt

[demberto]

Amazing work man, kudos 👏
I don't have any free time or motivation left in me to work on this project, but glad to see you are carrying it forward and keeping the spirit of reversing this format alive.

[ashduino101]

Thanks--I still need to figure out how some of the FL 2025 controller stuff works (controller targets used 7 bits for the insert prior to this update, which won't work now), but I'm working on throwing together a Rust crate that should support reading/writing modern FLP files

[ashduino101]

also threw together a little template (partially incomplete) for FL Studio Mobile project files in a few hours https://gist.github.com/ashduino101/249fd1d0b05ffb0967bb8b4373959287