record_old_recent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# README\n",
    "\n",
    "Run `adb logcat` in terminal to debug\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# import os\n",
    "# import time\n",
    "# import sounddevice as sd\n",
    "\n",
    "# import sounddevice as sd\n",
    "# import librosa\n",
    "# import subprocess\n",
    "# from time import sleep\n",
    "# import numpy as np\n",
    "# import glob # \n",
    "# import pathlib\n",
    "# import matplotlib.pyplot as plt\n",
    "# from scipy.signal import chirp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Android Audio Output over ADB ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\gabeb\\AppData\\Local\\Temp\\ipykernel_17168\\3837070283.py:75: FutureWarning: get_duration() keyword argument 'filename' has been renamed to 'path' in version 0.10.0.\n",
      "\tThis alias will be removed in version 1.0.\n",
      "  duration = librosa.get_duration(filename=wav_file_path)  # Use filename= for clarity\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File duration =  101.976\n",
      "/storage/emulated/0/Download/chimes.wav\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([[0., 0.],\n",
       "        [0., 0.],\n",
       "        [0., 0.],\n",
       "        ...,\n",
       "        [0., 0.],\n",
       "        [0., 0.],\n",
       "        [0., 0.]]),\n",
       " 101.976)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import subprocess\n",
    "# import soundfile as sf\n",
    "# import sounddevice as sd\n",
    "# import librosa\n",
    "\n",
    "# def play_android(wav_file_path, fs_rec):\n",
    "#     # Read the audio file\n",
    "#     data, fs_org = sf.read(wav_file_path)\n",
    "#     duration = librosa.get_duration(path=wav_file_path)\n",
    "#     print('File duration = ', duration)\n",
    "\n",
    "#     # Define the destination path on the Android device\n",
    "#     device_file_path = \"/storage/emulated/0/Download/\" + wav_file_path.split('/')[-1]\n",
    "#     print(device_file_path)\n",
    "\n",
    "#     # Push the file to the Android device\n",
    "#     subprocess.run([\"adb\", \"push\", wav_file_path, device_file_path])\n",
    "\n",
    "#     # Play the file on the Android device\n",
    "#     subprocess.run([\n",
    "#         \"adb\", \"shell\", \"am\", \"start\", \"-a\", \"android.intent.action.VIEW\",\n",
    "#         \"-d\", f\"file://{device_file_path}\", \"-t\", \"audio/*\"\n",
    "#     ], check=True)\n",
    "    \n",
    "#     # BREAKS PROGRAM\n",
    "#     # Delete the file from the Android device after playback\n",
    "#     # subprocess.run([\"adb\", \"shell\", \"rm\", device_file_path])\n",
    "\n",
    "#     return data,  duration\n",
    "    \n",
    "# wav_path = \"chimes.wav\"import subprocess\n",
    "# import soundfile as sf\n",
    "# import sounddevice as sd\n",
    "# import librosa\n",
    "\n",
    "# def play_android(wav_file_path, fs_rec):\n",
    "#     # Read the audio file\n",
    "#     data, fs_org = sf.read(wav_file_path)\n",
    "#     duration = librosa.get_duration(path=wav_file_path)\n",
    "#     print('File duration = ', duration)\n",
    "\n",
    "#     # Define the destination path on the Android device\n",
    "#     device_file_path = \"/storage/emulated/0/Download/\" + wav_file_path.split('/')[-1]\n",
    "#     print(device_file_path)\n",
    "\n",
    "#     # Push the file to the Android device\n",
    "#     subprocess.run([\"adb\", \"push\", wav_file_path, device_file_path])\n",
    "\n",
    "#     # Play the file on the Android device\n",
    "#     subprocess.run([\n",
    "#         \"adb\", \"shell\", \"am\", \"start\", \"-a\", \"android.intent.action.VIEW\",\n",
    "#         \"-d\", f\"file://{device_file_path}\", \"-t\", \"audio/*\"\n",
    "#     ], check=True)\n",
    "    \n",
    "#     # BREAKS PROGRAM\n",
    "#     # Delete the file from the Android device after playback\n",
    "#     # subprocess.run([\"adb\", \"shell\", \"rm\", device_file_path])\n",
    "\n",
    "#     return data,  duration\n",
    "\n",
    "# wav_path = \"chimes.wav\"\n",
    "# fs_rec = 16000\n",
    "# play_android(wav_path, fs_rec)\n",
    "# fs_rec = 16000\n",
    "# play_android(wav_path, fs_rec)\n",
    "\n",
    "import subprocess\n",
    "import soundfile as sf\n",
    "import librosa\n",
    "import os\n",
    "\n",
    "def play_android(wav_file_path, fs_rec):\n",
    "    # Read the audio file\n",
    "    data, fs_org = sf.read(wav_file_path)\n",
    "    duration = librosa.get_duration(filename=wav_file_path)  # Use filename= for clarity\n",
    "    print('File duration = ', duration)\n",
    "\n",
    "    # Use os.path to handle file paths for cross-platform compatibility\n",
    "    device_file_path = \"/storage/emulated/0/Download/\" + os.path.basename(wav_file_path)\n",
    "    print(device_file_path)\n",
    "\n",
    "    # Push the file to the Android device\n",
    "    # Add shell=True for Windows compatibility if adb is in PATH\n",
    "    subprocess.run([\"adb\", \"push\", wav_file_path, device_file_path], shell=True)\n",
    "\n",
    "    # Play the file on the Android device\n",
    "    subprocess.run([\n",
    "        \"adb\", \"shell\", \"am\", \"start\", \"-a\", \"android.intent.action.VIEW\",\n",
    "        \"-d\", f\"file://{device_file_path}\", \"-t\", \"audio/*\"\n",
    "    ], shell=True, check=True)\n",
    "    \n",
    "    # Uncomment to delete the file from the Android device after playback\n",
    "    # subprocess.run([\"adb\", \"shell\", \"rm\", device_file_path], shell=True)\n",
    "\n",
    "    return data, duration\n",
    "\n",
    "wav_path = \"chimes.wav\"\n",
    "fs_rec = 16000\n",
    "play_android(wav_path, fs_rec)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Swept Sin Audio Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start Recording at fs :\n",
      "Recording Done!\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy.signal import chirp\n",
    "import subprocess\n",
    "import sounddevice as sd\n",
    "\n",
    "def swept_sin(save, fs_org, fs_rec):\n",
    "    T = 3\n",
    "    # fs_org = 8000\n",
    "    t = np.arange(0, int(T * fs_org)) / fs_org\n",
    "    f0 = 7800\n",
    "    f1 = 100\n",
    "\n",
    "    directory = \"../Dataset/chirp/\"\n",
    "    if not os.path.exists(directory):\n",
    "        os.makedirs(directory)    \n",
    "    w = chirp(t, f0=f0, f1=f1, t1=T, method='linear')\n",
    "    # print(w)\n",
    "    file_name = 'chirp_{}_{}_{}s_{}.wav'.format(f1, f0, T, fs_org)\n",
    "    sf.write('../Dataset/chirp/' + file_name, w, fs_org)\n",
    "    # plt.plot(t,w)\n",
    "    # plt.show()\n",
    "    # w_fft = np.abs(fft.rfft(w, norm=\"ortho\"))\n",
    "    # freq = fft.rfftfreq(len(w), d=1/fs_org)\n",
    "    # plt.plot(freq, w_fft, alpha=0.8)\n",
    "    # plt.show()\n",
    "    # rec = sd.playrec(w, samplerate=fs, channels=2, blocking=True)\n",
    "\n",
    "    # file_name = os.path.basename(wav_file_path)\n",
    "    # subprocess.run([\"adb push ../Dataset/chirp/{} /sdcard/chirp/\".format(file_name)], shell=True)\n",
    "\n",
    "\n",
    "    subprocess.run([\n",
    "                       \"adb shell am start -a android.intent.action.VIEW -d file:///storage/emulated/0/chirp/{}  -t audio/* -f 0x00008000\".format(\n",
    "                           file_name)], shell=True)\n",
    "\n",
    "\n",
    "    # subprocess.run([\"adb shell am start -a android.intent.action.VIEW -d file:///storage/emulated/0/{}  -t video/* -f 0x00008000\".format(\"id00012_21Uxsk56VDQ_00006_00000.wav\")], shell=True)\n",
    "\n",
    "\n",
    "    #  # Define the destination path on the Android device\n",
    "    # device_file_path = \"/storage/emulated/0/Download/\"\n",
    "\n",
    "    # # Push the file to the Android device\n",
    "    # subprocess.run([\"adb\", \"push\", device_file_path])\n",
    "\n",
    "    # # Play the file on the Android device\n",
    "    # subprocess.run([\n",
    "    #     \"adb\", \"shell\", \"am\", \"start\", \"-a\", \"android.intent.action.VIEW\",\n",
    "    #     \"-d\", f\"file://{device_file_path}\", \"-t\", \"audio/*\"\n",
    "    # ], check=True)\n",
    "\n",
    "    # import subprocess\n",
    "\n",
    "    # file_name = \"your_audio_file_name_here.wav\"  # Ensure this is just the file name, not the full path\n",
    "    # device_file_path = \"/storage/emulated/0/chirp/\" + file_name\n",
    "    # adb_command = [\n",
    "    #     \"adb\", \"shell\", \"am\", \"start\", \"-a\", \"android.intent.action.VIEW\",\n",
    "    #     \"-d\", \"file://\" + device_file_path, \"-t\", \"audio/*\"\n",
    "    # ]\n",
    "\n",
    "    # Execute the command\n",
    "    # subprocess.run(adb_command, check=True)\n",
    "\n",
    "    \n",
    "    # fs = 8*1000\n",
    "    print('Start Recording at fs :')\n",
    "    fs = fs_rec\n",
    "    rec = sd.rec(int(T * fs), samplerate=fs, channels=2, blocking=True)\n",
    "    print(\"Recording Done!\")\n",
    "    rec_in = rec[:, 0]  # inside box\n",
    "    rec_out = rec[:, 1]  # outside box\n",
    "    rec_in_norm = rec_in / max(abs(rec_in)) * max(abs(w))\n",
    "    rec_out_norm = rec_out / max(abs(rec_out)) * max(abs(w))\n",
    "    # sf.write('../Dataset/Box_phone_chirp/direct_far_out_{}.wav'.format(fs), rec_out, fs)\n",
    "    # if save:\n",
    "    #     sf.write('../Dataset/Box_phone_chirp/{}_{}_play{}_org.wav'.format(L_in, r, fs_org), w, fs)\n",
    "    #     sf.write('../Dataset/Box_phone_chirp/{}_{}_play{}_in.wav'.format(L_in, r, fs_org), rec_in, fs)\n",
    "    #     sf.write('../Dataset/Box_phone_chirp/{}_{}_play{}_out.wav'.format(L_in, r, fs_org), rec_out, fs)\n",
    "    # _, band_filter, bandpass_filter, _ = resonant_filter_torch('../Dataset/'+file_name, f0, Q, round(fs/2/f0), False)\n",
    "    # band_filter = band_filter.cpu().detach().numpy().flatten()\n",
    "    # bandpass_filter = bandpass_filter.cpu().detach().numpy().flatten()\n",
    "    # get_transfer_function_scipy(w, rec_out_norm, rec_in_norm, fs, fs_org, T, save_fig=save,\n",
    "                                # title='../Dataset/Box_phone_chirp/{}_{}_play{}_16k.wav'.format(L_in, d, fs_org))\n",
    "    # get_transfer_function_scipy(rec_in, band_filter, bandpass_filter, fs, save_fig=False, title='sin_swept')\n",
    "\n",
    "swept_sin(False, 16000, 16000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         0.98766862 0.95090066 ... 0.97210459 0.98760938 0.99690744]\n",
      "File saved as chirp_100_7800_3s_8000.wav\n",
      "Transferring chirp_100_7800_3s_8000.wav to Android device...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Playing chirp_100_7800_3s_8000.wav on Android device...\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy.signal import chirp\n",
    "import subprocess\n",
    "import sounddevice as sd\n",
    "import soundfile as sf\n",
    "import os\n",
    "\n",
    "def swept_sin(save, fs_org, fs_rec):\n",
    "    T = 3\n",
    "    # fs_org = 8000\n",
    "    t = np.arange(0, int(T * fs_org)) / fs_org\n",
    "    f0 = 7800\n",
    "    f1 = 100\n",
    "\n",
    "    w = chirp(t, f0=f0, f1=f1, t1=T, method='linear')\n",
    "    print(w)\n",
    "    file_name = 'chirp_{}_{}_{}s_{}.wav'.format(f1, f0, T, fs_org)\n",
    "    # Save the chirp signal to a WAV file\n",
    "    if save:\n",
    "        sf.write(file_name, w, fs_org)\n",
    "        print(f\"File saved as {file_name}\")\n",
    "        \n",
    "        # Transfer the file to the Android device\n",
    "        adb_push_command = f\"adb push {file_name} /sdcard/\"\n",
    "        print(f\"Transferring {file_name} to Android device...\")\n",
    "        os.system(adb_push_command)\n",
    "        \n",
    "        # Play the WAV file on the Android device\n",
    "        adb_play_command = f\"adb shell am start -a android.intent.action.VIEW -d file:///sdcard/{file_name} -t audio/wav\"\n",
    "        print(f\"Playing {file_name} on Android device...\")\n",
    "        os.system(adb_play_command)\n",
    "\n",
    "# Example usage\n",
    "fs_org = 8000\n",
    "fs_rec = 8000\n",
    "swept_sin(save=True, fs_org=8000, fs_rec=8000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists recording devices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mRunning cells with 'venv' requires the ipykernel package.\n",
      "\u001b[1;31mRun the following command to install 'ipykernel' into the Python environment. \n",
      "\u001b[1;31mCommand: '\"c:/Users/gabeb/OneDrive - UW-Madison/Work/audio_recorder/venv/Scripts/python.exe\" -m pip install ipykernel -U --force-reinstall'"
     ]
    }
   ],
   "source": [
    "import pyaudio\n",
    "\n",
    "p = pyaudio.PyAudio()\n",
    "\n",
    "print(\"Available audio input devices:\")\n",
    "\n",
    "for i in range(p.get_device_count()):\n",
    "    dev = p.get_device_info_by_index(i)\n",
    "    if dev['maxInputChannels'] > 0:\n",
    "        print(f\"{i}: {dev['name']}\")\n",
    "\n",
    "p.terminate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Audio Recording with SR-XM1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mRunning cells with 'venv' requires the ipykernel package.\n",
      "\u001b[1;31mRun the following command to install 'ipykernel' into the Python environment. \n",
      "\u001b[1;31mCommand: '\"c:/Users/gabeb/OneDrive - UW-Madison/Work/audio_recorder/venv/Scripts/python.exe\" -m pip install ipykernel -U --force-reinstall'"
     ]
    }
   ],
   "source": [
    "import pyaudio\n",
    "import wave\n",
    "\n",
    "# The following parameters can be adjusted according to your needs\n",
    "FORMAT = pyaudio.paInt16              # Audio format (16-bit PCM)\n",
    "CHANNELS = 1                          # Number of audio channels (1 for mono, 2 for stereo)\n",
    "RATE = 44100                          # Sample rate (number of samples per second)\n",
    "CHUNK = 1024                          # Number of frames per buffer\n",
    "RECORD_SECONDS = 5                    # Duration of recording\n",
    "WAVE_OUTPUT_FILENAME = \"recording.wav\"   # Output file\n",
    "\n",
    "audio = pyaudio.PyAudio()\n",
    "\n",
    "# Start the recording\n",
    "stream = audio.open(format=FORMAT, channels=CHANNELS,\n",
    "                    rate=RATE, input=True,\n",
    "                    frames_per_buffer=CHUNK)\n",
    "print(\"Recording...\")\n",
    "\n",
    "frames = []\n",
    "\n",
    "for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):\n",
    "    data = stream.read(CHUNK)\n",
    "    frames.append(data)\n",
    "\n",
    "print(\"Finished recording.\")\n",
    "\n",
    "# Stop and close the stream\n",
    "stream.stop_stream()\n",
    "stream.close()\n",
    "audio.terminate()\n",
    "\n",
    "# Save the recorded data as a WAV file\n",
    "wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')\n",
    "wf.setnchannels(CHANNELS)\n",
    "wf.setsampwidth(audio.get_sample_size(FORMAT))\n",
    "wf.setframerate(RATE)\n",
    "wf.writeframes(b''.join(frames))\n",
    "wf.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Old"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def play_android(wav_file_path, fs_rec):\n",
    "#     # print(wav_file_path)\n",
    "#     data, fs_org = sf.read(wav_file_path)\n",
    "#     duration = librosa.get_duration(path=wav_file_path)\n",
    "#     print('File duration = ', duration)\n",
    "#     file_name = '/'.join(wav_file_path.split('/')[-3:])\n",
    "#     print(file_name)\n",
    "#     subprocess.run([\n",
    "#         \"adb shell am start -a android.intent.action.VIEW -d file:///storage/emulated/0/{}  -t audio/* -f 0x00008000\".format(\n",
    "#             file_name)], shell=True)\n",
    "#     print('Start Recording at fs = {}:'.format(fs_rec))\n",
    "#     rec = sd.rec(int(duration * fs_rec), samplerate=fs_rec, channels=2, blocking=True)\n",
    "#     print(\"Recording Done!\")\n",
    "#     rec_in = rec[:, 0]  # inside box\n",
    "#     rec_out = rec[:, 1]  # outside box\n",
    "#     return data, rec_in, rec_out, duration\n",
    "\n",
    "\n",
    "# import subprocess\n",
    "# def run_adb_logcat(package_name):\n",
    "#     \"\"\"The following Python script demonstrates how to execute adb logcat, capture its output, and filter \n",
    "#     it for messages related to a specific package name. Replace <your_package_name> with your actual Android app package name.\"\"\"\n",
    "#     # Build the adb logcat command\n",
    "#     adb_command = [\"adb\", \"logcat\"]\n",
    "\n",
    "#     # Execute the adb command\n",
    "#     process = subprocess.Popen(adb_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)\n",
    "\n",
    "#     try:\n",
    "#         # Continuously read the output from adb logcat\n",
    "#         while True:\n",
    "#             line = process.stdout.readline()\n",
    "#             if not line:\n",
    "#                 break  # Stop if no more output\n",
    "\n",
    "#             # Check if the current line contains the package name\n",
    "#             if package_name in line:\n",
    "#                 print(line.strip())  # Print the filtered log line\n",
    "\n",
    "#     except KeyboardInterrupt:\n",
    "#         # Handle Ctrl+C gracefully\n",
    "#         print(\"Stopping logcat\")\n",
    "#     finally:\n",
    "#         process.terminate()  # Make sure to terminate the process when done\n",
    "\n",
    "# # Replace 'your_package_name' with your actual package name\n",
    "# run_adb_logcat('<your_package_name>')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import os\n",
    "# import time\n",
    "# import sounddevice as sd\n",
    "\n",
    "# import sounddevice as sd\n",
    "# import librosa\n",
    "# import subprocess\n",
    "# from time import sleep\n",
    "# import numpy as np\n",
    "# import glob # \n",
    "# import pathlib\n",
    "# import matplotlib.pyplot as plt\n",
    "# from scipy.signal import chirp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import subprocess\n",
    "\n",
    "# def run_adb_logcat(package_name):\n",
    "#     \"\"\"The following Python script demonstrates how to execute adb logcat, capture its output, and filter \n",
    "#     it for messages related to a specific package name. Replace <your_package_name> with your actual Android app package name.\"\"\"\n",
    "#     # Build the adb logcat command\n",
    "#     adb_command = [\"adb\", \"logcat\"]\n",
    "\n",
    "#     # Execute the adb command\n",
    "#     process = subprocess.Popen(adb_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)\n",
    "\n",
    "#     try:\n",
    "#         # Continuously read the output from adb logcat\n",
    "#         while True:\n",
    "#             line = process.stdout.readline()\n",
    "#             if not line:\n",
    "#                 break  # Stop if no more output\n",
    "\n",
    "#             # Check if the current line contains the package name\n",
    "#             if package_name in line:\n",
    "#                 print(line.strip())  # Print the filtered log line\n",
    "\n",
    "#     except KeyboardInterrupt:\n",
    "#         # Handle Ctrl+C gracefully\n",
    "#         print(\"Stopping logcat\")\n",
    "#     finally:\n",
    "#         process.terminate()  # Make sure to terminate the process when done\n",
    "\n",
    "# # Replace 'your_package_name' with your actual package name\n",
    "# run_adb_logcat('<your_package_name>')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-30T16:00:53.980076Z",
     "start_time": "2023-04-30T16:00:53.978762Z"
    },
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'numpy'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[10], line 24\u001b[0m\n\u001b[1;32m     22\u001b[0m wav_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mchimes.wav\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m     23\u001b[0m fs_rec \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m16000\u001b[39m\n\u001b[0;32m---> 24\u001b[0m \u001b[43mplay_android\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwav_path\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfs_rec\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     27\u001b[0m \u001b[38;5;66;03m# def swept_sin(save, fs_org, fs_rec):\u001b[39;00m\n\u001b[1;32m     28\u001b[0m \u001b[38;5;66;03m#     T = 3\u001b[39;00m\n\u001b[1;32m     29\u001b[0m \u001b[38;5;66;03m#     # fs_org = 8000\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     76\u001b[0m \u001b[38;5;66;03m# fs_rec = 16000\u001b[39;00m\n\u001b[1;32m     77\u001b[0m \u001b[38;5;66;03m# play_android(wav_path, fs_rec)\u001b[39;00m\n",
      "Cell \u001b[0;32mIn[10], line 5\u001b[0m, in \u001b[0;36mplay_android\u001b[0;34m(wav_file_path, fs_rec)\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mplay_android\u001b[39m(wav_file_path, fs_rec):\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;66;03m# print(wav_file_path)\u001b[39;00m\n\u001b[0;32m----> 5\u001b[0m     data, fs_org \u001b[38;5;241m=\u001b[39m \u001b[43msf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwav_file_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      6\u001b[0m     duration \u001b[38;5;241m=\u001b[39m librosa\u001b[38;5;241m.\u001b[39mget_duration(path\u001b[38;5;241m=\u001b[39mwav_file_path)\n\u001b[1;32m      7\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mFile duration = \u001b[39m\u001b[38;5;124m'\u001b[39m, duration)\n",
      "File \u001b[0;32m~/Work/.venv/lib/python3.10/site-packages/soundfile.py:288\u001b[0m, in \u001b[0;36mread\u001b[0;34m(file, frames, start, stop, dtype, always_2d, fill_value, out, samplerate, channels, format, subtype, endian, closefd)\u001b[0m\n\u001b[1;32m    285\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m SoundFile(file, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m'\u001b[39m, samplerate, channels,\n\u001b[1;32m    286\u001b[0m                subtype, endian, \u001b[38;5;28mformat\u001b[39m, closefd) \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[1;32m    287\u001b[0m     frames \u001b[38;5;241m=\u001b[39m f\u001b[38;5;241m.\u001b[39m_prepare_read(start, stop, frames)\n\u001b[0;32m--> 288\u001b[0m     data \u001b[38;5;241m=\u001b[39m \u001b[43mf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43mframes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43malways_2d\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfill_value\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    289\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m data, f\u001b[38;5;241m.\u001b[39msamplerate\n",
      "File \u001b[0;32m~/Work/.venv/lib/python3.10/site-packages/soundfile.py:891\u001b[0m, in \u001b[0;36mSoundFile.read\u001b[0;34m(self, frames, dtype, always_2d, fill_value, out)\u001b[0m\n\u001b[1;32m    889\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m out \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    890\u001b[0m     frames \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_frames(frames, fill_value)\n\u001b[0;32m--> 891\u001b[0m     out \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_create_empty_array\u001b[49m\u001b[43m(\u001b[49m\u001b[43mframes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43malways_2d\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    892\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    893\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m frames \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m frames \u001b[38;5;241m>\u001b[39m \u001b[38;5;28mlen\u001b[39m(out):\n",
      "File \u001b[0;32m~/Work/.venv/lib/python3.10/site-packages/soundfile.py:1318\u001b[0m, in \u001b[0;36mSoundFile._create_empty_array\u001b[0;34m(self, frames, always_2d, dtype)\u001b[0m\n\u001b[1;32m   1316\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_create_empty_array\u001b[39m(\u001b[38;5;28mself\u001b[39m, frames, always_2d, dtype):\n\u001b[1;32m   1317\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Create an empty array with appropriate shape.\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1318\u001b[0m     \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[1;32m   1319\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m always_2d \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchannels \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m   1320\u001b[0m         shape \u001b[38;5;241m=\u001b[39m frames, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchannels\n",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'numpy'"
     ]
    }
   ],
   "source": [
    "# def swept_sin(save, fs_org, fs_rec):\n",
    "#     T = 3\n",
    "#     # fs_org = 8000\n",
    "#     t = np.arange(0, int(T * fs_org)) / fs_org\n",
    "#     f0 = 7800\n",
    "#     f1 = 100\n",
    "\n",
    "#     w = chirp(t, f0=f0, f1=f1, t1=T, method='linear')\n",
    "#     # print(w)\n",
    "#     file_name = 'chirp_{}_{}_{}s_{}.wav'.format(f1, f0, T, fs_org)\n",
    "#     # sf.write('../Dataset/chirp/'+file_name, w, fs_org)\n",
    "#     # plt.plot(t,w)\n",
    "#     # plt.show()\n",
    "#     # w_fft = np.abs(fft.rfft(w, norm=\"ortho\"))\n",
    "#     # freq = fft.rfftfreq(len(w), d=1/fs_org)\n",
    "#     # plt.plot(freq, w_fft, alpha=0.8)\n",
    "#     # plt.show()\n",
    "#     # rec = sd.playrec(w, samplerate=fs, channels=2, blocking=True)\n",
    "\n",
    "#     # file_name = os.path.basename(wav_file_path)\n",
    "#     # subprocess.run([\"adb push ../Dataset/chirp/{} /sdcard/chirp/\".format(file_name)], shell=True)\n",
    "#     subprocess.run([\n",
    "#                        \"adb shell am start -a android.intent.action.VIEW -d file:///storage/emulated/0/chirp/{}  -t video/* -f 0x00008000\".format(\n",
    "#                            file_name)], shell=True)\n",
    "#     # subprocess.run([\"adb shell am start -a android.intent.action.VIEW -d file:///storage/emulated/0/{}  -t video/* -f 0x00008000\".format(\"id00012_21Uxsk56VDQ_00006_00000.wav\")], shell=True)\n",
    "\n",
    "#     # fs = 8*1000\n",
    "#     print('Start Recording at fs :')\n",
    "#     fs = fs_rec\n",
    "#     rec = sd.rec(int(T * fs), samplerate=fs, channels=2, blocking=True)\n",
    "#     print(\"Recording Done!\")\n",
    "#     rec_in = rec[:, 0]  # inside box\n",
    "#     rec_out = rec[:, 1]  # outside box\n",
    "#     rec_in_norm = rec_in / max(abs(rec_in)) * max(abs(w))\n",
    "#     rec_out_norm = rec_out / max(abs(rec_out)) * max(abs(w))\n",
    "#     # sf.write('../Dataset/Box_phone_chirp/direct_far_out_{}.wav'.format(fs), rec_out, fs)\n",
    "#     if save:\n",
    "#         sf.write('../Dataset/Box_phone_chirp/{}_{}_play{}_org.wav'.format(L_in, r, fs_org), w, fs)\n",
    "#         sf.write('../Dataset/Box_phone_chirp/{}_{}_play{}_in.wav'.format(L_in, r, fs_org), rec_in, fs)\n",
    "#         sf.write('../Dataset/Box_phone_chirp/{}_{}_play{}_out.wav'.format(L_in, r, fs_org), rec_out, fs)\n",
    "#     # _, band_filter, bandpass_filter, _ = resonant_filter_torch('../Dataset/'+file_name, f0, Q, round(fs/2/f0), False)\n",
    "#     # band_filter = band_filter.cpu().detach().numpy().flatten()\n",
    "#     # bandpass_filter = bandpass_filter.cpu().detach().numpy().flatten()\n",
    "#     get_transfer_function_scipy(w, rec_out_norm, rec_in_norm, fs, fs_org, T, save_fig=save,\n",
    "#                                 title='../Dataset/Box_phone_chirp/{}_{}_play{}_16k.wav'.format(L_in, d, fs_org))\n",
    "#     # get_transfer_function_scipy(rec_in, band_filter, bandpass_filter, fs, save_fig=False, title='sin_swept')\n",
    "\n",
    "# swept_sin()\n",
    "# wav_path = \"chimes.wav\"\n",
    "# fs_rec = 16000\n",
    "# play_android(wav_path, fs_rec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ADB Connection Testing ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ADB Device detected. Trying to communicate...\n",
      "Device Serial Number: 99231FFBA00470\n"
     ]
    }
   ],
   "source": [
    "import subprocess\n",
    "\n",
    "# NOTE: Make sure \"adb\" is installed on your system and accessible via the command line. Directly accessing \"adb\".\n",
    "# may need to directly specify the adb path on windows even if adb is added to the system path.\n",
    "\n",
    "import subprocess\n",
    "import sys\n",
    "\n",
    "# Update to true path if using windows\n",
    "adb_path_windows = \"C:\\path\\to\\adb.exe\"\n",
    "\n",
    "def adb_command(command):\n",
    "    \"\"\"Executes an ADB command and returns the output.\"\"\"\n",
    "    try:\n",
    "        adb_exe = \"adb\" if sys.platform.startswith(\"linux\") or sys.platform.startswith(\"darwin\") else adb_path_windows\n",
    "        result = subprocess.run([adb_exe] + command.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)\n",
    "        return result.stdout.strip(), result.stderr.strip()\n",
    "    except Exception as e:\n",
    "        return \"\", str(e)\n",
    "\n",
    "def check_connection():\n",
    "    \"\"\"Checks for an ADB-connected device and tries to communicate with it.\"\"\"\n",
    "    devices_output, devices_error = adb_command(\"devices\")\n",
    "\n",
    "    if \"List of devices attached\" in devices_output and len(devices_output.splitlines()) > 1:\n",
    "        print(\"ADB Device detected. Trying to communicate...\")\n",
    "        \n",
    "        # Getting device serial number\n",
    "        serial_output, serial_error = adb_command(\"get-serialno\")\n",
    "\n",
    "        if serial_output:\n",
    "            print(f\"Device Serial Number: {serial_output}\")\n",
    "        else:\n",
    "            print(f\"Failed to communicate with the device. Error: {serial_error}\")\n",
    "    else:\n",
    "        print(\"No ADB devices detected. Error:\", devices_error)\n",
    "\n",
    "# Example usage\n",
    "check_connection()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Microphone Testing ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Record using sounddevice (this part assumes the recording starts and finishes with the playback)\n",
    "    # Add `rec_in, rec_out` to return statement if in use\n",
    "    # print('Start Recording at fs = {}:'.format(fs_rec))\n",
    "    # rec = sd.rec(int(duration * fs_rec), samplerate=fs_rec, channels=2, blocking=True)\n",
    "    # sd.wait()  # Wait for the recording to finish\n",
    "    # print(\"Recording Done!\")\n",
    "    # rec_in = rec[:, 0]  # inside box\n",
    "    # rec_out = rec[:, 1]  # outside box\n"
   ]
  }
 ],
 "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}