ISN-Python3-Son.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python 3 : Le BN pour le traitement du son"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le son au format audio WAV\n",
    "L'écriture et la lecture du contenu d'un fichier audio au format WAV est simplifiée par l'utilisation du module wave.\n",
    "\n",
    "### Ecriture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Création d'un fichier audio au format WAV (PCM 8 bits stéréo 44100 Hz)\n",
      "Son de forme sinusoïdale sur chaque canal\n",
      "\n",
      "Fréquence du son du canal de gauche (Hz) ? 440\n",
      "Fréquence du son du canal de droite (Hz) ? 880\n",
      "Niveau du son du canal de gauche (0 à 1) ? 0.5\n",
      "Niveau du son du canal de droite (0 à 1) ? 0.5\n",
      "Durée (en secondes) ? 5\n",
      "Nombre d'échantillons : 220500\n",
      "Veuillez patienter...\n",
      "\n",
      "Taille du fichier son.wav : 441044 octets\n",
      "Lecture du contenu de l'en-tête (44 octets) :\n",
      "b'52494646ccba060057415645666d7420100000000100020044ac0000885801000200080064617461a8ba0600'\n",
      "Nombre d'octets de données : 441000\n"
     ]
    }
   ],
   "source": [
    "# script audio.py\n",
    "# (C) Fabrice Sincère ; Jean-Claude Meilland\n",
    "import wave\n",
    "import math\n",
    "import binascii\n",
    "\n",
    "print(\"Création d'un fichier audio au format WAV (PCM 8 bits stéréo 44100 Hz)\")\n",
    "print(\"Son de forme sinusoïdale sur chaque canal\\n\")\n",
    "\n",
    "NomFichier = 'son.wav'\n",
    "Monson = wave.open(NomFichier,'w') # instanciation de l'objet Monson\n",
    "\n",
    "nbCanal = 2    # stéreo\n",
    "nbOctet = 1    # taille d'un échantillon : 1 octet = 8 bits\n",
    "fech = 44100   # fréquence d'échantillonnage\n",
    "\n",
    "frequenceG = float(input('Fréquence du son du canal de gauche (Hz) ? '))\n",
    "frequenceD = float(input('Fréquence du son du canal de droite (Hz) ? '))\n",
    "niveauG = float(input('Niveau du son du canal de gauche (0 à 1) ? '))\n",
    "niveauD = float(input('Niveau du son du canal de droite (0 à 1) ? '))\n",
    "duree = float(input('Durée (en secondes) ? '))\n",
    "\n",
    "nbEchantillon = int(duree*fech)\n",
    "print(\"Nombre d'échantillons :\",nbEchantillon)\n",
    "\n",
    "parametres = (nbCanal,nbOctet,fech,nbEchantillon,'NONE','not compressed')# tuple\n",
    "Monson.setparams(parametres)    # création de l'en-tête (44 octets)\n",
    "\n",
    "# niveau max dans l'onde positive : +1 -> 255 (0xFF)\n",
    "# niveau max dans l'onde négative : -1 ->   0 (0x00)\n",
    "# niveau sonore nul :                0 -> 127.5 (0x80 en valeur arrondi)\n",
    "\n",
    "amplitudeG = 127.5*niveauG\n",
    "amplitudeD = 127.5*niveauD\n",
    "\n",
    "print('Veuillez patienter...')\n",
    "for i in range(0,nbEchantillon):\n",
    "    # canal gauche\n",
    "    # 127.5 + 0.5 pour arrondir à l'entier le plus proche\n",
    "    valG = wave.struct.pack('B',int(128.0 + amplitudeG*math.sin(2.0*math.pi*frequenceG*i/fech)))\n",
    "    # canal droit\n",
    "    valD = wave.struct.pack('B',int(128.0 + amplitudeD*math.sin(2.0*math.pi*frequenceD*i/fech)))\n",
    "    Monson.writeframes(valG + valD) # écriture frame\n",
    "\n",
    "Monson.close()\n",
    "\n",
    "Fichier = open(NomFichier,'rb')\n",
    "data = Fichier.read()\n",
    "tailleFichier = len(data)\n",
    "print('\\nTaille du fichier',NomFichier, ':', tailleFichier,'octets')\n",
    "print(\"Lecture du contenu de l'en-tête (44 octets) :\")\n",
    "print(binascii.hexlify(data[0:44]))\n",
    "print(\"Nombre d'octets de données :\",tailleFichier - 44)\n",
    "Fichier.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le script crée le fichier son.wav dans le répertoire courant (mais on peut aussi choisir un emplacement en spécifiant le chemin relatif à partir de ce bloc-note : Mon dossier/son.wav').\n",
    "\n",
    "### Ecouter le son\n",
    "Vous pouvez écouter le son ainsi généré en double-cliquant sur le fichier son.wav dans l'environnement jupyter ou en local avec un lecteur multimédia quelconque (VLC par exemple).\n",
    "Notez que Python sait faire directement une lecture audio avec le module adéquat (module externe pygame.mixer, module ossaudiodev sous Linux, module winsound sous Windows, etc...)\n",
    "\n",
    "Le module pygame est un module externe de création de jeux vidéo en 2D.\n",
    "pygame contient un sous module pygame.mixer qui permet de charger et de lire des musiques ou des sons dans plusieurs formats (mp3, ogg, wav...)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pygame\n",
    "pygame.mixer.init()\n",
    "pygame.mixer.Sound(\"son.wav\").play()\n",
    "while pygame.mixer.get_busy():\n",
    "    # lecture en cours\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Editeur audio\n",
    "On peut compléter l'étude du fichier son.wav avec un éditeur de sons tel que Audacity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Editeur hexadécimal\n",
    "Un éditeur hexadécimal est aussi utile : https://www.onlinehexeditor.com/ OU https://hexed.it/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> A l’aide des documents ressources <a href=\"https://ericecmorlaix.github.io/pdf/FormatFichiersAudio.pdf\">Format de fichiers audio</a> et <a href=\"https://ericecmorlaix.github.io/pdf/FormatWAV.pdf\">Format WAV</a> «», analyser le fichier son produit et le code Python qui l’a généré…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lecture\n",
    "Le script suivant fonctionne avec tous les fichiers audio au format WAV (PCM sans compression)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# (C) Fabrice Sincère\n",
    "import wave\n",
    "import binascii\n",
    "\n",
    "NomFichier = input('Entrer le nom du fichier : ')\n",
    "Monson = wave.open(NomFichier,'r')\t# instanciation de l'objet Monson\n",
    "\n",
    "print(\"\\nNombre de canaux :\",Monson.getnchannels())\n",
    "print(\"Taille d'un échantillon (en octets):\",Monson.getsampwidth())\n",
    "print(\"Fréquence d'échantillonnage (en Hz):\",Monson.getframerate())\n",
    "print(\"Nombre d'échantillons :\",Monson.getnframes())\n",
    "print(\"Type de compression :\",Monson.getcompname())\n",
    "\n",
    "TailleData = Monson.getnchannels()*Monson.getsampwidth()*Monson.getnframes()\n",
    "\n",
    "print(\"Taille du fichier (en octets) :\",TailleData + 44)\n",
    "print(\"Nombre d'octets de données :\",TailleData)\n",
    "\n",
    "print(\"\\nAffichage d'une plage de données (dans l'intervalle 0 -\",Monson.getnframes()-1,\")\")\n",
    "\n",
    "echDebut = int(input('N° échantillon (début) : '))\n",
    "echFin = int(input('N° échantillon (fin) : '))\n",
    "\n",
    "print(\"\\nN° échantillon\tContenu\")\n",
    "\n",
    "Monson.setpos(echDebut)\n",
    "plage = echFin - echDebut + 1\n",
    "for i in range(0,plage):\n",
    "    print(Monson.tell(),'\\t\\t',binascii.hexlify(Monson.readframes(1)))\n",
    "\n",
    "Monson.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Source :\n",
    "http://fsincere.free.fr/isn/python/cours_python_ch9.php"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## python-sonic - Programming Music with Python, Sonic Pi or Supercollider"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python-Sonic is a simple Python interface for Sonic Pi, which is a real great music software created by Sam Aaron (http://sonic-pi.net). \n",
    "\n",
    "At the moment Python-Sonic works with Sonic Pi. It is planned, that it will work with Supercollider, too.\n",
    "\n",
    "If you like it, use it. If you have some suggestions, tell me (gkvoelkl@nelson-games.de)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* First you need Python 3 (https://www.python.org, ) - Python 3.5 should work, because it's the development environment\n",
    "* Then Sonic Pi (https://sonic-pi.net) - That makes the sound\n",
    "* Modul python-osc (https://pypi.python.org/pypi/python-osc) - Connection between Python and Sonic Pi Server\n",
    "* And this modul python-sonic - simply copy the source\n",
    "\n",
    "Or try"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "$ pip install python-sonic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That should work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Limitations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* You have to start _Sonic Pi_ first before you can use it with python-sonic\n",
    "* Only the notes from C2 to C6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changelog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Version       |                                                                                          |\n",
    "|--------------|------------------------------------------------------------------------------------------|\n",
    "|  0.2.0       | Some changes for Sonic Pi 2.11. Simpler multi-threading with decorator *@in_thread*. Messaging with *cue* and *sync*. |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many of the examples are inspired from the help menu in *Sonic Pi*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first sound"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play(70) #play MIDI note 70"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some more notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play(72)\n",
    "sleep(1)\n",
    "play(75)\n",
    "sleep(1)\n",
    "play(79) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In more tratitional music notation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play(C5)\n",
    "sleep(0.5)\n",
    "play(D5)\n",
    "sleep(0.5)\n",
    "play(G5) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play sharp notes like *F#* or dimished ones like *Eb*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play(Fs5)\n",
    "sleep(0.5)\n",
    "play(Eb5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play louder (parameter amp) or from a different direction (parameter pan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play(72,amp=2)\n",
    "sleep(0.5)\n",
    "play(74,pan=-1) #left"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different synthesizer sounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "use_synth(SAW)\n",
    "play(38)\n",
    "sleep(0.25)\n",
    "play(50)\n",
    "sleep(0.5)\n",
    "use_synth(PROPHET)\n",
    "play(57)\n",
    "sleep(0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ADSR *(Attack, Decay, Sustain and Release)* Envelope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play (60, attack=0.5, decay=1, sustain_level=0.4, sustain=2, release=0.5) \n",
    "sleep(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play some samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(AMBI_LUNAR_LAND, amp=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(LOOP_AMEN,pan=-1)\n",
    "sleep(0.877)\n",
    "sample(LOOP_AMEN,pan=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(LOOP_AMEN,rate=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(LOOP_AMEN,rate=1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(LOOP_AMEN,rate=-1)#back"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(DRUM_CYMBAL_OPEN,attack=0.01,sustain=0.3,release=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sample(LOOP_AMEN,start=0.5,finish=0.8,rate=-0.2,attack=0.3,release=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play some random notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "for i in range(5):\n",
    "    play(random.randrange(50, 100))\n",
    "    sleep(0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    play(random.choice([C5,E5,G5]))\n",
    "    sleep(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sample slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "\n",
    "number_of_pieces = 8\n",
    "\n",
    "for i in range(16):\n",
    "    s = random.randrange(0,number_of_pieces)/number_of_pieces #sample starts at 0.0 and finishes at 1.0\n",
    "    f = s + (1.0/number_of_pieces)\n",
    "    sample(LOOP_AMEN,beat_stretch=2,start=s,finish=f)\n",
    "    sleep(2.0/number_of_pieces)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An infinite loop and if"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "while True:\n",
    "  if one_in(2):\n",
    "    sample(DRUM_HEAVY_KICK)\n",
    "    sleep(0.5)\n",
    "  else:\n",
    "    sample(DRUM_CYMBAL_CLOSED)\n",
    "    sleep(0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to hear more than one sound at a time, use Threads."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "from psonic import *\n",
    "from threading import Thread\n",
    "\n",
    "def bass_sound():\n",
    "    c = chord(E3, MAJOR7)\n",
    "    while True:\n",
    "        use_synth(PROPHET)\n",
    "        play(random.choice(c), release=0.6)\n",
    "        sleep(0.5)\n",
    "\n",
    "def snare_sound():\n",
    "    while True:\n",
    "        sample(ELEC_SNARE)\n",
    "        sleep(1)\n",
    "\n",
    "bass_thread = Thread(target=bass_sound)\n",
    "snare_thread = Thread(target=snare_sound)\n",
    "\n",
    "bass_thread.start()\n",
    "snare_thread.start()\n",
    "\n",
    "while True:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every function *bass_sound* and *snare_sound* have its own thread. Your can hear them running."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "from threading import Thread, Condition\n",
    "from random import choice\n",
    "\n",
    "def random_riff(condition):\n",
    "    use_synth(PROPHET)\n",
    "    sc = scale(E3, MINOR)\n",
    "    while True:\n",
    "        s = random.choice([0.125,0.25,0.5])\n",
    "        with condition:\n",
    "            condition.wait() #Wait for message\n",
    "        for i in range(8):\n",
    "            r = random.choice([0.125, 0.25, 1, 2])\n",
    "            n = random.choice(sc)\n",
    "            co = random.randint(30,100)\n",
    "            play(n, release = r, cutoff = co)\n",
    "            sleep(s)\n",
    "\n",
    "def drums(condition):\n",
    "    while True:\n",
    "        with condition:\n",
    "            condition.notifyAll() #Message to threads\n",
    "        for i in range(16):\n",
    "            r = random.randrange(1,10)\n",
    "            sample(DRUM_BASS_HARD, rate=r)\n",
    "            sleep(0.125)\n",
    "\n",
    "condition = Condition()\n",
    "random_riff_thread = Thread(name='consumer1', target=random_riff, args=(condition,))\n",
    "drums_thread = Thread(name='producer', target=drums, args=(condition,))\n",
    "\n",
    "random_riff_thread.start()\n",
    "drums_thread.start()\n",
    "\n",
    "input(\"Press Enter to continue...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To synchronize the thread, so that they play a note at the same time, you can use *Condition*. One function sends a message with *condition.notifyAll* the other waits until the message comes *condition.wait*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More simple with decorator __@in_thread__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "from random import choice\n",
    "\n",
    "tick = Message()\n",
    "\n",
    "@in_thread\n",
    "def random_riff():\n",
    "    use_synth(PROPHET)\n",
    "    sc = scale(E3, MINOR)\n",
    "    while True:\n",
    "        s = random.choice([0.125,0.25,0.5])\n",
    "        tick.sync()\n",
    "        for i in range(8):\n",
    "            r = random.choice([0.125, 0.25, 1, 2])\n",
    "            n = random.choice(sc)\n",
    "            co = random.randint(30,100)\n",
    "            play(n, release = r, cutoff = co)\n",
    "            sleep(s)\n",
    "            \n",
    "@in_thread\n",
    "def drums():\n",
    "    while True:\n",
    "        tick.cue()\n",
    "        for i in range(16):\n",
    "            r = random.randrange(1,10)\n",
    "            sample(DRUM_BASS_HARD, rate=r)\n",
    "            sleep(0.125)\n",
    "\n",
    "random_riff()\n",
    "drums()\n",
    "\n",
    "input(\"Press Enter to continue...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "\n",
    "tick = Message()\n",
    "\n",
    "@in_thread\n",
    "def metronom():\n",
    "    while True:\n",
    "        tick.cue()\n",
    "        sleep(1)\n",
    "        \n",
    "@in_thread\n",
    "def instrument():\n",
    "    while True:\n",
    "        tick.sync()\n",
    "        sample(DRUM_HEAVY_KICK)\n",
    "\n",
    "metronom()\n",
    "instrument()\n",
    "\n",
    "while True:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play a list of notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "\n",
    "play ([64, 67, 71], amp = 0.3) \n",
    "sleep(1)\n",
    "play ([E4, G4, B4])\n",
    "sleep(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play chords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play(chord(E4, MINOR)) \n",
    "sleep(1)\n",
    "play(chord(E4, MAJOR))\n",
    "sleep(1)\n",
    "play(chord(E4, MINOR7))\n",
    "sleep(1)\n",
    "play(chord(E4, DOM7))\n",
    "sleep(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play arpeggios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play_pattern( chord(E4, 'm7')) \n",
    "play_pattern_timed( chord(E4, 'm7'), 0.25) \n",
    "play_pattern_timed(chord(E4, 'dim'), [0.25, 0.5]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play scales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play_pattern_timed(scale(C3, MAJOR), 0.125, release = 0.1) \n",
    "play_pattern_timed(scale(C3, MAJOR, num_octaves = 2), 0.125, release = 0.1) \n",
    "play_pattern_timed(scale(C3, MAJOR_PENTATONIC, num_octaves = 2), 0.125, release = 0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function *scale* returns a list with all notes of a scale. So you can use list methodes or functions. For example to play arpeggios descending or shuffeld."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "s = scale(C3, MAJOR)\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "play_pattern_timed(s.reverse(), 0.125, release = 0.1)\n",
    "play_pattern_timed(random.shuffle(s), 0.125, release = 0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Live Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the best in SONIC PI is the _Live Loop_. While a loop is playing music you can change it and hear the change. Let's try it in Python, too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "from threading import Thread\n",
    "\n",
    "def my_loop():\n",
    "  play(60)\n",
    "  sleep(1)\n",
    "\n",
    "def looper():\n",
    "  while True:\n",
    "    my_loop()\n",
    "\n",
    "looper_thread = Thread(name='looper', target=looper)\n",
    "\n",
    "looper_thread.start()\n",
    "\n",
    "input(\"Press Enter to continue...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now change the function *my_loop* und you can hear it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def my_loop():\n",
    "  use_synth(TB303)\n",
    "  play (60, release= 0.3)\n",
    "  sleep (0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def my_loop():\n",
    "  use_synth(TB303)\n",
    "  play (chord(E3, MINOR), release= 0.3)\n",
    "  sleep(0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def my_loop():\n",
    "    use_synth(TB303)\n",
    "    sample(DRUM_BASS_HARD, rate = random.uniform(0.5, 2))\n",
    "    play(random.choice(chord(E3, MINOR)), release= 0.2, cutoff=random.randrange(60, 130))\n",
    "    sleep(0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To stop the sound you have to end the kernel. In IPython with Kernel --> Restart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now with two live loops which are synch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "from threading import Thread, Condition\n",
    "from random import choice\n",
    "\n",
    "def loop_foo():\n",
    "  play (E4, release = 0.5)\n",
    "  sleep (0.5)\n",
    "\n",
    "\n",
    "def loop_bar():\n",
    "  sample (DRUM_SNARE_SOFT)\n",
    "  sleep (1)\n",
    "    \n",
    "\n",
    "def live_loop_1(condition):\n",
    "    while True:\n",
    "        with condition:\n",
    "            condition.notifyAll() #Message to threads\n",
    "        loop_foo()\n",
    "            \n",
    "def live_loop_2(condition):\n",
    "    while True:\n",
    "        with condition:\n",
    "            condition.wait() #Wait for message\n",
    "        loop_bar()\n",
    "\n",
    "condition = Condition()\n",
    "live_thread_1 = Thread(name='producer', target=live_loop_1, args=(condition,))\n",
    "live_thread_2 = Thread(name='consumer1', target=live_loop_2, args=(condition,))\n",
    "\n",
    "live_thread_1.start()\n",
    "live_thread_2.start()\n",
    "\n",
    "input(\"Press Enter to continue...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def loop_foo():\n",
    "  play (A4, release = 0.5)\n",
    "  sleep (0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def loop_bar():\n",
    "  sample (DRUM_HEAVY_KICK)\n",
    "  sleep (0.125)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If would be nice if we can stop the loop with a simple command. With stop event it works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *\n",
    "from threading import Thread, Condition, Event\n",
    "\n",
    "def loop_foo():\n",
    "  play (E4, release = 0.5)\n",
    "  sleep (0.5)\n",
    "\n",
    "\n",
    "def loop_bar():\n",
    "  sample (DRUM_SNARE_SOFT)\n",
    "  sleep (1)\n",
    "    \n",
    "\n",
    "def live_loop_1(condition,stop_event):\n",
    "    while not stop_event.is_set():\n",
    "        with condition:\n",
    "            condition.notifyAll() #Message to threads\n",
    "        loop_foo()\n",
    "            \n",
    "def live_loop_2(condition,stop_event):\n",
    "    while not stop_event.is_set():\n",
    "        with condition:\n",
    "            condition.wait() #Wait for message\n",
    "        loop_bar()\n",
    "\n",
    "\n",
    "\n",
    "condition = Condition()\n",
    "stop_event = Event()\n",
    "live_thread_1 = Thread(name='producer', target=live_loop_1, args=(condition,stop_event))\n",
    "live_thread_2 = Thread(name='consumer1', target=live_loop_2, args=(condition,stop_event))\n",
    "\n",
    "\n",
    "live_thread_1.start()\n",
    "live_thread_2.start()\n",
    "\n",
    "input(\"Press Enter to continue...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "stop_event.set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "More complex live loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sc = Ring(scale(E3, MINOR_PENTATONIC))\n",
    "\n",
    "def loop_foo():\n",
    "  play (next(sc), release= 0.1)\n",
    "  sleep (0.125)\n",
    "\n",
    "sc2 = Ring(scale(E3,MINOR_PENTATONIC,num_octaves=2))\n",
    "           \n",
    "def loop_bar():\n",
    "  use_synth(DSAW)\n",
    "  play (next(sc2), release= 0.25)\n",
    "  sleep (0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now a simple structure with four live loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "from psonic import *\n",
    "from threading import Thread, Condition, Event\n",
    "\n",
    "def live_1():\n",
    "    pass\n",
    "\n",
    "def live_2():\n",
    "    pass\n",
    "    \n",
    "def live_3():\n",
    "    pass\n",
    "\n",
    "def live_4():\n",
    "    pass\n",
    "\n",
    "def live_loop_1(condition,stop_event):\n",
    "    while not stop_event.is_set():\n",
    "        with condition:\n",
    "            condition.notifyAll() #Message to threads\n",
    "        live_1()\n",
    "            \n",
    "def live_loop_2(condition,stop_event):\n",
    "    while not stop_event.is_set():\n",
    "        with condition:\n",
    "            condition.wait() #Wait for message\n",
    "        live_2()\n",
    "\n",
    "def live_loop_3(condition,stop_event):\n",
    "    while not stop_event.is_set():\n",
    "        with condition:\n",
    "            condition.wait() #Wait for message\n",
    "        live_3()\n",
    "\n",
    "def live_loop_4(condition,stop_event):\n",
    "    while not stop_event.is_set():\n",
    "        with condition:\n",
    "            condition.wait() #Wait for message\n",
    "        live_4()\n",
    "        \n",
    "condition = Condition()\n",
    "stop_event = Event()\n",
    "live_thread_1 = Thread(name='producer', target=live_loop_1, args=(condition,stop_event))\n",
    "live_thread_2 = Thread(name='consumer1', target=live_loop_2, args=(condition,stop_event))\n",
    "live_thread_3 = Thread(name='consumer2', target=live_loop_3, args=(condition,stop_event))\n",
    "live_thread_4 = Thread(name='consumer3', target=live_loop_3, args=(condition,stop_event))\n",
    "\n",
    "live_thread_1.start()\n",
    "live_thread_2.start()\n",
    "live_thread_3.start()\n",
    "live_thread_4.start()\n",
    "\n",
    "input(\"Press Enter to continue...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After starting the loops you can change them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def live_1():\n",
    "    sample(BD_HAUS,amp=2)\n",
    "    sleep(0.5)\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def live_2():\n",
    "    #sample(AMBI_CHOIR, rate=0.4)\n",
    "    #sleep(1)\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def live_3():\n",
    "    use_synth(TB303)\n",
    "    play(E2, release=4,cutoff=120,cutoff_attack=1)\n",
    "    sleep(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def live_4():\n",
    "    notes = scale(E3, MINOR_PENTATONIC, num_octaves=2)\n",
    "    for i in range(8):\n",
    "        play(random.choice(notes),release=0.1,amp=1.5)\n",
    "        sleep(0.125)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And stop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "stop_event.set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from psonic import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Inspired by Steve Reich Clapping Music\n",
    "\n",
    "clapping = [1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0]\n",
    "\n",
    "for i in range(13):\n",
    "    for j in range(4):\n",
    "        for k in range(12): \n",
    "          if clapping[k] ==1 : sample(DRUM_SNARE_SOFT,pan=-0.5)\n",
    "          if clapping[(i+k)%12] == 1: sample(DRUM_HEAVY_KICK,pan=0.5)\n",
    "          sleep (0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More Informations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sonic Pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### OSC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MIDI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Sources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Joe Armstrong: Connecting Erlang to the Sonic Pi http://joearms.github.io/2015/01/05/Connecting-Erlang-to-Sonic-Pi.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Joe Armstrong: Controlling Sound with OSC Messages http://joearms.github.io/2016/01/29/Controlling-Sound-with-OSC-Messages.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}