csm_to_fm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data converter from a CSM data file to YM2203 f_number and block data file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import math\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read CSM file\n",
    "\n",
    "Time resolution is 10ms. Each line contains freq and amp data for 10ms period.    \n",
    "\n",
    "**Note**: CSM file line format  \n",
    "```\n",
    "freq1,amp1,freq2,amp2,freq3,amp3,freq4,amp4\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.26 sec\n"
     ]
    }
   ],
   "source": [
    "input_file = './csm_enc_synth/resources/apollo11_launch.csm'\n",
    "\n",
    "with open(input_file, 'r') as f:\n",
    "    lines = [[float(dt) for dt in (l.rstrip('\\n')).split(',')] for l in f.readlines()]\n",
    "\n",
    "# CSM data = [ [[f1,a1],[f2,a2],[f3,a3][f4,a4]], [[f1,a1],[f2,a2]].... ]\n",
    "csm_data = []\n",
    "for line in lines:\n",
    "    item = []\n",
    "    for idx in range(4):\n",
    "        item.append([line[idx*2], line[idx*2+1]])\n",
    "    csm_data.append(item)\n",
    "\n",
    "print(len(csm_data) * 0.01, 'sec')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convert (freq,amp) to (f_num, blk, amp) format\n",
    "\n",
    "```\n",
    "input = f1,a2,f2,a2,f3,a3,f4,a4\n",
    "output = fnum1,blk1,amp1,fnum2,blk2,amp2,fnum3,blk3,amp3,fnum4,blk4,amp4\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "amplitude min:0.0, max:17.74576759338379\n",
      "./csm_enc_synth/resources/apollo11_launch_ym2203.txt is generated.\n"
     ]
    }
   ],
   "source": [
    "#def freq_to_fnum(freq, prescaler):\n",
    "#    block = 1\n",
    "#    while True:\n",
    "#        f_num = (freq * (1<<20) / (1.2288e6/(12*prescaler))) / (1<<(block-1))\n",
    "#        f_num = int(f_num)\n",
    "#        if f_num <= 0x3ff:\n",
    "#            break\n",
    "#        block += 1\n",
    "#    return f_num, block\n",
    "\n",
    "# Convert frequency to F-number and block data for FM-sound device.\n",
    "def freq_to_fnum(freq, prescaler):\n",
    "    block = 1\n",
    "    f_num = ((freq * (1<<20)) / (1.2288e6/(12*prescaler))) / (1<<(block-1)) # prescaler=[2|3|6]\n",
    "    f_num = int(f_num)\n",
    "    if f_num > 0:  \n",
    "        bits = int(math.log10(f_num) / math.log10(2))   # how many bits are required to express f_num in binary?\n",
    "        if bits >= 10:                                  # 2^10 = 0x400\n",
    "            block = bits - 10 + 2\n",
    "            f_num >>= block - 1\n",
    "    return f_num, block\n",
    "\n",
    "# Convert amplitude to total-level data for FM-sound device (dB)\n",
    "# 1 bit = -0.75dB (YM2203), total 7 bits (0x7f == -95.25dB)\n",
    "def amp_to_tl(amp, max_amp):\n",
    "    if amp == 0:\n",
    "        return 0x7f\n",
    "    db = -20 * math.log10(amp / max_amp)\n",
    "    total_level = int(db / 0.75)\n",
    "    return total_level\n",
    "\n",
    "\n",
    "# Find the max amplitude value from the CSM data for dB calculation\n",
    "amp_max = 0\n",
    "amp_min = 10e20\n",
    "for csm in csm_data:\n",
    "    for c in range(4):\n",
    "        _, amp = csm[c]\n",
    "        amp_max = max(amp_max, amp)\n",
    "        amp_min = min(amp_min, amp)\n",
    "print(f'amplitude min:{amp_min}, max:{amp_max}')\n",
    "\n",
    "base, _ = os.path.splitext(input_file)\n",
    "output_file = base+'_ym2203.txt'\n",
    "\n",
    "# Generate data for YM2203 CSM playback \n",
    "# format: fnum1,blk1,tl1,fnum2,blk2,tl2,...,blk4,tl4\n",
    "with open(output_file, 'w') as f:\n",
    "    ym2203_csm = []           # ym2203_csm holds CMS data to generate a 'Mutsu' comatible register access log file in the next code block section\n",
    "    prescaler = 2\n",
    "    for csm in csm_data:\n",
    "        ym2203_csm.append([])\n",
    "        for c in range(4):\n",
    "            freq, amp = csm[c]\n",
    "            fnum, blk = freq_to_fnum(freq, prescaler)\n",
    "            tl = amp_to_tl(amp, amp_max)\n",
    "            if c != 0:\n",
    "                print(',', end='', file=f)\n",
    "            print(f'{fnum},{blk},{tl}', end='', file=f)\n",
    "            ym2203_csm[-1].append(fnum)\n",
    "            ym2203_csm[-1].append(blk)\n",
    "            ym2203_csm[-1].append(tl)\n",
    "        print(file=f)\n",
    "\n",
    "print(output_file, 'is generated.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./csm_enc_synth/resources/apollo11_launch_csm.log is generated.\n"
     ]
    }
   ],
   "source": [
    "def ym2203_reg(reg, val, timestamp=0, f=sys.stdout):\n",
    "    print(f'YM2203C Reg[${reg:02x}]=${val:02x} at {timestamp}', file=f)\n",
    "\n",
    "# Generate 'Mutsu', an FM-7 series emulator compatible register access log data.\n",
    "timestamp = 0\n",
    "base, _ = os.path.splitext(input_file)\n",
    "output_file = base+'_csm.log'\n",
    "with open(output_file, 'w') as f:\n",
    "    ym2203_reg(0x2f, 0x00, timestamp, f)            # set prescaler to 2\n",
    "    reg_table = [[0xa9, 0xad, 0x42], [0xaa, 0xae, 0x46], [0xa8, 0xac, 0x4a], [0xa2, 0xa6, 0x4e]]\n",
    "    for dt in ym2203_csm:\n",
    "        for c in range(4):\n",
    "            fn = dt[c * 3    ]\n",
    "            bl = dt[c * 3 + 1]\n",
    "            tl = dt[c * 3 + 2]\n",
    "            regs = reg_table[c]\n",
    "            fn1 = fn & 0xff\n",
    "            fn2 = (bl<<3) | ((fn >> 8) & 0x07)\n",
    "            ym2203_reg(regs[0], fn1, timestamp, f)\n",
    "            ym2203_reg(regs[1], fn2, timestamp, f)\n",
    "            ym2203_reg(regs[2], tl, timestamp, f)\n",
    "            ym2203_reg(0x25, 0x54, timestamp, f)\n",
    "        ym2203_reg(0x24, 0x3c, timestamp, f)\n",
    "        timestamp += 10e6\n",
    "\n",
    "print(output_file, 'is generated.')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.9 64-bit",
   "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.9"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "f700e5341652eb7c45c585a5fe3b71f06d67a6fc217eb8295c7f5651492a09ab"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}