I've been working on creating MIDI based animations and have started hitting some road blocks as Processing is my first coding platform (after I toyed with Java to get some basics down).

Here's a sample of what I'm making:  http://vimeo.com/30363314 . I aim to make more complex things for my own music, as I have more control over that, but need help!

Initial learning attempt (with some of my music):  http://vimeo.com/30696060 .

While I'm still way off from figuring out how to render and sync audio properly, there's a lot I need to figure out how to do first. Here is the basic code I've been using, I'll specify what I need - and what I've found as issues - afterward. This is of a somewhat more advanced version.

2. import promidi.*;
3. import processing.opengl.PGraphicsOpenGL;
4. MidiIO midiIO;
5. 
   
6. static Pill[] pills;
7. static int pillTop;
8. 
   
9. int h = 600;
10. int w = 1100;
11. int x = w /2;
12. int y = h /2;
13. int arraySize = 1024;
14. 
    
15. /* ===== setup ===== */
16. void setup() {
17.    size(w, h);
18.    smooth();
19.    frameRate(60);
20. 
    
21.    midiIO = MidiIO.getInstance(this); // grabs midi devices
22.    midiIO.printDevices(); // display inputs for debugging
23.   
24.    for(int i = 0; i <=15; i++) { 
25.       midiIO.openInput(0, i); // open all inputs
26.    }
27.   
28.    pills = new Pill[arraySize]; // sets up array for pills
29.    pillTop = 0;
30. }
31. 
    
32. /* ===== draw ===== */
33. void draw() {
34.    background(10);
35.    for (int i = 0; i < pillTop; i++) {
36.       pills[i].render();
37.       pills[i].update();
38.    }
39. }
40. 
    
41. /* ===== methods ===== */
42. void noteOn(Note note, int deviceNumber, int midiChan) {
43.    noteDisp(note, midiChan);
44. }
45. 
    
46. void noteDisp(Note note, int midiChan) {
47.    if (pillTop <= arraySize) {
48.       pills[pillTop] = new Pill(x, y, note, midiChan);
49.       pills[pillTop].tag = pillTop;
50.       pillTop++;
51.    }
52. }
53. 
    
54. void noteOff(Note note, int deviceNumber, int midiChan) {
55.    for (int i = 0; i < pillTop; i++) {
56.       if (pills[i].note == note) {
57.          killPill(pills[i], note);
58.          break;
59.       }
60.    }
61. }
62. 
    
63. static void killPill(Pill p, Note note) {
64.    pillTop--;
65.    pills[p.tag] = pills[pillTop];
66.    pills[p.tag].tag = p.tag;
67. }

2. class Pill {
3.    int tag;
4.    int x, y;
5. 
   
6.    Note note;
7.    int midiChan;
8. 
   
9.    int h, s, b, a, ab;
10.    float speedX, speedY;
11.    
12.    float rotator = 360;
13.    float rotAdd  = 8;
14.    float pitMult = 1;
15.    
16.    int rotCut = 180;
17.    int rotChange = 4;
18.    int aCut = 10;
19.    int aChange = 3;
20.    int abChange = 50;
21. 
    
22.    Pill(int nx, int ny, Note n, int mc) {
23.       x = nx;
24.       y = ny;
25.  
26.       speedX = 0;
27.       speedY = 0;
28.       midiChan = mc;
29.  
30.       colorMode(HSB, 100); // hue, sat, brightness
31.       h = midiChan *10;
32.       s = 100;
33.       b = n.getVelocity();
34.       a = 255;
35.       ab = 255;
36.  
37.       note = n;
38.       
39.       int pit = note.getPitch();
40.       int len = note.getLength();
41.       int vel = note.getVelocity();  
42.    }
43. 
    
44.    void render() {
45.       float mappedPitch = map(note.getPitch(), 70, 90, 100, 200);
46.       ellipseMode(CENTER);
47.       rectMode(CENTER);
48.  
49.       strokeWeight(1);
50.       noFill();
51. 
    
52.       strokeWeight(1);
53.       stroke(h, s, b, ab);
54.       
55.       /* current noteOn mult */
56.       for(int i = x; i <= x +20; i += 5) {
57.          arc(
58.             x, y,
59.             i +10 +mappedPitch *pitMult, i +mappedPitch *pitMult,
60.             radians(360), radians(360 +20)
61.          );
62.       }
63.       
64.       /* current noteOn displayer */
65.       strokeWeight(4);
66.       arc(
67.          x, y,
68.          x +mappedPitch *pitMult, x +mappedPitch *pitMult,
69.          radians(360), radians(360 +20)
70.          );
71.       
72.       /* radial note pushing */
73.       stroke(h, s, b, a);
74. 
    
75.       if(midiChan == 0) {
76.          strokeWeight(4);
77.          arc(
78.             x, y, 
79.             x +mappedPitch *pitMult, x +mappedPitch *pitMult, 
80.             radians(rotator), radians(rotator +rotAdd)
81.             );
82.       }
83.       else {
84.          strokeWeight(2);
85.          arc(
86.             x, y, 
87.             x +mappedPitch *pitMult, x +mappedPitch *pitMult, 
88.             radians(rotator), radians(rotator +rotAdd)
89.             ); 
90.       }
91.    }
92. 
    
93.    void update() {
94.       if(rotator >= rotCut) {
95.          rotator -= rotChange;
96.          
97.          speedY = 0;
98.          speedX = 0;
99. 
    
100.          x += speedX;
101.          y += speedY;
102.          
103.          ab -= abChange;
104.          
105.       }
106.       
107.       else {
108.          rotator -= rotChange;
109.          if(pitMult >= -0.7)
110.             pitMult -= 0.06;
111.          else
112.             pitMult = 0;
113.          a -= aChange; // lower opacity for removal
114.       }
115.     
116.       if (a <= aCut)
117.          miditest05i.killPill(this, note); // remove pill
118.    }
119. }

* There are some remnants of other ideas I was working on, apologies, tried to remove most of it.

This is all done with ProMidi. Trying to reach for some things has led me to RWMidi (though I can't use it because I can't figure out how to separate the channels like I have here).

These are the things that I most want to be able to mess with, though some of them may be limitations of ProMidi. It seems I need to explain my setup first.

Setup: Logic Pro outputs audio on soft synth midi channels, using cloned external midi outs to send midi data, with different channels for each instrument. Track is played and screen is captured. Thus is a real time render - midi data is displayed as it happens and is captured, though I would greatly like this not to be for complexity reasons. I do NOT need to be able to do this live - this project is more to simply create visuals for music that I can upload to have something to watch with the music. This has led to a lot of dead ends while searching the forums, as most need real time abilities.

• Producing arbitrary "groups" of notes: Example, groups of notes based on the time spawn of a single measure. While I certainly can't see how to do this with ProMidi, I understand that RWMidi has binary sysex reference that might be able to check time codes, which would help with some other problems.
• Note length: ProMidi can't handle this because it's setup to defined lengths. I've tried several while() and if() loops in order to try to tie display length to terminate when noteOff (or Velocity = 0) is sent. Nothing has worked, though I wonder more if it's simply that I'm not calling a note from the pills[] array to specify which to remove, of which I'm not sure how to. If you remove the noteOff code, you can see visual references to the noteOff markers, which seems like I should easily be able to do this, but I can't figure out how to.
• Note relations: To do more complex rendering, I'd need to be able to keep track of the X and Y of previous notes, so that, for example, I can draw a line from a previously rendered pill to a new "current" pill. I've tried creating variables that hold info but I'm fairly certain my placement is what is messing up - mostly static call issues.
• Storing MIDI data: A large inspiration for this project was MAM, or the Music Animation Machine. The creator managed to read MIDI data and I assume store it in a way that "future" notes (notes that will "play" after the current note) could be displayed. I figure that this could be done if I store the MIDI data first, and then render it non-realtime, but I'm at a loss as how to how to do this without, again, midi timing.
• Render maximums: I cannot render enough lines to complete my design goals. Usually it tends to slow gradually, eventually to freezing, if I do not remove the pills quickly enough. While this can be solved by, I assume, simply rendering separate tracks to video at a time and then combining them, or rendering frames to disk in non-realtime, I cannot do either at the moment. I do not understand how to eventually render these properly in full scope.

I've gotten to this point so far with some help from a java coder friend who cleaned my code up and placed this pill array into it. Previously I was using several arrays to capture and render data which was pretty slow.

Mostly I tinker with it to get the aesthetics I want, changing render and associated placements.

If anyone can please give me some insight, examples, or ideas of what to look into, I'll be glad to study whatever I need to get this going. But at this point I'm hitting walls and simply creating more smaller projects instead of fixing what's needed in the design.

So, any help would be greatly appreciated! 

While I am hesitant to put this code up, I realize it could help some others who have faced the same issues, so I'm willing to try to get some insight outside of simply asking my coder friend so that others may get a better idea of how to set up some MIDI-enabled visuals in a non-realtime environment.