Max (and its open source counterpart, PD) is a powerful environment for experimenting with sound and music. We use one of our own learning supplements, a Max patcher for generating scales (3.1.4), as an example of the kinds of programs you can write.

When you open this patcher, it is in presentation mode (Figure 3.47), as indicated by the drop-down menu in the bottom right corner. In presentation mode, the patcher is laid out in a user-friendly format, showing only the parts of the interface that you need in order to run the tutorial, which in this case allows you to generate major and minor scales in any key you choose. You can change to programming mode (Figure 3.48) by choosing this option from the drop-down menu.

Programming mode reveals more of the Max objects used in the program. You can now see that the scale-type menu is connected to a list object. This list changes in accordance with the selection, each time giving the number of semitones between consecutive notes on the chosen type of scale. You can also see that the program is implemented with a number of send, receive, and patcher objects. Send and receive objects pass data between them, as the names imply. Objects named s followed by an argument, as in s notepitch, are the send objects. Objects named r followed by an argument, as in r notepitch, are the receive objects. Patcher objects are “subpatchers” within the main program, their details hidden so that the main patcher is more readable.   You can open a patcher object in programming mode by double-clicking on it. The metronome, handlescale, and handlenote patcher objects are open in Figure 3.49, Figure 3.50, and Figure 3.51.

In this example, you still can’t see the details of how messages are being received and processed. To do so, you have to unlock the main patcher window by clicking the lock icon in the bottom left corner. This puts you in a mode where you can inspect and even edit objects. The main patcher is unlocked in Figure 3.52. You must have the full Max application, not just the runtime, to go into full programming mode.

With all the patcher objects exposed and the main patcher unlocked, you can now see how the program is initialized and how the user is able to trigger the sending and receiving of messages by selecting from a menu, turning the dial to set a tempo, and clicking the mouse on the keyboard display. Here’s how the program runs:

• The loadbang object is triggered when the program begins. It is used to initialize the tempo to 120 bpm and to set the default MIDI output device. Both of these can be changed by the user.
• The user can select a type of scale from a menu. The list of intervals is set accordingly and sent in the variable scalesintervals, to be received by the handlescale patcher object.
• The user can select a tempo through the dial object. The input value is sent to the metronome patcher object to determine the timing of the notes played in the scale.
• The user can click a key on the keyboard object. This initiates the playing of a scale by sending a keyhit message to both the metronome and the handlescale patcher.
• When the metronome patcher receives the keyhit message, it begins sending a tick every n milliseconds. The value of n is calculated based on the bpm value. Each tick of the metronome is what Max calls a bang message, which is used to trigger buttons and set actions in motion. In this case, the bang sets off a counter in the handlescale patcher, which counts out the correct number of notes as it plays a scale. The number of notes to play for a given type of scale is determined by a lookup list in the zl object, a multipurpose list processing object.
• The pitch of the note is determined by setting the keynote to the correct one and then accumulating offsets from there. As the correct notepitch is set for each successive note, it is sent to the handlenote patcher, which makes a MIDI message from this information and outputs the MIDI note. To understand this part of the patcher completely, you need to know a little bit about MIDI messages, which we don’t cover in detail until Chapter 6. It suffices for now to understand that middle C is sent as a number message with the value 60. Thus, a C major scale starting on middle C is created from the MIDI notes 60, 62, 64, 65, 67, 69, 71, and 72.

[wpfilebase tag=file id=36 tpl=supplement /]

Max has many types of built-in objects with specialized functions. We’ve given you a quick overview of some of them in this example. However, as a beginning Max programmer, you can’t always tell from looking at an object in programming mode just what type of object it is and how it functions. To determine the types of objects and look more closely at the implementation, you need to unlock the patcher, as shown in Figure 3.52. Then if you select an object and right click on it, you get a menu that tells the type of object at the top. In the example in Figure 3.53, the object is a kslider. From the context menu, you can choose to see the Help or an Inspector associated with the object. To see the full array of Max built-in objects, go to Max Help from the main Help menu, and from there to Object by Function.

Algorithm 3.2 is a C++ program analogous to the MATLAB program for generating scales. It uses the same functions for writing to the sound device as used the last section of Chapter 2. You can try your hand at a similar program by doing one of the suggested programming exercises. The first exercise has you generate (or recognize) chords of seven types in different keys. The second exercise has you generate equal tempered and just tempered scales and listen to the result to see if your ears can detect the small differences in frequencies. Both of these programs can be done in either MATLAB or C++.

[wpfilebase tag=file id=83 tpl=supplement /]

[wpfilebase tag=file id=79 tpl=supplement /]

[wpfilebase tag=file id=81 tpl=supplement /]

//This program works under the OSS library
#include <sys/ioctl.h> //for ioctl()
#include <math.h> //sin(), floor()
#include <stdio.h> //perror
#include <fcntl.h> //open, O_WRONLY
#include <linux/soundcard.h> //SOUND_PCM*
#include <iostream>
#include <stdlib.h>
using namespace std;
#define LENGTH 1 //number of seconds
#define RATE 44100 //sampling rate
#define SIZE sizeof(short) //size of sample, in bytes
#define CHANNELS 1 // number of stereo channels
#define PI 3.14159
#define SAMPLE_MAX 32767 // should this end in 8?
#define MIDDLE_C 262
#define SEMITONE 1.05946
enum types {BACK = 0, MAJOR, MINOR};
double getFreq(int index){
   return MIDDLE_C * pow(SEMITONE, index-1);
}
int getInput(){
   char c;
   string str;
   int i;
   while ((c = getchar()) != '\n' && c != EOF)
      str += c;
   for (i = 0; i < str.length(); ++i)
      str.at(i) = tolower(str.at(i));
   if (c == EOF || str == "quit")
      exit(0);
   return atoi(str.c_str());
}
int getIndex()
{   
   int input;
   cout
      << "Choose one of the following:\n"
      << "\t1) C\n"
      << "\t2) C sharp/D flat\n"
      << "\t3) D\n"
      << "\t4) D sharp/E flat\n"
      << "\t5) E\n"
      << "\t6) F\n"
      << "\t7) F sharp/G flat\n"
      << "\t8) G\n"
      << "\t9) G sharp/A flat\n"
      << "\t10) A\n"
      << "\t11) A sharp/B flat\n"
      << "\t12) B\n"
      << "\tor type quit to quit\n";
   input = getInput();
   if (! (input >= BACK && input <= 12))
      return -1;
   return input;
}
void writeToSoundDevice(short buf[], int buffSize, int deviceID) {
   int status;
   status = write(deviceID, buf, buffSize);
   if (status != buffSize)
      perror("Wrote wrong number of bytes\n");
   status = ioctl(deviceID, SOUND_PCM_SYNC, 0);
   if (status == -1)
      perror("SOUND_PCM_SYNC failed\n");
}
int getScaleType(){
   int input;
   cout
      << "Choose one of the following:\n"
      << "\t" << MAJOR << ") for major\n"
      << "\t" << MINOR << ") for minor\n"
      << "\t" << BACK << ") to back up\n"
      << "\tor type quit to quit\n";
   input = getInput();
   return input;
}
void playScale(int deviceID){
   int arraySize, note, steps, index, scaleType;
   int break1; // only one half step to here
   int break2; // only one half step to here
   int t, off;
   double f;
   short *buf;
   arraySize = 8 * LENGTH * RATE * CHANNELS; 
   buf = new short[arraySize];
   while ((index = getIndex()) < 0)
      cout << "Input out of bounds.  Please try again.\n";
   f = getFreq(index);
   while ((scaleType = getScaleType()) < 0)
      cout << "Input out of bounds.  Please try again.\n";
   switch (scaleType) {
      case MAJOR :
         break1 = 3;
         break2 = 7;
         break;
      case MINOR :
         break1 = 2;
         break2 = 5;
         break;
      case BACK :
         return;
      default :
         playScale(deviceID);
   }
   arraySize = LENGTH * RATE * CHANNELS;
   for (note = off = 0; note < 8; ++note, off += t) {
      if (note == 0)
         steps = 0;
      else if (note == break1 || note == break2)
         steps = 1;
      else steps = 2;
      f *= pow(SEMITONE, steps);
      for (t = 0; t < arraySize; ++t)
         buf[t + off] = floor(SAMPLE_MAX*sin(2*PI*f*t/RATE));
   }
   arraySize = 8 * LENGTH * RATE * SIZE * CHANNELS;
   writeToSoundDevice(buf, arraySize, deviceID);
   delete buf;
   return;
}
int main(){
   int deviceID, arg, status, index;
   deviceID = open("/dev/dsp", O_WRONLY, 0);
   if (deviceID < 0) 
      perror("Opening /dev/dsp failed\n");
   arg = SIZE * 8;
   status = ioctl(deviceID, SOUND_PCM_WRITE_BITS, &arg);
   if (status == -1)
      perror("Unable to set sample size\n");
   arg = CHANNELS;
   status = ioctl(deviceID, SOUND_PCM_WRITE_CHANNELS, &arg);
   if (status == -1)
      perror("Unable to set number of channels\n");
   arg = RATE;
   status = ioctl(deviceID, SOUND_PCM_WRITE_RATE, &arg);
   if (status == -1)
      perror("Unable to set sampling rate\n");
   while (true)
            playScale(deviceID);
}

Algorithm 3.2

[wpfilebase tag=file id=128 tpl=supplement /]

Let’s try making chords in Java as we did in C++. We’ll give you the code for this first exercise to get you started, and then you can try some exercises on your own. The “Chords in Java” program plays a chord selected from the list shown in Figure 3.54. The program contains two Java class files, one called Chord and the other called ChordApp. The top level class (i.e., the one that includes the main function) is the ChordApp class. The ChordApp class is a subclass of the JPanel, which is a generic window container. The JPanel provides functionality to display a window as a user interface. The constructor of the ChordApp class creates a list of radio buttons and displays the window with these options (Figure 3.54). When the user selects a type of chord, the method playChord() is called through the Chord class (line 138).

The ChordApp class contains the method playChord (line 7), which is a variation of the code shown in the MATLAB section. In the playChord method, the ChordApp object creates a Chord object, initializing it with the array scale, which contains the list of notes to be played in the chord. These notes are summed in the Chord class in lines 46 to 48.

 import java.awt.*;
 import java.awt.event.*;
 import javax.swing.*;

 public class ChordApp extends JPanel implements ActionListener {

     public static void playChord(String command)
     {/**Method that decides which Chord to play */
         float[] major7th = {0, 4, 7, 11};
         float[] minor7th = {0, 3, 7, 10};
         float[] domin7th = {0, 4, 7, 10};
         float[] dimin7th = {0, 3, 6, 10};
         float[] majorTri = {0, 4, 7};
         float[] minorTri = {0, 3, 7};
         float[] augmeTri = {0, 4, 8};
         float[] diminTri = {0, 3, 6};

         float[] scale;

         if      (command == "major7th")
             scale = major7th;
         else if (command == "minor7th")
             scale = minor7th;
         else if (command == "domin7th")
             scale = domin7th;
         else if (command == "dimin7th")
             scale = dimin7th;
         else if (command == "majorTri")
             scale = majorTri;
         else if (command == "minorTri")
             scale = minorTri;
         else if (command == "augmeTri")
             scale = augmeTri;
         else
             scale = diminTri;

         float startnote = 220*(2^((2+3)/12));

         for(int i=0;i<scale.length;i++){
             scale[i] = scale[i]/12;
             scale[i] = (float)Math.pow(2,scale[i]);
             scale[i] = startnote * scale[i];
         }

         //once we know which Chord to play, we call the Chord function
         Chord chord = new Chord(scale);
         chord.play();
     }

     public ChordApp() {
         super(new BorderLayout());

         try {
    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
             SwingUtilities.updateComponentTreeUI(this);
         } catch (Exception e) {
             System.err.println(e);
         }

         JRadioButton maj7thButton = new JRadioButton("Major Seventh");
         maj7thButton.setActionCommand("major7th");

         JRadioButton min7thButton = new JRadioButton("Minor Seventh");
         min7thButton.setActionCommand("minor7th");

         JRadioButton dom7thButton = new JRadioButton("Dominant Seventh");
         dom7thButton.setActionCommand("domin7th");

         JRadioButton dim7thButton = new JRadioButton("Diminished Seventh");
         dim7thButton.setActionCommand("dimin7th");

         JRadioButton majTriButton = new JRadioButton("Major Triad");
         majTriButton.setActionCommand("majorTri");

         JRadioButton minTriButton = new JRadioButton("Minor Triad");
         minTriButton.setActionCommand("minorTri");

         JRadioButton augTriButton = new JRadioButton("Augmented Triad");
         augTriButton.setActionCommand("augmeTri");

         JRadioButton dimTriButton = new JRadioButton("Diminished Triad");
         dimTriButton.setActionCommand("diminTri");

         ButtonGroup group = new ButtonGroup();
         group.add(maj7thButton);
         group.add(min7thButton);
         group.add(dom7thButton);
         group.add(dim7thButton);
         group.add(majTriButton);
         group.add(minTriButton);
         group.add(augTriButton);
         group.add(dimTriButton);

         maj7thButton.addActionListener(this);
         min7thButton.addActionListener(this);
         dom7thButton.addActionListener(this);
         dim7thButton.addActionListener(this);
         majTriButton.addActionListener(this);
         minTriButton.addActionListener(this);
         augTriButton.addActionListener(this);
         dimTriButton.addActionListener(this);

         JPanel radioPanel = new JPanel(new GridLayout(0, 1));
         radioPanel.add(maj7thButton);
         radioPanel.add(min7thButton);
         radioPanel.add(dom7thButton);
         radioPanel.add(dim7thButton);
         radioPanel.add(majTriButton);
         radioPanel.add(minTriButton);
         radioPanel.add(augTriButton);
         radioPanel.add(dimTriButton);

         add(radioPanel, BorderLayout.LINE_START);
         setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
     }

     public static void main(String[] args) {
         javax.swing.SwingUtilities.invokeLater(new Runnable() {
             public void run() {
                 ShowWindow();
             }
         });
     }

     private static void ShowWindow() {
         JFrame frame = new JFrame("Chords App");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

         JComponent newContentPane = new ChordApp();
         newContentPane.setOpaque(true); //content panes must be opaque
         frame.setContentPane(newContentPane);

         frame.pack();
         frame.setVisible(true);
     }
     /** Listens to the radio buttons. */
     public void actionPerformed(ActionEvent e) {
         ChordApp.playChord(e.getActionCommand());
     }
 }

Algorithm 3.3 ChordApp class

 
 
 import javax.sound.sampled.AudioFormat;
 import javax.sound.sampled.AudioSystem;
 import javax.sound.sampled.SourceDataLine;
 import javax.sound.sampled.LineUnavailableException;
 
 public class Chord {
     float[] Scale;
     
     public Chord(float[] scale) {
         Scale=scale;
     }
     
     public void play() {
         try {
             makeChord(Scale);
         } catch (LineUnavailableException lue) {
             System.out.println(lue);
         }
     }
     
     private void makeChord(float[] scale)
     throws LineUnavailableException
     {
         int freq = 44100;
         float[] x=new float[(int)(freq)];
         
         byte[] buf;
         AudioFormat audioF;
         
         for(int i=0;i<x.length;i++){
             x[i]=(float)(i+1)/freq;
         }
         
         buf = new byte[1];
         audioF = new AudioFormat(freq,8,1,true,false);
 
         SourceDataLine sourceDL = AudioSystem.getSourceDataLine(audioF);
         sourceDL = AudioSystem.getSourceDataLine(audioF);
         sourceDL.open(audioF);
         sourceDL.start();        
 
         for (int j=0;j<x.length;j++){
             buf[0]= 0;
             for(int i=0;i<scale.length;i++){
               buf[0]=(byte)(buf[0]+(Math.sin((2*Math.PI*scale[i])*x[j])*10.0)) 
             }
             sourceDL.write(buf,0,1);
         }

         sourceDL.drain();
         sourceDL.stop();
         sourceDL.close();
     }
 }

Algorithm 3.4  Chord class

[wpfilebase tag=file id=87 tpl=supplement /]

[wpfilebase tag=file id=85 tpl=supplement /]

As another exercise, you can try to play and compare equal vs. just tempered scales, the same program exercise linked in the C++ section above.

The last exercise associated with this section, you’re asked to create a metronome-type object that creates a beat sound according to the user’s specifications for tempo. You may want to borrow something similar to the code in the ChordApp class to create the graphical user interface.

[separator top=”1″ bottom=”0″ style=”none”]