CS 312 - Week 7 Class 2
CS 312 Audio Programming Winter 2020

cd $HOME312/cs312
mkdir hw72
mkdir  hw72/
cd hw72/hw721_gensin
mkdir build
touch CMakeLists.txt
touch hw721_gensin.cpp
code .

cmake_minimum_required(VERSION 3.5)

set(PROJECT_NAME hw721_gensin)
project(${PROJECT_NAME})

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall")

# CHANGE THE PATH TO YOUR COMMON FOLDER
set(COMMON "<your_full_pathname_to_course_common_folder>")
set(LIBSF "${COMMON}/libsndfile")
set(ULL "/usr/local/lib")

add_executable(
  ${PROJECT_NAME}
  ${LIBSF}/sndfile.hh
  ${PROJECT_NAME}.cpp
  )

target_include_directories(${PROJECT_NAME} PRIVATE ${COMMON} ${LIBSF})
target_link_libraries(${PROJECT_NAME} ${ULL}/libsndfile.1.dylib)

#include "sndfile.hh"
#include <iostream>
#include <vector>
#include <cmath> // for M_PI

// either_or
typedef float MY_TYPE;
#define LIB_SF_FORMAT SF_FORMAT_FLOAT; // SF_FORMAT_MY_TYPE defiend in  "sndfile.h"
// typedef double MY_TYPE;
// #define LIB_SF_FORMAT SF_FORMAT_DOUBLE; // SF_FORMAT_MY_TYPE defiend in  "sndfile.h"
// END either_or

const int FS = 44100;       // CD sample rate
const MY_TYPE T = 1.0 / FS; // sample period
const MY_TYPE k2PI = 2 * M_PI;
const MY_TYPE k2PIT = k2PI * T;

std::vector<MY_TYPE> gen_sin(MY_TYPE freq, MY_TYPE ampl, MY_TYPE secs)
{
  std::vector<MY_TYPE> v;
  std::cout << "You need to implement gen_sin(...)\n";
  /*----------------------------------------------------
    // FORMULA: samp(n) = A * sin( 2 * pi * freq * n * T);
    // calculute 2*pi*T outside of the for loop for efficiency
    // FORMULA: samp(n) = A * sin( k2PIT* freq * n);
  ----------------------------------------------------*/
  return v;
}

bool samples2wavfile(const char *fname, const std::vector<MY_TYPE> &v)
{
  // code borrowed and modified from libsndfile example sndfilehandle.cc
  // mostly from create_file(...) and format from main()
  SndfileHandle file;
  const int channels = 1;
  const int srate = FS;
  const int format = SF_FORMAT_WAV | LIB_SF_FORMAT;

  file = SndfileHandle(fname, SFM_WRITE, format, channels, srate);

  // using vector instead of buffer array
  // C++ vector elements are stored in contiguous memory, same as array
  // &v[0] is pointer to first element of vector
  file.write(&v[0], v.size());
  return true;
}

int main(int argc, char *argv[])
{
  // generate a 440 Hz, full 1.0 amplitude sine wave for one second
  std::vector<MY_TYPE> vsamps = gen_sin(440.0, 1.0, 1.0);
  samples2wavfile("hw721_a440sine_amp1.wav", vsamps);

  // generate a 440 Hz, half 0.5 amplitude sine wave for one second
  vsamps.clear();
  vsamps = gen_sin(440.0, 0.5, 1.0);
  samples2wavfile("hw721_a440sine_amp1half.wav", vsamps);

  return 0;
}

cd $HOME312/cs312/hw72/hw721_gensine/build
# build
cmake .. && make

# run and play
# cd build
./hw721_gensin

cd $HOME312/cs312/hw72
cp -R hw721_gensin/ hw722_gensin_phasor
cd hw722_gensin_phasor
mv hw721_gensin.cpp hw722_gensin_phasor.cpp
sed -i '' s/hw721_gensin/hw722_gensin_phasor/g CMakeLists.txt

#include "sndfile.hh"
#include <iostream>
#include <vector>
#include <cmath> // for M_PI

// either_or
typedef float MY_TYPE;
#define LIB_SF_FORMAT SF_FORMAT_FLOAT; // SF_FORMAT_MY_TYPE defiend in  "sndfile.h"
// typedef double MY_TYPE;
// #define LIB_SF_FORMAT SF_FORMAT_DOUBLE; // SF_FORMAT_MY_TYPE defiend in  "sndfile.h"
// END either_or

const int FS = 44100;       // CD sample rate
const MY_TYPE T = 1.0 / FS; // sample period
const MY_TYPE k2PI = M_PI * 2.0;
const MY_TYPE k2PIT = k2PI * T;

std::vector<MY_TYPE> gen_sin_phasor(MY_TYPE freq, MY_TYPE ampl, MY_TYPE secs)
{
  std::vector<MY_TYPE> v;
  std::cout << "You need to implement gen_sin_phasor(...)\n";
  /*----------------------------------------------------
  declare variable MY_TYPE phzNow
  declare variable MY_TYPE phzIncr
  set phzNow to zero
  calculate the phase increment in radians for freq
  BEGIN_LOOP from 0 to number of samples in secs paramater
  push ampl*sin(phzNow) to vector v
  increment phzNow
  check if phzNow greater than 2pi
  if so wrap around (phzNow = phzNow - 2pi)
  END_LOOP
  ----------------------------------------------------*/
  return v;
}

bool samples2wavfile(const char *fname, const std::vector<MY_TYPE> &v)
{
  // code borrowed and modified from libsndfile example sndfilehandle.cc
  // mostly from create_file(...) and format from main()
  SndfileHandle file;
  const int channels = 1;
  const int srate = FS;
  const int format = SF_FORMAT_WAV | LIB_SF_FORMAT;

  file = SndfileHandle(fname, SFM_WRITE, format, channels, srate);

  // using vector instead of buffer array
  // C++ vector elements are stored in contiguous memory, same as array
  // &v[0] is pointer to first element of vector
  file.write(&v[0], v.size());
  return true;
}

int main(int argc, char *argv[])
{
  std::vector<MY_TYPE> vsamps = gen_sin_phasor(440.0, 1.0, 1.5);
  samples2wavfile("hw722_a440sine_phasor.wav", vsamps);
  return 0;
}

cd $HOME312/cs312/hw72/hw722_gensine_phasor/build
# emptyBuildFolder.sh
# build
cmake .. && make

cd $HOME312/cs312/hw72
cp -R hw722_gensin_phasor/ hw724_gensin_ringmod
cd hw724_gensin_ringmod
mv hw722_gensin_phasor.cpp hw724_gensin_ringmod.cpp
sed -i '' s/hw722_gensin_phasor/hw724_gensin_ringmod/g CMakeLists.txt
sed -i '' s/hw723_gensin_beatDemo.wav/hw724_gensin_ringmod.wav/g hw724_gensin_ringmod.cpp
emptyBuildFolder.sh

int main(int argc, char *argv[])
{
/*----------------------------------------------
modulating sine wave at 400 Hz, ampl 1.0, duration 1.5 seconds
carrier sine wave at 700 Hz, ampl 1.0, duration 1.5 seconds
output wave file name: "hw724_gensin_ringmod.wav"
----------------------------------------------*/
  std::cout << "You need to implement ring modulation in main()\n";
  return 0;
}

cd ~/cs312/hw72/hw724_gensin_ringmod/build
# emptyBuildFolder.sh
cmake .. && make

cd $HOME312/cs312/hw72
cp -r hw724_gensin_ringmod hw725_gensin_ammod
cd hw725_gensin_ammod
mv hw724_gensin_ringmod.cpp hw725_gensin_ammod.cpp
sed -i '' s/hw724_gensin_ringmod/hw725_gensin_ammod/g CMakeLists.txt
sed -i '' s/hw724_gensin_ringmod.wav/hw725_gensin_ammod.wav/g hw725_gensin_ammod.cpp
emptyBuildFolder.sh

// Fc carrierFrequncy, Ac carrierAmplitude,
// Fm modulationFrequency, Am modulationAmplitude,
// M modulation Index, secs duration in seconds
std::vector<MY_TYPE> am_modulation(MY_TYPE Fc, MY_TYPE Ac,
                                   MY_TYPE Fm, MY_TYPE Am,
                                   MY_TYPE M, MY_TYPE secs)
{
  std::vector<MY_TYPE> v;
  const MY_TYPE kAM = k2PIT * Fm;
  const MY_TYPE kFC = k2PIT * Fc;

  /*----------------------------------------------------
   implement the FM formula on the class web page
   kAM = 2*pi*T*Fm is a constant that can be pre-calculated outside of the loop
   kFC = 2*pi*T*Fc is a constant that can be pre-calculated outside of the loop

  loop for samples 0 to total number of samples
       samp = (1 + M * sin(kAM * n)) * Ac * sin(kFC * n);
       vout.push_back(samp);
  end loop
  ----------------------------------------------------*/
  std::cout << "You need to implement std::vector<float> am_modulation(...)\n";
  return v;
}

int main(int argc, char *argv[])
{
  std::vector<MY_TYPE> vout;
  // params are
  // carrierFreq, carrierAmplitude, modulatorFreq, modulatorAmplitude, modulation Index, duration
  vout = am_modulation(400, 0.4, 97, 0.4, 1.25, 2.5);
  if (!samples2wavfile("hw725_m_test.wav", vout))
    std::cout << "Could not write am_test.wav";

  /*----------------------------------------------------
   These are the settings I used to generate the over and
   under modulated figures on the web page.
   Once you get it working try other settings.
  ----------------------------------------------------*/
  vout.clear();
  vout = am_modulation(700, 0.3, 7, 0.5, -0.5, 2.5);
  if (!samples2wavfile("hw725_am_undermod.wav", vout))
    std::cout << "Could not write am_undermod.wav";

  vout.clear();
  vout = am_modulation(700, 0.2, 7, 0.2, 3, 2.5);
  if (!samples2wavfile("hw725_am_overmod.wav", vout))
    std::cout << "Could not write am_overmod.wav";

  return 0;
}

cmake .. && make && ./hw725_gensin_ammod

cd $HOME312/cs312/hw72
cp -r hw725_gensin_ammod hw726_gensin_fmmod
cd hw726_gensin_fmmod
mv hw725_gensin_ammod.cpp hw726_gensin_fmmod.cpp
sed -i '' s/hw725_gensin_ammod/hw726_gensin_fmmod/g CMakeLists.txt
emptyBuildFolder.sh

#include "sndfile.hh"
#include <iostream>
#include <vector>
#include <cmath> // for M_PI

// either_or
typedef float MY_TYPE;
#define LIB_SF_FORMAT SF_FORMAT_FLOAT; // SF_FORMAT_MY_TYPE defiend in  "sndfile.h"
// typedef double MY_TYPE;
// #define LIB_SF_FORMAT SF_FORMAT_DOUBLE; // SF_FORMAT_MY_TYPE defiend in  "sndfile.h"
// END either_or

const int FS = 44100;     // CD sample rate
const MY_TYPE T = 1.0 / FS; // sample period
const MY_TYPE k2PI = M_PI * 2.0;
const MY_TYPE k2PIT = k2PI * T;

std::vector<MY_TYPE> gen_sin_phasor(MY_TYPE freq, MY_TYPE ampl, MY_TYPE secs)
{
  std::vector<MY_TYPE> v;
  MY_TYPE phzNow = 0;
  MY_TYPE phzIncr = k2PIT * freq;
  for (int n = 0; n < secs * FS; n++)
  {
    v.push_back(ampl * sin(phzNow));
    phzNow += phzIncr;
    // wrap around 2pi
    if (phzNow > k2PI)
      phzNow -= k2PI;
  }
  return v;
}

bool samples2wavfile(const char *fname, const std::vector<MY_TYPE> &v)
{
  // code borrowed and modified from libsndfile example sndfilehandle.cc
  // mostly from create_file(...) and format from main()
  SndfileHandle file;
  const int channels = 1;
  const int srate = FS;
  const int format = SF_FORMAT_WAV | LIB_SF_FORMAT;

  file = SndfileHandle(fname, SFM_WRITE, format, channels, srate);

  // using vector instead of buffer array
  // C++ vector elements are stored in contiguous memory, same as array
  // &v[0] is pointer to first element of vector
  file.write(&v[0], v.size());
  return true;
}

std::vector<MY_TYPE> fm_modulation(MY_TYPE A, MY_TYPE Fc, MY_TYPE Fm, MY_TYPE dFm, MY_TYPE secs)
{
// Function Parameters
// A:     amplitude
// Fc:    carrierFrequency
// Fm:    modulationFrequency
// secs:  duration in floating point seconds
// dFm:   deltaFm

// Variables/constants needed
// samp:  a single sample value
// n:     sample number as in samp[n]
// Fs:    sampling frequency 44100
// T:     sampling period 1/FS
// I:     modulationIndex

std::vector<MY_TYPE> vout;
  /*---------------------------------------------------
   implement the FM formula on the class web page
   carF = 2*pi*Fc*T is a constant that can be pre-calculated outside of the loop
   carM = 2*pi*Fm*T is a constant that can be pre-calculated outside of the loop

  loop for samples 0 to total number of samples
       samp = A * sin( carF * n + I* sin( carM * n ) );
       vout.push_back(samp);
  end loop
  ----------------------------------------------------*/
  std::cout << "You need to implement fm_modulation(...)\n";
  return vout;
}

void write_fm_file(const std::string &fname, const std::vector<MY_TYPE> &v)
{
  if (!samples2wavfile(fname.c_str(), v))
    std::cout << fname << std::endl;
}

int main(int argc, char *argv[])
{
  // DO NOT MODIFY
  /*--------------------------------------------------
      Chowning examples without Envelopes
      Parameters on class web page
      Chowning used A=1000 (amplitude) but did not indicate units
      Test with one example at a time until you get all to work
      Compare your results with mp3 files on web page.
    --------------------------------------------------*/
  MY_TYPE A = 1.0;
  std::vector<MY_TYPE> vout = fm_modulation(A, 100, 100, 400, 1.5);
  write_fm_file("Example1.wav", vout);

//  vout.clear();
//  vout = fm_modulation(A, 440, 440, 2200, 1.5);
//  write_fm_file("Example2.wav", vout);

//  vout = fm_modulation(A, 900, 300, 600, 1.5);
//  write_fm_file("Example3a.wav", vout);

//  vout = fm_modulation(A, 500, 100, 150, 1.5);
//  write_fm_file("Example3b.wav", vout);

//  vout.clear();
//  vout = fm_modulation(A, 900, 600, 2400, 1.5);
//  write_fm_file("Example3c.wav", vout);

//  vout.clear();
//  vout = fm_modulation(A, 200, 280, 2800, 6);
//  write_fm_file("Example4a.wav", vout);

//  vout.clear();
//  vout = fm_modulation(A, 200, 280, 560, 0.2);
//  write_fm_file("Example4b.wav", vout);

//  vout.clear();
//  vout = fm_modulation(A, 80, 55, 375, 2.0);
//  write_fm_file("Example4c.wav", vout);

  /*--------------------------------------------------
      JE examples
    --------------------------------------------------*/
//  vout.clear();
//  vout = fm_modulation(0.75, 549, 387, 300, 1.5);
//  write_fm_file("hw725_fm_bell.wav", vout);

//  vout.clear();
//  vout = fm_modulation(0.75, 440, 3.0, 3.0, 3.0);
//  write_fm_file("hw725_fm_vibrato.wav", vout);

//  vout.clear();
//  vout = fm_modulation(0.75, 440, 10, 10 * 20, 2.0);
//  write_fm_file("hw725_fm_raygun.wav", vout);


  /*--------------------------------------------------
     Create four of your own fm modulation examples below
    --------------------------------------------------*/

  return 0;
}

/*--------------------------------------------------
   Create four of your own fm modulation examples below
  --------------------------------------------------*/