[jmsl] Articulation request

[jmsl at music.columbia.edu]

Hi Peter and Georg

The expression marks and dynamics that I decided to include into JMSL 
Score were chosen by checking first for their exportability into SCORE 
by San Andreas Press, later into MusicXML (and later to LilyPond). So I 
tended to treat with a lower priority markings, dynamics, etc that could 
not export to these publishing programs, holding to the philosophy that 
JMSL Score is not a publishing environment, and relies instead on these 
applications for professional quality output. Since then, guys like 
Peter McCullough, Georg Hajdu, Jason Freeman, and others including 
myself have pushed the real-time score reading aspect further than I 
originally anticipated. So there is a kind of tension between the 
historical intentions of JMSL Score and the creative way it is currently 
being used to pioneer new music.

I'd like to extend JMSL Score to include your suggestions, and I like 
the idea of supporting custom drawing classes. Like custom Instruments 
whose class names are included in the Score file when saved and then 
instantiated when loaded, we could include a custom NoteOrnament 
interface which would be handed the Note when it is rendered, as well as 
its graphics context (from which the x,y position and other information 
could be derived; then you do whatever drawing you want from there).  
The caveat of course is that these classes would have to be in the 
classpath (probably the plug-ins folder would be best for this), which 
adds more housekeeping for the composer/programmer and for distribution

You are right that staccato and tenuto change the hold time on playback. 
Note.play() actually handles this as Note implements InstrumentPlayable. 
It calls getPerformanceData() on the double[] handed to it, and that 
checks for the presence of these two expression marks and ottava, and 
changes accordingly. Note that the array of performance data is 
temporary array. 

<getPerformanceData() CODE EXCERPT>
if (performExpressionMarks() && (getMark() == MARK_STACCATO || getMark() 
== MARK_ACCENT_STACCATO)) {
            double expressionFactor = 0.5;
            performanceData[3] = expressionFactor * performanceData[0];
        }
        if (performExpressionMarks() && getMark() == MARK_TENUTO) {
            double expressionFactor = 0.95;
            performanceData[3] = expressionFactor * performanceData[0];
        }
        if (is8va() ) {
            performanceData[1] += 12;
        } else if (is8vb() ) {
            performanceData[1] -= 12;
        }
</getPerformanceData() CODE EXCERPT>

Maybe we could let the user provide a custom class that implements 
getPerformanceData().  Note would default to the current implementation 
unless it found a custom one.  Thinking out loud here, not promising 
anything and not picturing yet how to implement this.

Anyway, all such discussion presumes sufficiently available development 
time on my part so I don't want to over-promise; but this is a good 
direction for these conversations to go.

Thanks
Nick

jmsl at music.columbia.edu wrote:
> I'd definitely second this request!  Some others that would be cool:
>
> Tenuto + Staccato
> Breath marks
> Square and triangular fermati
> Up bow, down bow
> n for niente or the 0 with slash?
> .. and ...
> staccatissimo
> //
> +
> arpeggiations
>
> Dynamics:
> sfz, sffz, fp, sfp, rfz, fz
>
> Also, a notehead + parentheses would be very handy for notating 
> alternating tremolos as wide trills.  (i.e. Original note with 
> trem~~~~~ and second notehead in parentheses)  (and perhaps with a 
> version with extra space on the left for accidental?)
>
> As I'm writing this, however, I'm also realizing that it's not 
> possible to combine articulations on one note.  For instance, an 
> accented note with a breath mark after it isn't possible.  Though this 
> not be an issue for all, it is something that comes up in my writing.  
> Same goes for dynamics.  Usually this isn't a problem, you could just 
> tie it and place the second dynamic on the second note, but for things 
> like fp it's problematic.
>
> It would really be nice to be able to customize accents and dynamics, 
> and I think that this could really enhance JScore.  /(It also, however 
> seems like this could wreak all manner of havoc.)  I'm assuming for 
> dynamics, for instance that they are parsed such that a dynamic is 
> mapped to the volume of an instrument. With articulations, JMSL plays 
> notes shorter when they are staccato.  It looks like JMSL's play() 
> method is taking care of this. (if I understand correctly that 
> NoteInterpreter is seeing MIDI data and not markings)
>
> At the risk of over-reaching, perhaps Articulation and Dynamics could 
> eventually become classes?  An articulation class could have a draw 
> method that could either use fonts, drawing, images to create the 
> symbol. (Emmenthaler, one of the fonts that comes with lilypond, is 
> fairly promising in these regards)   The articulation class could have 
> a play method that could be overridden to create custom effects.  
> This, for instance, might allow someone to build a custom trill object 
> that releases with an ornament, or aleatoric tremolos, a hi-hat part 
> that plays different samples for closed vs. open,  etc.     Some of 
> these things are possible now, but to be able to link them tightly to 
> the notation would be fantastic!  A note might have an articulation 
> and dynamics vector (order more important for dynamics?).  For legacy, 
> getMark() returns articulationVec.get(0), and getDynamic() return 
> dynamicVec.get(0).
>
> It seems like it would need both the play information (start time, 
> pitch, etc.) as well as the note info (staccato notes should be 
> interpreted differently when there's a slur over them, for instance).  
> There could be a standard library of articulations, but having the 
> ability to override and extend it would be really helpful.  For 
> instance, I could imagine in MaxScore using a custom articulation to 
> trigger a Max event while the score is playing, or a special 
> articulation for infinite sustain until the user chooses to continue 
> playing.
>
> Let me know what you think; this is a bit of a tall request, but I 
> think there's potentially a big payoff in the accessibility of some of 
> the elements that users are most likely to want to customize.
>
> thanks,
> Peter McCulloch
>
>
> _______________________________________________
> jmsl mailing list
> jmsl at music.columbia.edu
> http://music.columbia.edu/mailman/listinfo/jmsl