4.1 Class
CS 312 Audio Programming Winter 2020

smb://courses.ads.carleton.edu/COURSES/cs312-00-w20

setup312 <your_carleton_email_name>

/Volumes/cs312-00-w20/StuWork/email_name
$HOME312 = /Volumes/cs312-00-w20/StuWork/email_name (same as above)
Inside $HOME312 are these folders
bin common cs312 googletest (the big download from class 3.2)
# anything else is ignored in assignment setups

# hw411_random_int
cd $HOME312/cs312/
mkdir hw41 && cd hw41
mkdir hw411_rand_int && cd hw411_rand_int
touch hw411_rand_int.h
touch hw411_rand_int.cpp
touch hw411_main.cpp

# hw412_gmnames
cd $HOME312/cs312/hw41
mkdir hw412_gmnames && cd hw412_gmnames
touch instrumentGMcategories.txt
touch instrumentGMnames.txt
touch hw412_gmnames.cpp

#hw411_CScalesTrack
cd $HOME312/cs312/hw41
mkdir hw413_CScalesTrack && cd hw413_CScalesTrack
# CMake stuff
touch CMakeLists.txt
mkdir build
touch hw413_CMidiTrack.cpp
touch hw413_CMidiTrack.h
touch hw413_CScalesTrack.h
touch hw413_CScalesTrack.cpp
touch hw413_main.cpp

#hw413_measures_beats
cd $HOME312/cs312/hw41
mkdir hw414_measures_beats && cd hw414_measures_beats
mkdir build
touch CMakeLists.txt
touch hw414_CMeasuresBeatTrack.cpp
touch hw414_CMeasuresBeatTrack.h
touch hw414_main.cpp

// hw411_rand_int.h
#ifndef HW411_RAND_INT_H_
#define HW411_RAND_INT_H_

extern int get_rand_int(int lo, int hi);

#endif // HW411_RAND_INT_H_

#include <iostream>

#ifndef HW411_RAND_INT_H_
#include "hw411_rand_int.h"
#endif

int main(int argc, char const *argv[])
{
  for (int n = 0; n < 12; ++n)
    std::cout << get_rand_int(0, 12) << " ";
  std::cout << '\n';

  for (int n = 0; n < 12; ++n)
    std::cout << get_rand_int(55, 67) << " ";
  std::cout << '\n';

  for (int n = 0; n < 12; ++n)
    std::cout << get_rand_int(0, 1) << " ";
  std::cout << '\n';

  return 0;
}

je$ cl *.cpp && ./a.out
2 10 10 9 7 4 7 0 1 11 8 2
63 65 64 55 63 58 62 65 64 60 67 55
0 1 1 0 0 0 0 1 1 0 0 0

je$ cl *.cpp && ./a.out
0 6 12 1 11 10 9 1 8 1 0 0
66 64 67 64 58 55 56 64 57 59 63 60
0 0 1 1 1 1 1 1 1 0 0 0

Piano
Chromatic Percussion
Organ
Guitar
Bass
Strings
Ensemble
Brass
Reed
Pipe
Synth Lead
Synth Pad
Synth Effects
Ethnic
Percussive
Sound Effects

Acoustic Grand Piano
Bright Acoustic Piano
Electric Grand Piano
Honky-tonk Piano
Electric Piano 1
Electric Piano 2
Harpsichord
Clavinet
Celesta
Glockenspiel
Music Box
Vibraphone
Marimba
Xylophone
Tubular Bells
Dulcimer
Drawbar Organ
Percussive Organ
Rock Organ
Church Organ
Reed Organ
Accordion
Harmonica
Tango Accordion
Acoustic Guitar (nylon)
Acoustic Guitar (steel)
Electric Guitar (jazz)
Electric Guitar (clean)
Electric Guitar (muted)
Overdriven Guitar
Distortion Guitar
Guitar harmonics
Acoustic Bass
Electric Bass (finger)
Electric Bass (pick)
Fretless Bass
Slap Bass 1
Slap Bass 2
Synth Bass 1
Synth Bass 2
Violin
Viola
Cello
Contrabass
Tremolo Strings
Pizzicato Strings
Orchestral Harp
Timpani
String Ensemble 1
String Ensemble 2
SynthStrings 1
SynthStrings 2
Choir Aahs
Voice Oohs
Synth Voice
Orchestra Hit
Trumpet
Trombone
Tuba
Muted Trumpet
French Horn
Brass Section
SynthBrass 1
SynthBrass 2
Soprano Sax
Alto Sax
Tenor Sax
Baritone Sax
Oboe
English Horn
Bassoon
Clarinet
Piccolo
Flute
Recorder
Pan Flute
Blown Bottle
Shakuhachi
Whistle
Ocarina
Lead 1 (square)
Lead 2 (sawtooth)
Lead 3 (calliope)
Lead 4 (chiff)
Lead 5 (charang)
Lead 6 (voice)
Lead 7 (fifths)
Lead 8 (bass + lead)
Pad 1 (new age)
Pad 2 (warm)
Pad 3 (polysynth)
Pad 4 (choir)
Pad 5 (bowed)
Pad 6 (metallic)
Pad 7 (halo)
Pad 8 (sweep)
FX 1 (rain)
FX 2 (soundtrack)
FX 3 (crystal)
FX 4 (atmosphere)
FX 5 (brightness)
FX 6 (goblins)
FX 7 (echoes)
FX 8 (sci-fi)
Sitar
Banjo
Shamisen
Koto
Kalimba
Bag pipe
Fiddle
Shanai
Tinkle Bell
Agogo
Steel Drums
Woodblock
Taiko Drum
Melodic Tom
Synth Drum
Reverse Cymbal
Guitar Fret Noise
Breath Noise
Seashore
Bird Tweet
Telephone Ring
Helicopter
Applause
Gunshot

// hw413_CMidiTrack.h
#ifndef HW413_CMIDITRACK_H_
#define HW413_CMIDITRACK_H_

#ifndef HW332_CMIDIPACKET_H_
#include "hw332_CMidiPacket.h"
#endif

#include <vector>

// DO NOT MODIFY THIS CODE

using namespace CMP33;

class CMidiTrack
{
private: // not really needed they'd be private by default
  uint32_t beginTimestamp_;
  uint32_t endTimestamp_;
  uint8_t noteOffset_;
  uint8_t channel_;
  uint8_t patch_;
  uint8_t volume_;
  uint8_t pan_;
  uint8_t expr_;

public:
  std::vector<CMidiPacket> vtrk;

  // the big six - all default - not declared

  // only constructor
  // Note use of default parameter for expr
  // A default paramter does not need to be included when the constructor is called
  // unless you want to change it to a default value
  // You can have more than one default parameter but they must appear at then end
  CMidiTrack(uint32_t beginTime, uint32_t endTime, uint8_t noteoffset, uint8_t channel,
             uint8_t patch, uint8_t volume, uint8_t pan, uint8_t expr = 100);

  // Getters
  // These simple functions are all declared and defined inline
  // They do not appear in the .cpp file
  // You should only do this for simple functions.
  // Inline header files may not show up in the debugger
  uint32_t get_beginTimestamp() const { return beginTimestamp_; };
  uint32_t get_endTimestamp() const { return endTimestamp_; };
  uint8_t get_noteOffset() const { return noteOffset_; };
  uint8_t get_channel() const { return channel_; };
  uint8_t get_patch() const { return patch_; };
  uint8_t get_volume() const { return volume_; };
  uint8_t get_pan() const { return pan_; };
  uint8_t get_expression() const { return expr_; };

  // Setters - also declared and defined inline
  void set_beginTimestamp(const uint32_t &ts) { beginTimestamp_ = ts; };
  void set_endTimestamp(const uint32_t &ts) { endTimestamp_ = ts; };
  void set_noteOffset(const uint8_t &ofst) { noteOffset_ = ofst; };
  void set_channel(const uint8_t &chan) { channel_ = chan; };
  void set_patch(const uint8_t &patch) { patch_ = patch; };
  void set_volume(const uint8_t &vol) { volume_ = vol; };
  void set_pan(const uint8_t &pan) { pan_ = pan; };
  void set_expression(const uint8_t &expr) { expr_ = expr; };

  // Send these Midi Message
  // These will appear in the .cpp file and you'll need to implement them
  // For now send means write to std::cout
  void send_non(uint32_t tm, uint8_t chan, uint8_t note, uint8_t vel);
  void send_nof(uint32_t tm, uint8_t chan, uint8_t note);
  void send_patch(uint32_t tm, uint8_t chan, uint8_t patch);
  void send_volume(uint32_t tm, uint8_t chan, uint8_t vol);
  void send_pan(uint32_t tm, uint8_t chan, uint8_t pan);
  void send_expression(uint32_t tm, uint8_t chan, uint8_t expr);

  // Example of a pure virtual function
  // This is now an abstract bass class and cannot be created in other files
  // That means you'll have to write subclasses that inherit from CMidiTrack
  // Subclasses are required to declare an implement the write_track() function
  // Subclasses get all the functions found in CMidiTrack for free.
  virtual void write_track() = 0;
};

#endif // HW413_CMIDITRACK_H_

// hw413_CMidiTrack.cpp
#ifndef HW413_CMIDITRACK_H_
#include "hw413_CMidiTrack.h"
#endif

#include <iostream>

using namespace CMP33;

// This constructor initializes the class variables
// Subclasses can add additional parameters or class variables as needed
CMidiTrack::CMidiTrack(uint32_t beginTime, uint32_t endTime, uint8_t noteoffset, uint8_t channel,
                       uint8_t patch, uint8_t volume, uint8_t pan, uint8_t expr)
    : beginTimestamp_{beginTime}, endTimestamp_{endTime}, noteOffset_{noteoffset}, channel_{channel},
      patch_{patch}, volume_{volume}, pan_{pan}
{
} // expr not set because it defaults to 100.

// Functions to send MIDI messages
// for now send means write to std::cout
void CMidiTrack::send_non(uint32_t tm, uint8_t chan, uint8_t note, uint8_t vel)
{
  // I did the first one
  CMidiPacket mp(tm, chan, note, vel);
  std::cout << mp;
}

void CMidiTrack::send_nof(uint32_t tm, uint8_t chan, uint8_t note)
{
  // you write - use 0x80 with data2 == 0
}

void CMidiTrack::send_patch(uint32_t tm, uint8_t chan, uint8_t patch)
{
  // you write
}

void CMidiTrack::send_volume(uint32_t tm, uint8_t chan, uint8_t vol)
{
  // you write
}

void CMidiTrack::send_pan(uint32_t tm, uint8_t chan, uint8_t pan)
{
  // you write
}

void CMidiTrack::send_expression(uint32_t tm, uint8_t chan, uint8_t expr)
{
  // you write
}

// hw411_CScalesTrack.h
#ifndef HW413_CSCALESTRACK_H_
#define HW413_CSCALESTRACK_H_

#ifndef HW413_CMIDITRACK_H_
#include "hw413_CMidiTrack.h"
#endif

// DO NOT MODIFY THIS CODE

class CScalesTrack : public CMidiTrack
{
public:
  std::vector<int> vscale;
  std::vector<int> vrhythm;

  CScalesTrack(uint32_t beginTime, uint32_t endTime, uint8_t noteoffset, uint8_t channel,
               uint8_t patch, uint8_t volume, uint8_t pan);

  int get_note(); // choose a random scale note
  void write_scales_track();
  virtual void write_track(); // must define it was declared pure virtual in CMidiTrack
};

// SCALE NOTES
// See class web page for more information
// You can add your own to the list.
// clang-format off
const std::vector<int> vmajor_pentatonic{0, 2, 4, 7, 9, 12};        // Major pentatonic
const std::vector<int> vminor_pentatonic{0, 3, 5, 7, 10, 12};       // Minor pentatonic
const std::vector<int> vragtime{0, 2, 3, 4, 7, 9, 12};              // Ragtime scale
const std::vector<int> vrock_blues{0, 3, 4, 7, 9, 10, 12};          // Rock blues Scales
const std::vector<int> vminor_blues{0, 3, 5, 6, 7, 10, 12};         // Minor blues Scales
const std::vector<int> v6note_blues{0, 3, 5, 6, 7, 10, 12};         // 6 note blues Scales
const std::vector<int> v7note_blues{0, 2, 3, 5, 6, 9, 10, 12};      // 7 note blues Scales
const std::vector<int> vmideast{0, 1, 4, 5, 6, 8, 11, 12};          // Middle Eastern scale
const std::vector<int> vjapanese{0, 1, 5, 7, 8, 12};                // Japanese scale
const std::vector<int> voctotonic{0, 1, 3, 4, 6, 7, 9, 10, 12};     // Octotonic jazz scale half step, whole step
const std::vector<int> vwholetone{0, 2, 4, 6, 8, 10, 12};           // Whole tone, whole step, whole step
const std::vector<int> vflamenco{0, 1, 4, 5, 7, 8, 11, 12};          // Flamenco
const std::vector<int> vphrygian_dominant{0, 1, 4, 5, 7, 8, 10, 12}; // Phrygian dominant
// clang-format ON

#endif // HW411_CSCALESTRACK_H_

// hw413_CScalesTrack.cpp
#ifndef HW413_CSCALESTRACK_H_
#include "hw413_CScalesTrack.h"
#endif

// in common folder
#ifndef HW411_RAND_INT_H_
#include "hw411_rand_int.h"
#endif

// FOR REFERENCE
// assign scale - choose 1
// vmajor_pentatonic{0, 2, 4, 7, 9, 12};        // Major pentatonic
// vminor_pentatonic{0, 3, 5, 7, 10, 12};       // Minor pentatonic
// vragtime{0, 2, 3, 4, 7, 9, 12};              // Ragtime scale
// vrock_blues{0, 3, 4, 7, 9, 10, 12};          // Rock blues Scales
// vminor_blues{0, 3, 5, 6, 7, 10, 12};         // Minor blues Scales
// vheptatonic_blues{0, 2, 3, 5, 6, 9, 10, 12}; // Heptatonic blues Scales
// vmideast{0, 1, 4, 5, 7, 8, 10, 12};          // Middle Eastern scale
// vjapanese{0, 1, 5, 7, 8, 12};                // Japanese scale
// voctotonic{0, 1, 3, 4, 6, 7, 9, 10, 12};     // Octotonic jazz scale half step, whole step
// vwholetone{0, 2, 4, 6, 8, 10, 12};           // Sc-fi
// vflamenco{0, 1, 4, 5, 7, 8, 11, 12};         // Flamenco
// vphrygian_dominant{0, 1, 4, 5, 7, 8, 10, 12};// Phrygian_dominant

// additional constructor.
CScalesTrack::CScalesTrack(uint32_t beginTime, uint32_t endTime, uint8_t noteoffset, uint8_t channel,
                           uint8_t patch, uint8_t volume, uint8_t pan)
    : CMidiTrack(beginTime, endTime, noteoffset, channel,
                 patch, volume, pan)
{
  // assign vscale to one of the above scales
  // assign rhythm pattern
  // we'll use the long, short-short, long described on the class 4.1 web page
  vrhythm = {500, 250, 250, 500};
}

int CScalesTrack::get_note()
{
  // get a random note from the vscale
  // add the get_noteOffset
  // return the result
}

void CScalesTrack::write_scales_track()
{
  std::cout << "# CScalesTrack must override pure virtual function write_track()\n";

  /*
  CScalesTrack declares a private variable tm for keeping track
  I used a do..while loop because we set the endTime in the constructor
  do {
    get a random note from vscale
    vrhythm has 4 elements
    every time you get a new NON you'll have cycle through vrhythm 
        indices using the pattern 0 1 2 3 0 1 2 3 etc.
    every time it's vrhythm[0] the NON velocity is 127
    otherwise the NON velocity is 80.
    this will accent the first note of rhythm pattern every time it repeats.
    keep a running sum of the timestamps using the tm variable
    if the NON timestamp is tm, the NOF timestamp is tm - 1
  } while (tm < get_endTimestamp());
  */
}

void CScalesTrack::write_track()
{
  vtrk.clear();
  // these items should be set at the beginning of the track
  send_patch(0, get_channel(), get_patch());
  send_volume(0, get_channel(), get_volume());
  send_pan(0, get_channel(), get_pan());

  write_scales_track();
}

// hw411_main.cpp
#ifndef HW413_CSCALESTRACK_H_
#include "hw413_CScalesTrack.h"
#endif

#include <iostream>

// DO NOT MODIFY

int main()
{
  // beginTS, endTS, noteOffset, channel, patch, volume, pan
  CScalesTrack mtrk{0, 50000, 60, 0, 11, 100, 64};
  mtrk.write_track();
  for (auto itr : mtrk.vtrk)
    std::cout << itr;

  std::cout << "# Play in MIDIDisplay\n";
}

$HOME312/common
├── hw332_CMidiPacket.cpp
├── hw332_CMidiPacket.h
├── hw411_rand_int.cpp
├── hw411_rand_int.h
├── hw413_CMidiTrack.cpp
└── hw413_CMidiTrack.h

$HOME312/cs312/hw41
├── hw411_rand_int
│   ├── hw411_main.cpp
│   ├── hw411_rand_int.cpp
│   └── hw411_rand_int.h
├── hw412_gmnames
│   ├── hw412_gmnames1.cpp
│   ├── instrumentGMcategories.txt
│   └── instrumentGMnames.txt
├── hw413_CScalesTrack_org
│   ├── CMakeLists.txt
│   ├── build
│   ├── hw413_CMidiTrack.cpp
│   ├── hw413_CMidiTrack.h
│   ├── hw413_CScalesTrack.cpp
│   ├── hw413_CScalesTrack.h
│   └── hw413_main.cpp
└── hw414_CMeasuresBeatTrack
    ├── CMakeLists.txt
    ├── build
    ├── hw414_CMeasuresBeatTrack.cpp
    ├── hw414_CMeasuresBeatTrack.h
    └── hw414_main.cpp