Notifications
Clear all

Looking for a quick way to patch process synth patches into unify

6 Posts
2 Users
3 Reactions
126 Views
(@steamed)
Eminent Member
Joined: 10 months ago
Posts: 11
Topic starter  

Hi all

I find it tedious to set up a unify patch library one preset at a time.  I'm thinking this could possibly be batch processed as follows.  If someone has a better, easier idea, please share!

1) copy synth presets to be imported into unify to a temp_folder
2) use a doit program to add a unique number to the front of each preset name (example: presetName.h2p -> 1_presetName.h2p)
3) in unify, load a template synth preset with your desired generic setup
4) replace the template synth patch with each temp_folder patch one by one, quickly saving each by its prefix number ("1" in the above example)
5) use SQL to load 'presets.db' (within folder 'Library') and export 'presets.csv'
6) use a doit program to copy data from each renamed synth preset of temp_folder into presets.csv
7) use SQL to import the modified 'presets.csv'

8) delete temp_folder

unify should now have all the presets of temp_folder, with their correct name, tags, author, etc.

 


   
Quote
(@getdunne)
Illustrious Member Admin
Joined: 5 years ago
Posts: 4437
 

@steamed

This is what we refer to as a "unified" patch library, where each patch loads an instance of a given instrument plug-in, preloaded with one of that program's own presets. There are basically three techniques:

  1. The fully manual way is to create a “template” basic Unify patch with one instance of the target plug-in, then load each factory preset one at a time, and save the resulting Unify patch with the same name.
  2. The more common semi-automatic way is to create a custom script for an automation program such as AutoHotKey, and have it do the save/load operations. This method is discussed a lot in the Making Unified Libraries and Unified libraries sign-up sections of this forum.
  3. The ideal way, which I attempt to do myself, is to create a custom converter program in C++/JUCE, which reads the plug-in’s own factory preset files, and effectively converts them into Unify patch files. This requires detailed knowledge of how to convert the plug-in’s preset-file format into its binary state-data format; this usually involves quite a bit of reverse engineering. There are a few open-source examples of such preset converter utilities available at the PlugInGuru/unify-batch page on GitHub.

I have actually just been working on a variation of method 3, where the program creates an instance of the target plug-in, sends it MIDI program-change messages to make it load one preset at a time (item 4 in your list above), and then captures the plug-in's state the same way Unify (or any host/DAW) does, and saves it into a new Unify patch based on a template.

Item 4 in your list is the tricky part, because most modern plug-ins use their own unique preset format, and there is no standard technique to cause a plug-in to load one of its presets. For the Rob Papen plug-ins I was working with today, I was able to use MIDI, but not all plug-ins work that way.

There is no need to use SQL, because Unify's XML-based patch format makes it fairly easy to embed any necessary metadata (patch name, library name, author, category, tags, comments), and you can tell Unify to import newly-added patches into its database by clicking the "lightning-bolt" icon at the top of the patch browser.

To summarize: You can indeed create unified patches (semi-)automatically, but the method depends very much on the specific plug-in. Let me know which plug-in(s) you're interested in, and I may be able to give you some suggestions.

 


   
ReplyQuote
(@steamed)
Eminent Member
Joined: 10 months ago
Posts: 11
Topic starter  

Hi Shane,

Thanks for the quick response.  My current interest is to unify u-he's ACE factory content.

For my item 4, I was planning to do that part manually in unify - load a number-prefixed preset into the synth, then unify-save it as that patch's prefix number.  The line items within 'presets.csv'  to be completed can then easily be identified by their names: '1.unify', '2.unify', etc. 

Of course, this assumes I can change the 'presets.csv' filename from '1.unify' back to its original name.  I'll verify this process before investing effort.

This limits my coding effort to the easy stuff:  parsing a set patch names, categories, tags, etc. from a synth's unique textual patch format, and prefixing the names of those same patches with an integer number.  

Your discussion of modified method 3 gave me an idea for generality - suppose I have a folder of synth-presets and within that folder I also have a csv file with the information that unify needs, formatted the same as the 'presets.db'  (more specifically, 'presets.csv' exported from SQL of 'presets.db').  Assuming the corresponding synth accepts midi program change messages, could your method 3 then generically process the contents of that folder in one fell swoop? 


   
ReplyQuote
(@getdunne)
Illustrious Member Admin
Joined: 5 years ago
Posts: 4437
 

@steamed

I had written a program to unify u-he's Zebralette 3 VST3, and I tried it with ACE's presets and it seemed to work. Please try downloading this .guru file: https://www.dropbox.com/scl/fi/uqf6mxb5p73gfmyp64psg/Unified-u-he-ACE.guru?rlkey=33w5x5mcu7fo1gih82oblub1x&st=2np0j23m&dl=0 and see if it can serve as a useful starting point.

NOTE: If you have already created a library called "Unified - u-he ACE", please stash that library folder somewhere safe before using this .guru file, as otherwise your hard work would be overwritten.


UPDATE: If you downloaded that .guru file before 7pm US Eastern Time, 9 May 2024, please download again. I just updated all the patches, setting the Transport trigger mode to "Manual start/stop". This avoids notes cutting off abruptly when the transport stops and restarts.


   
steamed reacted
ReplyQuote
(@steamed)
Eminent Member
Joined: 10 months ago
Posts: 11
Topic starter  

Thanks, Shane.  You're process worked like a charm!


   
getdunne reacted
ReplyQuote
(@getdunne)
Illustrious Member Admin
Joined: 5 years ago
Posts: 4437
 

If anyone is interested, my Zebralette3 Unifier (which I modified for ACE) is open-source. It, along with numerous other tools for batch processing of Unify patch files, is available on GitHub here: https://github.com/pluginguru/unify-batch


   
don1thedon reacted
ReplyQuote
Share: