SoundCloud
NTS-1 digital kit
PROGRAMMABLE SYNTHESIZER KIT
Soporte
Saber mas
Sitios relacionados
Productos relacionados
Noticias relacionadas
[DOTEC-AUDIO x Nu:Tekt] Cómo crear efectos personalizados para el NTS-1
Crear plugins personalizados para el NTS-1 puede parecer bastante desalentador, ¡pero no te preocupes!
¡En esta serie de 5 partes de artículos exploraremos junto con DOTEC-AUDIO cómo crear efectos personalizados para NTS-1, paso a paso!
Artículo #1: Haciendo que los efectos personalizados funcionen con el NTS-1
¡Hola a todos! Mi nombre es Shinji Iijima de DOTEC-AUDIO, una empresa de desarrollo de plugins.
Hasta ahora hemos desarrollado principalmente plugins de audio sólo para PC y iPhone / iPad.
https://dotec-audio.com/
El kit digital Nu:Tekt NTS-1" (en adelante abreviado como el "NTS-1) es un kit de sintetizador digital “hazlo-tú-mismo) extremadamente interesante pero asequible. Entonces, ¿por qué DOTEC-AUDIO, un desarrollador de plugins para PC, está interesado en este sintetizador? Porque este sintetizador te permite escribir tus propios programas y luego instalar los sonidos (osciladores) y los efectos que has desarrollado en el NTS-1.
Otra cosa interesante sobre el NTS-1 es que tiene una entrada de audio estéreo (entrada de línea). Lo que esto significa es que puedes conectar un generador de sonido o un instrumento musical, y utilizar el NTS-1 no sólo como sintetizador, sino como una unidad de efectos compacta independiente.
En otras palabras, se obtiene un sintetizador que se puede programar libremente, así como efectos. Cuando escuchas eso, realmente te da ganas de probarlo tú mismo, ¿no crees?
OK, empecemos. ¡Echa un vistazo a este video!
Y...
Ambos efectos contienen parte de la funcionalidad multi-efectos de "DeeFX" de DOTEC-AUDIO, llevado al NTS-1.
En esta serie, publicaremos y profundizaremos en el código fuente de estos efectos; pero, para empezar, voy a explicar cómo descargar estos dos efectos e instalarlos en el NTS-1.
¡Si ya has comprado un NTS-1, definitivamente descarga estos efectos y experimenta con ellos tú mismo!
Cómo instalar los efectos
- 1/ Instala el Sound Librarian del NTS-1
En primer lugar, instala el programa NTS-1 Sound Librarian en tu ordenador (Win/Mac).
Sigue las instrucciones para instalar el software y asegúrate de conectar el NTS-1 al equipo. - 2/ Descarga los archivos de los efectos
A continuación, descarga estos archivos de efectos desarrollados por DOTEC-AUDIO.
Download Bitcrusher here
Download Stop FX here
La extracción de este archivo ZIP te dará los archivos "bitcrusher.ntkdigunit" y "stopfx.ntkdigunit". - 3/ Carga estos archivos en el Sound Librarian.
Para cargar los archivos, ves al menú "File", haz click en "Import User Unit" y selecciona los archivos que has descomprimido. Una vez que lo hayas hecho, el efecto "bitcrusher" se agrega a la categoría "USER MODULATION FX", y el efecto "stopfx" se agrega a la categoría "USER DELAY FX".
Por último, ves al menú "Send/Recv." y selecciona "Send User Data" para transferir estos dos efectos al NTS-1.
Una vez transferidos los efectos, podrás seleccionar "XXX" en "Mod" en el NTS-1 y "XXX" para el Delay.
¡Nos vemos la próxima vez!
Artículo #2: Cómo prepararse para desarrollar efectos para el NTS-1
¡Hola a todos! Soy Shinji Iijima de DOTEC-AUDIO.
La última vez hablamos de los efectos que hicimos para el NTS-1. ¿Los has probado ya? Esta vez, explicaremos el entorno que necesitarás para crear tus propios efectos originales (y osciladores) para el NTS-1.
En realidad, los conceptos básicos que necesitas saber se encuentran en la página "logue SDK", por lo que esta vez te daré algunos detalles adicionales. Debo mencionar que todo lo que estoy explicando está disponible de forma gratuita. Además, una de las cosas atractivas de esto es que puedes desarrollar en Windows, macOS o Linux, por lo que casi cualquier persona puede hacer esto.
(Ten en cuenta que los pasos de instalación son diferentes en cada sistema operativo).
logue SDK
https://korginc.github.io/logue-sdk/
Para empezar, hablemos de lo que es un "SDK". SDK significa "Kit de desarrollo de software", que es un conjunto de herramientas necesarias para desarrollar software específico. Por ejemplo, usarás el SDK de Windows para desarrollar aplicaciones para Windows o el SDK de iOS para desarrollar aplicaciones para el iPhone. Al desarrollar para el NTS-1, usamos el "SDK de logue".
https://github.com/korginc/logue-sdk
El SDK que se publica aquí es el propio SDK de logue. Lo mejor que puedes hacer es usar el software Git para obtener la última versión del SDK, pero para hacerlo necesitarás saber cómo usar Git.
Por esa razón, puedes ir a la página web mencionada anteriormente y hacer clic en el botón verde "Clonar o descargar" para descargar los archivos como un archivo ZIP. Ten en cuenta que el SDK a veces se actualiza, por lo que es mejor usar Git si siempre deseas obtener la versión más reciente del SDK.
MSYS2 (for Windows)
https://www.msys2.org/
El asunto más espinoso que debes tratar cuando se considera la creación de un entorno de desarrollo NTS-1 para Windows es "MSYS2". Me gustaría explicar eso ahora. Todos los comandos GNU usados con el SDK de logue ejecutan comandos con el sistema operativo Unix como requisito previo.
Para Linux, que es básicamente Unix, o macOS, que se basa en Unix, podrás instalar usando un mínimo de herramientas. Sin embargo, para Windows necesitarás un entorno adicional que pueda ejecutar comandos unix. En pocas palabras, MSYS2 es una plataforma para ejecutar comandos de Unix en Windows. Debido a esto, si estás desarrollando con Windows y MSYS2, ejecutarás los comandos dentro de la ventana "MSYS2".
Haz una búsqueda de "NTS-1 MSYS2" en la web y encontrarás artículos que enumeran los pasos específicos necesarios. Definitivamente te animo a usar esos sitios como referencia.
GNU Arm Embedded Toolchain
https://github.com/korginc/logue-sdk/tree/master/tools/gcc
Para desarrollar programas, necesitas un "compilador", que es un software que convierte los programas escritos por humanos en lenguaje de máquina que sea legible por una computadora. Con el SDK de logue, usaremos la "Colección de compiladores GNU" (GCC para abreviar).
El CCG es un tema tan complicado por derecho propio que podríamos escribir un libro grueso sobre él, así que me saltaré eso por ahora. Baste decir que la "GNU Arm Embedded Toolchain" explicada en esta página es el nombre de un conjunto de herramientas de programación que incluye el GCC.
El "Arm Embedded" se refiere al chip "STM32F4" con una CPU Arm que se utiliza en el NTS-1. La cadena de herramientas a la que nos referimos se utiliza para desarrollar programas que se ejecutan en esta CPU.
Como puedes ver en el archivo Readme, todo lo que necesitas hacer para instalar es ejecutar el script de shell preparado.
GNU Make
https://github.com/korginc/logue-sdk/tree/master/tools/make
"Make" es una herramienta que te permite configurar un solo comando para ahorrarle la molestia de ejecutar muchos comandos y compilar sus archivos cada vez. (Make es otra herramienta sobre la que podríamos tomar un libro entero para escribir).
Make no necesita ninguna instalación especial adicional en macOS, Linux y Windows (y MSYS2), pero explicaremos dónde es necesario instalar.
Info-ZIP
https://github.com/korginc/logue-sdk/tree/master/tools/zip
Esta es una herramienta utilizada para crear archivos ZIP, y al igual que con GNU Make no requiere una instalación especial en prácticamente ninguna plataforma.
logue-cli (optional)
https://github.com/korginc/logue-sdk/tree/master/tools/logue-cli
Este es un componente "opcional" y no todo el mundo lo necesita. Piensa en esto como la variante de línea de comandos de "Sound Librarian", que describimos la última vez. Ten en cuenta que hay una versión para Windows y macOS de Sound Librarian, pero no una versión de Linux.
Por esa razón, si estás planeando desarrollar en Linux, deberás instalar esta herramienta. Una vez que hayas instalado correctamente estas herramientas, vamos a compilar (crear el programa para) los componentes de ejemplo incluidos con el SDK.
Usaremos los pasos de la "Compilación del proyecto de demostración (Waves)" (
https://korginc.github.io/logue-sdk/) para trabajar.
Si has ejecutado correctamente los comandos, se generará un archivo denominado "waves.ntkdigunit". Esto debe cargarse en los "OSCILADORES DE USUARIO" de Sound Librarian como "ondas". Si has llegado hasta aquí, ¡el siguiente paso es programar! Es un poco como una tarea para poner las cosas en marcha.
Lo bueno es que hay mucha información en Internet sobre estas herramientas, por lo que te animo a hurgar en la Web para configurar tu entorno.
¡Nos vemos la próxima vez!
Artículo #3: Creación de un efecto original, Parte 1
Hola, mi nombre es Frank Shigetora, y soy productor de sonido en DOTEC-AUDIO. Como ha llegado la hora de crear nuestro efecto, estaré a cargo de esta parte, como diseñador del DSP.
¿Ya has configurado tu entorno de desarrollo, como explicamos la última vez?
Voy a hacer un seguimiento con aquellos de vosotros que habéis utilizado la línea de comandos o que estáis creando un entorno de programa por primera vez.
Con MSYS2, nos moveremos a una carpeta diferente usando el comando "cd
Para los nombres de carpeta realmente largos, escribe algunos de los caracteres iniciales y, a continuación, presiona la tecla TAB para completar automáticamente con los nombres que coinciden, empezando por el primer carácter.
Si quieres ver una lista de contenido de la carpeta actual, escribe el comando "ls" y presiona Enter.
Así, solo debes recordar "cd" para moverte a una carpeta diferente, y "ls" para enumerar su contenido.
Para volver a subir un nivel en el directorio, escribe "cd .." (dos períodos).
En realidad, en sistemas basados en UNIX, usamos el término "directorio" para una carpeta; pero ya que estamos usando Windows y Mac también, nos quedaremos con el término "carpeta" por ahora. (Esto probablemente no ofenderá a nadie, pero por si acaso ...)
Si instalamos "logue SDK" en la carpeta de inicio del usuario de MSYS2, nuestro trabajo posterior será más fácil.
Ejemplo: al instalar MSYS2 directamente en la unidad C: en Windows
C:\msys64\home\
Bien, pasemos a lo bueno. Primero, descarguemos el archivo que se muestra a continuación y descomprimamos los archivos en esta carpeta.
Plantilla efecto NTS-1
Aquí tenemos las plantillas para crear los efectos Mod (modulador), Delay y Reverb.
En realidad, ya hay una plantilla en logue SDK, pero lo haremos de una manera sencilla para que nuestra lección esta vez vaya bien. El hecho es que, si no estás familiarizado con la estructura de carpetas, puedes confundir las estructuras de carpetas de ejemplo entre sí y no saber dónde copiar los archivos.
Acerca de la estructura de carpetas de plantilla utilizada esta vez:
Las plantillas creadas por DOTEC-AUDIO esta vez siguen la estructura que se muestra a continuación.
- ld (carpeta)
- tpl (carpeta)
- principal.c
- Makefile
- manifest.json
- project.mk
La primera carpeta "ld" contiene el archivo de definición de los efectos que crearemos. Sin entrar en demasiados detalles, recordemos que los efectos que estamos haciendo son "Mod", "Delay" y "Reverb", y que el contenido de su carpeta es diferente de este. De la misma manera, "tpl" contiene los archivos que son las plantillas para cada tipo de efecto.
"ld" y "tpl" deben seleccionarse correctamente según el tipo de efecto que desee crear, pero no necesitará editarlos.
"Makefile", "manifest.json" y "project.mk" son archivos de definición. Los archivos que necesitarás reescribir según los efectos que crearás son "manifest.json" y "project.mk". Explicaremos dónde editar al final de este artículo.
El archivo "main.c" contiene el programa de efectos.
Esta vez, crearemos "bitcrusher", que está en la demostración. Este efecto es una versión simplificada del efecto bitcrusher que se encuentra en DeeFX, creado para que lo estudiemos.
Dejando esto a un lado, vamos a jugar con el efecto final.
Descarga los
archivos bitcrusher y descomprime los archivos de esta carpeta:
korg\v1.1\platform\nutekt-digital
Usando MSYS2, iremos (moveremos) a "korg\v1.1\platform\nutekt-digital\bitcrusher", lo cual es fácil de hacer si usas el truco de tecla TAB que expliqué anteriormente. Una vez que hayas ingresado a la carpeta "bitcrusher" usando el comando cd, use "make" como explicamos la última vez.
¿Te acuerdas de eso? Escribe "make" y presiona la tecla Enter.
Verás un largo bloque de caracteres parpadear, y finalmente verás:
Packaging to ./bitcrusher.ntkdigunit
Hecho
... si todo va bien. Se debe generar un archivo denominado "bitcrusher.ntkdigunit" en la carpeta "build". Al igual que la última vez, transferiremos ese archivo al NTS-1. Este efecto se aplica fuertemente cuando se utiliza el knob A.
¡Muy bien, vamos a echar un vistazo al código fuente! Usando el Bloc de notas, Hidemaru o cualquier editor de texto que prefieras, abre el archivo "main.c" ubicado en la carpeta "bitcrusher".
Al principio del archivo, verás:
#include "usermodfx.h"
#include "float_math.h"
Necesitaremos la primera línea para crear modfx. La segunda línea es necesaria para las operaciones de punto flotante.
Hay dos métodos utilizados para mostrar los tamaños de los números en los datos de audio digital: decimal fijo y coma flotante. El punto flotante se usa comúnmente, de la misma manera que cuando decimos "50% más". Es más fácil de entender para todo el mundo. Sin embargo, la desventaja del punto flotante es que los cálculos se procesan más lentamente.
El decimal fijo se procesa más rápido, pero es más difícil de entender. También es más difícil de manejar, ya que hay diferentes formatos (como el formato Q) para determinar el número de dígitos para enteros y decimales.
Aún así… ¡El NTS-1 tiene un procesador incorporado que se dedica a manejar coma flotante!
No hay ninguna razón por la que no debamos usarlo, así que hagámoslo.
Ahora, a la siguiente parte.
static float rate, lastSampleL,lastSampleR;
static uint32_t count;
Esto está aquí para poner una etiqueta en las "cajas" donde ponemos datos llamados "variables".
Esto crea tres variables estáticas de tipo flotante denominadas "rate", "lastSampleL" y "lastSampleR" y una variable estática de tipo uint32_t denominada "count".
Estos se denominan "declaraciones de variables (globales)" y son una parte clave del programa... así que puedes hacer una búsqueda con una frase como:
“C variable declarations”
para aprender más! Al hacerlo, también aprenderás sobre el significado y los tipos de "estático".
En pocas palabras, si no deseas que el contenido de la variable se borre cada vez que se ejecute un proceso, ajústalo en "estático" y el contenido se mantendrá.
El tipo "estático" tiene otros usos. Intenta buscar "variables estáticas".
Muy bien, ¿qué sigue?
void MODFX_INIT(uint32_t platform, uint32_t api) { lastSampleL = 0.f; lastSampleR = 0.f; count = 0; }
Lo anterior es lo que llamamos una "función".
Una función se representa mediante una etiqueta para cada proceso de programa por función, denominada nombre de función. Puedes llamar a las funciones por sus nombres desde todo tipo de lugares dentro del programa y usarlas en combinación para crear una sola cadena de resultados: su software. Las funciones son muy similares a las partes individuales utilizadas en un automóvil.
Value returned Function name (argument)
{
Processes to execute
}
El anterior es el formato utilizado para las funciones. El "valor devuelto" significa qué tipo de datos se utiliza para obtener los resultados del proceso ejecutado por la función, y el "argumento" son los datos y su tipo que se dan a la función cuando se llama.
Esta vez, estamos escribiendo un proceso de inicialización. El contenido de la variable que creamos se restablece a "0", pero ¿qué significa la "f" en "0.f"? Esto simplemente significa que estamos comprometiéndonos con un tipo float. Intenta hacer una búsqueda para esto. Entonces, ¿qué hay del "void" en el valor devuelto? Esto significa que no se devuelve nada en los resultados. Dado que la primera vez que hacemos el proceso de inicialización es también la última vez, obtenemos el valor "void".
Eso es todo lo que esta función tiene que hacer, ¡perfecto!
Ahora pasamos al procesamiento principal. Primero saltaremos para explicar la función en la parte inferior.
void MODFX_PARAM(uint8_t index, int32_t value)
{
const float valf = q31_to_f32(value);
switch (index) {
case k_user_modfx_param_time:
rate = valf;
break;
default:
break;
}
}
Wow, esto ya se ve bastante difícil!
Todo lo que esto está haciendo es obtener datos de los knobs A y B, y poner esos valores en nuestra variable.
Al girar los mandos, el sistema del NTS-1 llama a esta función y cuando se llama a esta función, el tipo de knob "índice" y su valor, "valor" se reciben como un argumento. Este valor viene en formato decimal fijo como cubrimos anteriormente, por lo que primero tenemos que convertirlo a punto flotante. En este ejemplo, convertimos el formato Q31 decimal fijo en punto flotante de 32 bits y almacenamos el resultado en una variable denominada "valf". Usamos "const" cuando el contenido de los datos no debe cambiarse. Intenta hacer una búsquedo sobre esto si necesitas más detalles.
Esto se procesa mediante la instrucción "switch case". Explicado simplemente, esto muestra el procesamiento que se produce cuando las variables que especificamos usando "switch" coinciden con estos casos respectivos.
Esta vez, usamos solo los datos del knob A, por lo que el contenido de "valf" se almacena en la variable "rate" cuando se reciben datos k_user_modfx_param_time (nombre de índice del knob A).
La variable "tasa" se utiliza para el procesamiento principal, por lo que he explicado esta función primero.
Ahora estamos en la parte principal.
void MODFX_PROCESS(const float *main_xn, float *main_yn,
const float *sub_xn, float *sub_yn,
uint32_t frames)
Con la función denominada MODFX_PROCESS, podemos obtener estos seis argumentos:
Main input: main_xn
Main output: main_yn
Sub input from the oscillator: sub_xn
Sub output from the oscillator: sub_yn
Total number of frames: frames
Los nombres de variable marcados con un asterisco llaman por referencia. Indican que, en esta función, cuando se cambia un valor la variable que lo llama también cambia. Esto significa básicamente que los datos recibidos son el original, no una copia. ¡Es posible que desees estudiar más acerca de llamar por referencia y pasar valores!
Aunque es posible que hayas descubierto esto mirando el argumento, todo lo que necesitas hacer es hacer el procesamiento de diversos efectos para los datos equivalentes al número de fotogramas en "main_xn", y escribir esto como la salida para main_yn.
No usaremos sub entrada / salida esta vez.
Aquí está la parte inicial:
for(uint32_t i = 0; i < frames; i++){
Esto significa que todo lo que tenemos que hacer es repetir lo que está dentro de los corchetes { } el número especificado de veces. Esto se denomina instrucción "for" y la usamos para repetir el procesamiento del número de fotogramas.
// Prepare the L and R audio
const float inL = main_xn[i * 2];
const float inR = main_xn[i * 2 + 1];
Las dos barras diagonales (//) al principio marcan un comentario. Usa estos para dejar notas en tu programa, ya que no tendrán ningún efecto en cómo se ejecuta el programa.
Ahora, en cuanto a la entrada, "main_xn", el audio estéreo (canales) alterna entre izquierda y derecha.
Podemos procesarlos alternativamente, pero en aras de la claridad los transferimos a variables cada vez, "inL" e "inR".
Volviendo a explicar la estructura de "main_xn", podemos ver el texto "LRLRLR", que representa conjuntos de "LR" según el número de fotogramas. La cantidad de datos es igual al doble del número de tramas. Las variables que contienen varios conjuntos de datos se denominan "variables de matriz". Deberías ser capaz de entender este término si haces una búsqueda sobre él. La cantidad de estos datos se conoce como el número de elementos. El número de elementos en "main_xn" es el doble del número de fotogramas escritos en "marcos".
Especificamos qué número de elemento utilizar con corchetes []. La parte difícil es que los números comienzan con cero, por lo que main_xn[0] indica el primer número de elemento. Por lo tanto, en esta instrucción "for", el valor de la variable denominada "i" aumenta en uno con cada bucle, siempre que el valor sea menor que "frames".
Como "i" comienza con cero, será el mismo en términos de número de veces que el número de fotogramas, pero solo mientras termine un número inferior a "fotogramas".
Estarás pensando, "¿por qué los números no comienzan con 1?". En ese caso, el bucle finalizaría una vez que el número alcance el mismo número que los "fotogramas". Dicho esto, solo hay una posibilidad de que los números sean los mismos... así que, si cometes un error en tu programación y repasas el número, terminarás con un bucle sin fin.
Si esto sucede, el programa puede congelarse, o tal vez el siguiente proceso comenzará en cero, lo que podría ser conveniente ... Eso se relaciona perfectamente con el siguiente tema.
Verás que la notación se lee como "[i * 2]", "[i * 2 + 1]" y así sucesivamente. Puesto que LR viene adentro alternativamente, el número cero es "L", y el número 1 es "R". Es fácil de entender cuando lo piensas así: cuando "i" es 0, [0 * 2][0 * 2 + 1] produce "0" y "1"; cuando "i" es 1,2... y así sucesivamente.
Así que ahora que tengo una mirada petulante en mi cara después de explicar todo esto, vamos a entrar en los secretos de cómo funciona el bitcrusher.
Para explicar primero cómo funciona bitcrusher, este efecto le da una frecuencia de muestreo "más áspera", ya que las frecuencias de muestreo más altas producen un sonido más detallado. Lo que quiero decir con "más áspero" es que la frecuencia de actualización de los datos de muestreo es menor, o los pasos (resolución) se vuelven menos definidos. Esta vez, reduciremos la frecuencia de actualización y cambiaremos la salida de datos una vez cada cierto número de veces. Si la entrada de datos es continua como "12345678", este efecto le da "11335577".
¡Esto le da un sonido como la reducción de la velocidad de muestreo, pero podrías argumentar que “esto no es un efecto bitcrusher (reducir la cuantización)!" Comprendo perfectamente esa objeción.
El hecho es que la mayoría de la gente tendrá problemas para entender si de repente hablamos de operaciones de bits. Además, los efectos bitcrusher disponibles ofrecen un sonido con mucha pegada al reducir la frecuencia de muestreo, no un efecto leve con solo dejar caer algunos bits. Por eso te di una explicación más interesante. Muy bien, ¡sigamos adelante!
// The larger the value, the grainier the sample
uint32_t skip = rate * 64;
Aquí es donde utilizamos los datos previamente recibidos de los knobs. ¡Por fin, aquí está! Los datos que recibimos son de 0 a 1, por lo que si queremos obtener un valor de 64 del número máximo (1), necesitamos multiplicarlo por 64.
Para que sea más fácil de entender, reemplazamos esto con la variable "skip".
// Update lastSample only when count is 0
if(count == 0){
lastSampleL = inL;
lastSampleR = inR;
}
Entenderás esta parte más a medida que avancemos. En primer lugar, explicaré sobre el procesamiento.
Esto actualiza la variable que mantiene la salida, pero solo cuando la variable "count" es "0".
En otras palabras, cuando el valor no es "0", "lastSmpleL/R" es el mismo valor que la última vez.
"count" comienza con cero tal como se inicializó (mencionado anteriormente) y de repente se actualiza al valor "inL/R".
// Continue lastSample sound
main_yn[i * 2] = lastSampleL;
main_yn[i * 2 + 1] = lastSampleR;
count++;
Esto hace lo contrario de lo que hicimos al separar la entrada en L y R. La salida se escribe en "main_yn" aquí para los sonidos L y R. Básicamente, escribimos el mismo sonido que acabamos de poner en "inL/R". ¡Nada ha cambiado!
Por cierto, después de esto vemos un "count++". Esto significa aumentar el "recuento" en uno.
Es por eso que "0" se convierte en "1". Con este método, también podemos escribir "i++" para la instrucción "for", de modo que "i" se incrementa en uno con cada paso. Otra forma de escribir esto es "count = count + 1".
Lo que sucede cuando el recuento llega a "1" es que "lastSampleL/R" no se actualiza al principio del siguiente paso. Los mismos datos de ejemplo siguen siendo generados. Entonces, ¿cuándo volvemos a cero?
// reset count to 0 if skip exceeded
if(count > (int)skip) count = 0;
Sí, aquí mismo.
Anteriormente, recibíamos un valor del knob, y si ese valor multiplicado por 64 excedía el "recuento", se restablecería a cero.
Lo que sucede es que con valores de "omisión" más grandes, los mismos datos se generan sin tener en cuenta la entrada y, por lo tanto, obtenemos una caída en la frecuencia de actualización de los datos de muestreo.
¡Hemos terminado!
Por último, tenemos estos:
}
}
En realidad, son importantes. El corchete cerrado en la parte superior es para la instrucción "for" y los corchetes en la parte inferior marcan el final de la función. Básicamente, utilizamos estos corchetes {} para encerrar todo tipo de procesos. Cuanto más largo sea el proceso, ¡lo más probable es que nos olvidemos de poner el corchete de cierre! Ten cuidado con esto, porque solo esta omisión hará que se produzca un error en la compilación.
Este tipo de error también es difícil de encontrar, y es común que los programadores pierdan mucho tiempo solo buscándolo.
¡Por supuesto, no soy una excepción! Cuando encuentras este tipo de error, ¡realmente te dan ganas tirate por la ventana!
El programa esta vez es "Modfx", y podemos crear este a partir de la plantilla "tmpMod". Te animo a comparar esto con el archivo "main.c" y ver lo que se ha agregado.
¡Intenta reemplazar los valores en “skip” con diferentes valores y pruébalo!
Finalmente, escribiremos el nombre del efecto que creamos en el parámetro "name" en "manifest.json" y en el parámetro "PROJECT" de "project.mk". Puedes hacerlo utilizando un editor de texto.
A continuación: StopFX
¡Esto será todo un desafío, así que espero que estés deseando que llegue!
¡Muchas gracias por leer este artículo tan largo!
Artículo #4: Creación de un efecto original, Parte 2
Hola, soy Frank Shigetora, productor de sonido en DOTEC-AUDIO.
Esta vez haremos otro efecto, así que como diseñador del DSP estaré a cargo de esta parte.
Voy a omitir las cosas que ya cubrimos en el artículo #3, así que por favor pon las cosas en orden!
Esta vez, crearemos un efecto bastante complejo, incluso más que la última vez.
Genial, eh? Es como detener un disco. Ahora te mostraré todo lo que necesitas saber para hacer este efecto.
En primer lugar, veremos el efecto en funcionamiento. Usa MSYS2 para ir a esta carpeta:
korg\v1.1\platform\nutekt-digital\stopfx
y ejecuta el comando "make". Si no tienes idea de lo que acabo de decir, por favor vuelve y echa un vistazo al artículo #3.
¿Ha funcionado? ¡Ahora, vamos a echar un vistazo al código fuente!
Vamos a abrir el archivo "main.c", ubicado en la carpeta "stopfx".
Al principio del archivo, verás:
#include "userdelfx.h"
#include "float_math.h"
#include "buffer_ops.h"
Necesitaremos la primera línea para crear delfx (el tipo de retardo). A continuación, ¿recuerdas la segunda línea?
Sí, al igual que con la última vez, necesitamos esto para las operaciones de punto flotante.
En la tercera línea, tenemos algo nuevo. Esto es necesario para almacenar una gran cantidad de sonidos en la memoria en el NTS-1.
Como te puedes imaginar, necesitarás mucha memoria para almacenar archivos largos de datos de música. El SDK del NTS-1 incluye una función para operaciones de memoria (control de memoria), y la tercera línea de nuestro código incluye la instrucción "#include buffer_ops.h" para ello.
Aquí hay una nueva palabra para recordar: "buffer". Probablemente hayas escuchado esta palabra.
Un búfer es un lugar donde se almacenan o guardan los datos para su procesamiento temporal. Esta vez, usaremos el búfer para la matriz que creamos la última vez. Queremos almacenar una gran cantidad de datos de sonido en este búfer, por lo que necesitamos hacer una matriz grande.
A continuación, entramos en las funciones. Inicializamos como lo hicimos la última vez:
void DELFX_INIT(uint32_t platform, uint32_t api) { buf_clr_f32(s_delay_ram, BUFFER_LEN); z = 0; z2 = 0; prev = 0; next = 0; p = 0.f; slope = 0.f; isStop = 0; }
Fíjate en la función utilizada especialmente para delfx. Lo único diferente es el nombre, cierto.
Para las otras variables, solo podemos usar "0" o el valor predeterminado; pero para el búfer, usamos la función "buf_clr_f32()" para la inicialización.
Detengámonos aquí para ver la última función, que explicaré.
void DELFX_PARAM(índice de uint8_t, valor int32_t)
Esta función se utiliza de la misma manera que la última vez, pero sólo tiene un nombre diferente. Si no recuerdas esto, vuelve y revisa el artículo #3 y todo volverá.
Ahora por fin nos estamos acercando al centro del asunto, el procesamiento de DSP.
void DELFX_PROCESS(float *xn, uint32_t frames)
Con la función denominada DELFX_PROCESS, podemos obtener estos dos argumentos:
Entrada/salida principal: main_xn
Número total de fotogramas: fotogramas
@@@ Wow, sólo dos esta vez, en lugar de seis la última vez! Lo tenemos fácil.
El punto clave aquí es que con "modfx", la entrada y la salida se separaron la última vez, pero esta vez se usa "xn" tanto para la entrada como para la salida.
Cómo funciona esto es que "xn" contiene datos de entrada, y esto se procesa para que los datos sobrescritos en el punto final de la función se conviertan en los datos de salida.
// Copy to sampling buffer
for(uint32_t i = 0; i < frames * 2; i++){ s_delay_ram[z++] = xn[i]; if(z > BUFFER_LEN - 1) z = 0; }
Esto coloca toda la entrada en el búfer que hemos preparado. Esta es la instrucción "for" que usamos para hacer un bucle la última vez y la instrucción "if" que toma decisiones condicionales. "Frames" es el número de tramas para un canal, por lo que estamos estableciendo este valor al doble de esa cantidad para dos canales (LR). Lo que es confuso es el "++" que viene después de la "z". "z" aumenta después de la entrada "zth" en el búfer.
En cuanto a la matriz, ah, comienza desde cero, ¿verdad? Por esa razón, esto se restablece a cero, para evitar un bloqueo no deseado en caso de que lleguemos al número representado por BUFFER_LEN. Como escribí la última vez, esta condición se puede escribir de diferentes maneras. Lo hemos estandarizado esta vez para que se cumplan las condiciones al alcanzar o superar el valor. Debes tener en cuenta que el NTS-1 no se romperá si el software se bloquea, ¡así que no te preocupes si cometes errores!
De esta manera, devolvemos el valor a cero y mantenemos el búfer en marcha (lo que significa que seguimos escribiendo en él). Esto se denomina "búfer de anillo" o "búfer cíclico".
A continuación, prepararemos el valor para ralentizar realmente la velocidad de reproducción.
// Reset when knob is turned all the way to the left
if(rate < 0.1f){ isStop = 0; rate = 0.f; }else{
Este es el procesamiento para volver a la velocidad de reproducción original cuando el knob se gira completamente a la izquierda. Cuando el knob se gira completamente a la izquierda, si las condiciones se establecen en "rate== 0.f", esto es bastante difícil de usar, así que vamos a establecer esto en "0.1f" o menos para darnos un margen para trabajar con. No queremos que el knob reaccione involuntariamente con solo un ligero movimiento del dedo.
"isStop" se usa para determinar si el efecto stop está activado o no. En el lenguaje C, podemos usar los números 1 y 0 como sustituto de true y false respectivamente, por lo que estableceremos esto en "0" antes del efecto stop.
Un valor apropiado se recoge de el knob cuando se cambia el efecto, por lo que restableceremos la "tasa" también.
Tome nota de cómo este bloque de código termina con "else". Usamos esta instrucción cuando queremos agregar un proceso que se produce cuando no se cumplen las condiciones anteriores. Cuando vi por primera vez ese código, lo leí como "borrar" (erase en inglés)... Eso fue bastante estúpido, ¡verdad! ?
Por lo tanto, cuando se cumplen las condiciones de la instrucción "else", se gira el knob, por lo que se procesa el efecto de parada.
En primer lugar, estableceremos el valor inicial cuando el knob se gira por primera vez.
¡Nos estamos metiendo en aguas turbulentas aquí!
// Determine the beginning stop point of the knob This is disabled when the knob is turning, since “isStop” is “1”.
if(!isStop){ isStop = 1; rate = 0.f; p = (z - frames * 2.f) / 2.f; if(p < 0.f)p = (BUFFER_LEN - 2.f * p) / 2.f; } // this is not the closing bracket for “else”, but for the “if” statement just before
El signo de exclamación que viene antes de "isStop" no significa que esté loco, significa una negación, o más bien "no". Cuando "isStop" no es cierto, o en otras palabras, cuando es falso se procesa el código dentro de la instrucción "if".
Puesto que anteriormente establecimos esto en "0", esto se procesa. Sin embargo, no queremos que el procesamiento ocurra cuando el knob comienza a girar, por lo que establecemos "isStop" en "1" directamente después. Esto significa que el procesamiento se omite hasta que el knob se gira todo el camino hacia la izquierda y se restablece el valor. Este tipo de procesamiento se denomina "bandera". Es la misma bandera que cuando decimos, "establecer la bandera XXX".
En algunos casos, el knob puede estar en una posición apropiada de la misma manera que antes... así que, en esos casos, saltamos más allá de las condiciones anteriores y restablecemos la "tasa" para saltar aquí.
La variable "p" indica el punto de reproducción del búfer. Dado que hemos almacenado dos veces la cantidad de "frames" de datos en el búfer, restamos hasta el punto en el que comenzamos a almacenar datos y luego devolvemos ese valor. Podrías preguntarte, "¿así que estamos dividiendo esto de nuevo por dos?", pero esto se aclarará después. Por último, escribimos el proceso para la instrucción "if" en caso de que "p" sea un valor negativo. Por ejemplo, si el búfer pasa por un ciclo y termina de escribir datos, restar el número total de esa posición nos daría un número negativo. Por eso restamos la diferencia del final.
Esta vez, tenemos un tamaño de búfer viable, por lo que no obtenemos un resultado negativo. Aún así, tenemos que acostumbrarnos a pensar en ubicaciones menos en nuestra matriz.
Parece que las cosas de repente se están complicando cuando hablamos de búferes, pero no es ningún problema. ¡Lo conseguirás!
Por cierto, notarás que esta instrucción "if" no tiene los corchetes {}. Dado que solo estamos procesando la última línea, podemos omitirlos. Es recomendable recordar esto cuando desees hacer una pequeña prueba agregando la parte "si".
Todavía no hemos terminado con nuestro viaje por el extraño camino de "else" (eso ha sido una pequeña broma).
for(uint32_t i = 0; i < frames; i++){ uint32_t length_mono = BUFFER_LEN / 2;
Dado que la instrucción "for" ha aparecido, desde aquí aplicaremos el efecto y nos ocuparemos de sobrescribir la variable "xn".
Podrías preguntarte por qué no doblamos "frames" aquí. Esto se debe a que se trata de una señal estéreo, por lo que procesamos dos líneas a la vez.
Entenderás esto más adelante, así que está bien si esto no tiene sentido todavía.
En primer lugar, usamos la longitud equivalente a la parte monoaural del búfer para establecer un nombre de variable que sea fácil de entender.
Reducir el valor a la mitad es siempre complicado, y el código se vuelve más difícil de hacer con las fórmulas agregadas.
Como se trata de un entero, el tipo de variable se establece en "uint32_t".
// Get the before-after index of the playback position, and the interpolating coefficient
prev = (uint32_t)p; slope = p - prev; next = prev + 1; if(next > length_mono - 1) next = 0;
¡Aquí está la parte importante!
El marco para reproducir lentamente es que calculamos el valor entre dos muestras y avanzamos lentamente la muestra. Al igual que cuando contamos lentamente, "o---ne, tw----o", calculamos la sección alargada a partir de dos puntos.
El tipo de variable "p" es "float", por lo que obtenemos números no redondeados como 1.2 y 5.4. Cuando se trata de matrices, no existe tal cosa como "ubicación 1.2". Es por eso que asumimos que para el valor en la ubicación "1.2", el valor es un 20% más cercano al primer valor.
A raíz de esto, podemos postular que los valores "1, 2, 3" avanzarán de esta manera para la extracción: "1.3, 1.6, 1.9, 2.2, 2.5..." En el caso de la altura de la forma de onda, estos valores representan la forma de onda en su pico.
Continuando con esta explicación, estamos convirtiendo "p" en un entero en la primera línea. Esta forma de escribir código por (tipo) se denomina "conversión". Usamos esto para convertir tipos.
Al convertir a entero, por ejemplo, podemos cambiar el valor de "7.4" en "p" a "7", dejando caer el decimal y luego almacenarlo en "prev".
En la segunda línea, el número restado de la "prev" que se convirtió en un entero de la "p" original se almacena en "pendiente".
¡Sí! Este es el decimal redondeado hacia abajo. En el ejemplo anterior, sería 0,4.
Tal vez algunos de vosotros ya os habéis dado cuenta de esto. Usamos este método para obtener un valor que es un 40% más que el valor en la ubicación "pth".
Entonces, ¿a dónde va esto? En la tercera línea, por supuesto, esa es la siguiente matriz después de la "pth". Ponemos eso en "siguiente".
Esto es para la instrucción "if" final, de modo que el "siguiente" no supera la matriz. Has visto esto antes, ¿verdad?
// Get the sound of the playback position
float s1L = s_delay_ram[prev * 2]; float s2L = s_delay_ram[next * 2]; float s1R = s_delay_ram[prev * 2 + 1]; float s2R = s_delay_ram[next * 2 + 1];
Por último, ¡el clímax de la historia!
"s1" es el primer sonido de entre los dos puntos mencionados anteriormente, y "s2" es la L y R que hemos preparado, es decir, el último sonido.
"prev" y "next" son los números de matriz de los dos puntos.
La parte sobre multiplicar por dos y hacer un par es la misma que explicamos antes, pero dado que LR se introduce alternativamente en el búfer, necesitamos extraer el sonido L de las ubicaciones pares en la matriz, y el sonido R de las ubicaciones impares en la matriz.
La variable "i" en la instrucción "for" se incrementa uno por uno, por lo que si calculamos 0, 1, 2, 3 y así sucesivamente, los resultados se separan en números pares e impares.
¡La razón por la que dividimos por dos al principio para obtener el valor de "p" fue para obtener el número duplicado aquí!
Así que de eso se trataba todo esto...
float currentL = 0.f,currentR = 0.f; currentL = s1L + (s2L - s1L)*slope; currentR = s1R + (s2R - s1R)*slope;
Hemos creado la primera variable para poner temporalmente la ubicación de nuestro sonido actual. Inicializamos sin sonido.
La siguiente fórmula calcula el valor para derivar el valor del punto mediano anterior. Solo estamos agregando varios por ciento aquí, la diferencia del siguiente valor al valor inicial. Por ejemplo, si los valores progresan como "0, 10", el valor de la ubicación cuando aumentamos 20% desde cero es:
0+(10-0)*0.2 = 2
Este es el valor cuando la "p" que mencionamos antes era la 1.2ª posición.
Así que, de repente... ¡felicidades!
Has superado el obstáculo más difícil.
// Overwrite as output.
xn[i * 2] = currentL; xn[i * 2 + 1] = currentR;
Dado que fuimos felizmente capaces de calcular el valor que queríamos para el sonido, actualizamos "xn" en orden LR!
El número máximo en este bucle era "frames", que utiliza el mismo valor "i" para procesar LR, por lo que si giramos el knob a mitad de camino estamos bien.
Podemos hacer eso desde el principio también, ya que no había necesidad de separarlos, simplemente giramos el knob.
// Advance the playback point according to the “rate” amount p += 1.f - rate; if(p > (float)length_mono - 1.f) p = 0.f; } // “for” ends here } // “else” ends here
Luego, avanzamos "p" de acuerdo con la tasa para el siguiente bucle.
El "+=" significa que agregamos el lado derecho al lado izquierdo. La razón por la que hacemos de esto un número recíproco es porque cuando giras el knob hacia abajo para hacer que la "tasa" sea igual a cero, el número avanza más rápido, y queremos detenerlo en "1". En cero, la matriz avanza uno por uno, que es la velocidad de reproducción estándar. Cuanto más gires el knob a la derecha, por ejemplo, avanzando 0.3 a la vez, más lento será.
La siguiente instrucción "if" devuelve el valor a cero después de que "p" avance la cantidad de un canal.
Terminamos agregando los corchetes de cierre para el "for" y "else".
¡Ahora nuestro viaje ha terminado!
Este programa es "Delfx", y podemos crear este a partir de la plantilla "tmpDelay".
Si comparas esto con "main.c", verás dónde necesitas escribir el programa.
Finalmente, al igual que la última vez, escribiremos el nombre del efecto que creamos en el parámetro "name" en "manifest.json" y en el parámetro "PROJECT" de "project.mk".
Aunque este efecto es una versión simplificada del efecto stop que se encuentra en "DeeFX" de DOTEC-AUDIO, los principios son los mismos. Creo que has sacado mucho de mirar esto.
El siguiente artículo: ¡resumen final!
Con esto concluye mi parte, el apartado DSP.
¡Muchas gracias por leer este largo artículo!
Artículo #5: Creando un Vocoder
¡Hola de nuevo a todos! Soy Shinji Iijima de DOTEC-AUDIO.
¿Habéis disfrutado de los dos artículos anteriores, donde Frank Shigetora nos dio los detalles sobre el procesamiento de DSP?
Honestamente, imagino que debió parecer bastante intimidante. Dicho esto, el procesamiento de los datos digitales que se introducen, emiten y luego se repiten forma los fundamentos de todos los programas de efectos digitales.
Los programas de muestra esta vez eran todos menos de 100 líneas de largo, así que realmente espero que aprovechéis esta oportunidad para utilizar la Web para buscar y aprender más con el fin de entender acerca de estos programas, y acerca de los elementos de desarrollo de efecto NTS-1 y cuestiones con respecto al oscilador (sintetizador) desarrollo que por desgracia no pudimos cubrir esta vez.
Esta vez, terminamos esta serie de artículos, por lo que no profundizaremos en los programas.
Sin embargo, me gustaría anunciar que en DOTEC-AUDIO, hemos puesto todo nuestro esfuerzo en hacer un vocoder de voz de 16 bandas y un oscilador dedicado que funcione en el NTS-1. Por lo tanto, esta vez daré algunas explicaciones básicas sobre estas cosas, así como sobre los complementos para PC que ha lanzado DOTEC-AUDIO.
En cuanto al vocoder que hemos desarrollado, es un vocoder completo de 16 bandas.
Conecta un micrófono (al que llamamos "modulador") al NTS-1 y haz que el oscilador suene mientras vocalizas para obtener una voz robotizada genial.
¿Qué te ha parecido? ¿No es sorprendente cómo se puede hacer funcionar un codificador de voz de 16 bandas en este sintetizador digital compacto?
Hemos conseguido esto aprovechando algunos trucos ocultos que ofrecen las especificaciones del NTS-1. Es un poco complicado, pero lo explicaré aquí.
En primer lugar, el NTS-1 cuenta con un conector AUDIO IN.
Podemos conectar una entrada de audio de nivel de línea a esta toma y aplicar efectos o mezclar el sonido del oscilador con esta entrada. (Esta es una de las fantásticas especificaciones que ofrece esta unidad). Sin embargo, la entrada debe ser de nivel de línea y el audio de entrada se mezcla con el sonido del oscilador, que son obstáculos que tuvimos que descubrir cómo superar.
- Acerca de la entrada de línea (nivel de entrada de audio)
Dado que la entrada del NTS-1 requiere una entrada de línea, normalmente necesitaríamos un amplificador de micrófono o un mezclador para amplificar el sonido si quisiéramos conectar un micrófono.
Además, dado que este conector fue diseñado para entrada de línea, esta unidad también cuenta con un atenuador que es necesario para atenuar los niveles.
Afortunadamente, el NTS-1 tiene ajustes de “parámetros globales”, que se pueden usar para cambiar el funcionamiento de las distintas operaciones en esta unidad.
Me gustaría que consultaras la sección "Parámetros globales" en el Manual del propietario que viene con el NTS-1 (en la parte inferior derecha de la página 16). Hay un parámetro llamado "Ajuste de entrada".
Si no puedes encontrarlo en tu manual de usuario, por favor descarga la última versión
desde aquí. También será necesario que actualices tu NTS-1 desde tu ordenador.
La configuración predeterminada de fábrica para este parámetro es “6: -6DB”, pero al configurarlo en “0: 0DB” podemos deshabilitar la atenuación. Usa esta configuración cuando desee conectar un micrófono dinámico o un dispositivo similar sin usar un amplificador.(No es necesario realizar esta configuración para un dispositivo de entrada de línea).
Si el volumen de entrada sigue siendo demasiado bajo, podemos solucionar este problema configurando el parámetro A del vocoder en “Gain” y ajustando esta perilla para amplificar el volumen 100 veces como máximo.
- Acerca del audio de entrada y el sonido del oscilador
Un vocoder usa el audio de una entrada de micrófono (el "modulador") para procesar el sonido de un sintetizador (el "portador"). Aunque ambos elementos requieren entradas separadas, el NTS-1 no tiene esta característica.
Lo que sucede es que los sonidos del sintetizador y la entrada externa se mezclan y luego son procesados por el efecto. Puedes probarlo y ver a qué me refiero.
Para evitar esto, se nos ocurrió una idea audaz de separar los sonidos utilizando el diferencial en el audio estéreo.
Por ejemplo, si tienes el mismo sonido de sintetizador en los canales izquierdo y derecho, pero luego agregas el sonido del micrófono a un solo canal, puedes extraer el audio del micrófono utilizando el diferencial de ambas señales. ¿Tiene sentido esta línea de razonamiento?
Asi, esto puede explicarse con esta fórmula;
(señal de micrófono + señal de sintetizador) – señal de sintetizador = señal de micrófono
Usando este método en el NTS-1, separamos el audio del sonido del oscilador y los procesamos para hacer que nuestro vocoder esta vez sea una realidad.
Aparte de eso, debemos tener en cuenta que hay un pequeño truco involucrado en la conexión del micrófono, algunos ejemplos de los cuales se muestran a continuación.(Requisito: usa el canal L como entrada de micrófono)
- Usa un micrófono dinámico monoaural - Desde el principio, prepara una fuente de sonido donde su voz se escuche solo en el canal L (el canal R debe estar en silencio) y usa la entrada de línea para llevar la señal estéreo al NTS-1 - Usa la entrada de línea de un mezclador para llevar la señal estéreo que contiene solo el sonido del micrófono en el canal L al NTS-1 - Use un cable splitter para conectar el micrófono solo al canal L
-
Ejemplo de conexión usando un micrófono dinámico
-
Ejemplo de conexión usando un cable splitter
Usar un micrófono de salida monoaural es la forma más sencilla. Si usas un micrófono con salida estéreo, puedes obtener el mismo resultado con un cable divisor. ¡Pruebalo!
Dicho esto, puedes descargar una versión de prueba de nuestro vocoder junto con el oscilador como un conjunto de forma gratuita. Puedes probarlo durante 3 minutos en una versión de prueba. Y ahora se vende una versión completa por $ 10 (sin impuestos) en el sitio web de DOTEC-AUDIO.
https://dotec-audio.com/nts1.html?lang=en
Francamente, estoy asombrado por el hecho de que podemos usar el NTS-1 como un codificador de voz.
Ya que estás aquí, me gustaría ofrecerte un resumen de quiénes somos en DOTEC-AUDIO, así como nuestra línea de productos original.
DOTEC-AUDIO es una marca de software administrada y operada de manera cooperativa por el músico e ingeniero Frank Shigetora y por fmfmsoft Corp.
Nuestro negocio general es el desarrollo y la venta de complementos para software relacionado con la música como DAW que operan en Windows, macOS e iOS (para algunos productos).
El KORG Gadget2 incluye un maximizador creado por DOTEC-AUDIO llamado "DeeMax", por lo que es posible que hayas oído hablar de nosotros.
Han pasado seis años desde que comenzó DOTEC-AUDIO, y ahora tenemos una línea de productos mucho más grande, que incluye productos para músicos que realizan producción musical en una PC y productos para distribución de contenido. Si estás interesado, visita nuestro sitio web. Hay algunos productos allí en particular que tienen una conexión profunda con lo que hemos hablado en esta serie de artículos.
- DeeFX Multi-Effect
Web:
https://dotec-audio.com/deefx.html
Comentamos brevemente este producto en el primer artículo. Este es un multiefecto que ofrece efectos estándar de distorsión, filtro y retardo, pero en un paquete en el que hemos trabajado duro para ajustarlo, lo que lo hace muy fácil de usar.
El diseño combina estos tres efectos, que puedes activar y desactivar individualmente y utilizar como procesadores de efectos independientes.
A esto se suman los efectos bitcrusher y vinyl stop, que son versiones simplificadas de lo que presentamos en este artículo para su uso en el NTS-1.
Este es un producto popular incluso entre muchos músicos profesionales.
- “DeeVocoder” vocoder
Web：
https://www.dotec-audio.com/deevocoder.html
Como su nombre indica, este producto es el vocoder de voz fabricado por DOTEC-AUDIO. Este vocoder de voz cuenta con un codificador de voz de tipo banco de filtros (que ahora está experimentando un resurgimiento) conmutable entre ocho, 16 y 32 bandas, así como capacidades de cambio de formante.
A diferencia de los productos de tipo FFT, nuestro vocoder de voz ofrece una capacidad de reproducción superior sin latencia, lo que ofrece el poder de crear esa voz de robot de sonido descarado que normalmente se crea con codificadores de voz analógicos.
Hemos puesto énfasis en el posicionamiento de este producto como un efecto, ya que, al utilizar este complemento de sintetizador familiar para la entrada de cadena lateral, el vocoder como portador abre infinitas posibilidades de creación de sonido. Por supuesto, cualquier entrada de audio a la cadena lateral se puede usar como portadora, por lo que puedes disfrutar usando este efecto de complemento a tu antojo, no solo para sonidos de sintetizador, sino también para guitarra, bajo, batería y más.
De esta manera, dado que se trata de un complemento para usar con DAW, ofrece un tipo de libertad diferente del vocoder que funciona con el NTS-1.
Todos los productos DOTEC-AUDIO cuentan con una versión de demostración que puedes probar de forma gratuita (sin necesidad de registro de usuario u otros problemas). Si usas software para complementos como VST o unidades de audio, ¡definitivamente esperamos que pruebes nuestros productos!
Esta serie de artículos es parte de una propuesta que le hicimos a KORG. La razón para hacer esto fue que queríamos hablar sobre cómo el NTS-1 es una plataforma tan atractiva para la programación.
Lo fantástico del NTS-1 es que su hardware compacto y su capacidad de programación le brindan un alto grado de libertad.
Además, como profesionales de la programación de audio, estamos muy entusiasmados con la forma en que el NTS-1 tiene una entrada de audio y se puede utilizar como sintetizador o como unidad de efectos. Es realmente interesante cómo el NTS-1 ofrece todo esto, sin dejar de ser eminentemente asequible. Es por eso por lo que propusimos esta serie de artículos: queríamos contarle a la mayor cantidad de personas posible lo fascinante que es este producto.
Como hemos escrito una y otra vez, los conceptos básicos de la programación de audio son los mismos, ya sea que esté utilizando el NTS-1 o trabajando con un complemento DAW.
Aunque puede haber un número infinito de formas de hacer que tu solución funcione, todo se reduce a cómo desea crear el sonido que busca, entre la entrada y la salida.
Esperamos que esta serie de artículos haya brindado la oportunidad a tantos usuarios como sea posible de desarrollar un interés en comprender cómo se diseñan sus aplicaciones de música y sintetizador favoritas, mientras juegan con el NTS-1.
Me gustaría dar las gracias de todo corazón a todos por leer esta serie de artículos!
También, mi agradecimiento a las personas involucradas en KORG, que aceptaron publicar esta serie.
¡Espero veros a todos algún día!
Frank & Iijima, DOTEC-AUDIO
NTS-1 digital kit
PROGRAMMABLE SYNTHESIZER KIT
Productos relacionados
Copyright © 2024 KORG Inc. Todos los derechos reservados
Elija su país 