cookbook/08-ctcsoundAPIExamples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ctcsound API Examples\n",
    "These examples are based on Steven Yi's Python \"How to use the Csound API\" files on https://github.com/csound/csoundAPI_examples\n",
    "\n",
    "All of the examples assume having the ctcsound module imported which is the module containing the Python interface to the Csound API.  This must be executed before the examples are run.\n",
    "\n",
    "This adaptation of Steven's examples as a notebook using ctcsound has been written by Mitch Kaufman."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ctcsound"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 1 - Simple Compilation with Csound\n",
    "This example is a barebones example for creating an instance of Csound, compiling a pre-existing CSD, calling \"perform\" to run Csound to completion, then reset.  The first thing we do is import the ctcsound module, which is the module containing the Python interface to the Csound API.\n",
    "\n",
    "All of the examples below must have the ctcsound module imported."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = ctcsound.Csound() \n",
    "ret = c.compileCsd(\"test1.csd\")\n",
    "if ret == ctcsound.CSOUND_SUCCESS:\n",
    "    c.start()\n",
    "    c.perform()\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 2 - Compilation with Csound without CSD\n",
    "In this example, we move from using an external CSD file to embedding our Csound ORC and SCO code within our Python project.  Besides allowing encapsulating the code within the same file, using the compileOrc() and compileSco() API calls is useful when the SCO or ORC are generated, or perhaps coming from another source, such as from a database or network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining our Csound ORC code within a multiline String\n",
    "orc = \"\"\"\n",
    "sr=44100\n",
    "ksmps=32\n",
    "nchnls=2\n",
    "0dbfs=1\n",
    "\n",
    "instr 1 \n",
    "aout vco2 0.5, 440\n",
    "outs aout, aout\n",
    "endin\"\"\"\n",
    "\n",
    "# Defining our Csound SCO code \n",
    "sco = \"i1 0 1\"\n",
    "\n",
    "#c = ctcsound.Csound()\n",
    "c.setOption(\"-odac\")  # Using SetOption() to configure Csound\n",
    "                      # Note: use only one commandline flag at a time\n",
    "\n",
    "c.compileOrc(orc)     # Compile the Csound Orchestra string\n",
    "c.readScore(sco)      # Compile the Csound SCO String\n",
    "c.start()  # When compiling from strings, this call is necessary before doing any performing\n",
    "c.perform()  # Run Csound to completion\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 3 - Using Our Own Performance Loop\n",
    "In this example, we use a while loop to perform Csound one audio block at a time.  This technique is important to know as it will allow us to do further processing safely at block boundaries.  We will explore the technique further in later examples.\n",
    "\n",
    "Note that c.performKsmps() and c.performBuffer() return False while the score is not finished. Here, a dot is displayed for each pass in the loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "..................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\n"
     ]
    }
   ],
   "source": [
    "orc = \"\"\"\n",
    "sr=44100\n",
    "ksmps=32\n",
    "nchnls=2\n",
    "0dbfs=1\n",
    "\n",
    "instr 1 \n",
    "aout vco2 0.5, 440\n",
    "outs aout, aout\n",
    "endin\"\"\"\n",
    "\n",
    "# Our Score for our project\n",
    "sco = \"i1 0 1\"\n",
    "\n",
    "\n",
    "#c = ctcsound.Csound()    # create an instance of Csound\n",
    "c.setOption(\"-odac\")  # Set option for Csound\n",
    "c.compileOrc(orc)     # Compile Orchestra from String\n",
    "c.readScore(sco)      # Read in Score from String\n",
    "c.start()             # When compiling from strings, this call is necessary before doing any performing\n",
    "\n",
    "# The following is our main performance loop. We will perform one block of sound at a time \n",
    "# and continue to do so while it returns 0, which signifies to keep processing.  We will\n",
    "# explore this loop technique in further examples.\n",
    "\n",
    "while not c.performKsmps():\n",
    "    print('.', end='')\n",
    "print()\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 4 - Using Csound's Performance Thread \n",
    "In this example, we use a CsoundPerformanceThread to run Csound in a native thread.  Using a native thread is important to get the best runtime performance for the audio engine.  It is especially important for languages such as Python that do not have true native threads and that use a Global Interpreter Lock. CsoundPerformanceThread has some convenient methods for handling events, but does not have features for doing regular processing at block boundaries.  In general, use CsoundPerformanceThread when the only kinds of communication you are doing with Csound are through events, and not using channels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Our Orchestra for our project\n",
    "orc = \"\"\"\n",
    "sr=44100\n",
    "ksmps=32\n",
    "nchnls=2\n",
    "0dbfs=1\n",
    "\n",
    "instr 1 \n",
    "aout vco2 0.5, 440\n",
    "outs aout, aout\n",
    "endin\"\"\"\n",
    "\n",
    "# Our Score for our project\n",
    "sco = \"i1 0 1\"\n",
    "\n",
    "#c = ctcsound.Csound() # create an instance of Csound\n",
    "c.setOption(\"-odac\")  # Set option for Csound\n",
    "c.compileOrc(orc)     # Compile Orchestra from String\n",
    "c.readScore(sco)      # Read in Score from String\n",
    "c.start()             # When compiling from strings, this call is necessary before doing any performing\n",
    "\n",
    "t = ctcsound.CsoundPerformanceThread(c.csound()) # Create a new CsoundPerformanceThread, passing in the Csound object\n",
    "t.play()              # starts the thread, which is now running separately from the main thread. This \n",
    "                      # call is asynchronous and will immediately return back here to continue code\n",
    "                      # execution.\n",
    "t.join()              # Join will wait for the other thread to complete. If we did not call join(),\n",
    "                      # after t.play() returns we would immediate move to the next line, c.stop(). \n",
    "                      # That would stop Csound without really giving it time to run. \n",
    "\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 5 - Generating Score\n",
    "In this example, we will look at three techniques for generating our Score. First we need to define our orchestra for the project."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "orc = \"\"\"\n",
    "sr=44100\n",
    "ksmps=32\n",
    "nchnls=2\n",
    "0dbfs=1\n",
    "\n",
    "instr 1 \n",
    "ipch = cps2pch(p5, 12)\n",
    "kenv linsegr 0, .05, 1, .05, .7, .4, 0\n",
    "aout vco2 p4 * kenv, ipch \n",
    "aout moogladder aout, 2000, 0.25\n",
    "outs aout, aout\n",
    "endin\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Static Score \n",
    "The first is one we have already seen, which is to just write out the score by hand as a String.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "sco = \"i1 0 1 0.5 8.00\"\n",
    "\n",
    "#c = ctcsound.Csound()    # create an instance of Csound\n",
    "c.setOption(\"-odac\")  # Set option for Csound\n",
    "c.compileOrc(orc)     # Compile Orchestra from String\n",
    "\n",
    "c.readScore(sco)      # Read in Score from pre-written String\n",
    "\n",
    "c.start()             # When compiling from strings, this call is necessary before doing any performing\n",
    "\n",
    "# The following is our main performanceu loop. We will perform one block of sound at a time \n",
    "# and continue to do so while it returns 0, which signifies to keep processing.  \n",
    "\n",
    "while (c.performKsmps() == 0):\n",
    "  pass\n",
    "\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating a Score String with a Loop\n",
    "Knowing that we pass strings into Csound to pass note events, we can also generate the string.  In the second example, sco2 starts as an empty string. Using a for-loop, we append to sco2 note strings using a string formatting string that has its replacement values replaced.  The replace values are calculated using the i value, and the result is an ascending note line. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i1 0 .25 0.5 8.00\n",
      "i1 0.25 .25 0.5 8.01\n",
      "i1 0.5 .25 0.5 8.02\n",
      "i1 0.75 .25 0.5 8.03\n",
      "i1 1 .25 0.5 8.04\n",
      "i1 1.25 .25 0.5 8.05\n",
      "i1 1.5 .25 0.5 8.06\n",
      "i1 1.75 .25 0.5 8.07\n",
      "i1 2 .25 0.5 8.08\n",
      "i1 2.25 .25 0.5 8.09\n",
      "i1 2.5 .25 0.5 8.10\n",
      "i1 2.75 .25 0.5 8.11\n",
      "i1 3 .25 0.5 8.12\n",
      "\n"
     ]
    }
   ],
   "source": [
    "sco2 = \"\"\n",
    "for i in range(13):\n",
    "    sco2 += \"i1 %g .25 0.5 8.%02g\\n\"%(i * .25,i)\n",
    "print(sco2)\n",
    "\n",
    "#c = ctcsound.Csound()    # create an instance of Csound\n",
    "c.setOption(\"-odac\")  # Set option for Csound\n",
    "c.compileOrc(orc)     # Compile Orchestra from String\n",
    "\n",
    "c.readScore(sco2)      # Read in Score from pre-written String\n",
    "\n",
    "c.start()             # When compiling from strings, this call is necessary before doing any performing\n",
    "\n",
    "# The following is our main performanceu loop. We will perform one block of sound at a time \n",
    "# and continue to do so while it returns 0, which signifies to keep processing.  \n",
    "\n",
    "while (c.performKsmps() == 0):\n",
    "  pass\n",
    "\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating a Score Using an Intermediate Data Structure\n",
    "In the final example, we are going to generate a list of lists.  This example generates a score using a random function and then converts to String.  The top-level list represents our score as a whole, and each sub-list within it represents the data for a single note.  The main list is then processed in two ways: first, it processes each sub-list and joins the values together into a single note string; second, it joins each individual note string into a single, large score string, separated by newlines.  The end result is a sequence of 13 notes with random pitches.\n",
    "\n",
    "The final example represents a common pattern of development.  For systems that employ some event-based model of music, it is common to use some kind of data structure to represent events.  This may use some kind of common data structure like a list, or it may be represented by using a class and instances of that class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is the list of lists that was converted into a list of strings:\n",
      "\n",
      "['i1 0.0 0.25 0.5 8.09', 'i1 0.25 0.25 0.5 8.00', 'i1 0.5 0.25 0.5 8.06', 'i1 0.75 0.25 0.5 8.01', 'i1 1.0 0.25 0.5 8.15', 'i1 1.25 0.25 0.5 8.02', 'i1 1.5 0.25 0.5 8.07', 'i1 1.75 0.25 0.5 8.00', 'i1 2.0 0.25 0.5 8.02', 'i1 2.25 0.25 0.5 8.10', 'i1 2.5 0.25 0.5 8.03', 'i1 2.75 0.25 0.5 8.08', 'i1 3.0 0.25 0.5 8.10']\n",
      "\n",
      "Here is the list of score events that was generated into a single string:\n",
      "\n",
      "i1 0.0 0.25 0.5 8.09\n",
      "i1 0.25 0.25 0.5 8.00\n",
      "i1 0.5 0.25 0.5 8.06\n",
      "i1 0.75 0.25 0.5 8.01\n",
      "i1 1.0 0.25 0.5 8.15\n",
      "i1 1.25 0.25 0.5 8.02\n",
      "i1 1.5 0.25 0.5 8.07\n",
      "i1 1.75 0.25 0.5 8.00\n",
      "i1 2.0 0.25 0.5 8.02\n",
      "i1 2.25 0.25 0.5 8.10\n",
      "i1 2.5 0.25 0.5 8.03\n",
      "i1 2.75 0.25 0.5 8.08\n",
      "i1 3.0 0.25 0.5 8.10\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "vals = []           #initialize a list to hold lists of values \n",
    "for i in range(13): #populate that list\n",
    "    vals.append([1, i * .25, .25, 0.5, \"8.%02g\"%(randint(0,15))])\n",
    "\n",
    "# convert list of lists into a list of strings\n",
    "vals = [\"i\" + \" \".join(map(str,a)) for a in vals] \n",
    "\n",
    "# now convert that list of strings into a single string\n",
    "sco3 = \"\\n\".join(vals)\n",
    "\n",
    "print('Here is the list of lists that was converted into a list of strings:')\n",
    "print()\n",
    "print(vals) \n",
    "print()\n",
    "print('Here is the list of score events that was generated into a single string:')\n",
    "print()\n",
    "print(sco3)\n",
    "\n",
    "#c = ctcsound.Csound()    # create an instance of Csound\n",
    "c.setOption(\"-odac\")  # Set option for Csound\n",
    "c.compileOrc(orc)     # Compile Orchestra from String\n",
    "\n",
    "c.readScore(sco3)      # Read in Score from pre-written String\n",
    "\n",
    "c.start()             # When compiling from strings, this call is necessary before doing any performing\n",
    "\n",
    "# The following is our main performanceu loop. We will perform one block of sound at a time \n",
    "# and continue to do so while it returns 0, which signifies to keep processing.  \n",
    "\n",
    "while (c.performKsmps() == 0):\n",
    "  pass\n",
    "\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 6 - Further Example of Generating Score\n",
    "This example continues on from Example 5, rewriting the example using a Class called Note. The note example has its __str__ method implemented to generate a well-formatted Csound SCO note.  This example also shows how a list of notes could be used multiple times.The first loop through we use the notes as-is, and during the second time we generate the notes again with the same properties except we alter the fifth p-field up 4 semitones. \n",
    "\n",
    "Note: Altering a Notes values like this is alright for this example, but it is a destructive edit.  Real world code might make copies of Notes or alter the score generation to maintain the original values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is the list of score events that was generated:\n",
      "\n",
      "i 1 0.0 0.25 0.5 8.09\n",
      "i 1 0.25 0.25 0.5 8.08\n",
      "i 1 0.5 0.25 0.5 8.09\n",
      "i 1 0.75 0.25 0.5 9.03\n",
      "i 1 1.0 0.25 0.5 9.02\n",
      "i 1 1.25 0.25 0.5 8.08\n",
      "i 1 1.5 0.25 0.5 9.03\n",
      "i 1 1.75 0.25 0.5 9.00\n",
      "i 1 2.0 0.25 0.5 8.10\n",
      "i 1 2.25 0.25 0.5 8.02\n",
      "i 1 2.5 0.25 0.5 8.10\n",
      "i 1 2.75 0.25 0.5 8.05\n",
      "i 1 3.0 0.25 0.5 8.02\n",
      "i 1 0.125 0.25 0.5 9.01\n",
      "i 1 0.375 0.25 0.5 9.00\n",
      "i 1 0.625 0.25 0.5 9.01\n",
      "i 1 0.875 0.25 0.5 9.07\n",
      "i 1 1.125 0.25 0.5 9.06\n",
      "i 1 1.375 0.25 0.5 9.00\n",
      "i 1 1.625 0.25 0.5 9.07\n",
      "i 1 1.875 0.25 0.5 9.04\n",
      "i 1 2.125 0.25 0.5 9.02\n",
      "i 1 2.375 0.25 0.5 8.06\n",
      "i 1 2.625 0.25 0.5 9.02\n",
      "i 1 2.875 0.25 0.5 8.09\n",
      "i 1 3.125 0.25 0.5 8.06\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "def midi2pch(num):\n",
    "    \"Convert MIDI Note Numbers to Csound PCH format\"\n",
    "    return \"%d.%02g\" % (3 + (num / 12), num % 12)\n",
    "\n",
    "class Note(object):\n",
    "    def __init__(self, *args):\n",
    "        self.pfields = list(args)\n",
    "\n",
    "    def __str__(self):\n",
    "        retVal = \"i\"\n",
    "        for i in range(len(self.pfields)):\n",
    "            if(i == 4):\n",
    "                retVal += \" \" + midi2pch(self.pfields[i])\n",
    "            else:\n",
    "                retVal += \" \" + str(self.pfields[i])\n",
    "        return retVal\n",
    "\n",
    "# Our Orchestra for our project\n",
    "orc = \"\"\"\n",
    "sr=44100\n",
    "ksmps=32\n",
    "nchnls=2\n",
    "0dbfs=1\n",
    "\n",
    "instr 1 \n",
    "ipch = cps2pch(p5, 12)\n",
    "kenv linsegr 0, .05, 1, .05, .7, .4, 0\n",
    "aout vco2 p4 * kenv, ipch \n",
    "aout moogladder aout, 2000, 0.25\n",
    "outs aout, aout\n",
    "endin\"\"\"\n",
    "\n",
    "#c = ctcsound.Csound()    # create an instance of Csound\n",
    "c.setOption(\"-odac\")  # Set option for Csound\n",
    "c.compileOrc(orc)     # Compile Orchestra from String\n",
    "\n",
    "\n",
    "notes = []           #initialize a list to hold lists of values \n",
    "for i in range(13): #populate that list\n",
    "    notes.append( Note(1, i * .25, .25, 0.5, randint(60,75)) )\n",
    "\n",
    "# now convert list of Note objects to string\n",
    "sco = \"\"\n",
    "for n in notes:\n",
    "    sco += \"%s\\n\"%n # this implicitly calls the __str__ method on the Note Class\n",
    "\n",
    "# generate notes again transposed a Major 3rd up\n",
    "for n in notes:\n",
    "    n.pfields[4] += 4\n",
    "    n.pfields[1] += .125\n",
    "    sco += \"%s\\n\"%n \n",
    "\n",
    "print('Here is the list of score events that was generated:')\n",
    "print()\n",
    "print(sco)\n",
    "\n",
    "c.readScore(sco)     # Read in Score generated from notes \n",
    "\n",
    "c.start()             # When compiling from strings, this call is necessary before doing any performing\n",
    "\n",
    "# The following is our main performance loop. We will perform one block of sound at a time \n",
    "# and continue to do so while it returns 0, which signifies to keep processing.  \n",
    "\n",
    "while (c.performKsmps() == 0):\n",
    "  pass\n",
    "\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 7 - Communicating Continuous Values with Csound's Channel System\n",
    "This example introduces using Csound's Channel System to communicate continuous control data (k-rate) from a host program to Csound. The first thing to note is the RandomLine class. It takes in a base value and a range in which to vary randomly.  The reset functions calculates a new random target value (self.end), a random duration in which to run (self.dur, expressed as # of audio blocks to last in duration), and calculates the increment value to apply to the current value per audio-block.  When the target is met, the Randomline will reset itself to a new target value and duration. \n",
    "\n",
    "In this example, we use two RandomLine objects, one for amplitude and another for frequency.  We start a Csound instrument instance that reads from two channels using the chnget opcode. In turn, we update the values to the channel from the host program.  In this case, because we want to keep our values generating in sync with the audio engine, we use a while-loop instead of a CsoundPerformanceThread. To update the channel, we call the SetChannel method on the Csound object, passing a channel name and value.  \n",
    "\n",
    "Note: The getValue method on the RandomLine not only gets us the current value, but also advances the internal state by the increment and by decrementing the duration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial amp value is: 0.6001901659225614\n",
      "Initial freq value is: 400.15407317046936\n"
     ]
    }
   ],
   "source": [
    "from random import randint, random\n",
    "\n",
    "class RandomLine(object):\n",
    "    def __init__(self, base, range):\n",
    "        self.curVal = 0.0\n",
    "        self.reset()\n",
    "        self.base = base\n",
    "        self.range = range\n",
    "\n",
    "    def reset(self):\n",
    "        self.dur = randint(256,512) \n",
    "        self.end = random() \n",
    "        self.increment = (self.end - self.curVal) / self.dur\n",
    "\n",
    "    def getValue(self):\n",
    "        self.dur -= 1\n",
    "        if(self.dur < 0):\n",
    "            self.reset()\n",
    "        retVal = self.curVal\n",
    "        self.curVal += self.increment\n",
    "        return self.base + (self.range * retVal)\n",
    "\n",
    "# Our Orchestra for our project\n",
    "orc = \"\"\"\n",
    "sr=44100\n",
    "ksmps=32\n",
    "nchnls=2\n",
    "0dbfs=1\n",
    "\n",
    "instr 1 \n",
    "kamp chnget \"amp\"\n",
    "kfreq chnget \"freq\"\n",
    "printk 0.5, kamp\n",
    "printk 0.5, kfreq\n",
    "aout vco2 kamp, kfreq\n",
    "aout moogladder aout, 2000, 0.25\n",
    "outs aout, aout\n",
    "endin\"\"\"\n",
    "\n",
    "#c = ctcsound.Csound()    # create an instance of Csound\n",
    "c.setOption(\"-odac\")  # Set option for Csound\n",
    "c.setOption(\"-m7\")  # Set option for Csound\n",
    "c.compileOrc(orc)     # Compile Orchestra from String\n",
    "\n",
    "sco = \"i1 0 60\\n\"\n",
    "\n",
    "c.readScore(sco)     # Read in Score generated from notes \n",
    "c.start()             # When compiling from strings, this call is necessary before doing any performing\n",
    "\n",
    "# The following is our main performance loop. We will perform one block of sound at a time \n",
    "# and continue to do so while it returns 0, which signifies to keep processing.  \n",
    "\n",
    "amp = RandomLine(.6, .2)    # create RandomLine for use with Amplitude\n",
    "freq = RandomLine(400, 80)  # create RandomLine for use with Frequency \n",
    "\n",
    "c.setControlChannel(\"amp\", amp.getValue())     # Initialize channel value before running Csound\n",
    "c.setControlChannel(\"freq\", freq.getValue())   # Initialize channel value before running Csound\n",
    "\n",
    "print('Initial amp value is: ' + str(amp.getValue()))\n",
    "print('Initial freq value is: ' + str(freq.getValue()))\n",
    "\n",
    "while (c.performKsmps() == 0):\n",
    "    c.setControlChannel(\"amp\", amp.getValue())   # update channel value \n",
    "    c.setControlChannel(\"freq\", freq.getValue()) # update channel value \n",
    "\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 8 - More Efficient Channel Communications\n",
    "This example builds on Example 7 by replacing the calls to SetChannel with using GetChannelPtr. In the Csound API, using SetChannel and GetChannel is great for quick work, but ultimately it is slower than pre-fetching the actual channel pointer.  This is because Set/GetChannel operates by doing a lookup of the Channel Pointer, then setting or getting the value.  This happens on each call. The alternative is to use channelPtr, which fetches the Channel Pointer and lets you directly set and get the value on the pointer.  When a pointer is returned by a function of the API, ctcsound encapsulates this pointer in an ndarray (numpy array). Once the pointer is connected to the array, values can be written directly into the array through the channel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial amp value is: 0.4002102470097178\n",
      "Initial freq value is: 400.19371569081983\n"
     ]
    }
   ],
   "source": [
    "from random import randint, random\n",
    "\n",
    "class RandomLine(object):\n",
    "    def __init__(self, base, range):\n",
    "        self.curVal = 0.0\n",
    "        self.reset()\n",
    "        self.base = base\n",
    "        self.range = range\n",
    "\n",
    "    def reset(self):\n",
    "        self.dur = randint(256,512) \n",
    "        self.end = random() \n",
    "        self.slope = (self.end - self.curVal) / self.dur\n",
    "\n",
    "    def getValue(self):\n",
    "        self.dur -= 1\n",
    "        if(self.dur < 0):\n",
    "            self.reset()\n",
    "        retVal = self.curVal\n",
    "        self.curVal += self.slope\n",
    "        return self.base + (self.range * retVal)\n",
    "\n",
    "# Our Orchestra for our project\n",
    "orc = \"\"\"\n",
    "sr=44100\n",
    "ksmps=32\n",
    "nchnls=2\n",
    "0dbfs=1\n",
    "\n",
    "instr 1 \n",
    "kamp chnget \"amp\"\n",
    "kfreq chnget \"freq\"\n",
    "printk 0.5, kamp\n",
    "printk 0.5, kfreq\n",
    "aout vco2 kamp, kfreq\n",
    "aout moogladder aout, 2000, 0.25\n",
    "outs aout, aout\n",
    "endin\"\"\"\n",
    "\n",
    "#c = ctcsound.Csound()    # create an instance of Csound\n",
    "c.setOption(\"-odac\")  # Set option for Csound\n",
    "c.setOption(\"-m7\")  # Set option for Csound\n",
    "c.compileOrc(orc)     # Compile Orchestra from String\n",
    "\n",
    "sco = \"i1 0 60\\n\"\n",
    "\n",
    "c.readScore(sco)     # Read in Score generated from notes \n",
    "\n",
    "c.start()             # When compiling from strings, this call is necessary before doing any performing\n",
    "\n",
    "# The following calls return a tuple. The first value of the tuple is a numpy array\n",
    "# encapsulating the Channel Pointer retrieved from Csound and the second\n",
    "# value is an error message, if an error happened (here it is discarded with _).\n",
    "ampChannel, _ = c.channelPtr(\"amp\",\n",
    "    ctcsound.CSOUND_CONTROL_CHANNEL | ctcsound.CSOUND_INPUT_CHANNEL)\n",
    "freqChannel, _ = c.channelPtr(\"freq\",\n",
    "    ctcsound.CSOUND_CONTROL_CHANNEL | ctcsound.CSOUND_INPUT_CHANNEL)\n",
    "\n",
    "amp = RandomLine(.4, .2)\n",
    "freq = RandomLine(400, 80)\n",
    "\n",
    "ampChannel[0] = amp.getValue()    # note we are now setting values in the ndarrays\n",
    "freqChannel[0] = freq.getValue()\n",
    "\n",
    "print('Initial amp value is: ' + str(amp.getValue()))\n",
    "print('Initial freq value is: ' + str(freq.getValue()))\n",
    "\n",
    "while (c.performKsmps() == 0):\n",
    "    ampChannel[0] = amp.getValue()\n",
    "    freqChannel[0] = freq.getValue()\n",
    "\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Example 9 - More Flexible and Efficient Channel Communications\n",
    "This example continues on from Example 9 and just refactors the creation and setup of numpy arrays into a createChannel() function.  This example illustrates some natural progression that might occur in your own API-based projects, and how you might simplify your own code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint, random\n",
    "\n",
    "class RandomLine(object):\n",
    "    def __init__(self, base, range):\n",
    "        self.curVal = 0.0\n",
    "        self.reset()\n",
    "        self.base = base\n",
    "        self.range = range\n",
    "\n",
    "    def reset(self):\n",
    "        self.dur = randint(256,512) \n",
    "        self.end = random() \n",
    "        self.slope = (self.end - self.curVal) / self.dur\n",
    "\n",
    "    def getValue(self):\n",
    "        self.dur -= 1\n",
    "        if(self.dur < 0):\n",
    "            self.reset()\n",
    "        retVal = self.curVal\n",
    "        self.curVal += self.slope\n",
    "        return self.base + (self.range * retVal)\n",
    "\n",
    "# The following call return a tuple. The first value of the tuple is a numpy array\n",
    "# encapsulating the Channel Pointer retrieved from Csound and the second\n",
    "# value is an error message, if an error happened (here it is discarded with _).\n",
    "def createChannel(channelName):\n",
    "    chn, _ = c.channelPtr(channelName,\n",
    "    ctcsound.CSOUND_CONTROL_CHANNEL | ctcsound.CSOUND_INPUT_CHANNEL)\n",
    "    return chn\n",
    "\n",
    "###############################\n",
    "\n",
    "# Our Orchestra for our project\n",
    "orc = \"\"\"\n",
    "sr=44100\n",
    "ksmps=32\n",
    "nchnls=2\n",
    "0dbfs=1\n",
    "\n",
    "instr 1 \n",
    "kamp chnget \"amp\"\n",
    "kfreq chnget \"freq\"\n",
    "printk 0.5, kamp\n",
    "printk 0.5, kfreq\n",
    "aout vco2 kamp, kfreq\n",
    "aout moogladder aout, 2000, 0.25\n",
    "outs aout, aout\n",
    "endin\"\"\"\n",
    "\n",
    "#c = ctcsound.Csound()    # create an instance of Csound\n",
    "c.setOption(\"-odac\")  # Set option for Csound\n",
    "c.setOption(\"-m7\")  # Set option for Csound\n",
    "c.compileOrc(orc)     # Compile Orchestra from String\n",
    "\n",
    "sco = \"i1 0 60\\n\"\n",
    "\n",
    "c.readScore(sco)     # Read in Score generated from notes \n",
    "\n",
    "c.start()             # When compiling from strings, this call is necessary before doing any performing\n",
    "\n",
    "ampChannel = createChannel(\"amp\")   # uses utility method to create a channel and get numpy array to write to\n",
    "freqChannel = createChannel(\"freq\")\n",
    "\n",
    "amp = RandomLine(.4, .2)\n",
    "freq = RandomLine(400, 80)\n",
    "\n",
    "ampChannel[0] = amp.getValue()\n",
    "freqChannel[0] = freq.getValue()\n",
    "\n",
    "while (c.performKsmps() == 0):\n",
    "    ampChannel[0] = amp.getValue()\n",
    "    freqChannel[0] = freq.getValue()\n",
    "\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Example 10 - Even More Flexible and Efficient Channel Communications\n",
    "This example continues on from Example 10 and introduces a ChannelUpdater object. The ChannelUpdater will create and store a numpy array that is wrapping a Csound Channel.  Additionally, it will store and call an object that has a  getValue() method to update values in the channel when update() is called. \n",
    "\n",
    "This example continues the illustration of a progression of a project.  Note that the process has changed a little bit where we now create a number of ChannelUpdater objects and store them in a list.  The list is then iterated through for updating the channel with the latest values.  In a real-world project, this kind of scenario occurs when there are n-number of items to update channels and one wants to have a flexible number that may even change dynamically at runtime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint, random\n",
    "\n",
    "class RandomLine(object):\n",
    "    def __init__(self, base, range):\n",
    "        self.curVal = 0.0\n",
    "        self.reset()\n",
    "        self.base = base\n",
    "        self.range = range\n",
    "\n",
    "    def reset(self):\n",
    "        self.dur = randint(256,512) \n",
    "        self.end = random() \n",
    "        self.slope = (self.end - self.curVal) / self.dur\n",
    "\n",
    "    def getValue(self):\n",
    "        self.dur -= 1\n",
    "        if(self.dur < 0):\n",
    "            self.reset()\n",
    "        retVal = self.curVal\n",
    "        self.curVal += self.slope\n",
    "        return self.base + (self.range * retVal)\n",
    "\n",
    "\n",
    "def createChannel(channelName):\n",
    "    chn, _ = c.channelPtr(channelName,\n",
    "    ctcsound.CSOUND_CONTROL_CHANNEL | ctcsound.CSOUND_INPUT_CHANNEL)\n",
    "    return chn\n",
    "\n",
    "class ChannelUpdater(object):\n",
    "    def __init__(self, channelName, updater):\n",
    "        self.updater = updater\n",
    "        self.channel = createChannel(channelName)\n",
    "\n",
    "    def update(self):\n",
    "        self.channel[0] = self.updater.getValue()\n",
    "\n",
    "###############################\n",
    "\n",
    "# Our Orchestra for our project\n",
    "orc = \"\"\"\n",
    "sr=44100\n",
    "ksmps=32\n",
    "nchnls=2\n",
    "0dbfs=1\n",
    "\n",
    "instr 1 \n",
    "kamp chnget \"amp\"\n",
    "kfreq chnget \"freq\"\n",
    "kres chnget \"resonance\"\n",
    "printk 0.5, kamp\n",
    "printk 0.5, kfreq\n",
    "printk 0.5, kres\n",
    "aout vco2 kamp, kfreq\n",
    "aout moogladder aout, 2000, kres\n",
    "outs aout, aout\n",
    "endin\"\"\"\n",
    "\n",
    "#c = ctcsound.Csound()    # create an instance of Csound\n",
    "c.setOption(\"-odac\")  # Set option for Csound\n",
    "c.setOption(\"-m7\")  # Set option for Csound\n",
    "c.compileOrc(orc)     # Compile Orchestra from String\n",
    "\n",
    "sco = \"i1 0 60\\n\"\n",
    "\n",
    "c.readScore(sco)     # Read in Score generated from notes \n",
    "\n",
    "c.start()             # When compiling from strings, this call is necessary before doing any performing\n",
    "\n",
    "# Create a set of ChannelUpdaters\n",
    "channels = [ChannelUpdater(\"amp\", RandomLine(.4, .2)),\n",
    "            ChannelUpdater(\"freq\", RandomLine(400, 80)),\n",
    "            ChannelUpdater(\"resonance\", RandomLine(0.4, .3))]\n",
    "\n",
    "# Initialize all Channel Values\n",
    "for chn in channels:\n",
    "    chn.update()\n",
    "\n",
    "while (c.performKsmps() == 0):\n",
    "    for chn in channels:   # update all channel values\n",
    "        chn.update()\n",
    "\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 11 - Graphical User Interfaces\n",
    "This example demonstrates a minimal Graphical User Interface application. The setup of Csound and starting of the CsoundPerformanceThread is done in the global scripting space.  Afterwards, a Tkinter GUI is created that has one button.  The button's callback (the command action) routes to a function that just sends an event to Csound.\n",
    "\n",
    "For this example, since there is no need to synchronize continous channel data changes with Csound, it is more efficient to use the CsoundPerformanceThread, as it is a native thread.  We use the CsoundPerformanceThread's inputMessage() function to ensure that the message is processed in a thread-safe manner. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "from random import randint, random\n",
    "\n",
    "###############################\n",
    "# Our Orchestra for our project\n",
    "\n",
    "orc = \"\"\"\n",
    "sr=44100\n",
    "ksmps=32\n",
    "nchnls=2\n",
    "0dbfs=1\n",
    "\n",
    "instr 1 \n",
    "kenv linsegr 0, .05, 1, .05, .9, .8, 0\n",
    "aout vco2 p4 * kenv, p5\n",
    "aout moogladder aout, 2000, p6\n",
    "outs aout, aout\n",
    "endin\"\"\"\n",
    "\n",
    "#c = ctcsound.Csound()    # create an instance of Csound\n",
    "c.setOption(\"-odac\")  # Set option for Csound\n",
    "c.setOption(\"-m7\")  # Set option for Csound\n",
    "c.compileOrc(orc)     # Compile Orchestra from String\n",
    "\n",
    "c.start()             # When compiling from strings, this call is necessary before doing any performing\n",
    "\n",
    "perfThread = ctcsound.CsoundPerformanceThread(c.csound())\n",
    "perfThread.play()\n",
    "\n",
    "class Application(Frame):\n",
    "\n",
    "    def __init__(self,master=None):\n",
    "        master.title(\"Csound API GUI Example\")\n",
    "        self.items = []\n",
    "        self.notes = []\n",
    "        Frame.__init__(self,master)\n",
    "        self.pack()\n",
    "        self.createUI()\n",
    "        self.master.protocol(\"WM_DELETE_WINDOW\", self.quit)\n",
    "\n",
    "    def createUI(self):\n",
    "        self.size = 600\n",
    "        self.canvas = Canvas(self,height=self.size,width=self.size,bg=\"darkgray\")\n",
    "        self.canvas.pack()\n",
    "        # create button and setup the playNote() callback\n",
    "        self.button = Button(self.canvas, text='Play Note', command=self.playNote)    \n",
    "        self.button.pack()\n",
    "\n",
    "    def playNote(self):\n",
    "        perfThread.inputMessage(\"i1 0 2 .5 400 .25\")\n",
    "\n",
    "    def quit(self):\n",
    "        self.master.destroy()\n",
    "        perfThread.stop()\n",
    "        perfThread.join()\n",
    "\n",
    "\n",
    "app = Application(Tk())\n",
    "app.mainloop()\n",
    "c.reset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example 12 - Graphical User Interfaces\n",
    "This example demonstrates a slightly more advanced GUI example. It uses a slider to allow setting the value of the frequency that the notes initiated by the button will play at.  \n",
    "\n",
    "Note: the actual use of update() here is not thread-safe.  In real-world usage, we would need to drive Csound from a loop calling PerformKsmps to ensure thread-safety.  For this example, the updating generally works as there are few things demanding computation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "95\n",
      "103\n",
      "118\n",
      "126\n",
      "141\n",
      "149\n",
      "164\n",
      "172\n",
      "179\n",
      "187\n",
      "195\n",
      "202\n",
      "210\n",
      "218\n",
      "225\n",
      "233\n",
      "241\n",
      "248\n",
      "256\n",
      "264\n",
      "271\n",
      "279\n",
      "286\n",
      "294\n",
      "302\n",
      "309\n",
      "317\n",
      "325\n",
      "332\n",
      "340\n",
      "348\n",
      "355\n",
      "363\n",
      "378\n",
      "386\n",
      "401\n",
      "416\n",
      "424\n",
      "432\n",
      "439\n",
      "455\n",
      "462\n",
      "470\n",
      "462\n",
      "455\n",
      "447\n",
      "439\n",
      "424\n",
      "416\n",
      "401\n",
      "394\n",
      "378\n",
      "371\n",
      "348\n",
      "332\n",
      "317\n",
      "294\n",
      "279\n",
      "271\n",
      "256\n",
      "248\n",
      "233\n",
      "225\n",
      "218\n",
      "210\n",
      "202\n",
      "195\n",
      "210\n",
      "218\n",
      "225\n",
      "241\n",
      "248\n",
      "256\n",
      "264\n",
      "271\n",
      "279\n",
      "294\n",
      "302\n",
      "317\n",
      "332\n",
      "355\n",
      "363\n",
      "378\n",
      "386\n",
      "394\n",
      "401\n",
      "409\n",
      "424\n",
      "432\n",
      "439\n",
      "447\n",
      "462\n",
      "470\n",
      "478\n",
      "485\n",
      "493\n",
      "485\n",
      "478\n",
      "470\n",
      "462\n",
      "447\n",
      "432\n",
      "424\n",
      "409\n",
      "401\n",
      "386\n",
      "371\n",
      "363\n",
      "348\n",
      "340\n",
      "332\n",
      "317\n",
      "302\n",
      "286\n",
      "279\n",
      "271\n",
      "264\n",
      "256\n",
      "248\n",
      "241\n",
      "233\n",
      "225\n",
      "218\n",
      "210\n",
      "202\n",
      "195\n",
      "202\n",
      "210\n",
      "195\n",
      "187\n",
      "179\n",
      "164\n",
      "156\n",
      "149\n",
      "141\n",
      "134\n",
      "126\n",
      "118\n",
      "111\n",
      "103\n",
      "95\n",
      "88\n",
      "80\n",
      "88\n",
      "95\n",
      "103\n",
      "111\n",
      "118\n",
      "126\n",
      "134\n",
      "141\n",
      "149\n",
      "156\n",
      "164\n",
      "172\n",
      "179\n",
      "187\n",
      "195\n",
      "202\n",
      "210\n",
      "218\n",
      "225\n",
      "233\n",
      "241\n",
      "248\n",
      "256\n",
      "264\n",
      "271\n",
      "279\n",
      "286\n",
      "294\n",
      "302\n",
      "309\n",
      "317\n",
      "325\n",
      "332\n",
      "340\n",
      "348\n",
      "355\n",
      "363\n",
      "371\n",
      "378\n",
      "386\n",
      "394\n",
      "401\n",
      "409\n",
      "416\n",
      "424\n",
      "432\n",
      "439\n",
      "447\n",
      "455\n",
      "462\n",
      "470\n",
      "478\n",
      "485\n",
      "493\n",
      "501\n",
      "508\n",
      "516\n",
      "524\n",
      "531\n",
      "539\n",
      "546\n",
      "554\n",
      "562\n",
      "569\n",
      "577\n",
      "585\n",
      "592\n",
      "600\n",
      "592\n",
      "585\n",
      "569\n",
      "562\n",
      "554\n",
      "546\n",
      "539\n",
      "524\n",
      "516\n",
      "501\n",
      "493\n",
      "485\n",
      "478\n",
      "470\n",
      "462\n",
      "447\n",
      "439\n",
      "424\n",
      "416\n",
      "409\n",
      "401\n",
      "394\n",
      "386\n",
      "378\n",
      "371\n",
      "363\n",
      "355\n",
      "363\n",
      "371\n",
      "378\n",
      "386\n",
      "394\n",
      "401\n",
      "409\n",
      "416\n",
      "424\n",
      "432\n",
      "439\n",
      "447\n",
      "455\n",
      "462\n",
      "470\n",
      "478\n",
      "470\n",
      "462\n",
      "455\n",
      "439\n",
      "432\n",
      "416\n",
      "409\n",
      "401\n",
      "394\n",
      "386\n",
      "378\n",
      "371\n",
      "363\n",
      "355\n",
      "348\n",
      "340\n",
      "332\n",
      "340\n",
      "332\n",
      "325\n",
      "317\n",
      "309\n",
      "302\n",
      "294\n",
      "286\n",
      "279\n",
      "271\n",
      "264\n",
      "256\n",
      "248\n",
      "241\n",
      "233\n",
      "225\n",
      "233\n",
      "241\n",
      "248\n",
      "256\n",
      "264\n",
      "279\n",
      "294\n",
      "302\n",
      "309\n",
      "317\n",
      "325\n",
      "317\n",
      "309\n",
      "302\n",
      "286\n",
      "271\n",
      "256\n",
      "248\n",
      "241\n",
      "233\n",
      "218\n",
      "202\n",
      "195\n",
      "187\n",
      "179\n",
      "172\n",
      "164\n",
      "156\n",
      "164\n",
      "172\n",
      "179\n",
      "187\n",
      "195\n",
      "202\n",
      "210\n",
      "218\n",
      "225\n",
      "233\n",
      "241\n",
      "233\n",
      "225\n",
      "210\n",
      "202\n",
      "179\n",
      "172\n",
      "156\n",
      "141\n",
      "134\n",
      "118\n",
      "111\n",
      "95\n",
      "88\n",
      "80\n",
      "88\n",
      "95\n",
      "111\n",
      "126\n",
      "134\n",
      "141\n",
      "156\n",
      "179\n",
      "187\n",
      "202\n",
      "210\n",
      "218\n",
      "225\n",
      "233\n",
      "218\n",
      "210\n",
      "202\n",
      "210\n",
      "202\n",
      "195\n",
      "187\n",
      "179\n",
      "187\n",
      "195\n",
      "202\n",
      "210\n",
      "218\n",
      "225\n",
      "241\n",
      "248\n",
      "256\n",
      "264\n",
      "271\n",
      "286\n",
      "294\n",
      "286\n",
      "294\n",
      "302\n",
      "309\n",
      "302\n",
      "294\n",
      "286\n",
      "271\n",
      "264\n",
      "256\n",
      "248\n",
      "241\n",
      "233\n",
      "225\n"
     ]
    }
   ],
   "source": [
    "from tkinter import *\n",
    "from random import randint, random\n",
    "\n",
    "###############################\n",
    "\n",
    "# Our Orchestra for our project\n",
    "orc = \"\"\"\n",
    "sr=44100\n",
    "ksmps=32\n",
    "nchnls=2\n",
    "0dbfs=1\n",
    "\n",
    "gkpch chnexport \"freq\", 1\n",
    "\n",
    "instr 1 \n",
    "kpch port gkpch, 0.01, i(gkpch)\n",
    "printk .5, gkpch\n",
    "kenv linsegr 0, .05, 1, .05, .9, .8, 0\n",
    "aout vco2 p4 * kenv, kpch\n",
    "aout moogladder aout, 2000, .25 \n",
    "outs aout, aout\n",
    "endin\"\"\"\n",
    "\n",
    "#c = ctcsound.Csound()    # create an instance of Csound\n",
    "c.setOption(\"-odac\")  # Set option for Csound\n",
    "c.setOption(\"-m7\")  # Set option for Csound\n",
    "c.compileOrc(orc)     # Compile Orchestra from String\n",
    "\n",
    "c.start()             # When compiling from strings, this call is necessary before doing any performing\n",
    "\n",
    "perfThread = ctcsound.CsoundPerformanceThread(c.csound())\n",
    "perfThread.play()\n",
    "\n",
    "\n",
    "def createChannel(channelName):\n",
    "    chn, _ = c.channelPtr(channelName,\n",
    "    ctcsound.CSOUND_CONTROL_CHANNEL | ctcsound.CSOUND_INPUT_CHANNEL)\n",
    "    return chn\n",
    "\n",
    "class SliderWrapper(object):\n",
    "    def __init__(self, csound, channelName, slider):\n",
    "        self.slider = slider\n",
    "        self.channel = createChannel(channelName)\n",
    "\n",
    "    def update(self):\n",
    "        self.channel[0] = self.slider.get()\n",
    "\n",
    "class Application(Frame):\n",
    "\n",
    "    def __init__(self,master=None):\n",
    "        master.title(\"Csound API GUI Example\")\n",
    "        self.items = []\n",
    "        self.notes = []\n",
    "        Frame.__init__(self,master)\n",
    "        self.pack()\n",
    "        self.createUI()\n",
    "        self.master.protocol(\"WM_DELETE_WINDOW\", self.quit)\n",
    "\n",
    "    def createUI(self):\n",
    "        self.size = 600\n",
    "        self.canvas = Canvas(self,height=self.size,width=self.size)\n",
    "        self.canvas.pack()\n",
    "        self.button = Button(self.canvas, text='Play Note', command=self.playNote)    \n",
    "        self.button.pack()\n",
    "        self.freqSlider = Scale(self.canvas,from_=80.0, to=600.0,command=self.setFreq,label=\"Freq\")\n",
    "        self.freqSlider.pack()\n",
    "        self.freqUpdater = SliderWrapper(c, \"freq\", self.freqSlider)\n",
    "\n",
    "    def playNote(self):\n",
    "        perfThread.inputMessage(\"i1 0 2 .3\")\n",
    "\n",
    "    def setFreq(self, val):\n",
    "        print(val)\n",
    "        self.freqUpdater.update()\n",
    "\n",
    "    def quit(self):\n",
    "        self.master.destroy()\n",
    "        perfThread.stop()\n",
    "        perfThread.join()\n",
    "\n",
    "\n",
    "app = Application(Tk())\n",
    "app.mainloop()\n",
    "c.stop\n",
    "del c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Author: Steven Yi, October 2013, Mitch Kaufman, May 2016"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}