PresetExtractor.cpp (16370B)
1 /* 2 ZynAddSubFX - a software synthesizer 3 4 PresetExtractor.cpp - Extract Presets from realtime data 5 Copyright (C) 2015 Mark McCurry 6 7 This program is free software; you can redistribute it and/or 8 modify it under the terms of the GNU General Public License 9 as published by the Free Software Foundation; either version 2 10 of the License, or (at your option) any later version. 11 */ 12 13 #include "../Params/PresetsStore.h" 14 15 #include "../Misc/Master.h" 16 #include "../Misc/Util.h" 17 #include "../Misc/Allocator.h" 18 #include "../Effects/EffectMgr.h" 19 #include "../Synth/OscilGen.h" 20 #include "../Synth/Resonance.h" 21 #include "../Params/ADnoteParameters.h" 22 #include "../Params/EnvelopeParams.h" 23 #include "../Params/FilterParams.h" 24 #include "../Params/LFOParams.h" 25 #include "../Params/PADnoteParameters.h" 26 #include "../Params/Presets.h" 27 #include "../Params/PresetsArray.h" 28 #include "../Params/SUBnoteParameters.h" 29 #include "../Misc/MiddleWare.h" 30 #include "PresetExtractor.h" 31 #include <rtosc/ports.h> 32 #include <rtosc/port-sugar.h> 33 #include <string> 34 35 namespace zyn { 36 37 using std::string; 38 static void dummy(const char *, rtosc::RtData&) {} 39 40 const rtosc::Ports real_preset_ports = 41 { 42 {"scan-for-presets:", 0, 0, 43 [](const char *, rtosc::RtData &d) { 44 MiddleWare &mw = *(MiddleWare*)d.obj; 45 assert(d.obj); 46 mw.getPresetsStore().scanforpresets(); 47 auto &pre = mw.getPresetsStore().presets; 48 d.reply(d.loc, "i", pre.size()); 49 for(unsigned i=0; i<pre.size();++i) 50 d.reply(d.loc, "isss", i, 51 pre[i].file.c_str(), 52 pre[i].name.c_str(), 53 pre[i].type.c_str()); 54 55 }}, 56 {"copy:s:ss:si:ssi", 0, 0, 57 [](const char *msg, rtosc::RtData &d) { 58 MiddleWare &mw = *(MiddleWare*)d.obj; 59 assert(d.obj); 60 std::string args = rtosc_argument_string(msg); 61 d.reply(d.loc, "s", "clipboard copy..."); 62 printf("\nClipboard Copy...\n"); 63 if(args == "s") 64 presetCopy(mw, rtosc_argument(msg, 0).s, ""); 65 else if(args == "ss") 66 presetCopy(mw, rtosc_argument(msg, 0).s, 67 rtosc_argument(msg, 1).s); 68 else if(args == "si") 69 presetCopyArray(mw, rtosc_argument(msg, 0).s, 70 rtosc_argument(msg, 1).i, ""); 71 else if(args == "ssi") 72 presetCopyArray(mw, rtosc_argument(msg, 0).s, 73 rtosc_argument(msg, 2).i, rtosc_argument(msg, 1).s); 74 else 75 assert(false && "bad arguments"); 76 }}, 77 {"paste:s:ss:si:ssi", 0, 0, 78 [](const char *msg, rtosc::RtData &d) { 79 MiddleWare &mw = *(MiddleWare*)d.obj; 80 assert(d.obj); 81 std::string args = rtosc_argument_string(msg); 82 d.reply(d.loc, "s", "clipboard paste..."); 83 if(args == "s") 84 presetPaste(mw, rtosc_argument(msg, 0).s, ""); 85 else if(args == "ss") 86 presetPaste(mw, rtosc_argument(msg, 0).s, 87 rtosc_argument(msg, 1).s); 88 else if(args == "si") 89 presetPasteArray(mw, rtosc_argument(msg, 0).s, 90 rtosc_argument(msg, 1).i, ""); 91 else if(args == "ssi") 92 presetPasteArray(mw, rtosc_argument(msg, 0).s, 93 rtosc_argument(msg, 2).i, rtosc_argument(msg, 1).s); 94 else 95 assert(false && "bad arguments"); 96 }}, 97 {"clipboard-type:", 0, 0, 98 [](const char *, rtosc::RtData &d) { 99 const MiddleWare &mw = *(MiddleWare*)d.obj; 100 assert(d.obj); 101 d.reply(d.loc, "s", mw.getPresetsStore().clipboard.type.c_str()); 102 }}, 103 {"delete:s", 0, 0, 104 [](const char *msg, rtosc::RtData &d) { 105 MiddleWare &mw = *(MiddleWare*)d.obj; 106 assert(d.obj); 107 mw.getPresetsStore().deletepreset(rtosc_argument(msg,0).s); 108 }}, 109 110 }; 111 112 // Documentation for real_preset_ports above. 113 const rtosc::Ports preset_ports 114 { 115 {"scan-for-presets:", rDoc("Scan For Presets"), 0, dummy}, 116 {"copy:s:ss:si:ssi", rDoc("Copy (s)URL to (s) Name/Clipboard from subfield (i)"), 0, dummy}, 117 {"paste:s:ss:si:ssi", rDoc("Paste (s) URL to (s) File-Name/Clipboard from subfield (i)"), 0, dummy}, 118 {"clipboard-type:", rDoc("Type Stored In Clipboard"), 0, dummy}, 119 {"delete:s", rDoc("Delete the given preset file"), 0, dummy}, 120 }; 121 122 //Relevant types to keep in mind 123 //Effects/EffectMgr.cpp: setpresettype("Peffect"); 124 //Params/ADnoteParameters.cpp: setpresettype("Padsynth"); 125 //Params/EnvelopeParams.cpp: //setpresettype("Penvamplitude"); 126 //Params/EnvelopeParams.cpp: //setpresettype("Penvamplitude"); 127 //Params/EnvelopeParams.cpp: //setpresettype("Penvfrequency"); 128 //Params/EnvelopeParams.cpp: //setpresettype("Penvfilter"); 129 //Params/EnvelopeParams.cpp: //setpresettype("Penvbandwidth"); 130 //Params/FilterParams.cpp: //setpresettype("Pfilter"); 131 //Params/LFOParams.cpp: // setpresettype("Plfofrequency"); 132 //Params/LFOParams.cpp: // setpresettype("Plfoamplitude"); 133 //Params/LFOParams.cpp: // setpresettype("Plfofilter"); 134 //Params/PADnoteParameters.cpp: setpresettype("Ppadsynth"); 135 //Params/SUBnoteParameters.cpp: setpresettype("Psubsynth"); 136 //Synth/OscilGen.cpp: setpresettype("Poscilgen"); 137 //Synth/Resonance.cpp: setpresettype("Presonance"); 138 139 140 /***************************************************************************** 141 * Implementation Methods * 142 *****************************************************************************/ 143 class Capture:public rtosc::RtData 144 { 145 public: 146 Capture(void *obj_) 147 { 148 matches = 0; 149 memset(locbuf, 0, sizeof(locbuf)); 150 memset(msgbuf, 0, sizeof(msgbuf)); 151 loc = locbuf; 152 loc_size = sizeof(locbuf); 153 obj = obj_; 154 } 155 156 virtual void reply(const char *path, const char *args, ...) 157 { 158 //printf("reply(%p)(%s)(%s)...\n", msgbuf, path, args); 159 //printf("size is %d\n", sizeof(msgbuf)); 160 va_list va; 161 va_start(va,args); 162 char *buffer = msgbuf; 163 rtosc_vmessage(buffer,sizeof(msgbuf),path,args,va); 164 va_end(va); 165 } 166 char msgbuf[1024]; 167 char locbuf[1024]; 168 }; 169 170 template <class T> 171 T capture(Master *m, std::string url); 172 173 template <> 174 std::string capture(Master *m, std::string url) 175 { 176 Capture c(m); 177 char query[1024]; 178 rtosc_message(query, 1024, url.c_str(), ""); 179 Master::ports.dispatch(query+1,c); 180 if(rtosc_message_length(c.msgbuf, sizeof(c.msgbuf))) { 181 if(rtosc_type(c.msgbuf, 0) == 's') 182 return rtosc_argument(c.msgbuf,0).s; 183 } 184 185 return ""; 186 } 187 188 template <> 189 void *capture(Master *m, std::string url) 190 { 191 Capture c(m); 192 char query[1024]; 193 rtosc_message(query, 1024, url.c_str(), ""); 194 Master::ports.dispatch(query+1,c); 195 if(rtosc_message_length(c.msgbuf, sizeof(c.msgbuf))) { 196 if(rtosc_type(c.msgbuf, 0) == 'b' && 197 rtosc_argument(c.msgbuf, 0).b.len == sizeof(void*)) 198 return *(void**)rtosc_argument(c.msgbuf,0).b.data; 199 } 200 201 return NULL; 202 } 203 204 template<class T> 205 std::string doCopy(MiddleWare &mw, string url, string name) 206 { 207 mw.doReadOnlyOp([url, name, &mw](){ 208 Master *m = mw.spawnMaster(); 209 //Get the pointer 210 T *t = (T*)capture<void*>(m, url+"self"); 211 assert(t); 212 //Extract Via mxml 213 t->copy(mw.getPresetsStore(), name.empty()? NULL:name.c_str()); 214 }); 215 216 return ""; 217 } 218 219 template<class T, typename... Ts> 220 void doPaste(MiddleWare &mw, string url, string type, XMLwrapper &xml, Ts&&... args) 221 { 222 //Generate a new object 223 T *t = new T(std::forward<Ts>(args)...); 224 225 //Old workaround for LFO parameters 226 if(strstr(type.c_str(), "Plfo")) 227 type = "Plfo"; 228 229 if(xml.enterbranch(type) == 0) 230 { 231 delete t; 232 return; 233 } 234 235 t->getfromXML(xml); 236 237 //Send the pointer 238 string path = url+"paste"; 239 char buffer[1024]; 240 rtosc_message(buffer, 1024, path.c_str(), "b", sizeof(void*), &t); 241 if(!Master::ports.apropos(path.c_str())) 242 fprintf(stderr, "Warning: Missing Paste URL: '%s'\n", path.c_str()); 243 //printf("Sending info to '%s'\n", buffer); 244 mw.transmitMsg(buffer); 245 246 //Let the pointer be reclaimed later 247 } 248 249 template<class T> 250 std::string doArrayCopy(MiddleWare &mw, int field, string url, string name) 251 { 252 //printf("Getting info from '%s'<%d>\n", url.c_str(), field); 253 mw.doReadOnlyOp([url, field, name, &mw](){ 254 Master *m = mw.spawnMaster(); 255 //Get the pointer 256 T *t = (T*)capture<void*>(m, url+"self"); 257 //Extract Via mxml 258 t->copy(mw.getPresetsStore(), field, name.empty()?NULL:name.c_str()); 259 }); 260 261 return ""; 262 } 263 264 template<class T, typename... Ts> 265 void doArrayPaste(MiddleWare &mw, int field, string url, string type, 266 XMLwrapper &xml, Ts&&... args) 267 { 268 //Generate a new object 269 T *t = new T(std::forward<Ts>(args)...); 270 271 if(xml.enterbranch(type+"n") == 0) { 272 delete t; 273 return; 274 } 275 t->defaults(field); 276 t->getfromXMLsection(xml, field); 277 xml.exitbranch(); 278 279 //Send the pointer 280 string path = url+"paste-array"; 281 char buffer[1024]; 282 rtosc_message(buffer, 1024, path.c_str(), "bi", sizeof(void*), &t, field); 283 if(!Master::ports.apropos(path.c_str())) 284 fprintf(stderr, "Warning: Missing Paste URL: '%s'\n", path.c_str()); 285 //printf("Sending info to '%s'<%d>\n", buffer, field); 286 mw.transmitMsg(buffer); 287 288 //Let the pointer be reclaimed later 289 } 290 291 /* 292 * Dispatch to class specific operators 293 * 294 * Oscilgen and PADnoteParameters have mixed RT/non-RT parameters and require 295 * extra handling. 296 * See MiddleWare.cpp for these specifics 297 */ 298 void doClassPaste(std::string type, std::string type_, MiddleWare &mw, string url, XMLwrapper &data) 299 { 300 //printf("Class Paste\n"); 301 if(type == "EnvelopeParams") 302 doPaste<EnvelopeParams>(mw, url, type_, data); 303 else if(type == "LFOParams") 304 doPaste<LFOParams>(mw, url, type_, data); 305 else if(type == "FilterParams") 306 doPaste<FilterParams>(mw, url, type_, data); 307 else if(type == "ADnoteParameters") 308 doPaste<ADnoteParameters>(mw, url, type_, data, mw.getSynth(), (FFTwrapper*)NULL); 309 else if(type == "PADnoteParameters") 310 doPaste<PADnoteParameters>(mw, url, type_, data, mw.getSynth(), (FFTwrapper*)NULL); 311 else if(type == "SUBnoteParameters") 312 doPaste<SUBnoteParameters>(mw, url, type_, data); 313 else if(type == "OscilGen") 314 doPaste<OscilGen>(mw, url, type_, data, mw.getSynth(), (FFTwrapper*)NULL, (Resonance*)NULL); 315 else if(type == "Resonance") 316 doPaste<Resonance>(mw, url, type_, data); 317 else if(type == "EffectMgr") 318 doPaste<EffectMgr>(mw, url, type_, data, DummyAlloc, mw.getSynth(), false); 319 else { 320 fprintf(stderr, "Warning: Unknown type<%s> from url<%s>\n", type.c_str(), url.c_str()); 321 } 322 } 323 324 std::string doClassCopy(std::string type, MiddleWare &mw, string url, string name) 325 { 326 //printf("doClassCopy(%p)\n", mw.spawnMaster()->uToB); 327 if(type == "EnvelopeParams") 328 return doCopy<EnvelopeParams>(mw, url, name); 329 else if(type == "LFOParams") 330 return doCopy<LFOParams>(mw, url, name); 331 else if(type == "FilterParams") 332 return doCopy<FilterParams>(mw, url, name); 333 else if(type == "ADnoteParameters") 334 return doCopy<ADnoteParameters>(mw, url, name); 335 else if(type == "PADnoteParameters") 336 return doCopy<PADnoteParameters>(mw, url, name); 337 else if(type == "SUBnoteParameters") 338 return doCopy<SUBnoteParameters>(mw, url, name); 339 else if(type == "OscilGen") 340 return doCopy<OscilGen>(mw, url, name); 341 else if(type == "Resonance") 342 return doCopy<Resonance>(mw, url, name); 343 else if(type == "EffectMgr") 344 doCopy<EffectMgr>(mw, url, name); 345 return "UNDEF"; 346 } 347 348 void doClassArrayPaste(std::string type, std::string type_, int field, MiddleWare &mw, string url, 349 XMLwrapper &data) 350 { 351 if(type == "FilterParams") 352 doArrayPaste<FilterParams>(mw, field, url, type_, data); 353 else if(type == "ADnoteParameters") 354 doArrayPaste<ADnoteParameters>(mw, field, url, type_, data, mw.getSynth(), (FFTwrapper*)NULL); 355 } 356 357 std::string doClassArrayCopy(std::string type, int field, MiddleWare &mw, string url, string name) 358 { 359 if(type == "FilterParams") 360 return doArrayCopy<FilterParams>(mw, field, url, name); 361 else if(type == "ADnoteParameters") 362 return doArrayCopy<ADnoteParameters>(mw, field, url, name); 363 return "UNDEF"; 364 } 365 366 //This is an abuse of the readonly op, but one that might look reasonable from a 367 //user perspective... 368 std::string getUrlPresetType(std::string url, MiddleWare &mw) 369 { 370 std::string result; 371 mw.doReadOnlyOp([url, &result, &mw](){ 372 Master *m = mw.spawnMaster(); 373 //Get the pointer 374 result = capture<std::string>(m, url+"preset-type"); 375 }); 376 //printf("preset type = %s\n", result.c_str()); 377 return result; 378 } 379 380 std::string getUrlType(std::string url) 381 { 382 assert(!url.empty()); 383 //printf("Searching for '%s'\n", (url+"self").c_str()); 384 auto self = Master::ports.apropos((url+"self").c_str()); 385 if(!self) 386 fprintf(stderr, "Warning: URL Metadata Not Found For '%s'\n", url.c_str()); 387 388 if(self) 389 return self->meta()["class"]; 390 else 391 return ""; 392 } 393 394 395 /***************************************************************************** 396 * API Stubs * 397 *****************************************************************************/ 398 399 #if 0 400 Clipboard clipboardCopy(MiddleWare &mw, string url) 401 { 402 //Identify The Self Type of the Object 403 string type = getUrlType(url); 404 printf("Copying a '%s' object", type.c_str()); 405 406 //Copy The Object 407 string data = doClassCopy(type, mw, url); 408 printf("Object Information '%s'\n", data.c_str()); 409 410 return {type, data}; 411 } 412 413 void clipBoardPaste(const char *url, Clipboard clip) 414 { 415 (void) url; 416 (void) clip; 417 } 418 #endif 419 420 void presetCopy(MiddleWare &mw, std::string url, std::string name) 421 { 422 (void) name; 423 doClassCopy(getUrlType(url), mw, url, name); 424 //printf("PresetCopy()\n"); 425 } 426 void presetPaste(MiddleWare &mw, std::string url, std::string name) 427 { 428 (void) name; 429 //printf("PresetPaste()\n"); 430 string data = ""; 431 XMLwrapper xml; 432 if(name.empty()) { 433 data = mw.getPresetsStore().clipboard.data; 434 if(data.length() < 20) 435 return; 436 if(!xml.putXMLdata(data.c_str())) 437 return; 438 } else { 439 if(xml.loadXMLfile(name)) 440 return; 441 } 442 443 doClassPaste(getUrlType(url), getUrlPresetType(url, mw), mw, url, xml); 444 } 445 void presetCopyArray(MiddleWare &mw, std::string url, int field, std::string name) 446 { 447 (void) name; 448 //printf("PresetArrayCopy()\n"); 449 doClassArrayCopy(getUrlType(url), field, mw, url, name); 450 } 451 void presetPasteArray(MiddleWare &mw, std::string url, int field, std::string name) 452 { 453 (void) name; 454 //printf("PresetArrayPaste()\n"); 455 string data = ""; 456 XMLwrapper xml; 457 if(name.empty()) { 458 data = mw.getPresetsStore().clipboard.data; 459 if(data.length() < 20) 460 return; 461 if(!xml.putXMLdata(data.c_str())) 462 return; 463 } else { 464 if(xml.loadXMLfile(name)) 465 return; 466 } 467 //printf("Performing Paste...\n"); 468 doClassArrayPaste(getUrlType(url), getUrlPresetType(url, mw), field, mw, url, xml); 469 } 470 #if 0 471 void presetPaste(std::string url, int) 472 { 473 printf("PresetPaste()\n"); 474 doClassPaste(getUrlType(url), *middlewarepointer, url, presetsstore.clipboard.data); 475 } 476 #endif 477 void presetDelete(int) 478 { 479 printf("PresetDelete()<UNIMPLEMENTED>\n"); 480 } 481 void presetRescan() 482 { 483 printf("PresetRescan()<UNIMPLEMENTED>\n"); 484 } 485 std::string presetClipboardType() 486 { 487 printf("PresetClipboardType()<UNIMPLEMENTED>\n"); 488 return "dummy"; 489 } 490 bool presetCheckClipboardType() 491 { 492 printf("PresetCheckClipboardType()<UNIMPLEMENTED>\n"); 493 return true; 494 } 495 496 }