Binaural Sound from Monoaural sound.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Binaural Sound From Monoaural Sound\n",
    "\n",
    " Here we have used MIT's dataset of head-related transfer functions (HRTF) containing measurements of a KEMAR dummy head microphone. Binaural synthesis has been performed on monoaural sound."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original framerate (in Hz) 16000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from numpy import *\n",
    "from scipy import *\n",
    "from scipy.io import wavfile\n",
    "import matplotlib.pyplot as plt \n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "def make_stereo(filename, sig_l, sig_r, fs=44100):\n",
    "    sig = array([sig_l, sig_r]).T\n",
    "    sig = sig / sig.max()\n",
    "    wavfile.write(filename, fs, (15000*sig).astype(int16))\n",
    "\n",
    "def read_impulse(elev, azimuth, N=128):\n",
    "    \"\"\" Accepts elev and azimuth in degrees, and returns closest impulse response and transfer function to that combination from compact KEMAR HRTF measurements\"\"\"\n",
    "\n",
    "    elev, azimuth, flip = setangles(elev, azimuth)\n",
    "\n",
    "    filename = \"filters/MIT_KEMAR/full/elev\"+str(elev)+\"/L\"+str(elev)+\"e\"+str(\"%03d\" % azimuth)+\"a.wav\"\n",
    "    fs, h_t_l = wavfile.read(filename)\n",
    "    filename = \"filters/MIT_KEMAR/full/elev\"+str(elev)+\"/R\"+str(elev)+\"e\"+str(\"%03d\" % (180-azimuth))+\"a.wav\"\n",
    "    fs, h_t_r = wavfile.read(filename)\n",
    "    # print elev,azimuth TODO\n",
    "    h_t_l = transpose(transpose(h_t_l))\n",
    "    h_t_r = transpose(transpose(h_t_r))\n",
    "    if flip:\n",
    "        return h_t_r, h_t_l\n",
    "    return h_t_l, h_t_r\n",
    "\n",
    "def setangles(elev, azimuth):\n",
    "    elev = int(elev)\n",
    "    azimuth = int(azimuth)\n",
    "\n",
    "    #bring to multiple of ten\n",
    "    if elev != 0:\n",
    "        while elev%10 > 0:\n",
    "            elev = elev + 1\n",
    "\n",
    "    if elev > 90:\n",
    "        elev = 90\n",
    "    if elev < -40:\n",
    "        elev = -40\n",
    "\n",
    "    #Set increment of azimuth based on elevation\n",
    "    if abs(elev) < 30:\n",
    "        incr = 5\n",
    "    elif abs(elev) == 30:\n",
    "        incr = 6\n",
    "    elif abs(elev) == 40:\n",
    "        incr = 6.43\n",
    "        opts = [0, 6, 13, 19, 26, 32, 29, 45, 51, 58, 64, 71, 77, 84, 90, 96, 103, 109, 116, 122, 129, 135, 141, 148, 154, 161, 167, 174, 180]\n",
    "    elif elev == 50:\n",
    "        incr = 8\n",
    "    elif elev == 60:\n",
    "        incr = 10\n",
    "    elif elev == 70:\n",
    "        incr = 15\n",
    "    elif elev == 80:\n",
    "        incr = 30\n",
    "    elif elev == 90:\n",
    "        incr = 0\n",
    "        azimuth = 0\n",
    "    flip = False\n",
    "\n",
    "    #bring into [-pi,pi]\n",
    "    while azimuth > 180:\n",
    "        azimuth = azimuth - 180\n",
    "    while azimuth < -180:\n",
    "        azimuth = azimuth + 180\n",
    "\n",
    "    #check if we need to flip left and right.\n",
    "    if azimuth < 0:\n",
    "        azimuth = abs(azimuth)\n",
    "        flip = True\n",
    "\n",
    "    if abs(elev) == 40:\n",
    "        incr = 6.43\n",
    "        num = incr\n",
    "        while azimuth > num:\n",
    "            num = num + incr\n",
    "\n",
    "        #azimuth = str(int(round(num)))\n",
    "        azimuth = int(round(num))\n",
    "        #special case for non-integer increment\n",
    "\n",
    "    elif azimuth != 0:\n",
    "        while azimuth % incr > 0:\n",
    "            azimuth = azimuth + 1\n",
    "\n",
    "    if int(azimuth) < 100:\n",
    "        azimuth = \"0\" + str(int(azimuth))\n",
    "\n",
    "    if int(azimuth) < 10:\n",
    "        azimuth = \"00\"+ str(int(azimuth))\n",
    "\n",
    "    return elev, int(azimuth), flip\n",
    "\n",
    "def project(sig, elev, azimuth):\n",
    "    h_t_l, h_t_r = read_impulse(elev, azimuth)\n",
    "\n",
    "    Hw_l = fft(h_t_l, len(sig))\n",
    "    Hw_r = fft(h_t_r, len(sig))\n",
    "\n",
    "    f_diner = fft(sig)\n",
    "    f_diner_l = Hw_l*f_diner\n",
    "    f_diner_r = Hw_r*f_diner\n",
    "    t_diner_l = ifft(f_diner_l, len(sig))\n",
    "    t_diner_r = ifft(f_diner_r, len(sig))\n",
    "    #t_diner_l = fftpack.convolve.convolve(sig, h_t_l)\n",
    "    #t_diner_r = fftpack.convolve.convolve(sig, h_t_r)\n",
    "    #print \"dtype of t_diner_l in project\", t_diner_l.dtype\n",
    "    return t_diner_l, t_diner_r\n",
    "\n",
    "\n",
    "def path(t_sig, start, end, duration=0, window_size=1024, fs=44100):\n",
    "    \"\"\" Moves a sound from start to end positions over duration (Seconds)\"\"\"\n",
    "    #print(window_size)\n",
    "    M = (fs/2) / window_size\n",
    "    w = r_[:fs/2:M]\n",
    "    N = len(w)\n",
    "    #print(len(w))\n",
    "    #window = hamming_window(N)(r_[:window_size])\n",
    "    window = hamming(N)#(r_[:window_size])\n",
    "    #window = cut_gaussian(N) # TODO\n",
    "    #window = sinc_times_gaussian(N) # TODO\n",
    "    #print(window.shape)\n",
    "    #print(window)\n",
    "    i = 1\n",
    "    elev = start[0]\n",
    "    elev_end = end[0]\n",
    "\n",
    "    if duration == 0:\n",
    "        duration = len(t_sig)/fs\n",
    "\n",
    "    azimuth = start[1]\n",
    "    azimuth_end = end[1]\n",
    "    N_steps = int(len(t_sig) * 2 / window_size)\n",
    "    elev_delta = float((elev_end - elev) / float(N_steps)) #deg/half-window\n",
    "    azimuth_delta = float((azimuth_end - azimuth) / float(N_steps))\n",
    "\n",
    "    output_l = zeros( len(t_sig) )\n",
    "    output_r = zeros( len(t_sig) )\n",
    "\n",
    "    while i*(window_size) < len(t_sig):\n",
    "        ind_min = int((i-1.)*window_size)\n",
    "        ind_max = int((i)*window_size)\n",
    "        #p=t_sig[ind_min:ind_max]\n",
    "        #print(p.shape)\n",
    "        t_sig_w = t_sig[ind_min:ind_max] * window        \n",
    "        t_output_l, t_output_r = project(t_sig_w, elev, azimuth)\n",
    "        output_l[ind_min:ind_max] =output_l[ind_min:ind_max] + t_output_l\n",
    "        output_r[ind_min:ind_max]= output_r[ind_min:ind_max] + t_output_r\n",
    "        elev = elev + elev_delta\n",
    "        azimuth = azimuth + azimuth_delta\n",
    "        i = i + 0.5\n",
    "    return output_l, output_r\n",
    "\n",
    "def inverse_transfer_function(Hw):\n",
    "    max_Hw = max(Hw)\n",
    "\n",
    "    inv_Hw = (Hw + 1./max_Hw ) ** -1\n",
    "    return inv_Hw\n",
    "\n",
    "fs, t_diner = wavfile.read('wav/sa1.wav')\n",
    "#print(t_diner)\n",
    "#fs2, t_diner2 = wavfile.read('wav/couchplayin.wav')\n",
    "#print(t_diner2)\n",
    "#fs, t_diner2 = wavfile.read('wav/sa2.wav')\n",
    "print(\"original framerate (in Hz)\", fs)\n",
    "\n",
    "t_diner_l, t_diner_r = path(t_diner, (0, -90), (0, 90), 5, fs/10, fs)\n",
    "#t_diner_l2, t_diner_r2 = path(t_diner2, (0,70), (0, -70), 0, fs/10., fs)\n",
    "\n",
    "final_l = t_diner_l # TODO longest of the two\n",
    "#final_l[:len(t_diner_l2)] += t_diner_l2\n",
    "final_r = t_diner_r\n",
    "#final_r[:len(t_diner_r2)] += t_diner_r2\n",
    "make_stereo('wav/360_headphone.wav', final_l, final_r, fs)\n",
    "plt.plot(final_l)\n",
    "plt.plot(final_r)\n",
    "plt.savefig(\"fig/test.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}