import ddf.minim.*;

Minim minim;
AudioPlayer player;

void setup()
{
  minim = new Minim(this);
  player = minim.loadFile("/data/samples/sample02.mp3");
  player.play();
}

void draw()
{  
  println("Gain: " + player.getGain()); //always prints 0.0 but I guess it's because it's not what I'm looking for
  println("Volume: " + player.getVolume()); //Minim error: Volume is not supported
}

Thank you!

This is part of a longer code so I have simplified it here to just the minim play/record issue, but it is why I am trying to keep the draw function clear.

Current Problems: 1. I'm at a complete loss how to control the play->record->save loop for a set number of times before returning to the Draw function. At the moment it moves through twice and then stops?

I hope someone can help -I've been trying for days now :/

<

pre lang="javascript">

import ddf.minim.*; import ddf.minim.AudioPlayer;

Minim minim; Minim record; AudioInput In;

static final int SONG = 5; final AudioPlayer[] audio = new AudioPlayer [SONG];

static final int RECORDED = 5; final AudioRecorder[] recorder = new AudioRecorder [RECORDED];

boolean pressSave; PFont f;

int audioidx = 0; int audiocount = 0; int recorderidx = 0; int recordercount = 0;

int saved; static final int SAVED = 5;

void setup() { size (512, 200, P3D); f= createFont ("Georgia", 16);

minim = new Minim(this); audio [0] = minim.loadFile ("Audio_01.mp3"); audio [1] = minim.loadFile ("Audio_02.mp3"); audio [2] = minim.loadFile ("Audio_03.mp3"); audio [3] = minim.loadFile ("Audio_04.mp3"); audio [4] = minim.loadFile ("Audio_05.mp3"); printArray (audio);

record = new Minim(this); In = record.getLineIn(); recorder [0] = record.createRecorder(In, "myrecording1.wav"); recorder [1] = record.createRecorder(In, "myrecording2.wav"); recorder [2] = record.createRecorder(In, "myrecording3.wav"); recorder [3] = record.createRecorder(In, "myrecording4.wav"); recorder [4] = record.createRecorder(In, "myrecording5.wav"); printArray (recorder); }

void keyPressed(){ if ( keyCode == TAB ){ recorder[recorderidx].save(); recordercount = recordercount+1; recorderidx =recorderidx+1; audiocount = audiocount+1; audioidx = audioidx+1; //recorderidx = recorderidx+1; pressSave = true; println ("recorder count", recordercount,"recorderidx", recorderidx); println ("audio count", audiocount,"audioidx", audioidx); } }

void draw() { background (255); textFont (f, 16); fill (0); playrecord(); }

void playrecord(){

for (int i=0; i<audio.length;i++) { for (int r=0; r<recorder.length;r++) {

  if (audioidx==i && !audio[audioidx].isPlaying()){
  audio[audioidx].play();
  audiocount = audiocount+1;
  println ("variable i", i);

  }     
  else if (audiocount==i+1){
  recorder[recorderidx].beginRecord();
  println ("variable r", r);
  //println ("recording", recorderidx);
    if(pressSave){
    println("Done saving.");
    pressSave = true;
     } else { 
     text ( "Press TAB to save", 10, 100);
     pressSave = false;
     }
     if (!pressSave){
     return;
     }           
     }
  else if (audiocount == i+1 && recordercount == r+1){
  audio[audioidx = (audioidx + 1) % SONG].play();
  recorderidx = recorderidx+1 ;
  println ("variable r", r);
  }
  else{
    return;
}
}

} }

I tried the setVolume or setGain instances both didn't change anything. I am trying to start with no sound till tuioCursorList.size is bigger than 0 and when it is, sound can fade in with a simple for loop but all my attempts on changing the volume failed so couldn't implement it to the code.

I got part of the code from Minim > Synthesis > realtimeControlExample and some stuff are out of my reach. In the code below. The out.PlayNote takes 3 parameter I got the idea of them first is the start point, second is the duration and thirds is the note which will be played. How can I set so that the note plays not just for defined time but as long as program is running?

And the I tried calling out.playNote in draw and didn't work, works only when its called setup which makes it harder for me to change the parameters.

// import everything necessary to make sound.
import ddf.minim.*;
import ddf.minim.ugens.*;

import ddf.minim.effects.*;

import TUIO.*;
TuioProcessing tuioClient = new TuioProcessing(this);
ArrayList<TuioCursor> tuioCursorList = new ArrayList<TuioCursor>();


Minim minim;
AudioOutput out;
NoiseInstrument myNoise;
float x = 0;
float y = 0;
float xPos;
float yPos;
void setup()
{
  size( 500, 500, P2D );


  minim = new Minim( this );
  out = minim.getLineOut( Minim.MONO, 512 );
  myNoise = new NoiseInstrument( 1.0, out );

  out.playNote( 0, 100.0, myNoise );
}


void draw()
{
  background( 0 );
  tuioCursorList = tuioClient.getTuioCursorList();

  for (int i=0; i<tuioCursorList.size(); i++) {

    TuioCursor tc = tuioCursorList.get(i);
    xPos = tc.getScreenX(width);
    yPos = tc.getScreenY(height);
    if ( tuioCursorList.size() > 0) {
      float freq = map( yPos, 0, height, 200, 120 );
      float q = map( xPos, 0, width, 15, 25 );
      myNoise.setFilterCF( freq );
      myNoise.setFilterQ( q );
      println(tuioCursorList.size());
    }
  }
}



// Every instrument must implement the Instrument interface so 
// playNote() can call the instrument's methods.

// This noise instrument uses white noise and two bandpass filters
// to make a "whistling wind" sound.  By changing using the methods which
// change the frequency and the bandwidth of the filters, the sound changes.

class NoiseInstrument implements Instrument
{
  // create all variables that must be used throughout the class
  Noise myNoise;
  Multiplier multiply;
  AudioOutput out;
  BandPass filt1, filt2;
  Summer sum; 
  float freq1, freq2, freq3;
  float bandWidth1, bandWidth2;
  float filterFactor;

  // constructors for this intsrument
  NoiseInstrument( float amplitude, AudioOutput output )
  {
    // equate class variables to constructor variables as necessary 
    out = output;

    // give some initial values to the realtime control variables
    freq1 = 150.0;
    bandWidth1 = 10.0;
    filterFactor = 1.7;

    // create new instances of any UGen objects
    myNoise = new Noise( amplitude, Noise.Tint.WHITE );
    multiply = new Multiplier( 0 );
    filt1 = new BandPass( freq1, bandWidth1, out.sampleRate() );
    filt2 = new BandPass( freq2(), bandWidth2(), out.sampleRate() );
    sum = new Summer();

    // patch everything (including the out this time)
    myNoise.patch( filt1 ).patch( sum );
    myNoise.patch( filt2 ).patch( sum );
    sum.patch( multiply );
  }

  // every instrument must have a noteOn( float ) method
  void noteOn( float dur )
  {
    // set the multiply to 1 to turn on the note
    multiply.setValue( 1 );
    multiply.patch( out );
  }

  // every instrument must have a noteOff() method
  void noteOff()
  {
    // set the multiply to 0 to turn off the note 
    multiply.setValue( 0 );
    multiply.unpatch( out );
  }

  // this is a helper method only used internally to find the second filter
  float freq2()
  {
    // calculate the second frequency based on the first
    return filterFactor*freq1;
  }

  // this is a helper method only used internally 
  // to find the bandwidth of the second filter
  float bandWidth2()
  {
    // calculate the second bandwidth based on the first
    return filterFactor*bandWidth1;
  }

  // this is a method to set the center frequencies
  // of the two filters based on the CF of the first
  void setFilterCF( float cf )
  {
    freq1 = cf;
    filt1.setFreq( freq1 );
    filt2.setFreq( freq2() );
  }

  // this is a method to set the bandwidths
  // of the two filters based on the BW of the first
  void setFilterBW( float bw )
  {
    bandWidth1 = bw;
    filt1.setBandWidth( bandWidth1 );
    filt2.setBandWidth( bandWidth2() );
  }

  // this is a method to set the Q (inverse of bandwidth)
  // of the two filters based on the  
  void setFilterQ( float q )
  {
    setFilterBW( freq1/q );
  }
}

// called when a cursor is added to the scene
void addTuioCursor(TuioCursor tcur) {
}

// called when a cursor is moved
void updateTuioCursor (TuioCursor tcur) {
}

// called when a cursor is removed from the scene
void removeTuioCursor(TuioCursor tcur) {
}

// --------------------------------------------------------------
// these callback methods are called whenever a TUIO event occurs
// there are three callbacks for add/set/del events for each object/cursor/blob type
// the final refresh callback marks the end of each TUIO frame

// called when an object is added to the scene
void addTuioObject(TuioObject tobj) {
}

// called when an object is moved
void updateTuioObject (TuioObject tobj) {
}

// called when an object is removed from the scene
void removeTuioObject(TuioObject tobj) {
}

// --------------------------------------------------------------
// called when a blob is added to the scene
void addTuioBlob(TuioBlob tblb) {
}

// called when a blob is moved
void updateTuioBlob (TuioBlob tblb) {
}

// called when a blob is removed from the scene
void removeTuioBlob(TuioBlob tblb) {
}

// --------------------------------------------------------------
// called at the end of each TUIO frame
void refresh(TuioTime frameTime) {
}

=== Minim Error === === Couldn't load the file oChristmasTree.mp3

any advice? minim library

Edit: I should also mention that I am getting linear averages, not accessing actual bands, and other components rely on the number of averages in an array being an exact value.

Edit------ The issue with live playback still stands - what I have done is create a huge float array containing data from the IFFT. I have a MultiChannelBuffer and using setSample I replace the original samples with the ones from the float array and then it black using a sampler. I know this works because the audio is just fine, but the moment I modify something using scaleFreq or so, I hear a lot of clicking noise. I'm not exactly sure what I am doing wrong, I'm sure there is some common practice how people would approach this?

I'm having issues exporting my processing program into a self contained application. I'm hoping someone here can help, and I apologize if I am asking this in the wrong place.

I have two instances of my program; one using the sound library and the other the minim library. Both run fine in the processing environment. I've tried exporting these in all possible formats (full screen, not full screen, with Java included, without)

When I export the version using the sound library, it crashes/hangs once a sound file is called. I tried commenting out the first couple of sound files and the program keeps going until the next sound file is called.

When I export the minim version, it just shows a grey screen and never starts the program.

I'm hoping someone out there might have an idea or two I can try to fix this.

The program is for an exhibit this weekend and will run in the background. I'm trying to export it as it's own application because I assume it will use less system resources than running it in processing. Is this assumption correct?

Thanks!

Nik

I'm thinking of fixing this by using only one audio file corresponding to any piano key, then somehow modify its frequency so that it makes pretty much the same sound as any piano key I want it to. I think this is doable with Minim, which we use. I've seen these kinds of things :

Frequency currentFreq currentFreq = Frequency.ofPitch( "A4" );

But I assume the object "Frequency" is not the same as an audio file. I couldn't make it work, anyway.

So I'd be really happy if someone could help, thanks a lot in advance. If there are any alternative, easier solutions (or if my idea isn't even doable in the first place), I'll definitely take them. In case this wasn't obvious enough, my Processing skills aren't exactly excellent. :P

(apologies if I asked this question in the wrong category)

I have been trying to learn Processing for the past few days as Im trying to create a interactive audio(Microphone) generated line art for my school final year project.

So, first the lines are randomly generated by audio and I want it to move from left to right slowly. The speed of the lines are not affected by audio, but when there is a audioinput, it will "disturb" the lines making it change its course by a bit while still moving to the right and more lines would be generated according to the input Volume.

I saw Daniel's perlin noise flow field video(managed to find the code for Processing) and also found processing files that are based on mouse movement mapping.

Please help me with this one, I don't have much time left with this project but I really want to use processing in it. Perlin noise is not a must if there is another possible way, it's just the closest thing I have found so far that I want.

I’m really a newbie in Processing and I have a deadline soon, I’ve been checking out many tutorials and have also coded myself but I just couldn’t solve those errors.

Do anyone have codes that gets similar results?

Do tell me if you need the codes that I have tried.

Thank You.

This is the kind of line waves I wanted (perlin noise flow field) but I don't know how to use a audioinput to make it interactive.

Mouse mapping generated art.

Generates circles when there is an audio input.

import ddf.minim.*;
Minim minim; 
AudioPlayer sound; 

void setup() {
  size(300, 200);
  minim = new Minim(this);
  sound = minim.loadFile("mySound.wav");

  println(sound.length());

  for (int i=0; i < sound.length()-1024; i+=16) {
   println( sound.mix.get(i));
  }
  exit();
}

this did not work because get(i) "Gets the i sample in the buffer", wich size is 1024...
how to have all the sample value inside the file ?
==> answer is getChannel()with AudioSample (cf AudioSample )

thx.