To all,

I have a question about sending a continuously changing array of samples to the output of my sound card using Minim.  Basically, a buffer of samples is created each time through my draw() loop.  The last step in the signal generation process is an inverse FFT, which updates a float[] buffer.  This is very similar to the example at the bottom of the Minim User Manual's page on FFT.

The Minim manual mentions that this example could be used to modify a real audio signal.  Now, I would like to send this buffer of samples to the sound card.  It appears that I can not directly write to any of AudioOutput's AudioBuffers (left, right, or mix).  Could anyone help me find a way to write "buffer" to the sound card output?

I'm not sure that I can write a user defined AudioSignal (like the MouseSaw example) because I create the samples in real-time from microphone data and several sawtooth signals.  Can I create several sawtooth waveforms and getLineIn() within a user defined AudioSignal class?

Does anybody have any suggestions?

Thanks in advance,
Adam

Have fun !!

it take signal on the left and plays back on the right .

not surpisingly the sound is crap, but it can give you an idea

h


import processing.core.PApplet;
import ddf.minim.*;
import ddf.minim.analysis.*;


       private FFT fft;
     private FFT fft2;
     private AudioInput input;
     private AudioOutput output;
     private Minim minim;

     private int SAMPLERATE = 44100;
     private int BUFFERSIZE = 512;
      void setup() {
             size(300,200);
             
             minim = new Minim(this);
             
     
             
             fft = new FFT(BUFFERSIZE, SAMPLERATE);
           //fft.window(FFT.HAMMING);
             
   
             
           

           input = minim.getLineIn(Minim.STEREO, BUFFERSIZE, SAMPLERATE);
           input.addListener(new Listener());

           output = minim.getLineOut(Minim.STEREO, BUFFERSIZE, SAMPLERATE);
           output.addSignal(new MySignal());
     }

     class Listener implements AudioListener {
           public void  samples(float[] sample){
             fft.forward(sample);
           }
           public void samples(float[] left, float[] right) {
             samples(left);
           }
     }

     
     private class MySignal implements AudioSignal{
           public void generate(float[] out) {

      fft2 = new FFT(BUFFERSIZE, SAMPLERATE);

              // out = new float[BUFFERSIZE];
               int u=2;
               if(u==1){//method 1
                     //FFT imaginary part used to reconstruct time info i think.
                     fft.inverse(out);
               }else{
                     //only use real part of the FFT. no time information i think.
                   fft2.window(FFT.HAMMING);
                   for(int i=0;i<BUFFERSIZE/2;i++){
                     fft2.setBand(i, fft.getBand(i));
                   }                
                   fft2.inverse(out);
               }
                                       
               for(int i=0;i<out.length;i++){
                     out[i]=out[i];
               }
             }

           public void generate(float[] left, float[] right) {
               generate(right);
           }
     }

hello,
hi !

the last for loop with the dummy assignment was used in debug mode in eclipse to multiply the ouput by an amplifier to lower or higher the volume so that i did not loose my ears

i of course noticed the "vocoderish" nature of the inverse FFT without the phase information. kinda funny.
one problem however i faced is the junction between generated audio buffer which  did not had matching begin/end. so it would produce a click between every audio buffer. i suppose this can be somehow sorted out.

my DSP lessons were long time ago... i should read again about FFT.


happy i could help !

volume modulation at around 80hz will be ring modulation

i though this problem could be actually related to the loss of the phasing information.

to be experimented !