Re: Bug in articulate.ly

[H. S. Teoh]

On Fri, Feb 27, 2015 at 05:14:09PM -0800, Flaming Hakama by Elaine wrote:
[...]
> I've recently been using lilypond with articulate.ly to produce midi
> versions of pieces and have to say that, despite its limitations, I've
> been getting results that are not terrible.

I've been getting mixed results. For certain types of pieces, it's quite
acceptable. But for others, it's quite a lot of work to get it to the
point of being tolerable.


> Among other things, it depends on the Virtual Instruments you use to
> render the sound.  Bad instruments will never sound good.

Definitely! I've been using a software synthesizer (TiMidity++) with
some high-quality soundfonts, and have been able to get quite decent
output for some pieces. It does require some effort to setup and tune,
though.


> Decent results are only possible if you include a lot of detailed
> articulations and dynamics, perhaps more than you would put in a part
> intended for a human.  Although some schools of thought say this is
> good for printed parts, too.

It's a toss-up for me. Some of my pieces intentionally leave a lot of
things open to interpretation -- because I want the performer the
freedom to interpret.  But for a computer, that obviously produces
rather poor results (very mechanical and dry -- perhaps even a
caricature of my intent!). Other pieces are more precise, and generally
tend to produce better results.

Ideally, I'd like to be able to specify interpretations of elements in
the typeset score, for example, something like:

        % (This is hypothetical syntax)
        | \interpret{ a1\prall } { b16 a gis b a2. } |

which would cause the { a1\prall } appear on the score, but { b16 a gis
b a2. } to be output to MIDI in its place.

I know \articulate already expands prall trillers, but the idea is that
you'd specify what should appear the score alongside with its specific
interpretation (or one of the many possible interpretations thereof).
Another example is that you could indicate "tempo rubato" and then
specify as interpretation one of the many possible actual tempo(s) that
would be used for rendering the MIDI.


> Also, it requires tweaking the parameters in articulate.ly to match
> the style of music.  (To get optimal results, these will likely have
> to vary for each different virtual instrument.)

That's a very good idea! So far I've been applying \articulate to the
entire score. It would probably work better to apply it individually to
each staff with parameters customized accordingly, or perhaps even to
individual passages to get a finer-grained control over the precise
parameters to use.


> If you do all that, you can certainly get tolerable representations of
> scores.

True! Thanks for the ideas!


[...]
> The several things I noticed when using it were:
> 
> I had to add a "fullValue" articulation definition since it expects
> tenuto to be defined as full value, which is used as the definition
> for how long to hold tied notes. I found this straightforward to
> change, so now I can set tenuto notes to be less than full value,
> while still having tied notes at full value.
> 
> It treats tied notes as two notes.  So, if you have something like:
> d4-.  d-. d-. r | r8 d4-. d8-. ~ d d4-. r8, and if your staccato
> setting is 50%, then the quarter notes will all sound at 50% duration,
> but the 8th tied to 8th will sound 100% for the first note because it
> is tied, and then whatever percentage that an unmarked note would
> hold.  If that unmarked note setting were 80%, then this tied note
> would sound at 90% of its combined value.

Hmm, I didn't realize that. I'll have to be more careful with tied notes
from now on!


> The main thing that a more sophisticated script would support is to
> add trigger notes (notes below the playable range of the instrument)
> which are used to indicate articulations in virtual instruments.  This
> would require turning notes into chords, or adding notes to chords,
> whenever the articulation changes.  The mapping of particular notes to
> particular articulations would need to be configurable for each staff
> (or voice?) since there is no standard.
[...]

Another sophisticated feature would be to implement an interface to the
MIDI expression control so that you can do things like brass \pp\<\ff
crescendo chords. Again, having a way of specifying interpretations
would allow you to write something like:

        {
          \interpret { <d c aes f>1\pp\<\ff }
          {
            \midiExpressionControl {
                ... % specify the value range(s) to use for the control
            }
          }
        }

without having to use workarounds like having two alternative passages,
one for printing and one for rendering MIDI.


T

-- 
Three out of two people have difficulties with fractions. -- Dirk Eddelbuettel