init.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.io, scipy.io.wavfile\n",
    "import oct2py\n",
    "import librosa as rosa\n",
    "import tqdm\n",
    "# Initialization of Matplotlib\n",
    "from matplotlib import pyplot as plt\n",
    "plt.style.use(\"solarized-light\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Constants(object):\n",
    "    # Seed of Generating Random Nums\n",
    "    RANDOM_STATE = 39\n",
    "    # Frequency of Middle C\n",
    "    FREQ_MIDDLE_C = 261.6255653 # <=> 440 * 2 ** (-9 / 12) = 440 / 2 ** .75\n",
    "    # Frequency of Sampling Rate\n",
    "    FREQ_SAMPLING_RATE = 44100\n",
    "    # Num of Channels\n",
    "    NUM_CHANNELS = 1\n",
    "    # Path of `matlab-midi` Files\n",
    "    PATH_MATLAB_MIDI_SRC = \"./lib/matlab-midi/src/\"\n",
    "    # Path of the MIDI File\n",
    "    PATH_MIDI_FILE = \"./STAGE_OF_SEKAI.mid\"\n",
    "    # Length of Noises' Chunk\n",
    "    # (which Determines the Tone, as the Content of each Term.)\n",
    "    LEN_NOISECHUNK = 4096\n",
    "    # Coefficients\n",
    "    COEF_DELAY = 1.28\n",
    "    COEF_SPEED = 192 / 120\n",
    "# Setting the Random State\n",
    "np.random.seed(Constants.RANDOM_STATE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 一块基础噪声, 其作为一个周期的内容决定着音色,\n",
    "# 保证其长度 > (采样率 / 频率) + 1, 足够即可\n",
    "NOISECHUNK = np.random.randn(Constants.LEN_NOISECHUNK, Constants.NUM_CHANNELS)\n",
    "NOISECHUNK -= NOISECHUNK.mean()\n",
    "NOISECHUNK /= NOISECHUNK.std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "采样频率 $ F_{samlping} = $ `44100`\n",
    "\n",
    "***\n",
    "\n",
    "如若需要合成的声音,\n",
    "\n",
    "频率为 $ f $ `(Hz)`,\n",
    "\n",
    "则其所对应的\n",
    "\n",
    "周期 $ T = \\frac{1}f $ `(s)`,\n",
    "\n",
    "因此一块噪声的长度 $ p = F_{sampling} \\cdot T = \\frac{F_{sampling}}f $,\n",
    "\n",
    "***\n",
    "\n",
    "注:\n",
    "* *`Karplus-Strong` 算法在 `[300, 1000] (Hz)` 范围内表现较好。*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def midi2freq(pitch:int) -> float:\n",
    "    # MIDI 音高 -> 频率值\n",
    "    # <=> (440 / 32) * (2 ** (x - 9) / 12)\n",
    "    return 55 * (2 ** (pitch / 12 - 2.75))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def freq2length(freq:float) -> int:\n",
    "    # 频率值 -> 振动一个\"周期\"的长度\n",
    "    return np.ceil(Constants.FREQ_SAMPLING_RATE / freq).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fourier_Sequence(object):\n",
    "    \"\"\"\n",
    "    >>> arr = [0] + [1] * 127 + [0] + [-1] * 127\n",
    "    >>> fourier = Fourier_Sequence(arr, 39)\n",
    "    >>> np.array([ fourier.fval(x + .5) for x in range(len(arr)) ])\n",
    "    \"\"\"\n",
    "    def __init__(self, arr:np.ndarray, numiter:int=6):\n",
    "        self.__arr = np.array(arr).flatten()\n",
    "        self.__numiter = numiter\n",
    "        # Parsing Parameters\n",
    "        self.__term = len(self.arr)\n",
    "        self.__params = np.zeros((self.numiter, 2)) # [ (a1, b1), (a2, b2), ..., (am, bm) ]\n",
    "        self.__tricoef = np.array([ ((k + 1) * 2 * np.pi / self.__term) for k in range(self.__numiter) ])\n",
    "        for k in range(self.__numiter):\n",
    "            self.__params[k, : ] += sum([\n",
    "                self.__arr[l] * np.array([\n",
    "                    np.cos((l + .5) * self.__tricoef[k]),\n",
    "                    np.sin((l + .5) * self.__tricoef[k]),\n",
    "                    ])\n",
    "                for l in range(self.__term)\n",
    "                ])\n",
    "    @property\n",
    "    def arr(self):\n",
    "        return self.__arr\n",
    "    @property\n",
    "    def numiter(self):\n",
    "        return self.__numiter\n",
    "    @property\n",
    "    def parameters(self):\n",
    "        return self.__params\n",
    "    # Value Estimated\n",
    "    def fval(self, x):\n",
    "        return sum([\n",
    "            (self.__params[k, : ] @ [ np.cos(x * self.__tricoef[k]), np.sin(x * self.__tricoef[k]) ])\n",
    "            for k in range(self.__numiter)\n",
    "            ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def noise2period(length:int, method:int=0) -> np.ndarray:\n",
    "    # 把噪声块压缩为需要的长度, 该长度由前文提到的\"周期\"所决定\n",
    "    assert 0 < length <= Constants.LEN_NOISECHUNK\n",
    "    assert method in [ 0, 1 ]\n",
    "    res = np.zeros((length, Constants.NUM_CHANNELS))\n",
    "    if method == 0:\n",
    "        res += NOISECHUNK.copy()[ : length , : ]\n",
    "    elif method == 1:\n",
    "        res += NOISECHUNK.copy()[ :: Constants.LEN_NOISECHUNK // length , : ][ : length , : ]\n",
    "    elif method == 2:\n",
    "        pass\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def karplus_strong(freq = Constants.FREQ_MIDDLE_C, ti = 3.9, rate_decay:float=0., rate_update:float=.5):\n",
    "    noisechunk = noise2period(freq2length(freq), 1)\n",
    "    len_period = noisechunk.shape[0]\n",
    "    len_output = np.round(Constants.FREQ_SAMPLING_RATE * ti).astype(int)\n",
    "    num_periods = int(len_output / len_period) - 1\n",
    "    new_indices = [noisechunk.shape[0] - 1] + list(range(noisechunk.shape[0] - 1))\n",
    "    res = np.zeros((len_output, Constants.NUM_CHANNELS))\n",
    "    for k in range(num_periods):\n",
    "        noisechunk = noisechunk * (1 - rate_update) + noisechunk[new_indices, : ] * rate_update\n",
    "        res[ len_period * k : len_period * (k + 1) , : ] += noisechunk\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parsemidi(filepath:str=Constants.PATH_MIDI_FILE, keyname:str=\"arr\") -> np.ndarray:\n",
    "    # Loading the MIDI Library `matlab-midi`\n",
    "    oct2py.octave.eval(\"addpath(\\\"%s\\\");\" % Constants.PATH_MATLAB_MIDI_SRC)\n",
    "    # Indices:\n",
    "    #     0: Pitch in MIDI;\n",
    "    #     1: Time to Begin;\n",
    "    #     2: Time to End;\n",
    "    oct2py.octave.eval(\"%s = midiInfo(readmidi(\\\"%s\\\"), 0)( : , [3, 5, 6]);\" % (keyname, filepath))\n",
    "    # https://stackoverflow.com/questions/45525233/loading-mat-and-m-files-with-loadmat-in-python/\n",
    "    oct2py.octave.eval(\"save \\\"%s.mat\\\" %s -v7\" % (filepath, keyname))\n",
    "    # Loading the `.mat` File Generated above, which Contains the Tensor of MIDI\n",
    "    matfile = scipy.io.loadmat(filepath + \".mat\")[keyname]\n",
    "    # Length of a Tensor of a 1-second-long Note\n",
    "    len_sec = Constants.FREQ_SAMPLING_RATE / Constants.COEF_SPEED\n",
    "    # Length of the whole Song\n",
    "    len_output = np.ceil((matfile[ -1, 2 ] + 3.9) * len_sec).astype(int) # 多加一点是为了防止音符渲染出的音频溢出总音频长度\n",
    "    res = np.zeros((len_output, Constants.NUM_CHANNELS))\n",
    "    for k in tqdm.trange(matfile.shape[0]):\n",
    "        freq_midi    = matfile[k, 0]\n",
    "        time_starter = matfile[k, 1]\n",
    "        time_ender   = matfile[k, 2]\n",
    "        index_starter = np.round(time_starter * len_sec).astype(int) # 加入速度系数\n",
    "        # Newnote Generated by Algorithm \"Karplus-Strong\"\n",
    "        newnote = karplus_strong(midi2freq(freq_midi), (time_ender - time_starter) * Constants.COEF_DELAY / Constants.COEF_SPEED)\n",
    "        res[ index_starter : index_starter + newnote.shape[0] , : ] += newnote\n",
    "    res /= np.abs(res).max()\n",
    "    print(\"Notes Rendering Finished!!\")\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████| 207/207 [00:02<00:00, 95.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Notes Rendering Finished!!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "output = parsemidi()\n",
    "if True:\n",
    "    scipy.io.wavfile.write(Constants.PATH_MIDI_FILE + \".wav\", Constants.FREQ_SAMPLING_RATE, output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "a8f61be024eba58adef938c9aa1e29e02cb3dece83a5348b1a2dafd16a070453"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}