music.py

#!/usr/bin/env python3
# Music
# -*- coding: utf-8 -*-

# Based of https://github.com/tsoding/haskell-music

__title__ = "Music"
__author__ = "CoolCat467"
__version__ = "0.0.0"

import math
import os
import struct

VOLUME = 0.3
SAMPLERATE = 44100  # 48000#Samples Per Seccond
PITCHSTANDARD = 440  # 440 hz
BPM = 120  # 120 Beats Per Minute
BEATDURATION = 60 / BPM  # Secconds per beat

# -- NOTE: the formula is taken from https://pages.mtu.edu/~suits/NoteFreqCalcs.html
# f = Semitones -> Hz
getHz = lambda s: PITCHSTANDARD * (2 ** (1 / 12)) ** s

# Interesting but probrably useless
# math.sin(x) * (-math.sin(x) * (x % 100))
# Looks cool but the same sound as reguar sine wave
# math.sin(x) + (math.sin(x/1000))
# Maybe a bell?
# math.sin(x) * math.sin(x*100)
# Polyphonic?
# math.sin(x) + (math.sin(x/2))
# Interesting but not too crazy
# sine(x) + triangle(x)
# Apparently kind of like an acordian
# triangle(x) + square(x)


def sine(x):
    return math.sin(x)


def square(x):
    if math.sin(x) > 0:
        return 1
    return -1


def triangle(x):
    # return abs(x % 4 - 2) - 1
    a = 1
    p = 12.5
    return ((2 * a) / math.pi) * math.asin(math.sin(((math.pi * 2) / p) * x))


def sawtooth(x):
    return x % 4 - 2


def trisquare(x):
    return -((x) % 4) + (x % 3)


def sigmoid(x):
    return 1 / (1 + (math.e ** (-x)))


FUNCTIONS = [sine, square, triangle, sawtooth, trisquare, sigmoid]


def getAttackAndRelease(outlen):
    def attack():
        n = 0
        while True:
            yield min(1, n)
            n += 0.001

    def release():
        t = outlen
        n = 1
        cng = 0.001
        active = outlen * cng
        while True:
            yield max(0, n)
            if t <= active * 2:
                n -= cng
            t -= 1

    return attack(), release()


def freq(hz, duration, function=0, doattack=True, dorelease=True):
    step = (hz * 2 * math.pi) / SAMPLERATE
    f = FUNCTIONS[function]
    output = (f(i * step) for i in range(int(SAMPLERATE * duration)))
    attack, release = getAttackAndRelease(int(SAMPLERATE * duration))
    blank = (1 for i in range(int(SAMPLERATE * duration)))
    tozip = [blank, output, blank]
    if doattack:
        tozip[0] = attack
    if dorelease:
        tozip[2] = release
    return [(x * y * z) * VOLUME for x, y, z in zip(*tozip)]


note = lambda n, beats, function=0, attack=True, release=True: freq(
    getHz(n), (beats * BEATDURATION), function, attack, release
)

song = lambda notes, beats, function=0, attack=True, release=True: sum(
    [note(n, b, function, attack, release) for n, b in zip(notes, beats)], []
)

## Sandstorm
##wave = [note(0, 0.25)
##    , note(0, 0.25)
##    , note(0, 0.25)
##    , note(0, 0.25)
##    , note(0, 0.5)
##    , note(0, 0.25)
##    , note(0, 0.25)
##    , note(0, 0.25)
##    , note(0, 0.25)
##    , note(0, 0.25)
##    , note(0, 0.25)
##    , note(0, 0.5)
##    , note(5, 0.25)
##    , note(5, 0.25)
##    , note(5, 0.25)
##    , note(5, 0.25)
##    , note(5, 0.25)
##    , note(5, 0.25)
##    , note(5, 0.5)
##    , note(3, 0.25)
##    , note(3, 0.25)
##    , note(3, 0.25)
##    , note(3, 0.25)
##    , note(3, 0.25)
##    , note(3, 0.25)
##    , note(3, 0.5)
##    , note((-2), 0.5)
##    , note(0, 0.25)
##    , note(0, 0.25)
##    , note(0, 0.25)
##    , note(0, 0.25)
##    , note(0, 0.5)
##    ]
##wave = sum([note(0, 0.25)*4,
##            note(0, 0.5),
##            note(0, 0.25)*6,
##            note(0, 0.5),
##            note(5, 0.25)*6,
##            note(5, 0.5),
##            note(3, 0.25)*6,
##            note(3, 0.5),
##            note((-2), 0.5),
##            note(0, 0.25)*4,
##            note(0, 0.5)], [])
notes = [0] * 12 + [5] * 7 + [3] * 7 + [-2] + [0] * 2
beats = [0.25] * 4 + sum([[0.5] + [0.25] * 6] * 3, []) + [0.5] * 2 + [0.25, 0.5]
wave = song(notes, beats, 0)
# wave5 = [sum(i) for i in zip(*[song(notes, beats, i) for i in range(len(FUNCTIONS))])]

hehehe = (
    sum(
        [
            note(0, 0.25),
            note(0, 0.25),
            note(12, 0.5),
            note(7, (0.5 + 0.25)),
            note(6, 0.5),
            note(5, 0.5),
            note(3, 0.5),
            note(0, 0.25),
            note(3, 0.25),
            note(5, 0.25),
        ],
        [],
    )
    * 2
)

# test = sum([note(i/4, 0.25) for i in range(-128, 128)], [])
# test = sum([note(i, 1) for i in range(16, -40, -8)], [])

# A  D   G   C
# 0 -7 -14 -21
# B 1 C 3 D 4
# E -5 F -4 G -2
#


def rest(duration):
    val = []
    for i in range(int(SAMPLERATE * duration)):
        val.append(0)
    return val


inst = 1

test = []
test = note(0, 1, inst)
test += note(4, 1.6, inst)
test += rest(0.8)
test += note(-12, 1, inst)
test += note(-8.1, 1.7, inst)
test += rest(0.9)
test *= 8
##xyz = [[-6, 0.5, 1], [-8, 0.5, 1]]
##test = sum([note(x, y, z) for x, y, z in xyz], [])
##notes = [i/4 for i in range(16, -40, -8)]
##notes = notes+[i for i in reversed(notes[:-1])]
##beats = [1 for i in range(len(notes))]
##test = song(notes, beats, 0)
# test5 = [sum(i) for i in zip(*[song(notes, beats, i) for i in range(len(FUNCTIONS))])]


def typ(x):
    if hasattr(x, "__reversed__"):
        return 0
    elif hasattr(x, "capitalize"):
        return 1
    elif hasattr(x, "real"):
        if str(x) in ("True", "False"):
            return 3
        return 2
    return None


def saveList(data, filename):
    """Save data to a file."""
    infl = lambda x: int(x) if round(float(x)) == float(x) else float(x)

    def sv(filedata, incount, lst):
        filedata.append(" " * incount + "{\n")
        incount += 2
        for thing in lst:
            t = typ(thing)
            if t == 0:
                if len(thing):
                    filedata, incount = sv(filedata, incount, thing)
                else:
                    filedata.append(" " * incount + "{}\n")
                # filedata.append(' '*incount+'/'+'&'.join(thing)+'/\n')
            elif t == 1:
                filedata.append(" " * incount + "$" + thing + "$\n")
            elif t == 2:
                filedata.append(" " * incount + "N" + str(infl(thing)) + "N\n")
            elif t == 3:
                filedata.append(" " * incount + "@" + str(thing) + "@\n")
        incount -= 2
        filedata.append(" " * incount + "}\n")
        return filedata, incount

    filedata, _ = sv([], 0, data)
    with open(filename, "w") as saveFile:
        saveFile.write("".join(filedata))
        saveFile.close()


def loadList(filename):
    """Return data retreved from a file."""
    infl = lambda x: int(x) if round(float(x)) == float(x) else float(x)

    def ld(data, lst, idx):
        add = []
        while True:
            if idx >= len(lst):
                break
            line = lst[idx]
            sp = line.count(" ")
            text = line[sp:]
            t = text[0]
            if text == "{}":
                add.append([])
                idx += 1
                continue
            if t == "{":
                idx += 1
                fromNext, idx = ld(add, lst, idx)
                # print(fromNext, add)
                add.append(fromNext)
            elif t == "}":
                break
            elif t == "$":
                add.append(text[1:-1])
            elif t == "N":
                add.append(infl(text[1:-1]))
            elif t == "@":
                add.append(True if text[1:-1] == "True" else False)
            idx += 1
        return add, idx

    with open(filename, "r") as loadFile:
        filedata = loadFile.read().splitlines()
        loadFile.close()
    data, _ = ld([], filedata, 0)
    return data[0]


def save(data, filename):
    file = open(filename, "wb")
    file.write(struct.pack(str(len(data)) + "f", *data))


def play(filename):
    # f32le = 32 bit float encoding in Little-endian byte order
    os.system(f"ffplay -autoexit -showmode 1 -f f32le -ar {SAMPLERATE} {filename}")


##    os.system(f'ffmpeg -f f32le -ar {SAMPLERATE} -i {filename} -acodec libmp3lame audio.mp3')


def testSave(notes, beats, file="output.txt"):
    ##    [list(i) for i in zip(notes, beats)]
    saveList([list(i) for i in zip(notes, beats)], file)


def testLoad(loadfile="output.txt", savefile="output.bin"):
    notes = []
    beats = []
    for n, b in loadList(loadfile):
        notes.append(n)
        beats.append(b)
    notes = [i + 0.43 for i in notes]
    save(song(notes, beats, 2), savefile)


def tune(instrument="viola", beatseach=30, square=False):
    rstart = -21
    if instrument in ("viola", "cello"):
        rstart = -21
    elif instrument == "violin":
        rstart = -14
    elif instrument == "base":
        rstart = -28
    wave = []
    for i in range(rstart, rstart + 28, 7):
        wave.append(note(i, 30, int(square)))
    save(sum(wave, []), f"{instrument}.bin")
    play(f"{instrument}.bin")


##saveList([notes, beats], 'output.txt')
##save(song(*loadList('output.txt')), 'output.bin')


def run():
    ##    tune('viola')
    tune("violin")


##    save(test, 'output.bin')
##    play('output.bin')
##    return
##    save(test, 'output.bin')
##    play('output.bin')

if __name__ == "__main__":
    run()