Programació ALSA a baix nivell

De Wikijoan
Dreceres ràpides: navegació, cerca

Contingut

Programació audio (PCM)

fer els exemples de

Els exemples del linuxjournal es poden descarregar de ftp.ssc.com/pub/lj/listings/issue126/6735.tgz.

Compilem i executem el primer exemple

1r exemple (6735l1):

$ gcc -o 6735l1 6735l1.c -lasound
$ ./6735l1
ALSA library version: 1.0.18

PCM stream types:
  PLAYBACK
  CAPTURE

PCM access types:
  MMAP_INTERLEAVED
  MMAP_NONINTERLEAVED
  MMAP_COMPLEX
  RW_INTERLEAVED
  RW_NONINTERLEAVED

PCM formats:
  S8 (Signed 8 bit)
  U8 (Unsigned 8 bit)
  S16_LE (Signed 16 bit Little Endian)
  S16_BE (Signed 16 bit Big Endian)
  U16_LE (Unsigned 16 bit Little Endian)
  U16_BE (Unsigned 16 bit Big Endian)/usr/include/alsa
  S24_LE (Signed 24 bit Little Endian)
  S24_BE (Signed 24 bit Big Endian)
  U24_LE (Unsigned 24 bit Little Endian)
  U24_BE (Unsigned 24 bit Big Endian)
  S32_LE (Signed 32 bit Little Endian)
  S32_BE (Signed 32 bit Big Endian)
  U32_LE (Unsigned 32 bit Little Endian)
  U32_BE (Unsigned 32 bit Big Endian)
  FLOAT_LE (Float 32 bit Little Endian)
  FLOAT_BE (Float 32 bit Big Endian)
  FLOAT64_LE (Float 64 bit Little Endian)
  FLOAT64_BE (Float 64 bit Big Endian)
  IEC958_SUBFRAME_LE (IEC-958 Little Endian)
  IEC958_SUBFRAME_BE (IEC-958 Big Endian)
  MU_LAW (Mu-Law)
  A_LAW (A-Law)
  IMA_ADPCM (Ima-ADPCM)
  MPEG (MPEG)
  GSM (GSM)
  SPECIAL (Special)
  S24_3LE (Signed 24 bit Little Endian in 3bytes)
  S24_3BE (Signed 24 bit Big Endian in 3bytes)
  U24_3LE (Unsigned 24 bit Little Endian in 3bytes)
  U24_3BE (Unsigned 24 bit Big Endian in 3bytes)
  S20_3LE (Signed 20 bit Little Endian in 3bytes)
  S20_3BE (Signed 20 bit Big Endian in 3bytes)
  U20_3LE (Unsigned 20 bit Little Endian in 3bytes)
  U20_3BE (Unsigned 20 bit Big Endian in 3bytes)
  S18_3LE (Signed 18 bit Little Endian in 3bytes)
  S18_3BE (Signed 18 bit Big Endian in 3bytes)
  U18_3LE (Unsigned 18 bit Little Endian in 3bytes)
  U18_3BE (Unsigned 18 bit Big Endian in 3bytes)

PCM subformats:
  STD (Standard)

PCM states:
  OPEN
  SETUP
  PREPARED
  RUNNING
  XRUN
  DRAINING
  PAUSED
  SUSPENDED
  DISCONNECTED

La llibreria asound es troba a /usr/include/alsa. Aquí és on puc trobar els fitxers asoundlib.h i els altres.

$ ls /usr/include/alsa

alisp.h             hwdep.h         pcm.h         seqmid.h
asoundef.h          iatomic.h       pcm_ioplug.h  seq_midi_event.h
asoundlib.h         input.h         pcm_old.h     sound
conf.h              mixer_abst.h    pcm_plugin.h  timer.h
control_external.h  mixer.h         pcm_rate.h    version.h
control.h           output.h        rawmidi.h
error.h             pcm_external.h  seq_event.h
global.h            pcm_extplug.h   seq.h

2n exemple (6735l2):

./6735l2

PCM handle name = 'default'
PCM state = PREPARED
access type = RW_INTERLEAVED
format = 'S16_LE' (Signed 16 bit Little Endian)
subformat = 'STD' (Standard)
channels = 2
rate = 44100 bps
period time = 725 us
period size = 32 frames
buffer time = 725 us
buffer size = 33791 frames
periods per buffer = 1024 frames
exact rate = 44100/1 bps
significant bits = 16
tick time = 0 us
is batch = 0
is block transfer = 1
is double = 0
is half duplex = 0
is joint duplex = 0
can overrange = 0
can mmap = 0
can pause = 0
can resume = 0
can sync start = 0

3r exemple (6735l3): playback

./6735l3 < /dev/urandom

efectivament, sentim un soroll aleatori. /dev/urandom genera soroll aleatori. Ho podem veure fent:

$ cat /dev/urandom

4rt exemple (6735l4): captura

Amb el micròfon podem capturar durant 5 segons el so, i després escoltar-lo amb el 3r exemple. Utilitzem el dispositiu per defecte (targeta de so interna). Amb alsamixer podem controlar el nivell de recording i de playback.

./6735l4 > sound.raw
./6735l3 < sound.raw

Ara segueixo el tutorial http://www.suse.de/~mana/alsa090_howto.html que parla de PCM i MIDI.

Basic PCM Audio (basic_pcm_audio.c)

The most important ALSA interfaces to the PCM devices are the "plughw" and the "hw" interface. If you use the "plughw" interface, you need not care much about the sound hardware. If your soundcard does not support the sample rate or sample format you specify, your data will be automatically converted. This also applies to the access type and the number of channels. With the "hw" interface, you have to check whether your hardware supports the configuration you would like to use.

Agafo el codi del how-to, afegeixo el include de la llibreria, fico el main, depuro algun error, i ja funciona el codi basic_pcd_audo.c. Allò interessant d'aquest codi és que el que sona és una funció de dent de serra que genera el codi i s'envia a la targeta de so. Per tant, és un exemple bàsic i bonic de síntesi d'audio.

/* Use the newer ALSA API */
#define ALSA_PCM_NEW_HW_PARAMS_API

#include <alsa/asoundlib.h>

int main() {

    /* Handle for the PCM device */ 
    snd_pcm_t *pcm_handle;          

    /* Playback stream */
    snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;

    /* This structure contains information about    */
    /* the hardware and can be used to specify the  */      
    /* configuration to be used for the PCM stream. */ 
    snd_pcm_hw_params_t *hwparams;
  
    /* Name of the PCM device, like plughw:0,0          */
    /* The first number is the number of the soundcard, */
    /* the second number is the number of the device.   */
    char *pcm_name;

    /* Init pcm_name. Of course, later you */
    /* will make this configurable ;-)     */
    pcm_name = strdup("plughw:0,0");

    /* Allocate the snd_pcm_hw_params_t structure on the stack. */
    snd_pcm_hw_params_alloca(&hwparams);

    /* Open PCM. The last parameter of this function is the mode. */
    /* If this is set to 0, the standard mode is used. Possible   */
    /* other values are SND_PCM_NONBLOCK and SND_PCM_ASYNC.       */ 
    /* If SND_PCM_NONBLOCK is used, read / write access to the    */
    /* PCM device will return immediately. If SND_PCM_ASYNC is    */
    /* specified, SIGIO will be emitted whenever a period has     */
    /* been completely processed by the soundcard.                */
    if (snd_pcm_open(&pcm_handle, pcm_name, stream, 0) < 0) {
      fprintf(stderr, "Error opening PCM device %s\n", pcm_name);
      return(-1);
    }

    /* Init hwparams with full configuration space */
    if (snd_pcm_hw_params_any(pcm_handle, hwparams) < 0) {
      fprintf(stderr, "Can not configure this PCM device.\n");
      return(-1);
    }

  
    int rate = 44100; /* Sample rate */
    int exact_rate;   /* Sample rate returned by */
                      /* snd_pcm_hw_params_set_rate_near */ 
    int dir;          /* exact_rate == rate --> dir = 0 */
                      /* exact_rate < rate  --> dir = -1 */
                      /* exact_rate > rate  --> dir = 1 */
    int periods = 2;       /* Number of periods */
    snd_pcm_uframes_t periodsize = 8192; /* Periodsize (bytes) */
  
  
    /* Set access type. This can be either    */
    /* SND_PCM_ACCESS_RW_INTERLEAVED or       */
    /* SND_PCM_ACCESS_RW_NONINTERLEAVED.      */
    /* There are also access types for MMAPed */
    /* access, but this is beyond the scope   */
    /* of this introduction.                  */
    if (snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) {
      fprintf(stderr, "Error setting access.\n");
      return(-1);
    }
  
    /* Set sample format */
    if (snd_pcm_hw_params_set_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_LE) < 0) {
      fprintf(stderr, "Error setting format.\n");
      return(-1);
    }

    /* Set sample rate. If the exact rate is not supported */
    /* by the hardware, use nearest possible rate.         */ 
    exact_rate = rate;
    if (snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, &exact_rate, 0) < 0) {
      fprintf(stderr, "Error setting rate.\n");
      return(-1);
    }
    if (rate != exact_rate) {
      fprintf(stderr, "The rate %d Hz is not supported by your hardware.\n ==> Using %d Hz instead.\n", rate, exact_rate);
    }

    /* Set number of channels */
    if (snd_pcm_hw_params_set_channels(pcm_handle, hwparams, 2) < 0) {
      fprintf(stderr, "Error setting channels.\n");
      return(-1);
    }

    /* Set number of periods. Periods used to be called fragments. */ 
    if (snd_pcm_hw_params_set_periods(pcm_handle, hwparams, periods, 0) < 0) {
      fprintf(stderr, "Error setting periods.\n");
      return(-1);
    }

    /* Set buffer size (in frames). The resulting latency is given by */
    /* latency = periodsize * periods / (rate * bytes_per_frame)     */
    if (snd_pcm_hw_params_set_buffer_size(pcm_handle, hwparams, (periodsize * periods)>>2) < 0) {
      fprintf(stderr, "Error setting buffersize.\n");
      return(-1);
    }
  
    /* Apply HW parameter settings to */
    /* PCM device and prepare device  */
    if (snd_pcm_hw_params(pcm_handle, hwparams) < 0) {
      fprintf(stderr, "Error setting HW params.\n");
      return(-1);
    }
  
    /* Write num_frames frames from buffer data to    */ 
    /* the PCM device pointed to by pcm_handle.       */
    /* Returns the number of frames actually written. */
    snd_pcm_sframes_t snd_pcm_writei(pcm_handle, data, num_frames);
  
    unsigned char *data;
    int pcmreturn, l1, l2;
    short s1, s2;
    int frames;

    data = (unsigned char *)malloc(periodsize);
    frames = periodsize >> 2;
    for(l1 = 0; l1 < 100; l1++) {
      for(l2 = 0; l2 < frames; l2++) {
        s1 = (l2 % 128) * 100 - 5000;  
        s2 = (l2 % 256) * 100 - 5000;  
        data[4*l2] = (unsigned char)s1;
        data[4*l2+1] = s1 >> 8;
        data[4*l2+2] = (unsigned char)s2;
        data[4*l2+3] = s2 >> 8;
      }
      while ((pcmreturn = snd_pcm_writei(pcm_handle, data, frames)) < 0) {
        snd_pcm_prepare(pcm_handle);
        fprintf(stderr, "<<<<<<<<<<<<<<< Buffer Underrun >>>>>>>>>>>>>>>\n");
      }
    }
  
    /* Stop PCM device and drop pending frames */
    snd_pcm_drop(pcm_handle);

    /* Stop PCM device after pending frames have been played */ 
    snd_pcm_drain(pcm_handle);
  
}

Programació MIDI

ALSA vs OSS

Conclusion and Recommendation

ALSA provides a better designed, more flexible API which in theory should allow it to support advanced hardware features more quickly. In many situations, particularly with Hardware MIDI support, this has been proven true. 

At some point in the future, ALSA will likely replace OSS as the main kernel sound driver API. If you have no need for ALSA's additional feature support, then there is really no reason to switch. If you want to get all you can out of your hardware, or if you need a feature that only ALSA provides, there is no reason not to switch. 

Conclusió: ho he de fer tot amb ALSA i deixar-se de OSS


Segueixo el tutorial de programació ALSA de

El tutorial és de l'any 2002. Era per la versió d'ALSA 0.9, i ara anem per al 1.0.18, però els exemples funcionen igual de bé. per compilar els exemples,

$ sudo gcc -o seqdemo seqdemo.c -lasound

Funciona!

$ sudo gcc -o miniArp miniArp.c -lasound
./miniArp 100 miniArp05.seq

miniArp és una aplicació ALSA, o sigui que arrenco JACK i el fluidsynth (fluidsynth -m alsa_seq -a jack /home/joan/soundfonts/AI-APiano02trans.sf2), connecto miniArp al fluisynth i fluidsynth al system. Si en la configuració del JACK he ficat el hw:1 (UA25-EX) com a dispositiu d'entrada i de sortida, ho escoltaré a través dels cascos del UA25-EX.

També funciona igual de bé utilitzant la targeta de so interna: hw:0. Si vull fer les connexions automàticament tot just arrenca l'aplicació, ho hauré de posar tot en un bash.

Els exemples de què disposo i que he d'estudiar són:

midiroute.c provides a simple example. It creates one input port and two ouput ports. The program takes the parameter split_point. Input note events with note < split_point are routed to the first output port, all other note events are routed to the second output port. Any other events (e.g. control or pitchbender events) are routed to both output ports simultaneously.

seqdemo.c

és un seqüenciador. Amb el JACK arrencat, apareix seqdemo a la pestanya de connexions i el puc connectar amb el vkeybd.

Em podria basar en aquest codi per refer el que tinc fet de playfine, sense necessitat de MidiShare,... doncs el que estic estudiant és la possibilitat de programar directament amb les llibreries de ALSA, sense necessitat de MidiShare. Aleshores, MidiShare podria quedar relegat per quan volgués fer alguna cosa amb JAVA.

midiroute.c

Midirouter.jpg

és un router de missatges MIDI, la qual cosa significa que hi ha un port d'entrada i dos ports de sortida, i els missatges els envio a un port o a l'altre en funció de la nota (és el paràmetre d'entrada que necessita l'executable, el número de nota MIDI split_point).

You can e.g. have different instrument played depending on the velocity

      if (ev->data.note.note < split_point) {
        snd_seq_ev_set_source(ev, out_ports[0]);
      } else {
        snd_seq_ev_set_source(ev, out_ports[1]);
      }

Per veure el funcionament, engego dos sintetitzadors: fluidsynth i Zyn. El virtual piano el connecto amb el port d'entrada del midirouter (que és una aplicació ALSA), i cada port de sortida del midirouter el connecto a un dels sintetitzadors. Veig com efectivament a partir de la nota 60 (Do central) (./midiroute 60), el so a l'esqurre va cap a un sinte i a la dreta va cap a l'altre sinte.

midiroute_split_channel.c

Aquesta és la primera modificació que faig. I és que el que busco és un router que depènd de la nota que toco soni un programa o un altre.

A partir de midoroute.c, faig la següent modificació:

  do {
    snd_seq_event_input(seq_handle, &ev);
    snd_seq_ev_set_subs(ev);  
    snd_seq_ev_set_direct(ev);
    if ((ev->type == SND_SEQ_EVENT_NOTEON)||(ev->type == SND_SEQ_EVENT_NOTEOFF)) {
		tipus=ev->type;
		nota=ev->data.note.note;
		canal=ev->data.note.channel;
      if (ev->data.note.note < split_point) {
			snd_seq_ev_set_pgmchange(ev,canal,prog1);
			snd_seq_ev_set_source(ev, out_ports[0]);
			snd_seq_event_output_direct(seq_handle, ev);
			if (tipus==SND_SEQ_EVENT_NOTEON) {
				snd_seq_ev_set_noteon(ev, canal, nota, 127);
			} else {
				snd_seq_ev_set_noteoff(ev, canal, nota, 127);
			}
		   snd_seq_ev_set_source(ev, out_ports[0]);
      } else {
			snd_seq_ev_set_pgmchange(ev,canal,prog2);
			snd_seq_ev_set_source(ev, out_ports[1]);
			snd_seq_event_output_direct(seq_handle, ev);
			if (tipus==SND_SEQ_EVENT_NOTEON) {
				snd_seq_ev_set_noteon(ev, canal, nota, 127);
			} else {
				snd_seq_ev_set_noteoff(ev, canal, nota, 127);
			}
		   snd_seq_ev_set_source(ev, out_ports[1]);
      }
      snd_seq_event_output_direct(seq_handle, ev);
    } else {
      snd_seq_ev_set_source(ev, out_ports[0]);
      snd_seq_event_output_direct(seq_handle, ev);
      snd_seq_ev_set_source(ev, out_ports[1]);
      snd_seq_event_output_direct(seq_handle, ev);
    }
    snd_seq_free_event(ev);
  } while (snd_seq_event_input_pending(seq_handle, 0) > 0);
}

Veiem com hem de guardar la nota que vull tocar, primer de tot fer el canvi de programa (snd_seq_ev_set_pgmchange), i aleshores fer sonar la nota (snd_seq_ev_set_noteon i snd_seq_ev_set_noteoff).

L'aplicació ara necessita tres paràmetres:

$ ./midiroute_split_channel <split_point> <prog1> <prog2>

i evidentment, necessito un soundfont que distingeixi clarament entre programes, com ara /collections/Musica_Theoria_GM.sf2.

En el fluidsynth és útil l'opció -d per veure els missatges midi que rep el fluidsynth:

event_pre_prog 0 8
event_post_prog 0 8
event_pre_noteon 0 69 127
event_post_noteon 0 69 127
event_pre_prog 0 8
event_post_prog 0 8
event_pre_noteoff 0 69 127
event_post_noteoff 0 69 127

Aquesta és la clau per fer regles més complicades de midi routers. Jo he provat amb les aplicacions mididings i la possibilitat de fer routing propi del fluidsynth, i no me n'he ensortit.

miniArp.c: scheduling

Each note is characterized by 4 or 5 characters vwxyz, where

v	is the note ('c', 'd', 'e', 'f', 'g', 'a', 'h'),
w	is an optional sharp ('#'),
x	specifies the octave,
y	denotes the length of the note and
z	the interval between this note and the following note.

y and z are both given as a fraction of a quarter note: length = 1 / y quarters. 
$ fluidsynth -j -m alsa_seq -a jack  /home/joan/soundfonts/reed/AltosaxJan.SF2
./miniArp 80 miniArp06.seq

Now, what are the secrets of this program ? Many techniques are already known from other sections. The interesting functions are init_queue, set_tempo, arpeggio, clear_queue, and get_tick. A signal handler for SIGINT and SIGTERM is implemented to avoid persisting notes.

At their scheduled time, they create a NOTEON event and then convert themselves to a NOTEOFF event which is scheduled at the current time plus note length. Since we would like the sequence to be looped, we schedule a SND_SEQ_EVENT_ECHO event after each sequence. This time, the destination is the application itself. When the SND_SEQ_EVENT_ECHO event is dispatched, it will cause the poll function in main() to return and midi_action is called. In midi_action, SND_SEQ_EVENT_ECHO will result in a call to arpeggio and the loop is complete.

Per tocar Una Plata d'Enciam, on hi ha tresets, necessito modificar aquest codi, doncs un sol valor per a y i z (longitud de la nota i interval entre notes) no és possible. A més, z=0 (per fer acords) no és vàlid.

miniArp_unaplatadenciam.c

He modificat miniArp per tal de poder tocar negres amb punt, corxees amb punt i triplets (multiplicant per 48, com ja havia fet). A més, ara l'aplicatiu necessita un tercer paràmetre, que és el nom del client ALSA, doncs llençaré dos clients alhora que els connectaré al fluidsynth, i d'aquesta manera puc escoltar les dues veus d'Una Plata d'Enciam.

$ gcc -o miniArp_unaplatadenciam miniArp_unaplatadenciam.c -lasound
$ ./miniArp_unaplatadenciam 25 una_plata_denciam_voice1.seq voice1

i aleshores connectem el client voice1 amb el fluidsynth. Si volem automatitzar el procés fem un script que inclogui el fluidsynth, l'execució de dues instàncies de l'aplicatiu, i les connexions amb aconnect:

$ ./una_plata_denciam_with_C.sh 

(aconnect -x per tancar les connexions, i ps_aux per matar els processos).

el script bash que automatitza l'execució és una_plata_denciam_with_C.sh:

#!/bin/bash
xterm -e '/usr/local/bin/fluidsynth -j -m alsa_seq -a jack /home/joan/soundfonts/AI-APiano02trans.sf2' &
sleep 2
./miniArp_unaplatadenciam 25 una_plata_denciam_voice1.seq voice1 &
./miniArp_unaplatadenciam 25 una_plata_denciam_voice2.seq voice2 &
aconnect voice1:0 FLUID Synth:0 &
aconnect voice2:0 FLUID Synth:0 &

no oblidar-se de tancar els dos processos al final (ps -aux). El fluidsynth s'executa en una altra finestra.

Una cosa més interessant és fer que les dues veus tinguin instruments diferents. Això ho puc fer amb el MIDI router que implementa el fluidsynth. A partir d'una nota es redirigeix a un programa o a un altre.

Seria algo similar a (fer-ho):

router_clear
router_begin note
router_par1 1 59 0 0
router_chan 0 15 0 1
router_end
router_begin note
router_par1 60 88 0 0
router_chan 0 15 0 2
router_end
# pan those 2 channels 
cc 5 10 8
cc 4 10 127

a mi, la veritat, no m'acaba de funcionar. Evidentment, s'ha d'utilitzar un soundfont on es distingeixin clarament els instruments, com ara

Una altra possibilitat és utilitzar un midi router extern com ara mididings (http://das.nasophon.de/mididings/) -> no me n'he ensortit.

La millor possibilitat és programar-ho directament amb ALSA. Mirar més amunt (midiroute_split_channel.c). Es crea un client ALSA amb un port d'entrada i dos ports de sortida. El miniArp_unaplatadenciam el connecto al router, i les dues sortides del router les connecto al fluidsynth. El router l'he arrencat amb la nota de tall i els dos programes que vull fer sonar. D'aquesta manera, les dues veus s'escolten amb instruments diferents.

Síntesi d'audio

Es tracta de fer una síntesi FM, i combinar MIDI per rebre els events, i PCM per generar el so. He trobat tres exemples diferents però similars, tots ells fets per Matthias Nagorni.

jack_miniFMsynth.c

Per compilar:

$ cc -o jack_miniFMsynth jack_miniFMsynth.c -ljack -lasound -lm

I have also written the tiny FM synthesizer jack_miniFMsynth.c which is both a JACK client and a client of the ALSA sequencer system. This example client is based on the example miniFMsynth.c of my ALSA 0.9.0 HOWTO .

<MIDI channel> 	MIDI channel for NOTE events
<FM> 	Strength of the frequency modulation
<harmonic> 	Harmonic of the master oscillator (integer)
<subharmonic> 	Subharmonic of the master oscillator (integer)
<transpose> 	Note offset for both oscillators (integer)
<a> <d> <s> <r> 	Attack, Decay, Sustain, Release

Some examples:

Harpsichord 	./jack_miniFMsynth 0 7.8 3 5 24 0.01 0.8 0.0 0.1
Bell 	./jack_miniFMsynth 0 3.5 7 9 0 0.01 0.2 0.3 1.5
Oboe 	./jack_miniFMsynth 0 0.7 1 3 24 0.05 0.3 0.8 0.2

jack_miniFMsynth reacts on pitchbender and modulation wheel events. Since it is not optimized with respect to performance (you would e.g. never call the expensive sin function in a "real" program), you might have to decrease the polyphony in the source by modifying the #define POLY.

i funciona perfectament. La idea és simple: jack_miniFMsynth és un client ALSA. Connectem el vkeybd al jack_miniFMsynth en la pestanya ALSA, i el jack_miniFMsynth al system, i ja puc tocar amb els paràmetres que hagi posat (síntesi d'audio).

Fer 50 Ways...

jackMiniSynth.c

Post en la LAU:

I've been looking for a simple, MIDI-controllable synth to play with, 
something without a lot of complexity.  I found jackMidiSynth.c here:

Per compilar:

$ gcc \
`pkg-config --cflags --libs jack` \
`pkg-config --cflags --libs alsa` \
-o jackMiniSynth \
jackMiniSynth.c

o bé

$ cc -o jackMiniSynth jackMiniSynth.c -ljack -lasound
$ ./jackMiniSynth 
jackMiniSynth <MIDI ch> <poly> <gain> <transpose> <resonance> <a> <d> <s> <r> <filt_a> <filt_d> <filt_s> <filt_r> <filt_env_amount> <sweep>

jackMiniSynth is a minimal subtractive synth (with Moog filter) for JACK

funciona:

./jackMiniSynth 0 1 1 24 1 0.01 0.8 0.0 0.1 0.5 0.5 0.5 0.5 0.5 1

de moment no he trobat informació de què signifiquen els paràmetres (els paràmetres que difereixen del jack_miniFMsynth)

El segon paràmetre, la polifonia, és evident. Si val 1 no pot haver-hi notes simultànies. Els paràmetres de filt és un filtre Moog, és a dir, filtres que fan que el so s'assembli als sintetitzadors Moog.

miniFMsynth.c

Compila però de moment no s'executa bé (fallo de segment) Un sintetitzador sofware efectivament necessita la part de MIDI (per rebre i entendre els missatges MIDI), i la part de PCM per poder produir sons.

$ ./miniFMsynth default 7.8 3 5 24 0.01 0.8 0.0 0.1

Em dóna un fallo de segmentación, igual que a aquesta persona.

Hi,
I've got ALSA, installed and configured. esdplay can playback a wav file.
When I compiled and ran miniFMsynth I get a segmentation fault error. What
can I do to
probe the setup and check the ALSA configuration is alright.

Thanks,
Daniel

gdb és el GNU debugger

$ gdb --args miniFMsynth default 7.8 3 5 24 0.01 0.8 0.0 0.1

GNU gdb 6.8-debian
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "i486-linux-gnu"...

(gdb) run
Starting program: /home/joan/50_ways/way6/alsa_pcm_seq_howto_0.0.4/miniFMsynth default 7.8 3 5 24 0.01 0.8 0.0 0.1
[Thread debugging using libthread_db enabled]
[New Thread 0xb7e086c0 (LWP 12098)]
[New Thread 0xb3c53b90 (LWP 12101)]

Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0xb7e086c0 (LWP 12098)]
0xb800c0be in ?? () from /usr/lib/libasound.so.2
(gdb) quit

NO me n'en surto. He d'aprendre bé el debugger gdb o bé utilitzar un IDE com Anjuta que em permeti fer debugging.

Eines de l'usuari
Espais de noms
Variants
Accions
Navegació
Institut Jaume Balmes
Màquines recreatives
CNC
Informàtica musical
joanillo.org Planet
Eines