Similar patches / Congratulations to Korg

[michelkeijzers]

I am currently busy with extending my PCG Tools app for generating lists with similar programs. I'm still busy with it but I could generate the following output from the factory Kronos.PCG file.

The first line in the table means: program I-A074 and U-E062 differ 6 bytes (program name difference is ignored). All other lines show other similar patches.

Of course a byte difference can mean a lot but at least it shows Korg was not lazy by just copying lots of patches, only in the U-A bank (drum kits) a lot of similar patches exist, probably because mainly different sample sets are used with other changes.

I set the max. differences to check to 50. Btw I hope I can increase the speed for generating this list because it took several minutes on my system to generate.

Besides a compliment to Korg for not just copy patches its also a preview of what you can generate with your own PCG too. I will need some time to finish it and I am quite busy next 2 weeks, but then you can find similar patches in your own PCG files.

I hope it will be useful for Korg owners.

I-A074 U-E062 6
I-B089 I-B095 44
I-F078 I-F118 43
I-F080 I-F120 19
I-F081 I-F121 25
I-F082 I-F122 49
I-F083 I-F123 3
I-F106 I-F124 26
U-A000 U-A001 6
U-A000 U-A002 7
U-A000 U-A003 41
U-A000 U-A004 46
U-A000 U-A005 47
U-A001 U-A002 4
U-A001 U-A003 39
U-A001 U-A004 46
U-A001 U-A005 45
U-A002 U-A003 38
U-A002 U-A004 47
U-A002 U-A005 44
U-A003 U-A004 6
U-A003 U-A005 3
U-A003 U-A006 12
U-A004 U-A005 10
U-A004 U-A006 19
U-A005 U-A006 16
U-A009 U-A010 14
U-A009 U-A011 41
U-A009 U-A012 17
U-A009 U-A013 13
U-A009 U-A014 15
U-A009 U-A019 39
U-A010 U-A011 32
U-A010 U-A012 23
U-A010 U-A013 4
U-A010 U-A014 6
U-A010 U-A019 38
U-A011 U-A012 50
U-A011 U-A013 31
U-A011 U-A014 33
U-A012 U-A013 20
U-A012 U-A014 22
U-A012 U-A019 46
U-A013 U-A014 3
U-A013 U-A019 35
U-A014 U-A019 36
U-A015 U-A016 30
U-A015 U-A017 43
U-A015 U-A018 43
U-A015 U-A019 50
U-A015 U-A020 11
U-A015 U-A021 10
U-A015 U-A022 10
U-A016 U-A017 40
U-A016 U-A018 40
U-A016 U-A020 22
U-A016 U-A021 21
U-A016 U-A022 21
U-A017 U-A018 1
U-A017 U-A019 41
U-A017 U-A020 37
U-A017 U-A021 36
U-A017 U-A022 36
U-A018 U-A019 41
U-A018 U-A020 37
U-A018 U-A021 36
U-A018 U-A022 36
U-A019 U-A020 44
U-A019 U-A021 43
U-A019 U-A022 43
U-A020 U-A021 2
U-A020 U-A022 2
U-A021 U-A022 1
U-A031 U-A032 30
U-A031 U-A034 31
U-A032 U-A034 27
U-A035 U-A038 31
U-A035 U-A044 31
U-A035 U-A045 32
U-A038 U-A039 43
U-A038 U-A044 19
U-A038 U-A045 17
U-A039 U-A041 33
U-A039 U-A044 49
U-A039 U-A045 45
U-A040 U-A042 31
U-A040 U-A046 39
U-A042 U-A043 47
U-A042 U-A046 32
U-A044 U-A045 16
U-A047 U-A048 32
U-A049 U-A050 40
U-A052 U-A053 21
U-A090 U-A091 39
U-A116 U-A117 8
U-A116 U-A118 15
U-A117 U-A118 17
U-A123 U-A124 10

[cynkh]

Did you start the diff algorithm after the patch name (24 bytes, I believe). As far as the time for comparing goes, what buffer size are you using to read in the patches? In my Java proggie I'm using a customized buffer size of 4960 (since that's the exact size of an EXi patch) to read in and just fill a structure with the appropriate bytes. For the diff part I just do a byte-by-byte comparison and store the offsets (since they're all less than 64k apart) in a byte array of 4960 bytes so I can actually see the difference between two patches.
Btw, just got my hands on KLC for Mac/AU so hopefully will be able to "convert" from Kronos/Oasys to KLC and vice-versa! Have over half of AL-1, PolySixEX and MS-20EX patch layout mapped (quite a time-consuming process even with customized diff proggie!) so hopefully we'll have a few extra banks floating around for Kronos/Oasys and also some Kronos/Oasys patches for KLC users!! Fingers crossed, knock on wood!

Cheers!

[michelkeijzers]

Did you start the diff algorithm after the patch name (24 bytes, I believe). As far as the time for comparing goes, what buffer size are you using to read in the patches? In my Java proggie I'm using a customized buffer size of 4960 (since that's the exact size of an EXi patch) to read in and just fill a structure with the appropriate bytes. For the diff part I just do a byte-by-byte comparison and store the offsets (since they're all less than 64k apart) in a byte array of 4960 bytes so I can actually see the difference between two patches.
Btw, just got my hands on KLC for Mac/AU so hopefully will be able to "convert" from Kronos/Oasys to KLC and vice-versa! Have over half of AL-1, PolySixEX and MS-20EX patch layout mapped (quite a time-consuming process even with customized diff proggie!) so hopefully we'll have a few extra banks floating around for Kronos/Oasys and also some Kronos/Oasys patches for KLC users!! Fingers crossed, knock on wood!

Cheers!

Hi Cynkh, good to hear from you again . Yes I ignored the patch names (and in my new app I also can ignore the set list slot descriptions). For the buffer size I use the patch size which is defined in the PCG (so it works correct for other Korg models too). I use a byte-to-byte compare, but I stop after the maximum number of differences has been reached otherwise it can take several minutes or more. I compare every program to every program (if you select all program banks), meaning about 13 (all except GM bank) * 128 * 13 * 128 = about 3 million program compares (each comparing those 4960 bytes).

I never heard of KLC... where can I find info about it?

[cynkh]

KLC is just the Korg Legacy Collection. I snagged a copy of the '07 Digital and Analog editions and have sussed out all of the PolySix patch parameters and most of the MS-20 patch params.
Working now on finishing reversing the Kronos PolySixEX and MS20EX patch parameters and get a conversion going between the two. So far I've learned that all of the patch parameters are stored as floats between 0.0 and 1.0 in the Legacy Collection.
It sounds like you're doing everything you should be doing with the patch comparison- it might just be time to split up threads. I haven't had a chance to check out the source yet to see if that's what you're already doing; but, that would be the next thing to do if not. It may be possible to do matrix-wise comparisons (on 32-bit processors it's possible to "pack" 4 bytes into a dword to do matrix transforms and operations and split them back up into the 4 bytes when the operations are complete). This might require some assembly programming since it's processor-specific but your compiler might have a switch or option someplace if it can detect that your goal is to operate matrix-wise.
Best of luck and keep up the great work! Hope the suggestions help and I'll have a look at the source over the weekend.

Cheers!

[michelkeijzers]

Should have known that (KLC). And good to hear you are also making a lot of progress.

I can give the code but the code you have does not contain the comparison part. I can send the code if you want to. Splitting up threads is not that trivial, since I gather lists which need to be combined. Besides it would only make it a factor 1, 2 or 4 at max faster (depending on the number of threads). Also, speed is not that important, it's not that people want to create hundreds of these lists. The main goal is to make it possible. And I'm not going to program in assembly if not absolutely needed. The compiler is mostly smart enough to optimize.

However, your idea might be useful to use some kind of block comparing. I will check if this is available in C#.

Greetings!

[jimknopf]

Btw, just got my hands on KLC for Mac/AU so hopefully will be able to "convert" from Kronos/Oasys to KLC and vice-versa! Have over half of AL-1, PolySixEX and MS-20EX patch layout mapped (quite a time-consuming process even with customized diff proggie!) so hopefully we'll have a few extra banks floating around for Kronos/Oasys and also some Kronos/Oasys patches for KLC users!! Fingers crossed, knock on wood!

Cheers!

Hi synkh,

I am would be very interested in all patches converted from the Legacy collection to Ms-20 and Polysix. So far I have only tested that with one or patches. Any PCG of that kind would be very welcome, even if some fine tuning would still be required.

[michelkeijzers]

Btw, just got my hands on KLC for Mac/AU so hopefully will be able to "convert" from Kronos/Oasys to KLC and vice-versa! Have over half of AL-1, PolySixEX and MS-20EX patch layout mapped (quite a time-consuming process even with customized diff proggie!) so hopefully we'll have a few extra banks floating around for Kronos/Oasys and also some Kronos/Oasys patches for KLC users!! Fingers crossed, knock on wood!

Cheers!

Hi synkh,

I am would be very interested in all patches converted from the Legacy collection to Ms-20 and Polysix. So far I have only tested that with one or patches. Any PCG of that kind would be very welcome, even if some fine tuning would still be required.

If I would use the MS20 or Polysix parameters later, could you give me the locations/values of each parameter (in the PCG)?

[cynkh]

I agree it would definitely not be a trivial thing to accomplish since you're basically re-writing the entire program to split up the work. I'm just throwing the idea out there in case the compiler has some built-in optimization/parallelization wizardry you can enable.
I'll definitely get you the full list when I'm done. Made a bit more progress today on Wavestation so hopefully very soon we'll have a nice two-way converter ready to go.
I'll keep both of you (and anyone else interested) in the loop on the conversion utilities including (or especially the nitty-gritty on offsets and "under the hood" information!

Cheers!

[michelkeijzers]

Completely rewriting is a bit too much, in C# you can do easily parallel for loops, only the problem is that all the results would be resorted afterwards ... maybe I can spend some time on it but I wait till too many people complain about the speed. I already noticed that with the default settings it's well under a minute and if you only select a few program banks it's instantly.

Thanks for keeping me in the loop; I will send the code to you today. There is not much PCG information to be found; the best source is the sysex implementation documents from Korg itself (which are good tough).