1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import wave
import numpy as np
from matplotlib import pyplot as plt

def read_wav_8bit(filepath):
    with wave.open(filepath, 'rb') as wf:
        n_channels = wf.getnchannels()       # 声道数
        sample_width = wf.getsampwidth()      # 每个样本的字节数
        framerate = wf.getframerate()         # 采样率
        n_frames = wf.getnframes()            # 总帧数
        raw_data = wf.readframes(n_frames)    # 原始字节数据
    # 将字节数据转换为 numpy 数组
    if sample_width == 1:
        # 8-bit: 无符号整数 [0, 255]
        audio_data = np.frombuffer(raw_data, dtype=np.uint8)
    elif sample_width == 2:
        # 16-bit: 无符号整数 [0, 65535]
        audio_data = np.frombuffer(raw_data, dtype=np.uint16)
    else:
        raise ValueError(f"不支持的样本宽度: {sample_width}")
    return framerate, n_channels, sample_width, audio_data

framerate, n_channels, sample_width, audio_data = read_wav_8bit("z2.wav")
print(len(audio_data))
look = int(len(audio_data))
plt.plot(np.arange(0, look) / framerate, audio_data[:look])
plt.plot([0, look / framerate], [65535, 65535], color='r')
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import wave
import numpy as np
# MorseTool是笔者自己写的
from MorseTool import Morse

framerate, n_channels, sample_width, audio_data = read_wav_8bit("z2.wav")
ALEN = len(audio_data)
FRAME_RATE = 44100 # 44.1kHz
DURATION = 0.06 # 60ms

# 解码成0101
SEGMENT_LEN = int(DURATION * FRAME_RATE)
SEGMENT_COUNT = int(ALEN / SEGMENT_LEN)
vars = np.zeros(SEGMENT_COUNT)
for i in range(SEGMENT_COUNT):
    segmentData = audio_data[i*SEGMENT_LEN:i*SEGMENT_LEN+SEGMENT_LEN]
    vars[i] = np.var(segmentData)
vars = vars / np.max(vars)
condition = vars > .9
vars[condition] = 1
vars[~condition] = 0
zocode = vars.astype(int).tolist()
zocode = map(str, zocode)
zostr = "".join(zocode)
# zostr: 11101000101010111000101011100010111011100010...

def parse_all(zos: str):
    words = zos.split("0"*7)
    result = " ".join([parse_word(w) for w in words])
    return result
def parse_word(zow: str):
    word = zow.split("0"*3)
    result = "".join([parse_char(c) for c in word])
    return result
def parse_char(zoc: str):
    bits = zoc.split("0")
    result = ""
    for b in bits:
        if len(b) == 1:
            result += "."
        elif len(b) == 3:
            result += "-"
        else:
            pass # never
    char = [k for k, v in Morse.codes.items() if v == result]
    if len(char) == 0:
        return ""
    return char[0]

secret = parse_all(zostr)
print(secret)

1
2
3
4
5
6
import base64

encoded_str = "NVUWW5PFR6X6PCFR4WLLKIJB"
decoded_bytes = base64.b32decode(encoded_str)
decoded_str = decoded_bytes.decode("utf-8")
print("解码:", decoded_str)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
from WaveTool import WaveUtil
from MorseTool import Morse
from pprint import pp
import numpy as np

FRAME_RATE = 44100
SAMPLE_WIDTH = 1 # Bytes
FREQ = 600
DURATION = 0.06 # 60ms
TEXT = "NVUWW5PFR6X6PCFR4WLLKIJB"
myWave = WaveUtil("puzzle.wav", FRAME_RATE, SAMPLE_WIDTH)
def get_dots(duration):
    return duration * FRAME_RATE
txt = Morse.get_codes(TEXT)
data = Morse.parse_to_data(txt)
voiceData = np.array([])
for item in data:
    dots = get_dots(DURATION * item["duration"])
    xpoints = np.arange(0, dots)
    if item["type"] == 0:
        ypoints = np.zeros_like(xpoints)
    else:
        ypoints_float = np.pow(np.sin(2 * np.pi * FREQ * xpoints / FRAME_RATE), 1)
        ypoints = (ypoints_float + 1) / 2 * (SAMPLE_WIDTH << 8)
    voiceData = np.concatenate((voiceData, ypoints))
print(txt)
# print(data)
print("FULL LENGTH", sum([i["duration"] for i in data]))
myWave.write_wav_8bit(voiceData)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import wave
import numpy as np
from pathlib import Path

class WaveUtil:
    def __init__(self, file, framerate, sample) -> None:
        self.file = str(Path(__file__).parent / file)
        self.framerate = framerate
        self.sample = sample
    def write_wav_8bit(self, data):
        raw = data.astype(np.uint8).tobytes()
        with wave.open(self.file, 'wb') as wf:
            wf.setnchannels(1)
            wf.setsampwidth(self.sample)
            wf.setframerate(self.framerate)
            wf.writeframes(raw)
        print("Successfully wrote", self.file)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
import re
class Morse:
    codes = {
        "A": ".-",
        "B": "-...",
        "C": "-.-.",
        "D": "-..",
        "E": ".",
        "F": "..-.",
        "G": "--.",
        "H": "....",
        "I": "..",
        "J": ".---",
        "K": "-.-",
        "L": ".-..",
        "M": "--",
        "N": "-.",
        "O": "---",
        "P": ".--.",
        "Q": "--.-",
        "R": ".-.",
        "S": "...",
        "T": "-",
        "U": "..-",
        "V": "...-",
        "W": ".--",
        "X": "-..-",
        "Y": "-.--",
        "Z": "--..",
        "0": "-----",
        "1": ".----",
        "2": "..---",
        "3": "...--",
        "4": "....-",
        "5": ".....",
        "6": "-....",
        "7": "--...",
        "8": "---..",
        "9": "----."
    }
    def __init__(self) -> None:
        pass
    @classmethod
    def get_code(cls, s: str):
        return cls.codes.get(s, "")
    @classmethod
    def get_codes(cls, s: str):
        s = re.sub(r"\s+", " ", s)
        morseList = [cls.get_code(c.upper()) if c != " " else "|" for c in s]
        result = "/".join(morseList)
        result = re.sub(r"/\|/", "|", result)
        result = re.sub(r"^\|/", "|", result)
        result = re.sub(r"/\|^", "|", result)
        return result
    @staticmethod
    def parse_to_data(codes):
        data = []
        last = "x"
        for c in codes:
            # 处理小间隔
            if (c in ".-") and (last in ".-"):
                data.append({
                    "type": 0,
                    "duration": 1
                })
            # 正常处理
            if c == ".":
                data.append({
                    "type": 1,
                    "duration": 1
                })
            elif c == "-":
                data.append({
                    "type": 1,
                    "duration": 3
                })
            # 字间隔 词间隔
            elif c == "/":
                data.append({
                    "type": 0,
                    "duration": 3
                })
            elif c == "|":
                data.append({
                    "type": 0,
                    "duration": 7
                })
            else:
                raise Exception("解析错误")
            last = c
        return data