CS 312 - Week 5.1
CS 312 Audio Programming Winter 2020

// hw511_CInstrument.h
#ifndef HW511_INSTRUMENT_H_
#define HW511_INSTRUMENT_H_

#ifndef HW423_CMIDITRACK_H_
#include "hw423_CMidiTrack.h"
#endif

// DO NOT MODIFY

// Blues form
const int kNUM_MEASURES = 12;
const int kNUM_REPEATS = 1;
const int kTOTAL_MEASURES = kNUM_REPEATS * kNUM_MEASURES;
const int kSONG_END_TIME = kTOTAL_MEASURES * 4000;

class CInstrument : public CMidiTrack
{
private:
  int start_note; // MIDI note offset for pitch 0 in kBLUES_SCALE;
  int meas_num;   // updates measure number as song is playing

public:
  // additional constructor
  CInstrument(uint32_t beginTm, uint32_t endTm, int noteOffset, int chan,
              int patch, int vol, int pan, int startNote, int measNum);

  // getters - defined inline
  int get_start_note() const { return start_note; }
  int get_meas_num() const { return meas_num; }

  // setters - defined inline
  void set_start_note(const int sn) { start_note = sn; };
  void set_meas_num(const int mn) { meas_num = mn; };

  // Utility functions used by melody, piano, and bass classes.
  int get_note_offset(int meas, int note_offset);
  uint32_t get_measure_start_time(int meas);

  // This is a pure virtual function in CMidiTrack
  // and we need to declare it here and define it in CInstrument.cpp
  void write_track() override;

  // write_one_measure is a pure virtual function in CInstrument
  // The sax, piano, and bass subclasses must implement their own versions
  virtual void write_one_measure(int meas, int chan) = 0;
};
#endif // HW511_INSTRUMENT_H_

// hw511_CInstrument.cpp
#ifndef HW511_CINSTRUMENT_H_
#include "hw511_CInstrument.h"
#endif

// additional constructor
CInstrument::CInstrument(uint32_t beginTm, uint32_t endTm, int noteOffset,
                         int chan, int patch, int vol, int pan, int startNote,
                         int measNum)
    : CMidiTrack(beginTm, endTm, noteOffset, chan, patch, vol, pan),
      start_note{startNote},
      meas_num{measNum}
{
}

// This is a pure virtual function in CInstrument and we need to implement it
// here. This CInstrument function does not implement write_one_measure() and
// instead calls the functions implemented in sax, piano, and bass CInstrument
// subclasses.
void CInstrument::write_track()
{
  vtrk.clear();
  push_patch(0, get_channel(), get_patch());
  push_volume(0, get_channel(), get_volume());
  push_pan(0, get_channel(), get_pan());

  // Calls write_one_measure(), however because it is a pure virtual function
  // it will be implemented in each of the Sax, Piano, and Bass subclasses
  // according to the needs of that subclass
  for (int ix = 0; ix < kTOTAL_MEASURES; ++ix)
    write_one_measure(ix, get_channel());
}

// changes the note offset based on which measure
// of the blues form is being written
// measure numbers are zero based; measure 1 == 0, measure 12 == 11
// Return the scale note offset for meas_num
// A 12 bar blues with 4 repeats means you have to account for measures 13-48
int CInstrument::get_note_offset(int meas, int note_offset)
{
  uint16_t offset;
  switch (meas % 12)
  {
  case 0:
  case 1:
  case 2:
  case 3:
  case 6:
  case 7:
  case 10:
    offset = note_offset;
    break;
  case 4:
  case 5:
  case 9:
    offset = note_offset + 5;
    break;
  case 8:
    offset = note_offset + 7;
    break;
  case 11:
    offset = note_offset - 5;
    break;
  default:
    offset = note_offset;
    break;
  }
  return offset;
}

// returns the timestamp at the start of the measure
// measure numbers are zero based
// there are 4 beats in a measure, each beat == 1000ms
uint32_t CInstrument::get_measure_start_time(int meas)
{
  return meas * 4000;
}

cp $HOME312/cs312/hw51/c511_CInstrument/hw511_CInstrument.h $HOME312/common
cp $HOME312/cs312/hw51/c511_CInstrument/hw511_CInstrument.cpp $HOME312/common

// hw511_CBluesPianoTrack.cpp
#ifndef HW511_CBLUESPIANOTRACK_H_
#include "hw511_CBluesPianoTrack.h"
#endif

struct ChordTm
{
  int note1;
  int note2;
  int note3;
  int note4;
  int dur;
};

// rock blues scale
ChordTm chord1{3, 7, 10, 12, 1500};
ChordTm chord2{7, 10, 12, 15, 2000}; // {7, 10, 12, 3+12}
ChordTm chord3{3, 7, 10, 12, 2500};

const std::vector<ChordTm> one_meas_chord_vec = {chord1, chord2, chord3};

// additional constructor
CBluesPianoTrack::CBluesPianoTrack(uint32_t beginTm, uint32_t endTm,
                                   int scaleOffset, int chan, int patch,
                                   int vol, int pan, int startNote, int meas)
    : CInstrument(beginTm, endTm, scaleOffset, chan, patch, vol, pan, startNote,
                  meas) {}

void CBluesPianoTrack::write_one_measure(int meas, int chn)
{
  CMidiPacket mp;

  uint16_t offset = get_note_offset(meas, get_start_note());
  uint32_t meas_tm = get_measure_start_time(meas);
  for (auto itr : one_meas_chord_vec)
  {
    push_non(meas_tm + itr.dur, chn, itr.note1 + offset, 127);
    push_non(meas_tm + itr.dur, chn, itr.note2 + offset, 127);
    push_non(meas_tm + itr.dur, chn, itr.note3 + offset, 127);
    push_non(meas_tm + itr.dur, chn, itr.note4 + offset, 127);

    push_nof(meas_tm + 300 + itr.dur, chn, itr.note1 + offset);
    push_nof(meas_tm + 300 + itr.dur, chn, itr.note2 + offset);
    push_nof(meas_tm + 300 + itr.dur, chn, itr.note3 + offset);
    push_nof(meas_tm + 300 + itr.dur, chn, itr.note4 + offset);
  }
  set_meas_num(get_meas_num() + 1);
}

// hw511_CBluesPianoTrack.h
#ifndef HW511_CBLUESPIANOTRACK_H_
#define HW511_CBLUESPIANOTRACK_H_

#ifndef HW511_CINSTRUMENT_H_
#include "hw511_CInstrument.h"
#endif

// DO NOT MODIFY

class CBluesPianoTrack : public CInstrument
{
public:
  // constructor
  CBluesPianoTrack(uint32_t beginTm, uint32_t endTm, int scaleOffset, int chan,
                   int patch, int vol, int pan, int startNote, int meas);

  // This is the only function needed
  void write_one_measure(int meas, int chan) override;
};
#endif // HW511_CBLUESPIANOTRACK_H_

// c512_main.cpp
#ifndef HW511_CINSTRUMENT_H_
#include "hw511_CInstrument.h"
#endif

#ifndef HW511_CBLUESPIANOTRACK_H_
#include "hw511_CBluesPianoTrack.h"
#endif

#ifndef HW421_CDELAYMS_H_
#include "hw421_CDelayMs.h"
#endif

#ifndef HW422_CAPPLEMIDISYNTH_H_
#include "hw422_CAppleMidiSynth.h"
#endif

#include <vector>

using namespace CMP33;

std::vector<CMidiPacket> vplay;

void write_piano()
{
  uint32_t startTm = 0;
  int scaleOffset = 0;
  int chan = 1;
  int patch = 0; // piano
  int vol = 100;
  int pan = 64; // pan center
  int startNote = 48;
  int meas = 0;

  CBluesPianoTrack pno_trk(startTm, kSONG_END_TIME, scaleOffset, chan, patch,
                           vol, pan, startNote, meas);
  pno_trk.write_track();
  // append to vplay
  std::copy(pno_trk.vtrk.begin(), pno_trk.vtrk.end(),
            std::back_inserter(vplay));
}

int main(int argc, char const *argv[])
{
  write_piano();

  CDelayMs::s_tempo = 135;
  CAppleMidiSynth ams;
  ams.send(vplay);

  return 0;
}

cmake_minimum_required(VERSION 2.8)
set(APPNAME "pianoChords")
project(${APPNAME})
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall ")

# JE sets FOR_CLASS to 0
# YOU set FOR_CLASS to 1
set(FOR_CLASS 0)
if(${FOR_CLASS})
  set( HOME "/Volumes/cs312-00-w20/StuWork/<your_email_name>" )
elseif(NOT ${FOR_CLASS})
  set( HOME "/Users/je/cs312/_cs312")
endif(${FOR_CLASS})
set(COMMON "${HOME}/common")

set(SOURCE_FILES
  ${COMMON}/hw332_CMidiPacket.cpp
  ${COMMON}/hw411_rand_int.cpp
  ${COMMON}/hw421_CDelayMs.cpp
  ${COMMON}/hw422_CAppleMidiSynth.cpp
  ${COMMON}/hw423_CMidiTrack.cpp
  ${COMMON}/hw511_CInstrument.cpp
  hw511_CBluesPianoTrack.cpp
  c512_main.cpp
)

include_directories(${COMMON})
add_executable(${APPNAME} ${SOURCE_FILES})

target_link_libraries(${PROJECT_NAME} PRIVATE "-framework AudioToolbox")
target_link_libraries(${PROJECT_NAME} PRIVATE "-framework CoreMIDI")
target_link_libraries(${PROJECT_NAME} PRIVATE  "-framework CoreAudio")

// c513_CMarkovBlues.cpp
#ifndef C513_CMARKOVBLUES_H_
#include "c513_CMarkovBlues.h"
#endif

#include <iostream>
#include <vector>
#include <random>

int CMarkovBlues::chooseMarkovNote(int note)
{
  // rock blues
  // const std::vector<int> kweigh{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
  const std::vector<int> k0weights{5, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0};
  const std::vector<int> k3weights{0, 0, 0, 2, 4, 0, 0, 4, 0, 0, 0, 0, 0};
  const std::vector<int> k4weights{0, 0, 0, 2, 3, 0, 0, 5, 0, 0, 0, 0, 0};
  const std::vector<int> k7weights{0, 0, 0, 0, 3, 0, 0, 4, 0, 0, 3, 0, 0};
  const std::vector<int> k9weights{0, 0, 0, 0, 0, 0, 0, 4, 0, 1, 5, 0, 0};
  const std::vector<int> k10weights{0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 2, 0, 4};
  const std::vector<int> k12weights{0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 3, 0, 3};

  std::random_device rd;
  std::default_random_engine engine(rd());

  std::discrete_distribution<int> distribution_k0(k0weights.begin(), k0weights.end());
  std::discrete_distribution<int> distribution_k3(k3weights.begin(), k3weights.end());
  std::discrete_distribution<int> distribution_k4(k4weights.begin(), k4weights.end());
  std::discrete_distribution<int> distribution_k7(k7weights.begin(), k7weights.end());
  std::discrete_distribution<int> distribution_k9(k9weights.begin(), k9weights.end());
  std::discrete_distribution<int> distribution_k10(k10weights.begin(), k10weights.end());
  std::discrete_distribution<int> distribution_k12(k12weights.begin(), k12weights.end());

  int n;
  switch (note)
  {
  case 0:
    n = distribution_k0(engine);
    break;

  case 3:
    n = distribution_k3(engine);
    break;

  case 4:
    n = distribution_k4(engine);
    break;

  case 7:
    n = distribution_k7(engine);
    break;

  case 9:
    n = distribution_k9(engine);
    break;

  case 10:
    n = distribution_k10(engine);
    break;

  case 12:
    n = distribution_k12(engine);
    break;

  default:
    n = distribution_k0(engine);
    break;
  }
  return n;
}

// c513_CMarkovBlues.h
#ifndef C513_CMARKOVBLUES_H_
#define C513_CMARKOVBLUES_H_

#include <iostream>
#include <vector>
#include <random>

extern std::random_device rd;
extern std::default_random_engine engine;

class CMarkovBlues
{
public:
  std::vector<int> vRBscale{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

  int chooseMarkovNote(int note);
};

#endif // CMARKOVBLUES_H_

// c513_main.cpp
#ifndef CMARKOVBLUES_H_
#include "CMarkovBlues.h"
#endif

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

#ifndef HW421_CDELAYMS_H_
#include "hw421_CDelayMs.h"
#endif

#ifndef HW422_CAPPLE_MIDISYNTH_H_
#include "hw422_CAppleMidiSynth.h"
#endif

#include <random>

int startNote{0};
bool isStartSet = false;

const std::vector<int> vscale{0, 3, 4, 7, 9, 10, 12}; // rock blues

void play_melody(std::vector<int> v)
{
  CDelayMs::s_tempo = 74;
  CMidiPacket mp;
  std::vector<CMidiPacket> vplay;
  uint32_t tm{0};
  for (int ix = 0; ix < v.size(); ++ix)
  {
    // NON
    uint8_t note = v.at(ix);
    {
      mp = {tm, 0x90, note, 100};
      if (ix % 2 == 0)
      {
        tm += 667;
        mp.set_data2(120);
      }
      else
      {
        tm += 333;
        mp.set_data2(85);
      }
      vplay.push_back(mp);

      // NOF
      mp = {tm - 1, 0x80, note, 0};
      vplay.push_back(mp);
    }
  }

  CAppleMidiSynth ams;
  ams.send(vplay);
  CDelayMs d(1000, false);
}

void gen_random_melody(const int numNotes)
{
  std::vector<int> vec;
  std::vector<int> vi;

  // vec.clear();
  // vi.clear();

  for (auto n = 0; n < numNotes; ++n)
  {
    // reset note for the next time through the inner loop
    int ni = get_rand_int(0, vscale.size() - 1);
    if (!isStartSet)
    {
      startNote = vscale.at(ni);
      isStartSet = true;
    }
    int note = vscale.at(ni) + 60;
    vec.push_back(note);
    vi.push_back(ni);
  }
  isStartSet = false;

  std::cout << "==== random_melody ====\n";
  for (auto itr : vi)
  {
    std::cout << vscale.at(itr) << " ";
  }
  std::cout << std::endl;
  play_melody(vec);
}

void gen_markov_melody(const int numNotes)
{
  // std::cout << "==== gen_markov_melody ====\n";
  CMarkovBlues mb;
  std::vector<int> vec;
  std::vector<int> vi;

  vec.clear();
  vi.clear();
  int note = startNote;
  // Inner for loop
  for (auto n = 0; n < numNotes; ++n)
  {
    // reset note for the next time through the inner loop
    if (n == 0)
      note = startNote;
    else
    {
      // This statement chooses the next note based on the previous one
      // note = mb.chooseMarkovNote(note);

      // This statement chooses all notes based on the starting note
      // that was set as the first starting note of the random melody
      note = mb.chooseMarkovNote(startNote);
    }
    vec.push_back(note + 60);
  }

  std::cout << "==== markov_melody ====\n";
  for (auto itr : vec)
  {
    std::cout << itr - 60 << " ";
  }
  std::cout << std::endl;
  play_melody(vec);
}

int main(int argc, char const *argv[])
{
  const int kNUM_NOTES = 8; // number of notes to generate
  const int kNUM_TESTS = 4; // number of experiments

  for (int i = 0; i < kNUM_TESTS; ++i)
  {
    gen_random_melody(kNUM_NOTES);
    // std::cout << std::endl;

    gen_markov_melody(kNUM_NOTES);
    std::cout << std::endl;
  }
  return 0;
}

cmake_minimum_required(VERSION 2.8)
set(APPNAME "markovTest")
project(${APPNAME})
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall ")

# JE sets FOR_CLASS to 0
# YOU set FOR_CLASS to 1
set(FOR_CLASS 0)
if(${FOR_CLASS})
  set( HOME "/Volumes/cs312-00-w20/StuWork/<your_email_name>" )
elseif(NOT ${FOR_CLASS})
  set( HOME "/Users/je/cs312/_cs312")
endif(${FOR_CLASS})
set(COMMON "${HOME}/common")

set(SOURCE_FILES
  ${COMMON}/hw332_CMidiPacket.cpp
  ${COMMON}/hw411_rand_int.cpp
  ${COMMON}/hw421_CDelayMs.cpp
  ${COMMON}/hw422_CAppleMidiSynth.cpp
  c513_CMarkovBlues.cpp
  c513_main.cpp
)

include_directories(${COMMON})
add_executable(${APPNAME} ${SOURCE_FILES})

target_link_libraries(${PROJECT_NAME} PRIVATE "-framework AudioToolbox")
target_link_libraries(${PROJECT_NAME} PRIVATE "-framework CoreMIDI")
target_link_libraries(${PROJECT_NAME} PRIVATE  "-framework CoreAudio")

// This statement chooses the next note based on the previous one
// note = mb.chooseMarkovNote(note);

// This statement chooses all notes based on the starting note
// that was set as the first starting note of the random melody
note = mb.chooseMarkovNote(startNote);