torstenanders

Thanks, but what is the Lisp function, not the shortcut, for stopping playback. I can start playback of the last score with (audition-last-score), how can I stop it Thanks! Best, Torsten

What is the Lisp function for stopping playback (bound to the shortcut cmd-esc)? ... I could never add a custom keyboard shortcut to the Opusmodus text editor Hemlock (and I tried), but I just managed adding keyboard shortcuts and a menu for playing Opusmodus snippets and my polyphonic score format to Emacs (thanks to the fact that scores now can be displayed in a separate window). Only need some key for stopping playback as well. (The main thing I will then miss when using Emacs as the Opusmodus IDE is the close integration of the document, but well, you cannot have everything On the plus side, I have a more stable editor and in particular a very good debugger.) Thanks! Torsten

>> Common Music does not "see" CLM and the interface to it is broken, because CLM is now seemingly defined in another package. > It looks like you don't know how to use CLM in Opusmodus I understand that CLM can be used directly from Opusmodus, but there also exists an interface between Common Music and CLM (I used that already in the 90s...), which is broken in the CLM port to Opusmodus when loading Common Music into it was well. Anyway, I doubt anyone with miss that Best, Torsten

Do you mean as an option for the function length-divide? That would be great, but my preferred solution would be to have some extra function complementing gen-swallow for added notes -- which then could be called within functions like length-divide -- because that would be a generic solution for all sorts of functions that somehow add notes. The slightly tricky bit would perhaps be for the function to notice which are the new notes, so it should likely get as an input both the original material and the material with the added notes to find out... I would be happy to help sketching such a function... One approach might also be if functions adding notes would somehow mark such notes with some custom articulation only used for that purpose, but that would only work for full OMN results, not single parameters (e.g., length-divide supports single length values). An alternative idea would be for functions adding notes to simply specify the positions in the resulting list that they added (with some special notation for nested lists). Anyway, if it would be much more simply to refactor only length-divide and friends, that would be welcome too...

The function LENGTH-DIVIDE and friends are a useful device for introducing some rhythmic variation to some material. However, when the processed sequence is a full OMN expression (see example below), then the added notes cause all other parameters to shift forward (additional parameters are added at the end by looping). For introducing only a slight variation to some existing material (e.g., motif) these functions are therefore not so useful, because this shift of all parameters to basically "fill" the new added notes with pitches etc. greatly change the varied material for a listener. (length-divide 1 2 '(q f3 leg+m1 q ab3 leg e c4 leg bb3 leg ab3 leg g3)) Basically, this is the opposite situation of the situation addressed by swallowing. Swallowing (e.g., with GEN-SWALLOW and the swallow argument of many other functions) avoids the shift of parameters like pitch etc. that would result from removing notes and turning them into rests. For addressing the situation above properly we would need something like the opposite of swallowing, some way to fill in parameters like pitch etc. for new notes to avoid shifting existing notes. I hope my explanation makes sense and you can see why something like the opposite of swallowing would be useful for functions that add notes to some input material. Now, the tricky question is of course, what parameters (pitch etc.) should be added in such cases. Musically useful and common in the classical literature would be, e.g., repeating the parameters (pitch etc.) of the predecessor note (though that might be a bit too simplistic and annoying at times) or somehow interpolating some pitch gap between the previous and next note with a little scale or arpeggio and only repeating the other parameters like articulations (resulting in some variation that is likely most similar to the input material, so it would be good to have that as an option). If the pitch interval between the two original notes is too small to add some pitch in between for the new now (or as an option in general for variety), it would also be good to add some ornamentation (e.g., using PITCH-ORNAMENT), but for a close similarity between the original material and the variation it would be best as an option to apply such ornamentation only to the newly added notes, not all notes. Of course, other options could also be useful for variations that vary the input material a bit more strongly, e.g., some random pitch for the new notes within certain interval bounds. Does some function that kind of is the opposite of GEN-SWALLOW in that it adds parameters like pitches for subdivided rhythmic values (to avoid the shifting) sound like a good idea? The idea with the interpolation of gaps could be implemented by turning the original duration values and pitches into some envelope and then reading that envelope with the new rhythmic values. So, that is rather strait forward. However, that would not allow for some ornamentation, because such algorithm would not recognise which notes are new that should be ornamented. Any other idea perhaps? Thanks!

Thank you very much indeed! Torsten

Thanks for coming back. Here is a little demo example snippet. This example shows a very simple motif and its repetition. I would like to annotate some motif label (I will use such labels also for segmenting parts for further processing -- that works fine). (add-text-attributes ;; motif start signs '(m1 "m1") '(m2 "m2") '(m3 "m3") '(m4 "m4") '(m5 "m5") '(m6 "m6") '(m7 "m7") '(m8 "m8") '(m9 "m9") '(m10 "m10") ) '(q c4 m1+leg d4 q c4 m1+leg d4) By contrast, the attribute num1 behaves differently. '(q c4 num1+leg d4 q c4 num1+leg d4) I would like to be able to define custom text-attributes that behave like num1 and friends. Thanks again! (If I am the only one who wants such a feature this does not need to have high priority :)

Some attributes are sticky (they do not need to be repeated to maintain being set, and when they are repeated they are not shown again in the score) -- while others are not. For example, the articulation pizz is sticky, while stacc is not. It seems that add-text-attributes declares only sticky attributes. Is it perhaps possible to also have custom non-sticky attributes? For example, want to annotate certain motif or phrase names, and if I repeat the same motif the text label is not shown again. Just in case this is already possible... Thank you! Best, Torsten

Ah, it is very useful to have all such changes collected in one place.

Ah, renaming is easy. I seemingly like that function, had to replace it 7 times

Has the function find-ambitus perhaps be renamed or otherwise be refactored? I cannot find it anymore, but some of my code depends on it. I seems it can be reproduced with possibly new function get-ambitus, but as I do not have the doc of find-ambitus with its defaults, but because I do not have the doc of find-ambitus anymore, I am not quite sure. Thank you! Best, Torsten

Dear all, After updating to a recent Opusmodus version 1.3, I ran into some errors when loading code that had been loaded and compiled before, e.g., quicklisp, quicklisp libraries, swank (the interface that allows using Emacs Slime with Opusmodus), and my own Lisp libraries. The errors I saw were rather cryptic, like the following: Error: The value "CL" is not of the expected type list. While executing: (:internal ccl::operation-on-all-specs ccl::%define-package), in process Listener-1(7). After exchanges with Janusz (thanks a lot for your help!) I learnt that the underlying Common Lisp version of Opusmodus had been upgraded to CCL version 1.12, and the format of compiled files (fasl files or dx64fsl files) of this version had changed. So, in case you run into similar problems, these can be fixed simply by deleting all previously compiled files (which Lisp stores if they do not change to speed up the load process), so that the Lisp compiler has to compile them again. In the folder ~/.cache/common-lisp just delete any folders starting with ccl-, so that all compiled files in this directory are compiled again. Best, Torsten

> While I can create a canon, counterpoint and a fugue myself with a bit of time, it would be much less time-consuming for me if I were able to use existing examples. Is there an existing library of OMN examples of these types of compositions? I cannot offer ready-made examples, but a constraint-based library with various counterpoint (and also harmony) rules ready-made. Cluster engine implements the constraint solver, and many functions for applying user-defined rules to various score contexts in a flexible way (e.g., consecutive notes in certain voices, simultaneous notes across voices at certain metric positions etc). https://github.com/tanders/cluster-engine Cluster rules provides a collection of ready-made rules for the cluster engine library. https://github.com/tanders/cluster-rules Both libraries were initially developed for PWGL, but we ported them to plain Common Lisp to make them usable, e.g., in Opusmodus (where I already used both) and the Max<->Lisp interface I just mentioned in other message. There are some demo/test examples that come with the library (https://github.com/tanders/cluster-rules/blob/master/tests/first-tests.lisp). More extensive documentation (tutorials) are available with the original PWGL versions of the libraries. Some code to smoothly interface the Cluster Library with Opusmodus is part of my tot library (e.g. in the file https://github.com/tanders/tot/blob/master/sources/constraints.lisp). For example, there are means to transform Cluster Library scores into Opusmodus scores (actually, my variant of it, see the docs) and some more complex functions that could be seen as example use cases. For example, the function revise-score-harmonically, expects an existing score that you might create with whatever Opusmodus methods, and some underlying harmony definitions, and that re-harmonises the score accordingly, taking some counterpoint rules etc. into account. I hope the available doc of these packages helps (of which there is also some HTML version online). I cannot provide any more help at this stage, as I am currently extremely busy in my new job... Best, Torsten

Here are some links to another project working on a bridge between Max and Common Lisp. They are calling SBCL in the background using the shell interface of Max, if I recall correctly. The project is not yet very mature, but they have several OpenMusic/PWGL libraries running with a Max interface for pedagogic purposes. LISP in Max: Exploratory Computer-Aided Composition in Real-Time QUOD.LIB.UMICH.EDU MOZ’Lib | bach WWW.BACHPROJECT.NET MOZ’Lib is a set of pedagogical tools designed to explore, at the same time: musical writing, creation and computer programming. It is currently developed by two composers based in Paris, Julien Vi… It is tricky to get recent sources of this work online. If you are interested, I suggest you best contact the developers directly, e.g., Julien Vincenot Bio | Julien Vincenot JULIENVINCENOT.COM Say hello from me Best, Torsten

> Sometimes is interesting for hearing snippets with different sounds without having to compile the entire score My Opmo score data structure already allows for that, though you always have to render snippets with an explicit function call, as we cannot define custom shortcuts so far. It is part of my tools at https://github.com/tanders/tot. Check out the function preview-score (https://tanders.github.io/tot/sources/score.html#_g232191). Various other functions allow to transform polyphonic score snippets for one or more instruments in various ways. Best, Torsten

FYI, the changes I proposed are meanwhile merged into the repository at https://github.com/ormf/cm, so you can directly load the Common Music version shared there into Opusmodus 1.3 again. Best, Torsten

I should add that all I fixed was that the full Common Music can be loaded again into Opusmodus 1.3. However, Common Music does not "see" CLM and the interface to it is broken, because CLM is now seemingly defined in another package. However, if anyone wants to use CM with CLM you can load it into a Lisp image without Opusmodus. Best, Torsten

Common Music (CM) is another interesting composition system (http://commonmusic.sourceforge.net), and a recent revision of the old CM version 2 (https://github.com/ormf/cm), which was still implemented in Common Lisp (in contrast to later versions defined in Scheme) can be loaded into and used alongside Opusmodus 1.2 without problems. This was possible primarily due to a largely revised load mechanism of the old CM sources. With the new Opusmodus 1.3 this is not possible any more. It seems the problem is caused by the fact that :CLM (and a number of variants) are still added to *features*, but there is no CLM package anymore. I cannot see the Opusmodus sources, but I assume that all CLM definitions have been added directly to the Opusmodus package. Anyway, due to the present feature CM assumes that CLM is there, but then cannot find its package. Anyway, I found a way around (by changing the relevant feature expressions from #-clm into #-(and clm (not opusmodus)) and will try to have that included in the relevant CM sources at https://github.com/ormf/cm Best, Torsten

EDIT: I fixed the problem by updating the Lisp side of SLIME manually, as the SLIME version in Quicklisp is quite old (20150709). Best, Torsten

Opusmodus 1.2 can be used from within the Emacs editor as well (see the post at the link below for details). For me as a programmer having additionally access to the Emacs Lisp IDE SLIME is greatly preferable due to various advanced features provided by Slime when compared with the more easy-to-use native IDE of Opusmodus. For more information on SLIME see its website: https://common-lisp.net/project/slime Unfortunately, the SLIME link is seemingly broken in Opusmodus 1.3, which I just started for the first time. For those who have no SLIME installed (but have Quicklisp set up), SLIME can be installed with the following command. (ql:quickload "quicklisp-slime-helper") Unfortunately, this results now in an error. To load "quicklisp-slime-helper": Load 1 ASDF system: quicklisp-slime-helper ; Loading "quicklisp-slime-helper" .. > Error: Undefined function asdf/interface::operation-forced called with arguments (#<load-op>) . > While executing: #<standard-method asdf/action:perform (asdf/lisp-action:load-op swank-loader::swank-loader-file)>, in process Listener-2(9). > Type cmd-/ to continue, cmd-. to abort, cmd-\ for a list of available restarts. > If continued: Retry applying asdf/interface::operation-forced to (#<load-op>). > Type :? for other options. I already had SLIME installed, but simply running it does not work either and results in the same error. (cl-user::start-swank) ? To load "swank": Load 1 ASDF system: swank ; Loading "swank" . > Error: Undefined function asdf/interface::operation-forced called with arguments (#<load-op>) . > While executing: #<standard-method asdf/action:perform (asdf/lisp-action:load-op swank-loader::swank-loader-file)>, in process Listener-2(9). > Type cmd-/ to continue, cmd-. to abort, cmd-\ for a list of available restarts. > If continued: Retry applying asdf/interface::operation-forced to (#<load-op>). > Type :? for other options. Any help? Thanks a lot! Best, Torsten

Do you perhaps mean the following? Reina, R. (2016) Applying Karnatic Rhythmical Techniques to Western Music. Routledge. https://books.google.co.uk/books?id=4RSrCwAAQBAJ&amp;printsec=frontcover#v=onepage&amp;q&amp;f=false Online material http://www.rafaelreina.org/book-online-material.html Related course http://www.contemporary-music-through-non-western-techniques.com Apologies for my late response. Best, Torsten

There is currently no support for multiple monitors, unfortunately, but it may be on the TODO list of the developers. See also the following link.

BTW: It seems that Opusmodus sends various redundant MIDI events when looking at its realtime output with MIDI monitor. Initially, CC 123 and 120 are initialised to 0 for all 16 channels, but this is done several times (at the end this is done again, but only once). More worryingly, notes are send multiple times. For example, when you send the example below in a score, a note-on for the first note (C5) is send twice almost simultaneously, followed by a note-off for both those notes simultaneously. Indeed, you can commonly hear the result of that as a quasi hick-up in the output, or that the first note is simply skipped. The next notes are also always output twice, but those double events are exactly simultaneously. (q c5 d5 e5 f5) A related problem is that note-offs and succeeding note-ons are exactly at the same time, which can result in problems for note repetitions. Best, Torsten

I am still working on getting playback for GrandOrgue working properly. I defined a sound set with various articulations (shown in a related post, see link below) for setting, e.g., which manual to use for the current hand, and which stop combinations on that manual. Those articulations already work individually in Opusmodus. The problem I am facing is that I need to constantly combine multiple of such articulations in a single note. For example, I may need to specify that the right hand stops playing on the manual I (one articulation), that it instead plays on manual II and III coupled (two further articulations) and which stop combinations to use for those manuals (two more articulations). So, in this example we have five articulations on a single note, and each needs to send a specific MIDI event. Such an occurrence is something completely normal in organ literature. In OMN, this could be written, e.g., as follows using my sound set shown in the post linked below. '((q c4 -I+II5+III6+II+III)) Now, my only problem is that whenever there are two articulations combined for a single note, where each should output its own MIDI event, Opusmodus always only outputs just one of these MIDI events. I confirmed this by checking the resulting MIDI events both in an exported MIDI file and with a realtime MIDI monitor (https://www.snoize.com/MIDIMonitor/). Note that my setup works with other software (notation software and DAWs), as they allow for having multiple articulations allocated to a single note outputting separate MIDI events. Is this perhaps somehow possible with Opusmodus as well? Best, Torsten PS: I realise that Opusmodus does send multiple MIDI events if multiple MIDI events are explicitly specified for a single articulation, as in the "VSL Cello Solo" file. However, I cannot really explicitly define all the possible articulation combinations as individual articulations instead, as what would result in an impractical large number of them. There are currently individual 48 articulations (for an organ with three manuals and 10 preset combinations each), and these articulations can be combined in various ways in pairs, triplets, quadruples etc., which would result in an impractically huge number of articulations to define. PPS: One potential workaround for some situations would be to instead allocate some of these articulations to rests immediately preceding the notes for which they are needed, but that is not possible either, because custom articulations cannot be added to rests. Instead, additional notes are added. PPPS: For completeness: a related post.

In common music notation, if you use some "sticky" playing technique and you want to "disable" it later, then you should tell so the performer, should you not? Best, Torsten