programé una serie de scripts de Python para construir mi piedra: Uno para el canal de violín I, uno para el canal de violín II, dos para el de viola, y tres para el de violoncello. Estos programas, entendiendo un poco de programación, son muy sencillos. Simplemente construyen archivos tipo .csd que luego serán traducidos por Csound a archivos de audio.
a continuación puedes echar un ojo al código del script que construye la tercera parte del canal de violoncello main_final.py. Si no entiendes el código, espero que los comentarios -todo aquello que está precedido de un “#“, con excepción de las dos primeras líneas- sean suficientes para seguir lo que está pasando.
#!/usr/bin/python
# -*- coding: UTF-8 -*-
#
# Importar submódulos
import Csd # clases para contruir archivos .csd que interpreta Csound
import Csnd_strings as CsndStrings # datos para construir un archivo .csd
import Note_methods as NoteMethods # clases que construyen notas y funciones
import celloData # listas de datos para las notas (amplitudes, etc.)
import celloDurs # Duración de las muestras de violoncello
#
# Superclases
Csd = Csd.PyOrcCsd # Construye archivos entendibles por Csound
CsndFunctions = CsndStrings.CsndFunctions # Define funciones para Csound
#
class Cello(Csd, CsndFunctions):
""" Contiene metodos para generar notas compuestas por samples de
cello.
"""
def __init__(self, orcFile, outFile):
""" Inicializa la clase.
orcFile ---> una cadena. El nombre de la orquesta de Csound a
utilizar
outFile ---> una cadena. El nombre del archivo .wav resultante
"""
# Utilizar la inicialización de la superclase Csd().
Csd.__init__(self, orcFile, outFile)
# Subclase que construye declaraciones de notas Csound.
self.I4Note = CsndStrings.CsndNotes(4, 7)
# Atributos globales
self.startOffset = 3
#
#
def noteI4(self, start, duration, ampScale, fileNum, pitch, fileNumInverse):
""" Construye una declaración de nota para el instrumento 4.
start ---> inicio del evento en segundos
duration ---> duración en segundos
ampScale ---> factor para modificar la amplitud
fileNum ---> número de archivo de la muestra
pitch ---> altura (velocidad de reproducción de la muestra)
1 = velocidad normal, 2 = doble de velocidad
"""
# Construir una nota.
start += self.startOffset # desplazar todo 3 segundos
noteStatement = self.I4Note.makeNote([start,
duration,
ampScale,
fileNum,
pitch,
totalDuration,
]
)
# Escribir la nota al archivo .csd que procesará Csound.
self.outFile.write(noteStatement)
##############################################################################
orcFile = 'csound/sfLoopsNew.orc' # nombre del archivo de la orquesta
outFile = 'csound/pythonGenerated_final.csd' # archivo .csd a crear
# Instanciar Cello con los archivos de entrada y salida
Cello = Cello(orcFile, outFile)
# Datos contenidos en submódulos
parameters = celloData.parameters
fileDurs = celloDurs.fileDurs
# Variables globales
start = 630.36 - fileDurs[-1][1]
totalDuration = 389.64
#
# Generar y escribir las notas recursivamente.
for parameter, fileDur, fileNumInverse in zip(parameters,
fileDurs,
fileNumInverses,
):
duration = fileDur[1] # duración de la muestra de audio.
# Incrementar la duración del evento mientras, sin exceder la
# duración total.
while duration < totalDuration:
duration += fileDur[1]
# Obtener el factor de amplitud, y el número de archivo de la
# muestra
ampScale = parameter[2]
fileNum = parameter[3]
pitch = 0.5 # iniciar la reproducción a la mitad de la velocidad.
Cello.noteI4(start, duration, ampScale, fileNum, pitch,
totalDuration,)
#Cello.insertAdvance(start) # Descomentar para iniciar la reproducción
# en un punto específico.
# Finalizar la escritura del archivo .csd que interpretará Csound.
Cello.writeEndOfCsd()
El programa construye un archivo tipo .csd que después será traducido a audio por Csound. El archivo define el comienzo de las notas, sus duraciones, la muestra que corresponde a cada nota, su factor de amplitud y la velocidad a la que se reproduce cada pista. Vale la pena notar que los algoritmos de csound complican bastante las cosas, ya que hay movimiento de velocidad y amplitud. Además, el algoritmo que interpreta una nota dispara más notas con distintos tiempos de inicio, duración y velocidad; generando una textura mucho más densa. Hablaré más de esto en otra entrada.