4.2 Class
CS 312 Audio Programming Winter 2020

cd $HOME312/cs312/hw42
mkdir hw421_CDelayMs
cd hw421_CDelayMs
mkdir build
touch CMakeLists.txt
touch CDelayMs.h
touch CDelayMs.cpp
touch hw421_main.cpp

// hw421_CDelayMs.h
#ifndef HW421_CDELAY_MS_H_
#define HW421_CDELAY_MS_H_

#include <iostream>
#include <chrono>
#include <thread>

// idea from Stroustroup "A Tour of C++ 2nd Edition" page 200.

class CDelayMs
{
private:
  uint32_t delay_;
  bool print_;

  std::chrono::time_point<std::chrono::steady_clock> t0;
  std::chrono::time_point<std::chrono::steady_clock> t1;

  void milli_time();
  void delay();

public:
  static uint32_t s_tempo;

  CDelayMs(uint32_t ms, bool print = false);
  virtual ~CDelayMs();
};

#endif // HW421_CDELAY_MS_H_

// hw421_CDelayMs.cpp
#ifndef HW421_CDELAY_MS_H_
#include "hw421_CDelayMs.h"
#endif

uint32_t CDelayMs::s_tempo = 60;

void CDelayMs::milli_time()
{
  t1 = std::chrono::steady_clock::now();
  std::cout << "# ms:\t\t\t\t";
  std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t1 - t0).count() << '\n';
}

void CDelayMs::delay()
{
  uint32_t dly = delay_ * 60 / s_tempo;
  std::this_thread::sleep_for(std::chrono::milliseconds(dly));
}

CDelayMs::CDelayMs(uint32_t ms, bool print) : delay_{ms}, print_{print}
{
  t0 = std::chrono::steady_clock::now();
  delay();
}

CDelayMs::~CDelayMs()
{
  if (print_)
    milli_time();
}

// hw421_main.cpp
#ifndef HW421_CDELAY_MS_H_
#include "hw421_CDelayMs.h"
#endif

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

// DO NOT MODIFY THIS FILE

#include <vector>

using namespace CMP33;

std::vector<CMidiPacket> vplay;

void stuffMidiPackets()
{
  // we're going to play an octave of MIDI notes: one a second
  // every NOF and next NON come at intervals of 1000ms
  uint32_t tm{0};
  uint32_t beat_length{0};

  for (int i = 0; i < 13; i++)
  {
    // Note Ons
    beat_length = 1000;
    if (i > 3 && i < 8)
      beat_length = 500;
    else if (i > 10)
      beat_length = 2000;

    CMidiPacket mp(tm, 0x90, 60 + i, 127);
    vplay.push_back(mp);

    // Note Offs
    tm += beat_length;
    mp.set_timestamp(tm); // 0 NOF 1000 NOF 2000 NOF etc
    mp.set_data2(0);
    vplay.push_back(mp);
  }
}

// Instead of playing sound which you'll do later in hw42
// here we're just sending packets to std::cout using timestamp delays
void send(const CMidiPacket &mp)
{
  // a static variable maintains its value between function calls
  // it's needed for calculating the difference between timestamp [n] and [n-1]
  static uint32_t prevTm{0};

  // calculate delay
  uint32_t ms_delay = mp.get_timestamp() - prevTm;
  prevTm = mp.get_timestamp(); // reset prevTm for next fn call

  // create timer delay and send the packet
  CDelayMs timer(ms_delay, true); // true = print time in ms
  std::cout << mp;
}

int main(int argc, char *argv[])
{
  stuffMidiPackets();
  for (auto itr : vplay)
    send(itr);
}

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

set(SOURCE_FILES
  c421_playSoftMidi.cpp
)

add_executable(${APPNAME} ${SOURCE_FILES})

# add framework libraries to your project.
target_link_libraries(${PROJECT_NAME} PRIVATE "-framework CoreServices")
target_link_libraries(${PROJECT_NAME} PRIVATE  "-framework AudioUnit")
target_link_libraries(${PROJECT_NAME} PRIVATE  "-framework AudioToolbox")

[100%] Built target hw421_delayTest
0       90      60      127
# ms:                           0
1000    90      60      0
# ms:                           1000
1000    90      61      127
# ms:                           0
2000    90      61      0
# ms:                           1003
2000    90      62      127
# ms:                           0
3000    90      62      0
# ms:                           1005
3000    90      63      127
# ms:                           0
4000    90      63      0
# ms:                           1004
4000    90      64      127
# ms:                           0
4500    90      64      0
# ms:                           501
4500    90      65      127
# ms:                           0
5000    90      65      0
# ms:                           502
5000    90      66      127
# ms:                           0
5500    90      66      0
# ms:                           501
5500    90      67      127
# ms:                           0
6000    90      67      0
# ms:                           500
6000    90      68      127
# ms:                           0
7000    90      68      0
# ms:                           1003
7000    90      69      127
# ms:                           0
8000    90      69      0
# ms:                           1003
8000    90      70      127
# ms:                           0
9000    90      70      0
# ms:                           1001
9000    90      71      127
# ms:                           0
11000   90      71      0
# ms:                           2003
11000   90      72      127
# ms:                           0
13000   90      72      0
# ms:                           2001

cd $HOME312/cs312/hw42
mkdir hw422_CAppleMidiSynth
cd hw422_CAppleMidiSynth
mkdir build
touch CMakeLists.txt
touch hw422_CAppleMidiSynth.h
touch hw422_CAppleMidiSynth.cpp
touch hw422_main.cpp

// hw422_CAppleMidiSynth.h
#ifndef HW422_CAPPLE_MIDISYNTH_H_
#define HW422_CAPPLE_MIDISYNTH_H_

#include <CoreServices/CoreServices.h> //for file stuff
#include <AudioUnit/AudioUnit.h>
#include <AudioToolbox/AudioToolbox.h> //for AUGraph

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

#include <vector>

// DO NOT MODIFY

using namespace CMP33;

class CAppleMidiSynth
{
public:
  CAppleMidiSynth();
  virtual ~CAppleMidiSynth();
  CAppleMidiSynth(const CAppleMidiSynth &) = default;
  CAppleMidiSynth(CAppleMidiSynth &&) = default;
  CAppleMidiSynth &operator=(const CAppleMidiSynth &) = default;
  CAppleMidiSynth &operator=(CAppleMidiSynth &&) = default;

  // three overridden send methods
  void send(uint32_t waitTm, uint8_t st, uint8_t d1, uint8_t d2);
  void send(const CMidiPacket &mp);
  void send(const std::vector<CMidiPacket> &vmp);

private:
  AUGraph outGraph;
  AudioUnit outSynth;
};

#endif // HW531_CAPPLEMIDISYNTH_H_

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

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

// #include <AssertMacros.h>

CAppleMidiSynth::CAppleMidiSynth()
{
  // taken from c411_PlaySoftMIDI

  /*=============== From CreateAUGraph() =============== 
  Copy/paste everything from:

  OSStatus result;
  to
  // ok we're good to go - get the Synth Unit...
  __Require_noErr(result = AUGraphNodeInfo(outGraph, synthNode, 0, &outSynth), home);
  ======================================================*/

  /*=============== From main() =============== 
  // ok we're set up to go - initialize and start the outGraph
  __Require_noErr(result = AUGraphInitialize(outGraph), home);

    CAShow(outGraph); // prints out the outGraph so we can see what it looks like...

  __Require_noErr(result = AUGraphStart(outGraph), home);
  ======================================================*/

  /*================= JE modification ===================
home:
  if (result == noErr)
    std::cout << "CAppleMidiSynth() success\n";
  else
    std::cout << "Failed to construct CAppleMidiSynth()\n";
  ======================================================*/
}

CAppleMidiSynth::~CAppleMidiSynth()
{
  if (outGraph)
  {
    // Stop and Dispose AUGraph
  }
}

void CAppleMidiSynth::send(uint32_t waitTm, uint8_t st, uint8_t d1, uint8_t d2)
{
  // Called by the next two functions
  // waitTm is calculated by them
  CDelayMs d(waitTm, false);
  MusicDeviceMIDIEvent(outSynth, st, d1, d2, 0);
}

void CAppleMidiSynth::send(const CMidiPacket &mp)
{
  // You know now_time and previous_time
  // Difference is wait time
  // call CAppleMidiSynth::send(uint32_t waitTm, uint8_t st, uint8_t d1, uint8_t d2)
  // update previous_time
}

void CAppleMidiSynth::send(const std::vector<CMidiPacket> &vmp)
{
  // figure it out
}

// hw422_main.cpp
#ifndef HW422_CAPPLE_MIDISYNTH_H_
#include "hw422_CAppleMidiSynth.h"
#endif

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

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

#include <vector>

// Do not modify stuffPackets
void stuffPackets(std::vector<CMidiPacket> &v)
{
  // brute force
  CMidiPacket mp = {0, 0x90, 60, 100}; //C
  v.push_back(mp);                     //NON
  mp.set_timestamp(mp.get_timestamp() + 1000);
  mp.set_data2(0);
  v.push_back(mp); //NOF

  mp = {1000, 0x90, 62, 100}; //D
  v.push_back(mp);            //NON
  mp.set_timestamp(mp.get_timestamp() + 1000);
  mp.set_data2(0);
  v.push_back(mp); //NOF

  mp = {2000, 0x90, 64, 100}; //E
  v.push_back(mp);            //NON
  mp.set_timestamp(mp.get_timestamp() + 1000);
  mp.set_data2(0);
  v.push_back(mp); //NOF

  mp = {3000, 0x90, 65, 100}; //F
  v.push_back(mp);            //NON
  mp.set_timestamp(mp.get_timestamp() + 1000);
  mp.set_data2(0);
  v.push_back(mp); //NOF

  mp = {4000, 0x90, 67, 100}; //G
  v.push_back(mp);            //NON
  mp.set_timestamp(mp.get_timestamp() + 1000);
  mp.set_data2(0);
  v.push_back(mp); //NOF

  mp = {5000, 0x90, 69, 100}; //A
  v.push_back(mp);            //NON
  mp.set_timestamp(mp.get_timestamp() + 1000);
  mp.set_data2(0);
  v.push_back(mp); //NOF

  mp = {6000, 0x90, 71, 100}; //B
  v.push_back(mp);            //NON
  mp.set_timestamp(mp.get_timestamp() + 1000);
  mp.set_data2(0);
  v.push_back(mp); //NOF

  mp = {7000, 0x90, 72, 100}; //C
  v.push_back(mp);            //NON
  mp.set_timestamp(mp.get_timestamp() + 1000);
  mp.set_data2(0);
  v.push_back(mp); //NOF
}
// end Do not modify stuffPackets

int main(int argc, char const *argv[])
{
  // main expects exactly one parameter for tempo
  /*
     display usage message 
     "Usage:\n\thw422_cams <tempo>\n"
      exit not exactly one parameter

     set CDelayMs::s_tempo to argv[1]
     display error message if tempo range is outside 20-300
     exit if tempo is too low or too high
  */

  // stuff packets
  std::vector<CMidiPacket> vplay;
  stuffPackets(vplay);

  // play using CAppleMidiSynth
  CAppleMidiSynth ams;
  ams.send(vplay);

  return 0;
}

cmake_minimum_required(VERSION 2.8)
set(APPNAME "amsTest")
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}/hw421_CDelayMs.cpp
  hw422_CAppleMidiSynth.cpp
  hw422_main.cpp
)

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

target_link_libraries(${PROJECT_NAME} PRIVATE "-framework CoreServices")
target_link_libraries(${PROJECT_NAME} PRIVATE  "-framework AudioUnit")
target_link_libraries(${PROJECT_NAME} PRIVATE  "-framework AudioToolbox")

cmake .. && make && ./amsTest #ams AppleMIDISynth

Feel free to email /jellinge@carleton.edu/ on any part of the homework that is unclear to you. Chances are if you have questions other students do too. I will answer those questions by email to everyone in the class. The original sender will remain anonymous. I have tried to provide clues to the homework in the web pages, reading assignments, and labs. Sometimes what seems obvious to me is not obvious to students just learning C++.

Create a folder named */hwNN_LastnameFirstname1_LastnameFirstname2/*. \\
Substitute your name and your partner's name for LastnameFirstname1_LastnameFirstname2.

*Remember*
- Boilerplate header at top of every file.
- Make sure your program compiles before submitting. \\
- Programs that compile and produce partially correct output will be graded. \\
- You can send notes to me in your homework files by enclosing them in block comments.\\
- Programs that do not compile get an automatic F (59%).
- Each partner must submit identical homework folders to the course Hand-in folder. \\
- If only one partner submits the homework send me an email explaining why.
- Empty your /build/ or /build-debug/ folders using the command /emptyBuildFolder.sh/
- Only include .h, .cpp, Makefiles, CMakeLists.txt
- Do not include these folders/files \\
  .git \\
  .vscode \\
- Double check for the above two folders using this command \\
  #+begin_src sh
ls -a hwNN_LastnameFirstname1_LastnameFirstname2
# if either .git or .vscode exist in the folder you're submitting remove them with
# rm -fR .git
# rm -fR .vscode
  #+end_src

$HOME312/common
├── hw332_CMidiPacket.cpp
├── hw332_CMidiPacket.h
├── hw411_rand_int.cpp
├── hw411_rand_int.h
├── hw421_CDelayMs.cpp
├── hw421_CDelayMs.h
├── hw422_CAppleMidiSynth.cpp
├── hw422_CAppleMidiSynth.h
├── hw423_CMidiTrack.cpp
└── hw423_CMidiTrack.h

$HOME312/cs312/hw42
├── hw421_CDelayMs
│   ├── CMakeLists.txt
│   ├── build
│   ├── hw421_CDelayMs.cpp
│   ├── hw421_CDelayMs.h
│   └── hw421_main.cpp
├── hw422_CAppleMidiSynth
│   ├── CMakeLists.txt
│   ├── build
│   ├── hw422_CAppleMidiSynth.cpp
│   ├── hw422_CAppleMidiSynth.h
│   └── hw422_main.cpp
└── hw423_CScalesTrio
    ├── hw423_fave.txt
    ├── CMakeLists.txt
    ├── build
    ├── hw423_CAltoTrack.cpp
    ├── hw423_CAltoTrack.h
    ├── hw423_CBassTrack.cpp
    ├── hw423_CBassTrack.h
    ├── hw423_CScalesTrack.cpp
    ├── hw423_CScalesTrack.h
    ├── hw423_CSopranoTrack.cpp
    ├── hw423_CSopranoTrack.h
    └── hw423_main.cpp