Home

Partiture musicali e sonore¶

  • Introduzione
  • Organici vocali e strumentali
  • Terminologia
  • Domande sospese
  • Rappresentazioni informatiche
    • Codice
      • Score
      • MIDI files
    • Musica
    • Suono
In [2]:
import os
import sys

path = os.path.abspath('rappresenta')
sys.path.append(path)                     
from main import *

Introduzione ¶

Nei capitoli precedenti abbiamo introdotto i principali elementi di base comuni a qualsiasi linguaggio musicale:

  • altezze e la loro organizzazione in temperamenti, modi o scale.
  • tempo e le sue possibili organizzazioni in strutture temporali musicali.
  • note intese come unità semantica minima nell'organizzazione della musica.
  • sequenze melodiche intese come organizzazione semantica nella dimensione musicale orizzontale.
  • accordi come sopra ma nella dimensione verticale.
  • strumenti intesi come morfologia timbrica dei suoni.

In questo capitolo li metteremo in relazione tra loro all'interno di contenitori chiamati partiture la cui funzione principale è quella di costruire musica.

Possiamo considerare le partiture come dei foglietti di istruzioni attraverso i quali un interprete umano, meccanico o elettronico può:

  • comporre un brano musicale - in questo caso scrive la partitura.
  • riprodurre un brano musicale - in questo caso interpreta la partitura.

Come illustrato nel capitolo dedicato alle diverse rappresentazioni del suono e della musica possiamo avere due tipi di partiture che contengono informazioni differenti:

  • partitura musicale - codifica e rappresentazione degli elementi propri di un linguaggio musicale.

    • simbolica - le informazioni sono codificate attraverso simboli appartenenti alla notazione musicale che in questo per-corso stiamo approfondento attraverso il software Lilypond.

      No description has been provided for this image

    • numerica - le informazioni sono codificate attraverso valori numerici secondo qualche tipo di protocollo (MIDI o altro) che in questo per-corso stiamo approfondendo attraverso il linguaggio Python.

      No description has been provided for this image

  • partitura sonora - codifica e rappresentazione degli elementi acustici senza alcuna informazione riguardante l'eventuale linguaggio musicale presente nel testo sonoro che in questo per-corso stiamo approfondendo attraverso la DAW Audacity.

    No description has been provided for this image

Osserviamo la struttura comune con le diverse combinazioni:

No description has been provided for this image
  • A. Timeline
    • definizione e organizzazione di tempo e metro generalmente comune a tutti gli strumenti presenti in partitura.
    • sincronizzazione grafica verticale.
    • possono cambiare entrambe nel corso del brano.
      No description has been provided for this image
      No description has been provided for this image
  • B. uno strumento un rigo e una voce.
    No description has been provided for this image
    No description has been provided for this image
  • C. uno strumento un rigo e più voci.
    No description has been provided for this image
    No description has been provided for this image
  • D. uno strumento più righi e più voci.
    No description has been provided for this image
    No description has been provided for this image
  • E. un sistema con più strumenti, più righi e più voci.
    No description has been provided for this image
    No description has been provided for this image

La struttura gerarchica comune ai diversi tipi di partitura:

  • Partitura (Score)
    • Tempo (Timeline)
    • Sistema (Staff system)
      • Rigo (Staff o Instrument Voice)
        • Voce (Voice)
          • Dinamiche (fisse o variabili per ogni Voce)

Organici vocali e strumentali ¶

In questo paragrafo percorriamo una linea del tempo che inanella i principali tipi di organici strumentali impiegati dai compositori della tradizione musicale occidentale.

No description has been provided for this image

Origini (0 - X secolo)¶

Le prime forme musicali erano esclusivamente canti monodici che potevano essere eseguiti da un solo cantore oppuure da un coro maschile.

  • Cantillazione (dal 70 ca.)

  • Canto Gallicano e Mozarabico (V - IX secolo)

  • Canto Gregoriano (dall'VIII secolo)

Medioevo e rinascimento (X - XVI secolo)¶

A partire dal X secolo appaiono i primi esempi di polifonia vocale non accompagnata da alcuno strumento (a cappella).

  • Organum (X secolo) - voci parallele

  • Ars antiqua (XIII secolo)

    • Perotinus - organum complessi a quattro voci.
    • Adam del la Halle - trovatori e trovieri - in quest'epoca parallelamente alla musica vocale appaiono i primi esempi di musica profana accompagnata da strumenti musicali - narrazioni di trovatori e trovieri.

  • Ars Nova (XV secolo)

    • Mottetto - imitazione - Schola Notre Dame

    • F.Landini - polifonia accompagnata - Dolce stil novo - nuove relazioni tra musica e poesia.

  • Ars perfecta (XVI secolo)

    • Messa - G.P.Palestrina - contrappunto - linguaggio musicale sempre più complesso e simbolico.
    • Madrigale - A.Willaert - musica profana
    • Monodia accompagnata - G.Caccini - basso cifrato - orizzontalità vs verticalità (armonia).

Periodo Barocco (XVII secolo)¶

In epoca barocca si realizza il passaggio da un linguaggio musicale organizzato secondo le regole del contrappunto a uno basato sulle regole proprie dell'armonia.

Si affermano inoltre i primi organici di musica esclusivamente strumentale che possiamo schematizzare in:

  • Strumento solo

  • Strumento accompagnato

    • Formazioni da camera
    • Concerti grossi - strumenti concertanti
    • Concerti solistici

  • Primi organici orchestrali - sinfonie

Parallelamente i compositori ampliano gli organici della musica vocale-strumentale scrivendo per soli, coro e orchestra principalmente nell'ambito della musica sacra.

La musica profana si sviluppa invece nelle prime opere di teatro musicale con lo stile del recitar cantando.

Periodo Classico (XVIII secolo)¶

Nel classicismo si definiscono alcuni organici standard che sono giunti fino ai nostri giorni.

Per quasi tutti gli organici vengono scritte importanti raccolte di brani caratterizzati da specifiche forme musicali come Sonate e Sinfonie (Haydn, Mozart, Beethoven).

Alcune di queste raccolte prendono il nome direttamente dal'organico strumentale (trii, quartetti, quintetti, etc.).

Musica da camera¶

  • Strumento solo
    • in questo periodo principalmente strumenti a tastiera.
  • Duo
  • Trio
  • Quartetto

Orchestra¶

  • D'archi

  • Classica

  • Di fiati

Concerti per strumento e orchestra¶

Soli, coro e orchiestra¶

Periodo Romantico (XIX secolo)¶

Nel periodo romantico non vengono introdotti dai compositori insiemi di nuovi organici strumentali ma la tendenza è quella di aumentare le dimensioni sia delle formazioni da camera che di quelle orchestrali.

Per quanto riguarda gli strumenti soli o solisti si perfezionano le tecniche strumentali che postano alla creazione di brani sempre più virtuosistici.

  • Soli
  • Quintetto, Sestetto, Ottetto
  • Orchestra

Novecento (XX secolo)¶

  • Soli
    • Tecniche aumentate
  • Musica da camera
    • Gli organici si differenziano timbricamente.

  • Orchestra

    • Ulteriore ingigantimento dell'organico.

  • Musica elettronica

    • Musica su supporto.
    • Musica mista.
    • Strumenti aumentati (Hyperstrumento)
    • Laptop orchestra

Terminologia ¶

  • Partitura musicale - organizzazione grafica di più voci all'interno di più righi musicali contemporanei (sovrapposti).
  • Partitura sonora - organizzazione acustica su più tracce contemporanee (sovrapposte).
  • Timeline - linea o traccia posta al di sopra dei righi o delle tracce che organizza l'andamento temporale di un brano.
  • Organico strumentale - insieme di strumenti che compongono una formazione strumentale. Valenza non esclusivamente timbrica ma anche culturale.
  • Parti strumentali - spartiti estratti da una partitura che contengono solo la parte di un singolo strumento.

Domande sospese ¶

Impostare e sostenere una tesi specifica riguardo una o più tematiche legate alla semiotica musicale e/o generale affrontate fino a questo momento prendendo come spunto uno o più brani illustrati nel paragrafo organici strumentali oppure scegliendone uno a piacere che sia significativo rispetto alla tematica scelta.

Rappresentazioni informatiche ¶

Score ¶

La classe Score() può essere considerata un contenitore all'interno della quale organizzare le classi che già conosciamo.

No description has been provided for this image
No description has been provided for this image
In [3]:
partitura = Score()
  • aggiungiamo gli strumenti musicali.
In [5]:
catalogo = InstrumentCatalog.instance()

partitura.add_instrument_voice(InstrumentVoice(catalogo.get_instrument('violin'), 2)) # Aggiunge 2 violini
partitura.add_instrument_voice(InstrumentVoice(catalogo.get_instrument('cello')))     # Aggiunge 1 cello
  • aggiungiamo una sequenza per i cambiamenti di tempo ed una per quelli di metro.
In [7]:
partitura.tempo_sequence.add(TempoEvent( Tempo( TempoType.Grave), Position(0)))      # Tempo iniziale
partitura.tempo_sequence.add(TempoEvent( Tempo( TempoType.Moderato), Position(3,4))) # Dopo 3/4 cambia in Moderato

partitura.time_signature_sequence.add(TimeSignatureEvent(TimeSignature(3, TSBeatType.Quarter), Position(0))) # Aggiunge cambi di metro
partitura.time_signature_sequence.add(TimeSignatureEvent(TimeSignature(2, TSBeatType.Half), Position(3,4)))  # dopo 3/4 diventa 2/2
  • inseriamo gli agglomerati musicali per ogni strumento.
In [9]:
# Violini

vl = partitura.get_instrument_voice('violin')[0]               # Recupera lo strumento dalla partitura (2 violini)

vl_1 = Line([Note(DiatonicPitch(4, y), Duration(1,8)) for y in 'abcd']) # Scrive una sequenza del VL_1
vl_2 = Line([Note(DiatonicPitch(4, y), Duration(1,8)) for y in 'abcd']) # Scrive un'altra sequenza del VL_2

vl.voice(0).pin(vl_1 , Offset(1, 8))                           # La inserisce nella partitura
vl.voice(1).pin(vl_2, Offset(1, 4))                            # La inserisce nella partitura

# Violoncello

vc = partitura.get_instrument_voice('cello')[0]  

vc_3 = Line([Note(DiatonicPitch(3, y), Duration(1,4)) for y in 'cg']) 
vc.voice(0).pin(vc_3, Offset(0))
  • aggiungiamo una sequenza di dinamiche per ogni voce
In [11]:
vl.voice(0).dynamics_sequence.add(DynamicsFunctionEvent(Dynamics.F, Position(0)))       # Sequenza dinamiche Vl_1
vl.voice(0).dynamics_sequence.add(DynamicsFunctionEvent(Dynamics.FFF, Position(2,4)))   
vl.voice(1).dynamics_sequence.add(DynamicsFunctionEvent(Dynamics.P, Position(0)))       # Sequenze dinamiche VL_2
vc.voice(0).dynamics_sequence.add(DynamicsFunctionEvent(Dynamics.MP, Position(1,4)))    # Sequenze dinamiche vc

Terminata la partitura possiamo recuperare diverse informazioni:

  • sequenza di tempi e metri
In [13]:
tempi = partitura.tempo_sequence
metri = partitura.time_signature_sequence

print(tempi)
print(metri)

[0, Tempo(Tempo[35, 1/4])], [3/4, Tempo(Tempo[114, 1/4])]
[0, TimeSignature(TS[3, 1/4])], [3/4, TimeSignature(TS[2, 1/2])]
  • sequenza delle dinamiche per ogni voce.
In [15]:
vl_1_din = vl.voice(0).dynamics_sequence
vl_2_din = vl.voice(1).dynamics_sequence
vc_din   = vc.voice(0).dynamics_sequence

print(vl_1_din)
print(vl_2_din)
print(vc_din)

[0, [DyFctn(Function(cst, 96))]], [1/2, [DyFctn(Function(cst, 120))]]
[0, [DyFctn(Function(cst, 49))]]
[1/4, [DyFctn(Function(cst, 64))]]
  • tutte le note che cominciano in un intervallo di tempo.
In [17]:
#                                                               Inizio          fine
mappa = partitura.get_notes_starting_in_wnt_interval(Interval(Position(0), Position(2, 4))) 

for (k, v) in mappa.items():
    print('Strumento: {}'.format(k))
    for (k1, v1) in v.items():
        print('            Voce: {0} --> [{1}]'.format( k1.instrument, 
                                                       ', '.join(str(n) for n in v1)))

Strumento: IV[Violin [G:3-A:7], 2]
            Voce: Violin [G:3-A:7] --> [[A:4<1/8>-(1/8)] off=0 f=1, [B:4<1/8>-(1/8)] off=1/8 f=1, [C:4<1/8>-(1/8)] off=1/4 f=1]
            Voce: Violin [G:3-A:7] --> [[A:4<1/8>-(1/8)] off=0 f=1, [B:4<1/8>-(1/8)] off=1/8 f=1]
Strumento: IV[Cello [C:2-C:6], 1]
            Voce: Cello [C:2-C:6] --> [[C:3<1/4>-(1/4)] off=0 f=1, [G:3<1/4>-(1/4)] off=1/4 f=1]
  • durata delle sequenze musicali:
    • come whole note.
    • come tempo assoluto in millisecondi.
In [19]:
whole  = str(partitura.duration)
millis = str(partitura.real_duration)

print(whole)
print(millis)

3/4
5142.857142857143

MIDI Files ¶

Possiamo renderizzare un'istanza di Score() in un MIDI file attraverso la classe ScoreToMidiConverter().

Se l'ultimo argomento è True stampa info nella console.

Installare il modulo mido.

In [23]:
! pip install mido

Collecting mido
  Downloading mido-1.3.2-py3-none-any.whl.metadata (6.4 kB)
Requirement already satisfied: packaging~=23.1 in /opt/anaconda3/lib/python3.12/site-packages (from mido) (23.2)
Downloading mido-1.3.2-py3-none-any.whl (54 kB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 54.6/54.6 kB 3.9 MB/s eta 0:00:00
Installing collected packages: mido
Successfully installed mido-1.3.2
In [21]:
midi     = Score()
catalogo = InstrumentCatalog.instance()

midi.add_instrument_voice(InstrumentVoice(catalogo.get_instrument('violin'), 2)) # Aggiunge 2 violini
midi.add_instrument_voice(InstrumentVoice(catalogo.get_instrument('cello')))     # Aggiunge 1 cello

midi.tempo_sequence.add(TempoEvent( Tempo( TempoType.Allegro), Position(0)))                            # Tempo iniziale
midi.time_signature_sequence.add(TimeSignatureEvent(TimeSignature(4, TSBeatType.Quarter), Position(0))) # Metro iniziale

# Violini

vl = midi.get_instrument_voice('violin')[0]                             # Recupera lo strumento dalla partitura (2 violini)

vl_1 = Line([Note(DiatonicPitch(4, y), Duration(1,8)) for y in 'cgegcgfgdgfgcgeg']) # Scrive una sequenza del VL_1
vl_2 = Line([Note(DiatonicPitch(4, y), Duration(1,4)) for y in 'cgdgcgd']) # Scrive un'altra sequenza del VL_2

vl.voice(0).pin(vl_1 , Offset(0))                              # La inserisce nella partitura
vl.voice(1).pin(vl_2, Offset(1, 4))                            # La inserisce nella partitura

# Violoncello

vc = midi.get_instrument_voice('cello')[0]  

vc_3 = Line([Note(DiatonicPitch(3, y), Duration(2,4)) for y in 'cgag']) 
vc.voice(0).pin(vc_3, Offset(0))  

mfile = ScoreToMidiConverter(midi)
mfile.create('esempio_midi.mid', True)

0/0 note_on[2]:pv=(60, 64)
240/240 note_off[2]:pv=(60, 64)
0/240 note_on[2]:pv=(67, 64)
240/480 note_off[2]:pv=(67, 64)
0/480 note_on[2]:pv=(64, 64)
240/720 note_off[2]:pv=(64, 64)
0/720 note_on[2]:pv=(67, 64)
240/960 note_off[2]:pv=(67, 64)
0/960 note_on[2]:pv=(60, 64)
240/1200 note_off[2]:pv=(60, 64)
0/1200 note_on[2]:pv=(67, 64)
240/1440 note_off[2]:pv=(67, 64)
0/1440 note_on[2]:pv=(65, 64)
240/1680 note_off[2]:pv=(65, 64)
0/1680 note_on[2]:pv=(67, 64)
240/1920 note_off[2]:pv=(67, 64)
0/1920 note_on[2]:pv=(62, 64)
240/2160 note_off[2]:pv=(62, 64)
0/2160 note_on[2]:pv=(67, 64)
240/2400 note_off[2]:pv=(67, 64)
0/2400 note_on[2]:pv=(65, 64)
240/2640 note_off[2]:pv=(65, 64)
0/2640 note_on[2]:pv=(67, 64)
240/2880 note_off[2]:pv=(67, 64)
0/2880 note_on[2]:pv=(60, 64)
240/3120 note_off[2]:pv=(60, 64)
0/3120 note_on[2]:pv=(67, 64)
240/3360 note_off[2]:pv=(67, 64)
0/3360 note_on[2]:pv=(64, 64)
240/3600 note_off[2]:pv=(64, 64)
0/3600 note_on[2]:pv=(67, 64)
240/3840 note_off[2]:pv=(67, 64)
480/480 note_on[2]:pv=(60, 64)
480/960 note_off[2]:pv=(60, 64)
0/960 note_on[2]:pv=(67, 64)
480/1440 note_off[2]:pv=(67, 64)
0/1440 note_on[2]:pv=(62, 64)
480/1920 note_off[2]:pv=(62, 64)
0/1920 note_on[2]:pv=(67, 64)
480/2400 note_off[2]:pv=(67, 64)
0/2400 note_on[2]:pv=(60, 64)
480/2880 note_off[2]:pv=(60, 64)
0/2880 note_on[2]:pv=(67, 64)
480/3360 note_off[2]:pv=(67, 64)
0/3360 note_on[2]:pv=(62, 64)
480/3840 note_off[2]:pv=(62, 64)
0/0 note_on[3]:pv=(48, 64)
960/960 note_off[3]:pv=(48, 64)
0/960 note_on[3]:pv=(55, 64)
960/1920 note_off[3]:pv=(55, 64)
0/1920 note_on[3]:pv=(57, 64)
960/2880 note_off[3]:pv=(57, 64)
0/2880 note_on[3]:pv=(55, 64)
960/3840 note_off[3]:pv=(55, 64)

Info minime sul protocollo MIDI.

L'acronimo sta per Musical Instrument Digital Iterface ed è uno standard adottato dai produttori di hardware musicale associati alla MIDI Manufacturer's Association.

E' un protocollo che permette la comunicazione fra diversi hardware e software.

Permette di inviare messaggi riguardanti i parametri musicali non quelli acustici per i quali sono adottati altri formati come WAV, MP3, etc.

Un MIDI file è una collezione di questi messaggi ordinati attraverso una timeline per il playback.

Gli elementi principali semplificando di molto sono:

  • Canali - che possiamo pensare come linea ferroviaria che collega due dispositivi o software (ne abbiamo a disposizione 16).
  • Tracce - che possiamo pensare come la singola coppia di binari della linea.
  • Messaggi - che possiamo pensare come i treni che percorrono la tratta ferroviaria.

In termini più musicali e relati a come avviene in questo caso la conversione attraverso la classe ScoreToMidiConverter() nell'esempio:

  • InstrumentVoice (vl) $\rightarrow$ canale 0.
    • Voice (vl_1) $\rightarrow$ traccia 0.
    • Voice (vl_2) $\rightarrow$ traccia 1.
  • InstrumentVoice (vc) $\rightarrow$ canale 1.
    • Voice (vc) $\rightarrow$ traccia 0.

Il protocollo MIDI in realtà è molto complesso ma non è questa la sede opportuna per approfondirlo ulteriormente.

Il file generato può essere letto da qualsiasi software che supporta questo tipo di file.

Installiamo il modulo pypianoroll.

In [43]:
!pip install pypianoroll

Collecting pypianoroll
  Downloading pypianoroll-1.0.4-py3-none-any.whl.metadata (3.8 kB)
Requirement already satisfied: numpy>=1.12.0 in /opt/anaconda3/lib/python3.12/site-packages (from pypianoroll) (1.26.4)
Requirement already satisfied: scipy>=1.0.0 in /opt/anaconda3/lib/python3.12/site-packages (from pypianoroll) (1.13.1)
Collecting pretty-midi>=0.2.8 (from pypianoroll)
  Downloading pretty_midi-0.2.10.tar.gz (5.6 MB)
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 5.6/5.6 MB 35.1 MB/s eta 0:00:0000:0100:01
  Preparing metadata (setup.py) ... done
Requirement already satisfied: matplotlib>=1.5 in /opt/anaconda3/lib/python3.12/site-packages (from pypianoroll) (3.8.4)
Requirement already satisfied: contourpy>=1.0.1 in /opt/anaconda3/lib/python3.12/site-packages (from matplotlib>=1.5->pypianoroll) (1.2.0)
Requirement already satisfied: cycler>=0.10 in /opt/anaconda3/lib/python3.12/site-packages (from matplotlib>=1.5->pypianoroll) (0.11.0)
Requirement already satisfied: fonttools>=4.22.0 in /opt/anaconda3/lib/python3.12/site-packages (from matplotlib>=1.5->pypianoroll) (4.51.0)
Requirement already satisfied: kiwisolver>=1.3.1 in /opt/anaconda3/lib/python3.12/site-packages (from matplotlib>=1.5->pypianoroll) (1.4.4)
Requirement already satisfied: packaging>=20.0 in /opt/anaconda3/lib/python3.12/site-packages (from matplotlib>=1.5->pypianoroll) (23.2)
Requirement already satisfied: pillow>=8 in /opt/anaconda3/lib/python3.12/site-packages (from matplotlib>=1.5->pypianoroll) (10.3.0)
Requirement already satisfied: pyparsing>=2.3.1 in /opt/anaconda3/lib/python3.12/site-packages (from matplotlib>=1.5->pypianoroll) (3.0.9)
Requirement already satisfied: python-dateutil>=2.7 in /opt/anaconda3/lib/python3.12/site-packages (from matplotlib>=1.5->pypianoroll) (2.9.0.post0)
Requirement already satisfied: mido>=1.1.16 in /opt/anaconda3/lib/python3.12/site-packages (from pretty-midi>=0.2.8->pypianoroll) (1.3.2)
Requirement already satisfied: six in /opt/anaconda3/lib/python3.12/site-packages (from pretty-midi>=0.2.8->pypianoroll) (1.16.0)
Downloading pypianoroll-1.0.4-py3-none-any.whl (26 kB)
Building wheels for collected packages: pretty-midi
  Building wheel for pretty-midi (setup.py) ... done
  Created wheel for pretty-midi: filename=pretty_midi-0.2.10-py3-none-any.whl size=5592292 sha256=d94a45c3d1dd73768257f96177239b4fc5488f31c3b85801ccc1176d704435bf
  Stored in directory: /Users/andreavigani/Library/Caches/pip/wheels/a4/f9/9e/08350c27e386558df0ae234e28a8facd145ba45506ddd1b989
Successfully built pretty-midi
Installing collected packages: pretty-midi, pypianoroll
Successfully installed pretty-midi-0.2.10 pypianoroll-1.0.4
In [23]:
import pypianoroll

piano = pypianoroll.read("esempio_midi.mid")
print(piano)
piano.plot()

Multitrack(name=None, resolution=24, tempo=array(shape=(96, 1), dtype=float64), tracks=[StandardTrack(name='Violin', program=0, is_drum=False, pianoroll=array(shape=(96, 128), dtype=uint8)), StandardTrack(name='Violin', program=0, is_drum=False, pianoroll=array(shape=(96, 128), dtype=uint8)), StandardTrack(name='Cello', program=0, is_drum=False, pianoroll=array(shape=(96, 128), dtype=uint8))])
Out[23]:
[<Axes: xlabel='time (beat)', ylabel='Violin\n\npitch'>,
 <Axes: xlabel='time (beat)', ylabel='Violin\n\npitch'>,
 <Axes: xlabel='time (beat)', ylabel='Cello\n\npitch'>]
No description has been provided for this image

Se vogliamo salvare come MIDI file esempi musicali non complessi possiamo renderizzare direttamente Line() senza costruire una Score().

Il metodo è convert_line() e gli argomenti sono:

  • Line - l'istanza da convertire.
  • Filename - il nome del file risultante.
  • Tempo - definisce il tempo (60 bpm di default).
  • TimeSignature - definisce il metro (4/4 di default).
  • Instrument_name - definisce lo strumento (Piano di default)
In [25]:
n1 = Note(DiatonicPitch(4, 'a'), Duration(1, 8))
n2 = Note(DiatonicPitch(5, 'c'), Duration(1, 8))
n3 = Note(DiatonicPitch(5, 'b'), Duration(1, 8))
n4 = Note(DiatonicPitch(5, 'd'), Duration(1, 8))
n5 = Note(DiatonicPitch(5, 'e'), Duration(1, 8))
n6 = Note(DiatonicPitch(5, 'd'), Duration(1, 8))
n7 = Note(DiatonicPitch(4, 'g'), Duration(1, 8))
n8 = Note(DiatonicPitch(4, 'c'), Duration(1, 8))

seq = Line([n1, n2, n3, n4, n5, n6, n7, n8])

ScoreToMidiConverter.convert_line(seq, 'esempio_line.mid', instrument_name='violin')

Differenze tra MIDI in tempo reale e MIDI files.

Musica ¶

In [ ]:
! /Applications/Frescobaldi.app/Contents/MacOS/Frescobaldi

qt.qpa.fonts: Populating font family aliases took 161 ms. Replace uses of missing font family "Monospace" with one that exists to avoid this cost.

Anche in Lilypond dobbiamo formalizzare il pensiero suddividendo il codice in diverse parti per poi collocarle nel blocco \score{}.

  • Titoli vari (\header{}).
In [ ]:
\version "2.24.3"
\language "english"

\header {                          % Titoli e altro
         title = "Che bel lavoro"
         composer = "Me medesimo"
         tagline = ""
         }
  • Formato e margini della pagina (blocco \paper{}).
In [ ]:
\paper {                           % Formato pagina e margini
        #(set-paper-size "a4") 
        top-margin    = 10         % in mm di default
        bottom-margin = 10
        left-margin   = 10
        right-margin  = 10
        }
  • Indicazioni comuni a tutti gli strumenti (assegnato a una variabile).
In [ ]:
global = {                                       % Indicazioni comuni 
          \key c \major                          % a tutti gli strumenti
          \numericTimeSignature
          \time 3/4
          \override Score.MetronomeMark.padding = 3  % Sposta in verticale
          \tempo "Andante" 4 = 100
          }
  • Contenuto musicale di ogni rigo (assegnato a variabili).
In [ ]:
flute = \relative c'' {                            % Contenuto musicale
                       \global                     % Indicazioni comuni
                       c4 d e f g a c, d e f g a c, d e f g a
                       c, d e f g a c, d e f g a c, d e f g a
                       \bar "|."                   % Linea di battuta finale
                       }

violin = \relative c'' {
                        \global
                        c2 b4 a2 a4 c2 b4 a2 a4 c2 b4 a2 a4
                        c2 b4 a2 a4 c2 b4 a2 a4 c2 b4 a2 a4
                        }

viola = \relative c' {
                      \global
                      f4 f2 d4 d2 f4 f2 d4 d2 f4 f2 d4 d2 
                      f4 f2 d4 d2 f4 f2 d4 d2 f4 f2 d4 d2 
                      }

cello =  \relative c {
                      \global
                      c2. c  c c c c
                      c2. c  c c c c
                      }

right =\relative c'' {
                      \global
                      c8 d e f g a b d c a f d c d e f g a b d c a f d c d e f g a b d c a f d
                      c8 d e f g a b d c a f d c d e f g a b d c a f d c d e f g a b d c a f d
                      }

left = \relative c, {
                     \global
                     c2. g' c g c g
                     c2. g' c g c g
                     }
  • Parti singole (\new Staff) per permettere di estrarle facilmente.
In [ ]:
flutePart = \new Staff \with {
                              instrumentName = "Flauto"
                              shortInstrumentName = "Fl."
                              midiInstrument = "flute"
                              }  \flute            % Musica

violinPart = \new Staff \with {
                               instrumentName = "Violino"
                               shortInstrumentName = "Vl."
                               midiInstrument = "violin"
                               } \violin

violaPart = \new Staff \with {
                              instrumentName = "Viola"
                              shortInstrumentName = "V.la"
                              midiInstrument = "viola"
                              } {\clef alto        % Chiave
                                 \viola}           % Musica

celloPart = \new Staff \with {
                              instrumentName = "Violoncello"
                              shortInstrumentName = "Vlc."
                              midiInstrument = "cello"
                              } {\clef bass 
                                 \cello }

pianoPart = \new PianoStaff \with {
                                   instrumentName = "Pianoforte"
                                   shortInstrumentName = "Pf."
                                   }
                                   <<
                                     \new Staff = "right" \with {
                                                                 midiInstrument = "acoustic grand"
                                                                 } \right
                                     \new Staff = "left"  \with {
                                                                 midiInstrument = "acoustic grand"
                                                                 } {\clef bass 
                                                                    \left }
                                   >>
  • Partitura (\score{}) che include tutto e genera:
    • un file pdf (\layout)
    • un file MIDI (\midi)
In [ ]:
\score {
        <<
          \flutePart
          \violinPart
          \violaPart
          \celloPart
          \pianoPart
        >>
        \layout {                              % Genera file pdf
                 #(layout-set-staff-size 20) 
                 indent             = 20                       
                 short-indent = 10                        
                 }                               
        \midi {\tempo 4 = 100}                 % Genera file MIDI
        }

Suono ¶

Per quanto riguarda le DAW il concetto di partitura abbraccia i seguenti temi:

  • Timeline e posizionamento forzato sulla griglia temporale (aggancia) o libero.
  • Organizzazione e sovrapposizione delle tracce.
    • Nome
    • Colore
  • Effetti applicati su:
    • soundfile singoli (distruttivi).
    • tracce singole (conservativi).
    • master (tutte le tracce)