soundrecorder-v0.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "ImportError",
     "evalue": "No module named pyaudio",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-1-1e804fd0d7ec>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mget_ipython\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmagic\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mu'matplotlib inline'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[1;32mimport\u001b[0m \u001b[0mpyaudio\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mwave\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mImportError\u001b[0m: No module named pyaudio"
     ]
    }
   ],
   "source": [
    "# Tools for monitoring audio and maybe recording too\n",
    "%matplotlib inline\n",
    "\n",
    "import pyaudio\n",
    "import wave\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import sys\n",
    "import time\n",
    "import os\n",
    "\n",
    "def make_folder(bird, sess, path_type, exp_folder = '/Volumes/gentner/earneodo/bci_zf/'):\n",
    "    assert(os.path.isdir(exp_folder))\n",
    "    bird_folder = os.path.join(os.path.abspath(exp_folder), path_type, bird)\n",
    "    sess_folder = os.path.join(bird_folder, str(sess).zfill(3))\n",
    "    if not os.path.isdir(sess_folder):\n",
    "        os.makedirs(sess_folder)\n",
    "    return sess_folder\n",
    "\n",
    "def dated_file_path(path_pars = None):\n",
    "    if path_pars == None:\n",
    "        sess_path = os.getcwd()\n",
    "    else:\n",
    "        try:\n",
    "            sess_path = path_pars['sess_path']\n",
    "        except:\n",
    "            print 'Wrong path_parameters (sess_path key missing)'\n",
    "    \n",
    "    st = time.strptime(time.ctime())\n",
    "    file_name = \"{:04d}{:02d}{:02d}t{:02d}{:02d}{:02d}_sound.wav\".format(st.tm_year, st.tm_mon, st.tm_mday, \n",
    "                                                                 st.tm_hour, st.tm_min, st.tm_sec)\n",
    "    return os.path.join(sess_path, file_name)\n",
    "\n",
    "def unpack_bits(stream, dtype='<h', n_chans=1):\n",
    "    formatted = np.fromstring(stream, dtype=np.dtype(dtype))\n",
    "    return formatted\n",
    "\n",
    "def rms(x):\n",
    "    return np.linalg.norm(np.array(x, dtype=np.int64))/np.sqrt(x.size)\n",
    "\n",
    "def mad(x):\n",
    "    med = np.median(x)\n",
    "    dev = np.abs(x - np.median(x))\n",
    "    return np.median(dev)\n",
    "\n",
    "def msg(string):\n",
    "    print string\n",
    "    sys.stdout.flush()\n",
    "\n",
    "class audioBuffer:\n",
    "    \n",
    "    def __init__(self, dtype='<h', n_chans=1):\n",
    "        self._stream = ''\n",
    "        self.dtype = '<h'\n",
    "        self.n_chans = n_chans\n",
    "\n",
    "    def append(self, new_stream):\n",
    "        self._stream = self._stream + new_stream\n",
    "    \n",
    "    def write(self, new_stream):\n",
    "        self._stream = new_stream\n",
    "        \n",
    "    def read_binary(self):\n",
    "        return self._stream\n",
    "    \n",
    "    # size in bytes\n",
    "    def get_size(self):\n",
    "        return len(self._stream)\n",
    "    \n",
    "    def get_n_formatted(self):\n",
    "        return len(self._stream) / np.zeros(1, dtype=np.dtype(self.dtype)).nbytes\n",
    "    \n",
    "    def clear_data(self):\n",
    "        self._stream = ''\n",
    "    \n",
    "    def read_formatted(self):\n",
    "        return unpack_bits(self._stream, self.dtype, self.n_chans)\n",
    "\n",
    "\n",
    "class Recorder:\n",
    "    \n",
    "    \n",
    "    def __init__(self, channels=1, rate=44100, frames_per_buffer=1024, monitor_pars=None, path_pars=None):\n",
    "        self.channels = channels\n",
    "        self.rate = rate\n",
    "        self.sampling_step_ms = 1000./rate\n",
    "        self.frames_per_buffer = frames_per_buffer\n",
    "        self._pa = pyaudio.PyAudio()\n",
    "        self._stream = None\n",
    "        self.stream_buffer = audioBuffer(dtype='<h', n_chans = channels)\n",
    "        self.wavefile = None\n",
    "    \n",
    "        self._is_recording = False\n",
    "        self.rms_thresh = 2000.\n",
    "        self.rms_stop_thresh = 1400.\n",
    "        self.monitor_channel = 0\n",
    "        self.monitor_buffer_size_ms = 2000\n",
    "        self.monitor_buffer_max_elem = self.monitor_buffer_size_ms/self.sampling_step_ms * channels\n",
    "        self.monitor_status = 'off'\n",
    "        self.recorded_samples = 0\n",
    "        self.record_epoch_ms = 10000 #records maximum 60 sec epochs\n",
    "        self.record_epoch_max_elem = self.record_epoch_ms/self.sampling_step_ms * channels\n",
    "        self.ms_in_buf = 0\n",
    "        self.callback_count = 0\n",
    "        \n",
    "        self.path_pars = path_pars\n",
    "        self.monitor_pars = monitor_pars #TODO: for entering and updating monitor parameters (thresholds, channel, etc)\n",
    "        \n",
    "    def msec_to_frames(self, n_msec):\n",
    "        return np.int(np.ceil(self.rate/(1000.*self.frames_per_buffer)*n_msec))\n",
    "    \n",
    "    \n",
    "    def read_frames(self, n, msec=True):\n",
    "        self._stream = self._pa.open(format=pyaudio.paInt16,\n",
    "                                    channels=self.channels,\n",
    "                                    rate=self.rate,\n",
    "                                    input=True,\n",
    "                                    frames_per_buffer=self.frames_per_buffer)\n",
    "        self._is_recording = True\n",
    "        n_frames = self.msec_to_frames(n) if msec else n_frames\n",
    "        self.stream_buffer.clear_data()\n",
    "        for frame in range(n_frames):\n",
    "            self.stream_buffer.append(self._stream.read(self.frames_per_buffer))\n",
    "        self._is_recording = False\n",
    "        return self.stream_buffer\n",
    "    \n",
    "    def get_avg_rms(self, window_len = 3000):\n",
    "        rms_buffer_formatted = self.read_frames(3000).read_formatted()\n",
    "        \n",
    "        return rms(rms_buffer_formatted), np.median(rms_buffer_formatted), mad(rms_buffer_formatted)\n",
    "    \n",
    "    \n",
    "    def start_triggered_mode(self):\n",
    "        msg(\"starting monitoring\")\n",
    "        self._stream = self._pa.open(format=pyaudio.paInt16,\n",
    "                            channels=self.channels,\n",
    "                            rate=self.rate,\n",
    "                            input=True,\n",
    "                            frames_per_buffer=self.frames_per_buffer,\n",
    "                            stream_callback=self.get_callback())\n",
    "        \n",
    "        self.stream_buffer.clear_data()\n",
    "        self.monitor_status = 'armed'\n",
    "        self._stream.start_stream()\n",
    "        return self\n",
    "    \n",
    "    def stop_triggered_mode(self):\n",
    "        msg('Stopping monitor: ' + self.monitor_status)\n",
    "        if self.monitor_status == 'triggered':\n",
    "            self.stop_triggered_recording()\n",
    "            \n",
    "        self._stream.stop_stream()\n",
    "        self.monitor_status = 'off'\n",
    "        \n",
    "        \n",
    "    def get_callback(self):\n",
    "        def callback(in_data, frame_count, time_info, status):\n",
    "            \n",
    "            self.callback_count = self.callback_count + 1\n",
    "            self.stream_buffer.append(in_data)            \n",
    "            elem_in_buf = self.stream_buffer.get_n_formatted()\n",
    "            \n",
    "            # Decide whether to analyze state of the machine\n",
    "            if elem_in_buf > self.monitor_buffer_max_elem:\n",
    "                #print \"full buffer\"\n",
    "                #plt.plot(self.stream_buffer.read_formatted())\n",
    "                #msg(str(rms(self.stream_buffer.read_formatted())))\n",
    "                \n",
    "                if self.monitor_status == 'armed':\n",
    "                    msg('Armed with rms ' + str(rms(self.stream_buffer.read_formatted())))\n",
    "                    \n",
    "                    if rms(self.stream_buffer.read_formatted()) > self.rms_thresh:\n",
    "                        print('Should start recording')\n",
    "                        sys.stdout.flush()\n",
    "                        self.start_triggered_recording()\n",
    "                        self.recorded_samples = elem_in_buf\n",
    "\n",
    "                \n",
    "                elif self.monitor_status == 'triggered':\n",
    "                    msg('Triggered with rms ' + str(rms(self.stream_buffer.read_formatted())))\n",
    "                    if rms(self.stream_buffer.read_formatted()) >= self.rms_stop_thresh:\n",
    "                        self.continue_triggered_recording()\n",
    "                        self.recorded_samples = self.recorded_samples + elem_in_buf\n",
    "                        if self.recorded_samples > self.record_epoch_max_elem:\n",
    "                            msg('Recording went too long, stopping it')\n",
    "                            self.stop_triggered_recording()\n",
    "                    else:\n",
    "                        self.stop_triggered_recording()\n",
    "                \n",
    "                self.stream_buffer.clear_data()\n",
    "            return in_data, pyaudio.paContinue\n",
    "        return callback\n",
    "    \n",
    "    def start_triggered_recording(self):\n",
    "        print \"Starting to record\"\n",
    "        sys.stdout.flush()\n",
    "        file_name = self.make_file_path()\n",
    "        self._prep_file(file_name)\n",
    "        self._buffer_to_file()\n",
    "        self.monitor_status = 'triggered'\n",
    "        \n",
    "    def continue_triggered_recording(self):\n",
    "        print \"continuing recording\"\n",
    "        sys.stdout.flush()\n",
    "        self._buffer_to_file()\n",
    "    \n",
    "    def stop_triggered_recording(self):\n",
    "        print \"Recording Stopped\"\n",
    "        self._buffer_to_file()\n",
    "        self._close_file()\n",
    "        self.monitor_status = 'armed'\n",
    "        return self\n",
    "        \n",
    "    def make_file_path(self):\n",
    "        return dated_file_path(self.path_pars)\n",
    "    \n",
    "    def _prep_file(self, file_name, mode='wb'):\n",
    "        msg(\"preparing file \" + file_name)\n",
    "        self.wavefile = wave.open(file_name, mode)\n",
    "        self.wavefile.setnchannels(self.channels)\n",
    "        self.wavefile.setsampwidth(self._pa.get_sample_size(pyaudio.paInt16))\n",
    "        self.wavefile.setframerate(self.rate)\n",
    "        msg('file open')\n",
    "    \n",
    "    def _close_file(self):\n",
    "        self.wavefile.close()\n",
    "        \n",
    "    def _buffer_to_file(self):\n",
    "        # send the data to file\n",
    "        print \"storing data\"\n",
    "        self.wavefile.writeframes(self.stream_buffer.read_binary())\n",
    "        #plt.plot(self.stream_buffer.read_formatted())\n",
    "        self.stream_buffer.clear_data()\n",
    "\n",
    "\n",
    "\n",
    "## Now do something with all this\n",
    "exp_folder = '/Volumes/gentner-1/earneodo/bci_zf/'\n",
    "bird = 'z007'\n",
    "sess = 1\n",
    "\n",
    "sess_path = make_folder(bird, sess, 'raw_data', exp_folder=exp_folder)\n",
    "moni = Recorder(path_pars={'sess_path': sess_path})\n",
    "#moni.start_triggered_mode()\n",
    "#bufread = moni.read_frames(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "path_pars = {'sess_path' : sess_path}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dated_file_path(moni.path_pars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "moni.rms_thresh = 2000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting monitoring\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.Recorder instance at 0x107bb5ea8>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Armed with rms 550.83482332\n",
      "Armed with rms 258.838900947\n",
      "Armed with rms 75.5198953321\n",
      "Armed with rms 70.9709306037\n",
      "Armed with rms 64.3410125379\n",
      "Armed with rms 90.9137124752\n",
      "Armed with rms 134.672198032\n",
      "Armed with rms 120.810176868\n",
      "Armed with rms 239.720627773\n",
      "Armed with rms 93.3811686287\n",
      "Armed with rms 66.441981935\n",
      "Armed with rms 78.2012033528\n",
      "Armed with rms 293.183582477\n",
      "Armed with rms 69.8596426286\n",
      "Armed with rms 59.8799233617\n",
      "Armed with rms 59.4696058906\n",
      "Armed with rms 66.5250819798\n",
      "Armed with rms 104.063822381\n",
      "Armed with rms 67.7041177125\n",
      "Armed with rms 71.3084382375\n",
      "Armed with rms 76.4020703644\n",
      "Armed with rms 58.6287994788\n",
      "Armed with rms 88.4231843969\n",
      "Armed with rms 58.9745966765\n"
     ]
    }
   ],
   "source": [
    "moni.start_triggered_mode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stopping monitor: armed\n"
     ]
    }
   ],
   "source": [
    "moni.stop_triggered_mode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bufread = moni.read_frames(2000)\n",
    "chunk = bufread.read_formatted()\n",
    "plt.plot(chunk)\n",
    "print rms(chunk)\n",
    "print np.std(chunk)\n",
    "print mad(chunk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "moni.monitor_status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "moni.stop_triggered_mode()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "moni.stop_triggered_mode()"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Tf 1.2 py3.6",
   "language": "python",
   "name": "tf"
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}