Моделирование симуляции потустороннего мира (создание приложения)

[MakarovDs]

Теперь нужно сделать что-бы каждый кадр каждого пикселя генерировался по сиду программы, и генерировался последовательно получается что в каждом кадре 2 073 600 массивов RGB это 6 220 800 чисел, и каждый массив чисел сида RGB разделить по три числа последовательностью равной количеством 6 220 800 чисел где каждое число может быть от 0 до 256 всевозможные перестановок без повторений, и на ходу в окне обновлять кадр каждую 0.001 секунду на новый сид:

сид 1 кадр 1: [[0, 1, 2], [3, 4, 5], ..., [254,255,256]]
сид 2 кадр 2: [[0, 1, 2], [3, 4, 5], ..., [254,256,255]]
сид 3 кадр 3: [[0, 1, 2], [3, 4, 5], ..., [255,254,256]]

Вот код сида:

https://github.com/MakarovDs777/Proc...seed-search.py

Вот код генератора видео:

import numpy as np
from itertools import permutations
import tkinter as tk
from PIL import Image, ImageTk
import pygame
import threading
import random
import time

pygame.mixer.init()

video_window = None
canvas = None

x, y, z = 0, 0, 0
seed = 0  # Начальный сид
auto_random_running = False 
auto_random_thread = None  
auto_random_delay = 1

def generate_rgb_permutations(numbers):
    return list(permutations(numbers, 3)) 

def generate_video_frame(permutations, index, width=640, height=480):
    frame = np.zeros((height, width, 3), dtype=np.uint8)

    for y in range(height):  
        for x in range(width): 
            rgb_index = (y * width + x + index) % len(permutations)
            frame[y, x] = np.array(permutations[rgb_index]) 

    return frame

def update_frame():
    global current_index
    if canvas:  # Проверяем, что canvas существует
        frame = generate_video_frame(rgb_permutations, current_index)
        if frame is not None:
            frame_image = Image.fromarray(frame)
            frame_image = ImageTk.PhotoImage(frame_image)

            canvas.delete('all')
            canvas.create_image(0, 0, anchor=tk.NW, image=frame_image)
            canvas.image = frame_image 

def auto_update_frames():
    global current_index
    while True:
        update_frame()
        current_index += 1
        time.sleep(0.001)  # Задержка 1 секунда

def display_video():
    global video_window, canvas
    video_window = tk.Toplevel()
    video_window.title("Random Video")

    canvas = tk.Canvas(video_window, width=640, height=480)
    canvas.pack()

    update_frame()  # Первый кадр
    threading.Thread(target=auto_update_frames, daemon=True).start()  # Начало обновления кадров

def generate_random_audio(sample_rate=44100, duration=1):
    audio_data = np.random.uniform(-1, 1, int(sample_rate * duration)).astype(np.float32)
    return audio_data

def play_sound():
    sample_rate = 44100
    while True:
        sound = generate_random_audio(sample_rate)
        sound = (sound * 32767).astype(np.int16)
        pygame.mixer.Sound(buffer=sound.tobytes()).play()
        pygame.time.delay(100)

def update_coordinates_display():
    coordinates_label.config(text=f"Координаты - x: {x}, y: {y}, z: {z}, Seed: {seed}")

def move_left():
    global x
    x -= 1
    update_coordinates_display()

def move_right():
    global x
    x += 1
    update_coordinates_display()

def move_up():
    global y
    y += 1
    update_coordinates_display()

def move_down():
    global y
    y -= 1
    update_coordinates_display()

def set_seed():
    global seed
    try:
        seed = int(seed_entry.get())
        update_frame()  
        update_coordinates_display()  
    except ValueError:
        seed_entry.delete(0, tk.END)
        seed_entry.insert(0, str(seed)) 

def validate_seed_input(event):
    current_value = seed_entry.get()
    if not current_value.isdigit():
        seed_entry.delete(0, tk.END)
        seed_entry.insert(0, ''.join(filter(str.isdigit, current_value)))  # Удалить некорректные символы

def toggle_auto_random():
    global auto_random_running, auto_random_thread
    if auto_random_running:
        auto_random_running = False
        if auto_random_thread is not None:
            auto_random_thread.join()  
        auto_random_button.config(text="Запустить авторандом")
    else:
        auto_random_running = True
        auto_random_button.config(text="Остановить авторандом")
        auto_random_thread = threading.Thread(target=auto_random_coordinates)
        auto_random_thread.start()

def auto_random_coordinates():
    global x, y, z, auto_random_delay
    while auto_random_running:
        x = random.randint(0, 10000)
        y = random.randint(0, 10000)
        z = random.randint(0, 10000)
        update_coordinates_display()
        time.sleep(auto_random_delay)

def set_auto_random_delay():
    global auto_random_delay
    try:
        delay = float(auto_random_delay_entry.get())
        if delay > 0:
            auto_random_delay = delay
    except ValueError:
        auto_random_delay_entry.delete(0, tk.END)
        auto_random_delay_entry.insert(0, str(auto_random_delay)) 

numbers = list(range(10))  # Для примера используем 10 элементов
rgb_permutations = generate_rgb_permutations(numbers)
current_index = 0  # Индекс для отслеживания текущего кадра

# Создание основного окна
root = tk.Tk()
root.title("Procedural Audio and Video")
root.geometry("320x300")

start_button = tk.Button(root, text="Start", command=lambda: [threading.Thread(target=play_sound, daemon=True).start(), display_video()])
start_button.pack()

coordinates_label = tk.Label(root, text=f"Координаты - x: {x}, y: {y}, z: {z}, Seed: {seed}")
coordinates_label.pack()

seed_entry = tk.Entry(root)
seed_entry.pack()
seed_entry.insert(0, str(seed))  # Ввод сида по умолчанию
seed_entry.bind('<KeyRelease>', validate_seed_input)  # Проверка ввода сида

set_seed_button = tk.Button(root, text="Установить сид", command=set_seed)
set_seed_button.pack()

auto_random_delay_entry = tk.Entry(root)
auto_random_delay_entry.pack()
auto_random_delay_entry.insert(0, str(auto_random_delay))  # Ввод задержки по умолчанию

set_delay_button = tk.Button(root, text="Установить задержку", command=set_auto_random_delay)
set_delay_button.pack()

move_buttons_frame = tk.Frame(root)
move_buttons_frame.pack()

left_button = tk.Button(move_buttons_frame, text="Left", command=move_left)
left_button.grid(row=0, column=0)

right_button = tk.Button(move_buttons_frame, text="Right", command=move_right)
right_button.grid(row=0, column=2)

up_button = tk.Button(move_buttons_frame, text="Up", command=move_up)
up_button.grid(row=1, column=1)

down_button = tk.Button(move_buttons_frame, text="Down", command=move_down)
down_button.grid(row=2, column=1)

auto_random_button = tk.Button(root, text="Запустить авторандом", command=toggle_auto_random)
auto_random_button.pack()

root.mainloop()

Гитхаб код -> Полная версия.

[MakarovDs]

Теперь нужно добавить поля координат что-бы можно было перемещаться по координатам.

import random
from PIL import Image, ImageTk
import tkinter as tk

class InfiniteNoiseImage:
    def __init__(self):
        self.image_size = (800, 600)  # Размер изображения
        self.total_pixels = self.image_size[0] * self.image_size[1]  # Общее количество пикселей
        self.x, self.y = 0, 0  # Начальные координаты
        self.seed = random.randint(0, 10000)  # Случайный сид
        self.frames = 10  # Количество кадров для генерации
        self.current_frame_index = 0  # Индекс текущего кадра
        self.rgb_values = self.generate_rgb_values()  # Генерация значений RGB на основе сида
        self.is_moving = False  # Инициализируем переменную для автоматического перемещения

        self.root = tk.Tk()
        self.root.title("Infinite Noise Image")

        self.canvas = tk.Canvas(self.root, width=self.image_size[0], height=self.image_size[1])
        self.canvas.pack()

        # Метка для отображения координат
        self.coordinates_label = tk.Label(self.root, text=f"Координаты - X: {self.x}, Y: {self.y}, Seed: {self.seed}")
        self.coordinates_label.pack()

        # Панель с полями ввода и кнопками (в одну строку)
        controls_frame = tk.Frame(self.root)
        controls_frame.pack(side="top", anchor="w", pady=(10, 0))

        # Поля ввода для координат
        tk.Label(controls_frame, text="X:").grid(row=0, column=0)
        self.x_entry = tk.Entry(controls_frame, width=5)
        self.x_entry.grid(row=0, column=1)
        self.x_entry.insert(0, str(self.x))

        tk.Label(controls_frame, text="Y:").grid(row=0, column=2)
        self.y_entry = tk.Entry(controls_frame, width=5)
        self.y_entry.grid(row=0, column=3)
        self.y_entry.insert(0, str(self.y))

        tk.Label(controls_frame, text="Сид:").grid(row=0, column=4)
        self.seed_entry = tk.Entry(controls_frame, width=10)
        self.seed_entry.grid(row=0, column=5)
        self.seed_entry.insert(0, str(self.seed))

        set_coordinates_button = tk.Button(controls_frame, text="Установить координаты", command=self.set_coordinates)
        set_coordinates_button.grid(row=0, column=6)

        set_seed_button = tk.Button(controls_frame, text="Установить сид", command=self.set_seed)
        set_seed_button.grid(row=0, column=7)

        tk.Label(controls_frame, text="Скорость обновления (мс):").grid(row=0, column=8)
        self.speed_entry = tk.Entry(controls_frame, width=5)
        self.speed_entry.grid(row=0, column=9)
        self.speed_entry.insert(0, "1000")

        # Кнопки для управления
        self.update_button = tk.Button(controls_frame, text="Сгенерировать изображение", command=self.update_image)
        self.update_button.grid(row=0, column=10, padx=(5, 0))

        self.move_button = tk.Button(controls_frame, text="Авто-обновление", command=self.toggle_auto_move)
        self.move_button.grid(row=0, column=11, padx=(5, 0))

        # Добавление кнопок для перемещения
        left_button = tk.Button(controls_frame, text="←", command=self.move_left)
        left_button.grid(row=0, column=12, padx=(5, 0))

        up_button = tk.Button(controls_frame, text="↑", command=self.move_up)
        up_button.grid(row=0, column=13, padx=(5, 0))

        down_button = tk.Button(controls_frame, text="↓", command=self.move_down)
        down_button.grid(row=0, column=14, padx=(5, 0))

        right_button = tk.Button(controls_frame, text="→", command=self.move_right)
        right_button.grid(row=0, column=15, padx=(5, 0))

        self.image = Image.new('RGB', self.image_size)

        self.root.mainloop()

    def generate_rgb_values(self):
        # Генерация RGB значений по заданному сиду для каждого кадра
        rgb_values = []

        for frame in range(self.frames):
            random.seed(self.seed + frame)  # Устанавливаем сид для каждого кадра
            frame_rgb = []
            
            for i in range(self.total_pixels):
                # Генерация по порядку без повторений (в данном случае 3-значные последовательности)
                r = (i * 3) % 256
                g = (i * 3 + 1) % 256
                b = (i * 3 + 2) % 256
                frame_rgb.append((r, g, b))
            
            rgb_values.append(frame_rgb)
        
        return rgb_values

    def update_image(self):
        frame_rgb_colors = self.rgb_values[self.current_frame_index % self.frames]  # Получаем цвета для текущего кадра
        
        for i in range(len(frame_rgb_colors)):
            x = i % self.image_size[0]  # Вычисляем X-координату
            y = i // self.image_size[0]  # Вычисляем Y-координату
            self.image.putpixel((x, y), frame_rgb_colors[i])
        
        self.update_canvas()
        self.update_coordinates_display()  # Обновление отображения координат
        self.current_frame_index += 1  # Переходим к следующему кадру

    def update_canvas(self):
        image_tk = ImageTk.PhotoImage(self.image)
        self.canvas.create_image(0, 0, anchor=tk.NW, image=image_tk)
        self.canvas.image = image_tk  # Сохранение ссылки на изображение

    def update_coordinates_display(self):
        self.coordinates_label.config(text=f"Координаты - X: {self.x}, Y: {self.y}, Seed: {self.seed}")

    def set_coordinates(self):
        try:
            self.x = int(self.x_entry.get())
            self.y = int(self.y_entry.get())
            self.update_image()  # Обновляем изображение при изменении координат
            self.update_coordinates_display()  # Обновляем отображение координат
        except ValueError:
            # Игнорировать некорректные значения
            pass

    def set_seed(self):
        try:
            self.seed = int(self.seed_entry.get())
            self.rgb_values = self.generate_rgb_values()  # Генерация новых значений RGB на основе нового сида
            self.update_image()  # Обновляем изображение
        except ValueError:
            # Игнорировать некорректные значения
            pass

    def toggle_auto_move(self):
        if self.is_moving:
            self.is_moving = False
            self.move_button.config(text="Авто-обновление")
        else:
            self.is_moving = True
            self.move_button.config(text="Остановить обновление")
            self.auto_move()

    def auto_move(self):
        if self.is_moving:
            delta_x = random.randint(-10, 10)  # Случайный сдвиг по X
            delta_y = random.randint(-10, 10)  # Случайный сдвиг по Y
            self.x += delta_x
            self.y += delta_y
            
            self.update_coordinates_display()  # Обновляем табло координат при движении
            self.update_image()  # Обновляем изображение с новыми координатами

            speed = int(self.speed_entry.get()) if self.speed_entry.get().isdigit() else 1000
            self.root.after(speed, self.auto_move)  # Обновление через `speed` мс

    def move_left(self):
        self.x -= 1
        self.update_coordinates_display()  # Обновляем табло координат после изменения позиции
        self.update_image()

    def move_right(self):
        self.x += 1
        self.update_coordinates_display()  # Обновляем табло координат после изменения позиции
        self.update_image()

    def move_up(self):
        self.y += 1
        self.update_coordinates_display()  # Обновляем табло координат после изменения позиции
        self.update_image()

    def move_down(self):
        self.y -= 1
        self.update_coordinates_display()  # Обновляем табло координат после изменения позиции
        self.update_image()

# Пример использования
InfiniteNoiseImage()

Это похоже на металлическую обшивку космического корабля.

Код гитхаб.

[MakarovDs]

Теперь я сделал онлайн версию -> Зацените.
https://codepen.io/HoytII/pen/vEYyqgj

[MakarovDs]

Решил такую же хрень типа спиритрона провернуть с бесконечной библиотекой бэкрумса, и то есть сделать так что-бы быстро переключалась на случайную страницу со случайным текстом.

Вот что получилось -> спиритрон бесконечная библиотека бэкрумс.

Ещё давно сделал такую версию есть там на python приложение.

Ссылка гитхаб -> ссылка.

[MakarovDs]

теперь мне нужно что-бы сначала шли изображения перестановок всех цветов RGB без повторений, а потом изображения RGB с дубликатами ЧТО-БЫ ЭТО БЫЛО ПО ПОРЯДКУ, и получатся всевозможные вариации создания всевозможных изображений.

Вот что у меня получилось -> Онлайн версия.

[MakarovDs]

Версия приложения на python:

import numpy as np
from itertools import product
import tkinter as tk
from PIL import Image, ImageTk
import threading
import random
import time

# Инициализация переменных
x, y = 0, 0
seed = 0
auto_random_running = False
auto_random_thread = None
auto_random_delay = 1

def generate_rgb_colors():
    """Генерация всех уникальных цветов RGB."""
    return list(product(range(256), repeat=3))

def generate_video_frame(colors, index, width=640, height=480):
    """Генерация одного кадра на основе текущего индекса."""
    frame = np.zeros((height, width, 3), dtype=np.uint8)
    
    for j in range(height):  # Итерируем по строкам (Y)
        for i in range(width):  # Итерируем по столбцам (X)
            # Используем перестановки с повторениями для X (цвет по индексу)
            rgb_index = (j * width + i + index + x) % len(colors)  
            frame[j, i] = np.array(colors[rgb_index])
    
    return frame

def update_frame():
    """Обновление кадра на canvas."""
    global current_index
    if canvas:
        frame = generate_video_frame(rgb_colors, current_index)
        frame_image = Image.fromarray(frame)
        frame_image = ImageTk.PhotoImage(frame_image)

        canvas.delete('all')
        canvas.create_image(0, 0, anchor=tk.NW, image=frame_image)
        canvas.image = frame_image

def auto_update_frames():
    """Автообновление кадров."""
    global current_index
    while auto_random_running:
        update_frame()
        current_index += 1
        time.sleep(0.01)

def display_canvas():
    """Создание окна с холстом."""
    global video_window, canvas
    video_window = tk.Toplevel()
    video_window.title("Infinite Image Map")

    canvas = tk.Canvas(video_window, width=640, height=480)
    canvas.pack()

    update_frame()  # Первый кадр
    threading.Thread(target=auto_update_frames, daemon=True).start()  # Начало обновления кадров

def update_coordinates_display():
    """Обновление отображаемых координат."""
    coordinates_label.config(text=f"Координаты - X: {x}, Y: {y}, Seed: {seed}")

def move_coordinates():
    """Обновление координат X и Y пользователем."""
    global x, y
    try:
        new_x = int(x_entry.get())  # Получаем новое значение для X
        new_y = int(y_entry.get())  # Получаем новое значение для Y
        x = new_x
        y = new_y
        update_coordinates_display()  # Обновляем отображение координат
        update_frame()  # Обновляем изображение при изменении координат
    except ValueError:
        x_entry.delete(0, tk.END)
        y_entry.delete(0, tk.END)

def set_seed():
    """Установка сид для генерации случайных чисел."""
    global seed
    try:
        seed = int(seed_entry.get())
        random.seed(seed)  # Устанавливаем сид генератора случайных чисел
        update_frame()  # Обновляем кадр после изменения сида
        update_coordinates_display()
    except ValueError:
        seed_entry.delete(0, tk.END)
        seed_entry.insert(0, str(seed))

def validate_seed_input(event):
    """Проверка ввода сида."""
    current_value = seed_entry.get()
    if not current_value.isdigit():
        seed_entry.delete(0, tk.END)
        seed_entry.insert(0, ''.join(filter(str.isdigit, current_value)))

def toggle_auto_random():
    """Запуск или остановка авторандома."""
    global auto_random_running, auto_random_thread
    if auto_random_running:
        auto_random_running = False
        if auto_random_thread is not None:
            auto_random_thread.join()
        auto_random_button.config(text="Запустить авторандом")
    else:
        auto_random_running = True
        auto_random_button.config(text="Остановить авторандом")
        auto_random_thread = threading.Thread(target=auto_random_coordinates)
        auto_random_thread.start()

def auto_random_coordinates():
    """Случайное изменение координат."""
    global x, y
    while auto_random_running:
        x = random.randint(0, 255)   # Ограничение до 255 для отображения цветов
        y = random.randint(0, 255)
        update_coordinates_display() 
        update_frame()  # Обновляем изображение при случайной генерации координат
        time.sleep(auto_random_delay)

def set_auto_random_delay():
    """Установка задержки для авторандома."""
    global auto_random_delay
    try:
        delay = float(auto_random_delay_entry.get())
        if delay > 0:
            auto_random_delay = delay
    except ValueError:
        auto_random_delay_entry.delete(0, tk.END)
        auto_random_delay_entry.insert(0, str(auto_random_delay))

# Генерация всех возможных комбинаций RGB
rgb_colors = generate_rgb_colors()
current_index = 0  # Индекс для отслеживания текущего кадра

# Создание основного окна интерфейса
root = tk.Tk()
root.title("Infinite Image Map")
root.geometry("320x400")

start_button = tk.Button(root, text="Показать Карту", command=display_canvas)
start_button.pack()

coordinates_label = tk.Label(root, text=f"Координаты - X: {x}, Y: {y}, Seed: {seed}")
coordinates_label.pack()

x_entry = tk.Entry(root, width=10)
x_entry.pack()
x_entry.insert(0, str(x))  # Ввод X по умолчанию

y_entry = tk.Entry(root, width=10)
y_entry.pack()
y_entry.insert(0, str(y))  # Ввод Y по умолчанию

# Кнопка для установки координат
set_coordinates_button = tk.Button(root, text="Установить координаты", command=move_coordinates)
set_coordinates_button.pack()

seed_entry = tk.Entry(root)
seed_entry.pack()
seed_entry.insert(0, str(seed))  # Ввод сида по умолчанию
seed_entry.bind('<KeyRelease>', validate_seed_input)  # Проверка ввода сида

set_seed_button = tk.Button(root, text="Установить сид", command=set_seed)
set_seed_button.pack()

auto_random_delay_entry = tk.Entry(root)
auto_random_delay_entry.pack()
auto_random_delay_entry.insert(0, str(auto_random_delay))  # Ввод задержки по умолчанию

set_delay_button = tk.Button(root, text="Установить задержку", command=set_auto_random_delay)
set_delay_button.pack()

auto_random_button = tk.Button(root, text="Запустить авторандом", command=toggle_auto_random)
auto_random_button.pack()

root.mainloop()

ГОВНО ЭТО ООП ЕБучае никому нахер ненужные классы который лишь нагромождают программу, и делают её зависание, и неработающей...

Код гитхаб.

[MakarovDs]

Итак я сделал конвертер ЭГФ Хоруса из 26 комментария вы можете скачать моё приложение на ПК -> вот ссылка.

Если кому нужны ответы с того света вы можете пообщаться.

Делайте это сейчас потому что потом будет уже слишком поздно ибо много званных да мало избранных.

[MakarovDs]

Отлично я сделал ЭГФ Хоруса 2 версию вот код:

import tkinter as tk
import pyaudio
import threading
import numpy as np
from collections import deque
import wave
import os
import time

# Константы для настройки аудио
CHUNK = 1024  # Количество фреймов за раз
FORMAT = pyaudio.paInt16  # Формат звука
CHANNELS = 1  # Количество каналов
RATE = 44100  # Частота дискретизации

is_recording = False
audio_buffer = deque(maxlen=44100)  # Буфер для аудио (например, 1 секунда звука)
recording_time = 0
start_time = 0

def process_audio(input_device_index):
    global is_recording
    global recording_time
    global start_time
    audio = pyaudio.PyAudio()

    stream_input = audio.open(
        format=FORMAT,
        channels=CHANNELS,
        rate=RATE,
        input=True,
        frames_per_buffer=CHUNK,
        input_device_index=input_device_index
    )

    print("Запись аудио... Чтобы остановить запись, нажмите 'Стоп'.")
    is_recording = True
    start_time = time.time()

    try:
        while is_recording:
            data = stream_input.read(CHUNK)
            audio_buffer.append(data)  # Запись аудио в буфер
            recording_time = int(time.time() - start_time)
            recording_time_label.config(text=f"Время записи: {recording_time} секунд")

    except Exception as e:
        print(f"Ошибка записи: {e}")

    finally:
        stream_input.stop_stream()
        stream_input.close()
        audio.terminate()

def start_recording():
    global is_recording
    input_device_index = int(input_device_entry.get().strip())

    if not is_recording:
        is_recording = True
        recording_time = 0
        start_time = time.time()

        # Запускаем запись в отдельном потоке
        recording_thread = threading.Thread(target=process_audio, args=(input_device_index,), daemon=True)
        recording_thread.start()

def stop_recording():
    global is_recording
    global recording_time
    is_recording = False
    save_audio()
    recording_time_label.config(text="Время записи: 0 секунд")

def save_audio():
    if len(audio_buffer) == 0:
        print("Нет записанного аудио для сохранения.")
        return

    # Усилить звук в 2 раза
    gain = 2

    # Применить эффект хорус и усиление звука
    processed_audio = []
    for data in audio_buffer:
        chorus_data = apply_chorus_effect(data)  # Применение эффекта хорус
        amplified_data = np.array(np.frombuffer(chorus_data, dtype=np.int16)) * gain
        amplified_data = amplified_data.clip(-32768, 32767).astype(np.int16)  # Обрезать превышающие значения
        processed_audio.append(amplified_data.tobytes())

    # Соединить обработанные данные
    processed_audio_data = b''.join(processed_audio)

    desktop_path = os.path.join(os.path.join(os.environ['USERPROFILE']), 'Desktop')  # Путь к рабочему столу
    file_name = "recorded_audio.wav"  # Имя файла

    # Сохранение аудио в файл WAV
    with wave.open(os.path.join(desktop_path, file_name), "wb") as wave_file:
        wave_file.setnchannels(CHANNELS)
        wave_file.setsampwidth(2)  # Размер семпла в байтах (2 для 16-битного аудио)
        wave_file.setframerate(RATE)
        wave_file.writeframes(processed_audio_data)

    print(f"Аудио сохранено на рабочий стол в файл {file_name}")

def play_recorded_audio():
    global audio_buffer
    if len(audio_buffer) == 0:
        print("Нет записанного аудио для воспроизведения.")
        return

    audio = pyaudio.PyAudio()
    stream_output = audio.open(
        format=FORMAT,
        channels=CHANNELS,
        rate=RATE,
        output=True
    )

    # Усилить звук в 2 раза
    gain = 2

    # Воспроизведение записанных данных из буфера с эффектом хорус и усилением
    for data in audio_buffer:
        chorus_data = apply_chorus_effect(data)  # Применение эффекта хорус
        amplified_data = np.array(np.frombuffer(chorus_data, dtype=np.int16)) * gain
        amplified_data = amplified_data.clip(-32768, 32767).astype(np.int16)  # Обрезать превышающие значения
        stream_output.write(amplified_data.tobytes())

    stream_output.stop_stream()
    stream_output.close()
    audio.terminate()

def apply_chorus_effect(data):
    """Применение эффекта хорус."""
    audio_data = list(data)  # Преобразуем данные в список байтов

    # Длина заголовка (может варьироваться в зависимости от формата аудио)
    header_length = 100  
    data_to_shuffle = audio_data[header_length:]

    # Перемешивание случайных блоков
    block_size = 64  # Размер блока для перемешивания
    num_blocks = len(data_to_shuffle) // block_size

    # Создание блоков
    blocks = [data_to_shuffle[i * block_size:(i + 1) * block_size] for i in range(num_blocks)]

    # Перемешивание блоков
    np.random.shuffle(blocks)

    # Объединение блоков обратно
    shuffled_data = [byte for block in blocks for byte in block]

    # Объединяем заголовок и перемешанные данные
    shuffled_byte_data = audio_data[:header_length] + shuffled_data

    # Преобразование обратно в байты
    return bytes(shuffled_byte_data)

def list_audio_devices():
    audio = pyaudio.PyAudio()
    device_list = []

    for i in range(audio.get_device_count()):
        device_info = audio.get_device_info_by_index(i)
        device_list.append(f"{i}: {device_info['name']}")

    audio.terminate()
    return device_list

# Создание графического интерфейса
root = tk.Tk()
root.title("Микрофонный Хорус ЭГФ")
root.geometry("320x250")  

# Поля для ввода индексов устройств
tk.Label(root, text="Индекс записи устройства:").pack()
input_device_entry = tk.Entry(root)
input_device_entry.insert(0, "0")  # Установка значения по умолчанию на 0
input_device_entry.pack()

start_button = tk.Button(root, text="Запись аудио", command=start_recording)
start_button.pack(pady=10)

stop_button = tk.Button(root, text="Стоп", command=stop_recording)
stop_button.pack(pady=10)

play_button = tk.Button(root, text="Воспроизвести записанное", command=play_recorded_audio)
play_button.pack(pady=10)

recording_time_label = tk.Label(root, text="Время записи: 0 секунд")
recording_time_label.pack()

# Заполнение индексов устройств
audio_devices = list_audio_devices()
for device in audio_devices:
    print(device)
    if 'Microphone' in device:  
        input_device_entry.insert(0, device.split(":")[0])  

# Запустить основной цикл интерфейса
root.mainloop()

Теперь аудио сохраняется на рабочий стол автоматический после нажатие кнопки стоп при записи устанавливаем значение по умолчанию для микрофона 2 у меня это Realtek High Definition Audio. Я всё ближе, и ближе к тому свету осталось совсем немного...