Upload 34 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+audios/audios/input_audios/linus.mp3 filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,14 +1,165 @@
----
-title: Voice Human2Robot
-emoji: 👁
-colorFrom: yellow
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.4.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: 'This Demo follows to '
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Robot Voice with Enhanced Features
+
+This project builds upon the excellent work of [Neil Lakin](https://github.com/nrlakin) on his **robot_voice** project, adding several exciting new features:
+
+## **Get Started:**
+
+This project aims to offer a more dynamic and customizable approach to robot voice synthesis. Explore the code, experiment with the features, and contribute to the ongoing development! 
+
+
+## Enhanced Capabilities:
+
+- **Real-time Recording:** Capture your voice instantly and manipulate it with the same robotic effects applied to text input.
+- **Virtual Audio Driver Connectivity:** Seamlessly integrate with virtual audio drivers, allowing you to route the synthesized voice output to various applications and devices.
+- **Expanded Presets:** Utilize a wider variety of pre-configured voice settings to customize the robotic sound to your liking, with sample audio included for demonstration.
+
+## Project Foundation:
+
+The core code of this project is based on Neil Lakin's original "robot_voice" project. For a deeper understanding of the underlying concepts and techniques, I encourage you to explore his repository:
+
+**[Neil Lakin's "robot_voice" repository](https://github.com/nrlakin/robot_voice)**
+
+## **How to Use:**
+
+### 1. Audio Files
+   - Place your audio files (e.g., .wav, .mp3) in the `audios/audios/input_audios` folder.
+   - The processed robotic voice versions of your files will be saved in the `audios/audios/output_audios` folder with the same filenames.
+
+### 2. Configuration
+
+- Configuration File of all configurations are stored in `config_folder/config.yaml`. You can control whether the program prompts for configuration by setting `ASK_NEW_CONFIG` to `true` or `false`. If set to `false`, the program will not ask for configuration.
+
+- Keyboard Shortcuts Use the following keyboard shortcuts to control the program:
+
+   - `s`: Start recording
+   - `q`: Stop recording
+   - `e`: Stream Robot Voice to microphone
+
+### 3. Real-time Recording
+   - Record your voice using the provided interface and `write_to_file=True`.
+        - Your recordings will be saved in `audios/records/input_records/mic.wav`.
+        - The robotic versions of your recordings will be saved in `audios/records/output_records/mic.wav`.
+
+    - If `write_to_file=False`. The robotic versions of your recordings will be saved in `audios/records/output_records/mic.wav`.
+
+
+- Config 
+
+### 4. Parameters for Adjusting
+
+This section explains the parameters you can use to fine-tune the sound of the generated speech.
+
+#### 4.1. Parameter Short Explanation and Default Values
+
+| Parameter | Default Value | Description |
+|---|---|---|
+| `VB` | 0.2 |  Controls the volume of the **bright** part of the speech. Higher values result in a shorter voice that might be difficult to hear clearly. |
+| `VL` | 0.4 |  Controls the volume of the **low** part of the speech. Higher values result in a shorter voice that might be difficult to hear clearly. |
+| `H` | 4 |  Controls the slope of the linear section of the diode model's response, which kicks in after the voltage exceeds `VL`. |
+| `LOOKUP_SAMPLES` | 1024 |  Determines the size of the **lookup table** used for sound synthesis. Lower values can introduce noise. |
+| `MOD_F` | 50 | Controls the **modulation frequency**, which influences the "robotic" effect. Higher values produce a more robotic sound. |
+
+#### **Important Notes:**
+
+* Each parameter has a default value. You can adjust them to fine-tune the sound to your liking.
+* `VB` and `VL` are independent and do not have the same value.
+* `VB` and `VL` must be below 1.0.
+
+#### 4.2. Parameter Short Explanation
+   ##### 4.2.1. Explaining the Parameters in the Diode-Based Ring Modulator Model
+
+The parameters you listed are used in a digital model of a diode-based ring modulator, as described in the article "A SIMPLE DIGITAL MODEL OF THE DIODE-BASED RING-MODULATOR". This model aims to recreate the distinctive sound of an analog diode-based ring modulator, which is characterized by its non-linear behavior and added harmonics.
+
+Here's a breakdown of each parameter and its role in the model:
+
+-   **`VB` (Default: 0.2): Diode Forward Bias Voltage**
+
+    -   This parameter emulates the forward bias voltage of a diode, controlling the point at which the diode starts conducting.
+    -   It essentially sets the threshold for the signal to pass through the diode model.
+    -   The paper mentions using values of **0.2** and **0.4**, and it's important to keep this value **below 1**.
+
+-   **`VL` (Default: 0.4):  Transition to Linear Behavior**
+
+    -   This parameter determines the voltage at which the diode model transitions from a curved response to a linear response.
+    -   Beyond this voltage, the output of the diode model is proportional to the input.
+    -   Like `VB`,  **`VL`** should be kept **below 1**, and the paper uses **0.4** as a value.
+
+-   **`H` (Default: 4): Slope of Linear Section**
+
+    -   This parameter controls the slope of the linear section of the diode model's response, which kicks in after the voltage exceeds `VL`.
+    -   A higher `H` value means a steeper slope, leading to a more pronounced effect of the diode's non-linearity.
+    -   By adjusting `H`, you can influence the overall distortion characteristics of the ring modulator.
+
+-   **`LOOKUP_SAMPLES` (Default: 1024): Size of Lookup Table**
+
+    -   This parameter determines the number of samples used in a lookup table that represents the diode's non-linearity.
+    -   A larger table can potentially provide a more accurate representation of the non-linearity, but it comes at the cost of increased memory usage.
+    -   The article recommends leaving this value as is unless you have specific reasons to change it.
+
+-   **`MOD_F` (Default: 50): Modulating Frequency**
+
+    -   This parameter sets the frequency of the modulating signal in Hertz (Hz).
+    -   In ring modulation, the modulating signal multiplies the carrier signal, creating sum and difference frequencies.
+    -   `MOD_F` determines the frequency of one of the input signals to the ring modulator.
+
+Understanding these parameters helps you to control and manipulate the sound of the digital diode-based ring modulator. You can experiment with different values to achieve a wide range of timbres, from subtle saturation to harsher, more distorted sounds.
+
+##### 4.2.2. Exploring the Impact of High and Low Parameter Values
+
+Adjusting the parameters in the digital model of a diode-based ring modulator influences the sound by altering the behavior of the simulated diodes. Here's a breakdown of what happens when these parameters are set to high or low values:
+
+-   **`VB` (Diode Forward Bias Voltage)**
+
+    -   **High `VB`:** With a higher forward bias voltage, the diode takes longer to start conducting.  This means a larger portion of the input signal will fall below the threshold and be effectively clipped, resulting in a more pronounced distortion effect.
+    -   **Low `VB`:** A lower `VB`  allows the diode to conduct at lower signal levels. This leads to less clipping and a more subtle, less distorted sound. The signal will pass through with less alteration.
+
+-   **`VL` (Transition to Linear Behavior)**
+
+    -   **High `VL`:**  Increasing `VL`  expands the curved, non-linear region of the diode's response. This enhances the initial distortion and coloration before the signal reaches the linear section.
+    -   **Low `VL`:** A lower `VL`  means a shorter curved region. The diode's response becomes linear more quickly, resulting in less initial distortion and a faster transition to a cleaner output.
+
+-   **`H` (Slope of Linear Section)**
+
+    -   **High `H`:** A steeper slope in the linear section amplifies the differences between the input and output signals. This leads to a more significant change in the signal's overall shape, emphasizing the harmonic content introduced by the diode's non-linearity and creating a more distorted sound.
+    -   **Low `H`:** A gentler slope reduces the difference between the input and output signals in the linear region. The effect of the non-linearity becomes less pronounced, resulting in less distortion.
+
+-   **`LOOKUP_SAMPLES` (Size of Lookup Table)**
+
+    -   **High `LOOKUP_SAMPLES`:**  While increasing the lookup table size can potentially improve the accuracy of the diode non-linearity representation, it might not significantly impact the perceived sound. It also increases memory usage.
+    -   **Low `LOOKUP_SAMPLES`:**  A smaller lookup table might introduce some inaccuracies in the representation of the diode non-linearity, potentially leading to a slightly less accurate emulation of the analog behavior.
+
+-   **`MOD_F` (Modulating Frequency)**
+
+    -   **High `MOD_F`:**  Increasing the modulating frequency shifts the sum and difference frequencies generated by the ring modulation process higher in the frequency spectrum. This can create a brighter, more metallic or clangorous sound.
+    -   **Low `MOD_F`:**  A lower modulating frequency results in lower sum and difference frequencies, leading to a darker, muddier, or more subtle ring modulation effect.
+
+Remember that the perception of "high" and "low" for these parameters depends on the context of the specific sounds you are working with. Experimentation is key to finding the sweet spots that create the desired sonic results. 
+
+#### 4.2 Preset Styles
+
+
+### 5. Connect to Virtual Audio Cable
+- Download and Install Driver in https://vb-audio.com/Cable/.
+
+- This flowchart illustrates the audio routing for real-time distortion processing using VB-Audio CABLE.
+
+```mermaid
+graph LR
+A[Recorded Audio] --> B(CABLE Output);
+B --> C{VB-Audio Virtual Cable};
+C --> D(CABLE Input);
+D --> E[Distorted Audio Output];
+```
+
+The process flows as follows:
+
+   - **Recorded Audio:**  Audio data from a recording source (e.g., microphone, instrument) is sent to...
+   - **CABLE Output:** The virtual output of VB-Audio CABLE.  This acts as a virtual audio interface output.
+   - **VB-Audio Virtual Cable:**  The audio data is passed through the VB-Audio Virtual Cable driver. This is where the distortion processing would occur (using a plugin or other software that intercepts the virtual cable's audio stream).
+   - **CABLE Input:** The processed audio is then received by the virtual input of VB-Audio CABLE.
+   - **Distorted Audio Output:** Finally, the distorted audio is sent to the desired output destination (e.g., speakers, headphones, recording software).
+
+- Note that: **CABLE Output**, **VB-Audio Virtual Cable:**, and **CABLE Input** can be replace by **Input**, **Other Microphone**, and **Output**.
+
+## **Note** 
+This readme assumes the project structure includes folders like `audios`, `records`, `input_audios`, `output_audios`, etc. If your project uses a different folder structure, adjust the paths accordingly. 

app.py

@@ -0,0 +1,21 @@
+import gradio as gr
+import numpy as np
+from robot_voice.change_to_robot_voice import RobotVoice
+from config_folder.config import run_config
+
+def convert_to_robot_voice(audio_array):
+    _, _, _, _, VB, VL, H, LOOKUP_SAMPLES, MOD_F, _, _ = run_config()
+
+    rv_obj = RobotVoice(vb=VB, vl=VL, h=H, lookup_samples=LOOKUP_SAMPLES, mod_f=MOD_F)
+    robot_voice_arr, sr = rv_obj.run((audio_array, None), use_record=False, save_to_file=False)
+
+    return robot_voice_arr
+
+demo = gr.Interface(
+    convert_to_robot_voice,
+    [gr.Audio(sources=["upload"], label="Input Human Voice"),
+     gr.Audio(sources=["microphone"], label="Input Human Voice", streaming=True)],
+     gr.Audio(label="Output Robot Voice"),
+)
+
+demo.launch()

audios/audios/input_audios/linus.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9367855472f8b275824b5975540842ed6037858e53160f1c392520c5c88a37e3
+size 5292044

config_folder/config.py

@@ -0,0 +1,156 @@
+import os
+import yaml
+import sounddevice as sd
+
+FOLDER_CONFIG = "config_folder"
+CONFIG_FILE = "config.yaml"
+CONFIG_PATH = os.path.join(FOLDER_CONFIG, CONFIG_FILE)
+
+class ConfigProcess():
+    def read_config(self, path):
+        with open(path, "r") as yaml_file:        
+            return yaml.load(yaml_file, Loader=yaml.FullLoader)
+
+    def write_config(self, yaml_file, data):
+        with open(yaml_file, 'w') as file:
+            yaml.dump(data, file)
+
+def record_and_save_robot() -> (bool, bool):
+    asking_1 = True
+    asking_2 = True
+
+    while asking_1:
+        use_recording_s = input("USE RECORDING? (y/n): ")
+        if use_recording_s in ["Y", "y"]:
+            use_recording = True
+            asking_1 = False
+        elif use_recording_s in ["N", "n"]:
+            use_recording = False
+            asking_1 = False
+        else:
+            print('You only need type "y" or "n"') 
+
+    while asking_2:
+        save_robot_to_file_s = input("SAVE ROBOT VOICE TO FILE? (y/n): ")
+        if save_robot_to_file_s == 'y' or save_robot_to_file_s == 'Y':
+            save_robot_to_file = True
+            asking_2 = False
+        elif save_robot_to_file_s == 'n' or save_robot_to_file_s == 'N':
+            save_robot_to_file = False
+            asking_2 = False
+        else:
+            print('You only need type "y" or "n"') 
+    
+    print(f"USE_RECORD = {use_recording}")
+    print(f"SAVE_ROBOT_TO_FILE = {save_robot_to_file}")
+    return use_recording, save_robot_to_file
+
+def choose_audio_device():
+    audio_device_list = sd.query_devices()
+    audio_hostapis_list = sd.query_hostapis()
+    print(f"Here are Indecies and Full-Name of Audio Devices (Just enter the device index): \n\
+          {audio_device_list}\n")
+    index_is_not_int = True
+
+    while index_is_not_int:
+        idx_input_device = input("Please enter Your Index Input Audio: ")
+        idx_output_device = input("Please enter Your Index Output Audio: ")
+        try:
+            idx_input_device = int(idx_input_device)
+            idx_output_device = int(idx_output_device)
+            index_is_not_int = False
+        except:
+            print("Make sure 2 Index are integer.")
+
+    in_device_name = audio_device_list[idx_input_device]['name'] + ", " + \
+                  audio_hostapis_list[audio_device_list[idx_input_device]['hostapi']]['name']
+
+    out_device_name = audio_device_list[idx_output_device]['name'] + ", " + \
+                  audio_hostapis_list[audio_device_list[idx_output_device]['hostapi']]['name']
+
+    print("- You have chosen Input Device: ", in_device_name)
+    print("- You have chosen Output Device: ", out_device_name)
+
+    in_device = {"index": idx_input_device, "name": in_device_name}
+    out_device = {"index": idx_output_device, "name": out_device_name}
+
+    return in_device, out_device
+
+def change_config_dict(config_data: dict, **new_cfg):
+
+    for idx, element in enumerate(new_cfg):
+        config_data[element] = list(new_cfg.values())[idx]
+    return config_data
+
+def re_config():    
+    
+    in_device, out_device = choose_audio_device()
+    use_recording, save_robot_to_file = record_and_save_robot()
+    
+    new_cfg = {'Input_device': in_device,
+                'Output_device': out_device,
+                'USE_RECORDING': use_recording,
+                'SAVE_ROBOT_TO_FILE': save_robot_to_file}
+
+    # Read from config file
+    cfg_dict = ConfigProcess().read_config(CONFIG_PATH)
+    cfg_dict = change_config_dict(cfg_dict, **new_cfg)
+
+    # Write to config file
+    ConfigProcess().write_config(CONFIG_PATH, cfg_dict)
+
+    return in_device, out_device, use_recording, save_robot_to_file
+
+def run_config():
+    
+    cfg_dict = ConfigProcess().read_config(CONFIG_PATH)
+    ask_new_config = cfg_dict['ASK_NEW_CONFIG']
+    if ask_new_config:
+        asking = True
+
+        while asking:
+            use_past_config_s = input("Do you want to use past configuration? (y/n): ")
+            if use_past_config_s in ["Y", "y"]:
+                use_past_config = True
+                asking = False
+            elif use_past_config_s in ["N", "n"]:
+                use_past_config = False
+                asking = False
+            else:
+                print('You only need type "y" or "n"')
+
+            
+        if not use_past_config:        
+            in_device, out_device, use_recording, save_robot_to_file = re_config()
+
+        else:
+            in_device = cfg_dict['Input_device']
+            out_device = cfg_dict['Output_device']
+            use_recording = cfg_dict['USE_RECORDING']
+            save_robot_to_file = cfg_dict['SAVE_ROBOT_TO_FILE']
+
+    else:
+        in_device = cfg_dict['Input_device']
+        out_device = cfg_dict['Output_device']
+        use_recording = cfg_dict['USE_RECORDING']
+        save_robot_to_file = cfg_dict['SAVE_ROBOT_TO_FILE']
+
+    STREAM_TO_VIRTUAL_MIC = cfg_dict['STREAM_TO_VIRTUAL_MIC']
+    PARALLEL = cfg_dict['PARALLEL']
+    
+    VB = cfg_dict['Robot_Voice_config']['vb']
+    VL = cfg_dict['Robot_Voice_config']['vl']
+    H = cfg_dict['Robot_Voice_config']['h']
+    LOOKUP_SAMPLES = cfg_dict['Robot_Voice_config']['lookup_samples']
+    MOD_F = cfg_dict['Robot_Voice_config']['mod_f']
+
+    return in_device, out_device, use_recording, save_robot_to_file,\
+           VB, VL, H, LOOKUP_SAMPLES, MOD_F, STREAM_TO_VIRTUAL_MIC, PARALLEL
+
+if __name__ == "__main__":
+
+    in_device, out_device, use_recording, save_robot_to_file,\
+         VB, VL, H, LOOKUP_SAMPLES, MOD_F, STREAM_TO_VIRTUAL_MIC, PARALLEL  = run_config()
+
+    print(in_device, out_device, use_recording, save_robot_to_file,\
+         VB, VL, H, LOOKUP_SAMPLES, MOD_F, STREAM_TO_VIRTUAL_MIC, PARALLEL)

config_folder/config.yaml

@@ -0,0 +1,24 @@
+ASK_NEW_CONFIG: false
+
+Input_device:
+  index: 11
+  name: CABLE Input (VB-Audio Virtual Cable), Windows DirectSound
+
+Output_device:
+  index: 2
+  name: CABLE Output (VB-Audio Virtual , MME
+
+Robot_Voice_config:
+  h: 4
+  lookup_samples: 512
+  mod_f: 50
+  vb: 0.005
+  vl: 0.006
+
+SAVE_ROBOT_TO_FILE: false
+
+USE_RECORDING: true
+
+STREAM_TO_VIRTUAL_MIC: true
+
+PARALLEL: false

in_out_micro/record_and_convert.py

@@ -0,0 +1,38 @@
+import os
+import librosa
+# from robot_voice.change_to_robot_voice import RobotVoice
+from in_out_micro.voice_record import Recorder
+
+def record(out_device, use_recording):
+    # Record and convert to Robot voice
+    if use_recording:
+        base_name_file = "mic.mp3"
+        recorder = Recorder(os.path.join("audios","records","input_records",base_name_file),
+                            input_device_index=out_device['index'])
+        audo_arr, sr = recorder.record(write_to_file=True)
+        # print(audo_arr.shape)
+
+    else:
+        input_file = input("Paste your file path: ")
+        base_name_file = os.path.basename(input_file)
+        audo_arr, sr = librosa.load(input_file)
+    return audo_arr, sr, base_name_file
+
+def convert(rv_obj, out_device, use_recording, save_robot_to_file):
+
+    # Record and convert to Robot voice
+    audo_arr, sr, base_name_file = record(out_device, use_recording)
+
+    # Create Object of RobotVoice
+
+    if use_recording:
+        robot_voice_arr, sr = rv_obj.run(input_func=(audo_arr, sr),
+                                    output_func=os.path.join('audios','records','output_records',base_name_file),
+                                    use_record=use_recording, save_to_file=save_robot_to_file)
+
+    else:
+        robot_voice_arr, sr = rv_obj.run(os.path.join('audios','audios','input_audios',base_name_file),
+                                    os.path.join('audios','audios','output_audios',base_name_file),
+                                    use_record=use_recording, save_to_file=save_robot_to_file)
+
+    return robot_voice_arr, sr

in_out_micro/stream_to_virtual_mic.py

@@ -0,0 +1,19 @@
+import keyboard
+from in_out_micro.to_virtual_micro import push_to_mic
+
+def stream(data, sr, device_name, start_key='e'):
+    start_streaming = False
+    if start_key is not None:
+        print(f"Press '{start_key}' to start stream to {device_name}!")
+    
+        while not start_streaming:
+                if keyboard.is_pressed(start_key) or keyboard.is_pressed(start_key.upper()):
+                    start_streaming = True            
+                    push_to_mic(data, sr, device_name)
+
+    else:
+        while not start_streaming:
+            start_streaming = True
+            push_to_mic(data, sr, device_name)
+    
+                

in_out_micro/to_virtual_micro.py

@@ -0,0 +1,50 @@
+import time
+import librosa
+import numpy as np
+import sounddevice as sd
+
+def select_device():
+    devices = sd.query_devices()
+    input_devices = [device for device in devices if device['max_input_channels'] > 0]
+    device_names = [device['name'] for device in input_devices]
+
+    # Check for "Sound Mixer"
+    for name in input_devices:
+        if "Sound Mixer" in name:
+            return name
+
+    # Check for "CABLE Output"
+    for name in input_devices:
+        if "CABLE Input" in name:
+            return name
+
+# 'CABLE Input (VB-Audio Virtual Cable)'
+def push_to_mic(data, sr, device_name):
+    # path = "audios/audios/input_audios/5g_Viet.mp3"
+    # data, sr = librosa.load(path)
+
+    # devices[11]
+    # {'name': 'CABLE Input (VB-Audio Virtual Cable)',
+    #  'index': 11,
+    #  'hostapi': 1,
+    #  'max_input_channels': 0,
+    #  'max_output_channels': 8,
+    #  'default_low_input_latency': 0.0,
+    #  'default_low_output_latency': 0.12,
+    #  'default_high_input_latency': 0.0,
+    #  'default_high_output_latency': 0.24,
+    #  'default_samplerate': 44100.0}
+
+    # devicename = select_device()
+    #'CABLE Input (VB-Audio Virtual Cable), Windows DirectSound'#'Speakers (Realtek(R) Audio), MME'
+    
+    print(f"Pushing data to {device_name}")  
+    # Play the audio through 'headphone' output device
+    sd.play(data, sr, device=device_name)
+    sd.wait()  # Wait until file is done playing
+    sd.stop()
+
+if __name__ == "__main__":
+    data, sr = librosa.load('audios/audios/output_audios/mic.mp3')
+    device_name = 'CABLE Input (VB-Audio Virtual Cable), Windows DirectSound'
+    push_to_mic(data, sr, device_name)

in_out_micro/voice_record.py

@@ -0,0 +1,58 @@
+import keyboard
+import pyaudio
+import sounddevice as sd
+import numpy as np
+import soundfile as sf
+import time
+
+class Recorder():
+    def __init__(self, filename, sample_rate=22050, channels=1, input_device_index=2):
+        self.audio_format = pyaudio.paFloat32 # pyaudio.paInt16
+        self.channels = channels
+        self.sample_rate = sample_rate
+        self.chunk = int(0.03*self.sample_rate)
+        self.filename = filename
+        self.START_KEY = 's'
+        self.STOP_KEY = 'q'
+        self.input_device_index = input_device_index
+
+    def record_procssing(self, write_to_file):
+        recorded_data = []
+        p = pyaudio.PyAudio()
+
+        stream = p.open(format=self.audio_format, channels=self.channels,
+                        rate=self.sample_rate, input=True, 
+                        frames_per_buffer=self.chunk, input_device_index=self.input_device_index)
+
+        while True:              
+            data = stream.read(self.chunk)
+            recorded_data.append(data)
+            if keyboard.is_pressed(self.STOP_KEY) or keyboard.is_pressed(self.STOP_KEY.upper()):
+
+                print("Stop recording")
+                # stop and close the stream
+                stream.stop_stream()
+                stream.close()
+                p.terminate()
+                #convert recorded data to numpy array
+                recorded_data = [np.frombuffer(frame, dtype=np.float32) for frame in recorded_data]
+                audio_arr = np.concatenate(recorded_data, axis=0)
+                if write_to_file:
+                    sf.write(self.filename, audio_arr, self.sample_rate)
+                    print("Saved to Record directory")
+                return audio_arr
+                break                
+
+    def record(self, write_to_file=True):
+        print(f"Press '{self.START_KEY}' to Start and '{self.STOP_KEY}' to Stop!")
+        while True:
+            if keyboard.is_pressed(self.START_KEY) or keyboard.is_pressed(self.START_KEY.upper()):
+                print("Recodrding...")
+                audio_arr = self.record_procssing(write_to_file)
+                return audio_arr, self.sample_rate
+                break
+            
+if __name__ == "__main__":
+    recorder = Recorder("audios/records/input_records/mic.mp3") #name of output file
+    audo_arr, sr = recorder.record()
+    print(audo_arr.shape)

main.py

@@ -0,0 +1,28 @@
+import os
+import keyboard
+from robot_voice.change_to_robot_voice import RobotVoice
+from in_out_micro.record_and_convert import convert
+from config_folder.config import run_config
+from in_out_micro.stream_to_virtual_mic import stream
+
+# Run Configuration
+IN_DEVICE, OUT_DEVICE, USE_RECORDING, SAVE_ROBOT_TO_FILE,\
+    VB, VL, H, LOOKUP_SAMPLES, MOD_F, STREAM_TO_VIRTUAL_MIC, PARALLEL = run_config()
+
+def voice_human2robot():  
+
+    rv_obj = RobotVoice(vb=VB, vl=VL, h=H, lookup_samples=LOOKUP_SAMPLES, mod_f=MOD_F)
+
+    # Line 1
+    robot_voice_arr, sr = convert(rv_obj, OUT_DEVICE, USE_RECORDING, SAVE_ROBOT_TO_FILE)
+
+    # Line 2
+    # To Virtual Microphone
+    if STREAM_TO_VIRTUAL_MIC:
+        stream(robot_voice_arr, sr, IN_DEVICE['name'])
+    else:
+        # return 
+        return  robot_voice_arr, sr
+
+if __name__ == "__main__":
+    voice_human2robot()

main_parallel.py

@@ -0,0 +1,24 @@
+import os
+import keyboard
+import 
+from robot_voice.change_to_robot_voice import RobotVoice
+from in_out_micro.record_and_convert import convert
+from config_folder.config import run_config
+from in_out_micro.stream_to_virtual_mic import stream
+
+def voice_human2robot():
+    # Run Configuration
+    IN_DEVICE, OUT_DEVICE, USE_RECORDING, SAVE_ROBOT_TO_FILE, VB, VL, H, LOOKUP_SAMPLES, MOD_F, STREAM_TO_VIRTUAL_MIC = run_config()
+
+    rv_obj = RobotVoice(vb=VB, vl=VL, h=H, lookup_samples=LOOKUP_SAMPLES, mod_f=MOD_F)
+
+    # Line 1
+    robot_voice_arr, sr = convert(rv_obj, OUT_DEVICE, USE_RECORDING, SAVE_ROBOT_TO_FILE)
+
+    # Line 2
+    # To Virtual Microphone
+    if STREAM_TO_VIRTUAL_MIC:
+        stream(robot_voice_arr, sr, IN_DEVICE['name'])
+    else:
+        # return 
+        return  robot_voice_arr, sr

requirements.txt

@@ -0,0 +1,7 @@
+sounddevice
+keyboard
+scipy
+librosa
+soundfile
+numpy
+wavio

robot_voice/change_to_robot_voice.py

@@ -0,0 +1,131 @@
+import numpy as np
+import scipy.io.wavfile as wavfile
+from robot_voice.waveshaper import Waveshaper
+import librosa
+import soundfile as sf
+
+class RobotVoice:
+    """
+    Simulates a ring modulator to create a robotic voice effect.
+
+    This implementation is based on the research paper:
+    http://recherche.ircam.fr/pub/dafx11/Papers/66_e.pdf
+
+    Parameters:
+    
+        - `vb` (float, optional): Controls the volume of the "bright" part of the speech.
+            Must be LESS than 1.0. Higher values result in a shorter, potentially less clear voice.
+            Defaults to 0.2. Paramerter `vb` and `vl` must be deferent.
+        - `vl` (float, optional): Controls the volume of the "low" part of the speech.
+            Must be LESS than 1.0. Higher values result in a shorter, potentially less clear voice.
+            Defaults to 0.4. Paramerter `vb` and `vl` must be deferent.
+        - `h` (float, optional): Controls the slope of the linear section of the diode model's response,
+            which takes effect after the voltage exceeds `vl`. Defaults to 4.
+        - `lookup_samples` (int, optional): Determines the size of the lookup table used for sound synthesis.
+            Lower values can introduce noise. Defaults to 1024.
+        - `mod_f` (float, optional): Controls the modulation frequency, which influences the "robotic" effect.
+            Higher values produce a more pronounced robotic sound. Defaults to 50.
+
+    Returns:
+        numpy.ndarray: The processed audio data with the robotic voice effect applied.  (This assumes your function returns the processed audio - adjust if needed)
+
+
+    Example usage (assuming the function is named `robotic_voice`):
+
+    >>> processed_audio = RobotVoice(vb=0.3,  vl=0.4, h=3, lookup_samples=512, mod_f=30)
+
+    """
+    def __init__(self, vb=0.2, vl=0.4, h=4, lookup_samples=1024, mod_f=50):
+
+        self.vb = vb
+        self.vl = vl
+        self.h = h
+        self.lookup_samples = lookup_samples
+        self.mod_f = mod_f
+    
+    def diode_lookup(self, n_samples):
+        result = np.zeros((n_samples,))
+        for i in range(0, n_samples):
+            v = float(i - float(n_samples)/2)/(n_samples/2)
+            v = abs(v)
+            if v < self.vb:
+                result[i] = 0
+            elif self.vb < v <= self.vl:
+                result[i] = self.h * ((v - self.vb)**2)/(2*self.vl - 2*self.vb)
+            else:
+                result[i] = self.h * v - self.h * self.vl + (self.h * (self.vl - self.vb) ** 2) / (2 * self.vl - 2 * self.vb)
+
+        return result
+
+    def raw_diode(self, signal):
+        result = np.zeros(signal.shape)
+        for i in range(0, signal.shape[0]):
+            v = signal[i]
+            if v < self.vb:
+                result[i] = 0
+            elif self.vb < v <= self.vl:
+                result[i] = self.h * ((v - self.vb)**2)/(2*self.vl - 2*self.vb)
+        else:
+            result[i] = self.h*v - self.h*self.vl + (self.h*(self.vl-self.vb)**2)/(2*self.vl-2*self.vb)
+        return result
+        
+    def run(self, input_func, output_func, use_record=False, save_to_file=True):
+
+                
+        if use_record:
+            data, rate = input_func
+        else:
+            data, rate = librosa.load(input_func)
+        print("data.shape, rate",data.shape, rate)
+
+        # Get max value to scale to original volume at the end
+        scaler = np.max(np.abs(data))
+
+        # Normalize to floats in range -1.0 < data < 1.0
+        data = data.astype('float')/scaler
+
+        # Length of array (number of samples)
+        n_samples = data.shape[0]
+
+        # Create the lookup table for simulating the diode.
+        d_lookup = self.diode_lookup(self.lookup_samples)
+        diode = Waveshaper(d_lookup)
+
+        # Simulate sine wave of frequency self.mod_f (in Hz)
+        tone = np.arange(n_samples)
+        tone = np.sin(2*np.pi*tone*self.mod_f/rate)
+
+        # Gain tone by 1/2
+        tone = tone * 0.5
+
+        # Junctions here
+        tone2 = tone.copy() # to top path
+        data2 = data.copy() # to bottom path
+
+        # Invert tone, sum paths
+        tone = -tone + data2 # bottom path
+        data = data + tone2 #top path
+
+        # top
+        data = diode.transform(data) + diode.transform(-data)
+
+        # bottom
+        tone = diode.transform(tone) + diode.transform(-tone)
+
+        result = data - tone
+
+        #scale to +-1.0
+        result /= np.max(np.abs(result))
+        #now scale to max value of input file.
+        result *= scaler
+        # wavfile.write wants ints between +-5000; hence the cast
+        # wavfile.write('robot.wav', rate, result.astype(np.int16))
+        
+        if save_to_file:
+            sf.write(output_func, result, rate)
+        return result, rate
+
+if __name__ == "__main__":
+    obj = RobotVoice(vb=0.1, vl=0.15, h=4, lookup_samples=1024, mod_f=20)
+    robot_voice_arr, sr = obj.run('audios/audios/input_audios/linus.mp3',
+                                  'audios/audios/output_audios/linus.mp3')

robot_voice/waveshaper.py

@@ -0,0 +1,22 @@
+import numpy as np
+
+class Waveshaper():
+    """
+    Apply a transform to an audio signal; store transform as curve,
+    use curve as lookup table.  Implementation of jQuery's WaveShaperNode
+    API:
+        http://webaudio.github.io/web-audio-api/#the-waveshapernode-interface
+    """
+    def __init__(self, curve):
+        self.curve = curve
+        self.n_bins = self.curve.shape[0]
+
+    def transform(self, samples):
+        # normalize to 0 < samples < 2
+        max_val = np.max(np.abs(samples))
+        if max_val >= 1.0:
+            result = samples/np.max(np.abs(samples)) + 1.0
+        else:
+            result = samples + 1.0
+        result = result * (self.n_bins-1)/2
+        return self.curve[result.astype('int')]

test.ipynb

@@ -0,0 +1,607 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from change_to_robot_voice import RobotVoice\n",
+    "import IPython.display as ipd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "obj = RobotVoice(vb=-5, vl=6, h=4, lookup_samples=1024, mod_f=20)\n",
+    "robot_voice_arr, sr = obj.run('audio-Wizard-of-Oz-Dorthy.wav', 'audio-Wizard-of-Oz-Dorthy_robot.mp3')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from IPython.display import Audio\n",
+    "\n",
+    "Audio(filename='audio-Wizard-of-Oz-Dorthy_robot.mp3', autoplay=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from voice_record import Recorder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "recorder = Recorder(\"audios/recordsinput_records/mic.wav\") #name of output file\n",
+    "audo_arr = recorder.record()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(132861,) 22050\n",
+      "data.shape, rate (69405,) 22050\n",
+      "here data.shape, rate (69405,) 22050\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import librosa\n",
+    "import numpy as np\n",
+    "from change_to_robot_voice import RobotVoice\n",
+    "from voice_record import Recorder\n",
+    "\n",
+    "USE_RECORD = False\n",
+    "SAVE_TO_FILE = True\n",
+    "\n",
+    "if USE_RECORD:\n",
+    "    base_name_file = \"mic.mp3\"\n",
+    "    recorder = Recorder(os.path.join(\"audios\", \"records\", \"input_records\", base_name_file)) #name of output file\n",
+    "    audio_arr, sr = recorder.record(write_to_file=True)\n",
+    "    print(audio_arr.shape)\n",
+    "\n",
+    "else:\n",
+    "    input_file = r'audios\\records\\input_records\\mic.mp3'#input(\"Paste your file path: \")\n",
+    "    base_name_file = os.path.basename(input_file)\n",
+    "    audio_arr, sr = librosa.load(input_file)\n",
+    "\n",
+    "print(audio_arr.shape, sr)\n",
+    "\n",
+    "obj = RobotVoice(vb=0.1, vl=0.001, h=1, lookup_samples=1024, mod_f=10)\n",
+    "# audio_arr = librosa.util.normalize(audio_arr)\n",
+    "if USE_RECORD:  \n",
+    "    robot_voice_arr, sr = obj.run(input_func=(audio_arr, sr),\n",
+    "                                  output_func=os.path.join('audios','records','output_records',base_name_file),\n",
+    "                                  use_record=USE_RECORD, save_to_file=SAVE_TO_FILE)\n",
+    "\n",
+    "else:\n",
+    "    robot_voice_arr, sr = obj.run(os.path.join('audios','audios','input_audios',base_name_file),\n",
+    "                                  os.path.join('audios','audios','output_audios',base_name_file),\n",
+    "                                  USE_RECORD, SAVE_TO_FILE)\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sounddevice as sd\n",
+    "\n",
+    "sd.play(robot_voice_arr, sr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vl_10 = robot_voice_arr.copy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sd.play(vl_10, sr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sd.play(audio_arr, sr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sd.stop()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "audio_arr_2, sr = librosa.load(r'audios\\records\\input_records\\mic.mp3')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 0.00872803,  0.00704956, -0.00872803, ..., -0.08926392,\n",
+       "       -0.11709595, -0.0836792 ], dtype=float32)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "audio_arr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 0.01161877,  0.00981571, -0.00999575, ..., -0.08572178,\n",
+       "       -0.1190884 , -0.08362549], dtype=float32)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "audio_arr_2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "17251"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.max(audio_arr)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\MyLaptop\\AppData\\Local\\Temp\\ipykernel_13176\\3951130461.py:4: RuntimeWarning: overflow encountered in scalar subtract\n",
+      "  normalized_data = 2 * (data - np.min(data)) / (np.max(data) - np.min(data)) - 1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "array([-0.1477003 , -0.14747774, -0.15341246, ...,  0.16268546,\n",
+       "        0.11876855,  0.01973294])"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def normalize_data(data):\n",
+    "  \"\"\"Normalizes data to the range of -1 to 1 using numpy.\"\"\"\n",
+    "  data = np.array(data)\n",
+    "  normalized_data = 2 * (data - np.min(data)) / (np.max(data) - np.min(data)) - 1\n",
+    "  return normalized_data\n",
+    "\n",
+    "e = normalize_data(audio_arr)\n",
+    "e"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0., 0., 0., ..., 0., 0., 0.])"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "robot_voice_arr"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "11"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import yaml\n",
+    "\n",
+    "def read_config(path):\n",
+    "    with open(path, \"r\") as yaml_file:        \n",
+    "        return yaml.load(yaml_file, Loader=yaml.FullLoader)\n",
+    "\n",
+    "def write_config(yaml_file, data):\n",
+    "    yaml.dump(data, yaml_file)\n",
+    "\n",
+    "FOLDER_CONFIG = \"configuration\"\n",
+    "CONFIG_FILE = \"config.yaml\"\n",
+    "yaml_file_path = os.path.join(FOLDER_CONFIG, CONFIG_FILE)\n",
+    "\n",
+    "cfg = read_config(yaml_file_path)\n",
+    "url = cfg['Input']['id']\n",
+    "url"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Write successful\n"
+     ]
+    }
+   ],
+   "source": [
+    "yaml_file_path = os.path.join(FOLDER_CONFIG, \"abc.yaml\")\n",
+    "\n",
+    "\n",
+    "\n",
+    "article_info = [\n",
+    "    {\n",
+    "        'Details': {\n",
+    "        'domain' : 'www.abc.com',\n",
+    "        'language': 'jav',\n",
+    "        'date': '11/09/2021990'\n",
+    "        }\n",
+    "    }\n",
+    "]\n",
+    "\n",
+    "with open(yaml_file_path, 'a') as yamlfile:\n",
+    "    data = yaml.dump(article_info, yamlfile)\n",
+    "    print(\"Write successful\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"config.yaml\", \"w\") as f:\n",
+    "    cfg = yaml.dump(\n",
+    "        cfg, stream=f, default_flow_style=False, sort_keys=False\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from change_to_robot_voice import RobotVoice\n",
+    "aa = RobotVoice()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'A list with information about all available audio devices.\\n\\n    This class is not meant to be instantiated by the user.\\n    Instead, it is returned by `query_devices()`.\\n    It contains a dictionary for each available device, holding the keys\\n    described in `query_devices()`.\\n\\n    This class has a special string representation that is shown as\\n    return value of `query_devices()` if used in an interactive\\n    Python session.  It will also be shown when using the :func:`print`\\n    function.  Furthermore, it can be obtained with :func:`repr` and\\n    :class:`str() <str>`.\\n\\n    '"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sd.query_devices().__doc__"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "({'name': 'MME',\n",
+       "  'devices': [0, 1, 2, 3, 4, 5],\n",
+       "  'default_input_device': 1,\n",
+       "  'default_output_device': 4},\n",
+       " {'name': 'Windows DirectSound',\n",
+       "  'devices': [6, 7, 8, 9, 10, 11],\n",
+       "  'default_input_device': 6,\n",
+       "  'default_output_device': 9},\n",
+       " {'name': 'Windows WASAPI',\n",
+       "  'devices': [12, 13, 14, 15],\n",
+       "  'default_input_device': 15,\n",
+       "  'default_output_device': 13},\n",
+       " {'name': 'Windows WDM-KS',\n",
+       "  'devices': [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31],\n",
+       "  'default_input_device': 16,\n",
+       "  'default_output_device': 26})"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sd.query_hostapis()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   0 Microsoft Sound Mapper - Input, MME (2 in, 0 out)\n",
+      ">  1 Microphone Array (Intel® Smart , MME (4 in, 0 out)\n",
+      "   2 CABLE Output (VB-Audio Virtual , MME (8 in, 0 out)\n",
+      "   3 Microsoft Sound Mapper - Output, MME (0 in, 2 out)\n",
+      "<  4 Speakers (Realtek(R) Audio), MME (0 in, 8 out)\n",
+      "   5 CABLE Input (VB-Audio Virtual C, MME (0 in, 8 out)\n",
+      "   6 Primary Sound Capture Driver, Windows DirectSound (2 in, 0 out)\n",
+      "   7 Microphone Array (Intel® Smart Sound Technology for Digital Microphones), Windows DirectSound (4 in, 0 out)\n",
+      "   8 CABLE Output (VB-Audio Virtual Cable), Windows DirectSound (8 in, 0 out)\n",
+      "   9 Primary Sound Driver, Windows DirectSound (0 in, 2 out)\n",
+      "  10 Speakers (Realtek(R) Audio), Windows DirectSound (0 in, 8 out)\n",
+      "  11 CABLE Input (VB-Audio Virtual Cable), Windows DirectSound (0 in, 8 out)\n",
+      "  12 CABLE Input (VB-Audio Virtual Cable), Windows WASAPI (0 in, 2 out)\n",
+      "  13 Speakers (Realtek(R) Audio), Windows WASAPI (0 in, 2 out)\n",
+      "  14 CABLE Output (VB-Audio Virtual Cable), Windows WASAPI (2 in, 0 out)\n",
+      "  15 Microphone Array (Intel® Smart Sound Technology for Digital Microphones), Windows WASAPI (2 in, 0 out)\n",
+      "  16 Microphone Array 1 (), Windows WDM-KS (2 in, 0 out)\n",
+      "  17 Microphone Array 2 (), Windows WDM-KS (2 in, 0 out)\n",
+      "  18 Microphone Array 3 (), Windows WDM-KS (4 in, 0 out)\n",
+      "  19 Microphone Array 4 (), Windows WDM-KS (4 in, 0 out)\n",
+      "  20 CABLE Output (VB-Audio Point), Windows WDM-KS (8 in, 0 out)\n",
+      "  21 Speakers (VB-Audio Point), Windows WDM-KS (0 in, 8 out)\n",
+      "  22 Stereo Mix (Realtek HD Audio Stereo input), Windows WDM-KS (2 in, 0 out)\n",
+      "  23 Headphones 1 (Realtek HD Audio 2nd output with SST), Windows WDM-KS (0 in, 2 out)\n",
+      "  24 Headphones 2 (Realtek HD Audio 2nd output with SST), Windows WDM-KS (0 in, 8 out)\n",
+      "  25 PC Speaker (Realtek HD Audio 2nd output with SST), Windows WDM-KS (2 in, 0 out)\n",
+      "  26 Speakers 1 (Realtek HD Audio output with SST), Windows WDM-KS (0 in, 2 out)\n",
+      "  27 Speakers 2 (Realtek HD Audio output with SST), Windows WDM-KS (0 in, 8 out)\n",
+      "  28 PC Speaker (Realtek HD Audio output with SST), Windows WDM-KS (2 in, 0 out)\n",
+      "  29 Microphone 1 (Realtek HD Audio Mic input with SST), Windows WDM-KS (2 in, 0 out)\n",
+      "  30 Microphone 2 (Realtek HD Audio Mic input with SST), Windows WDM-KS (4 in, 0 out)\n",
+      "  31 Microphone 3 (Realtek HD Audio Mic input with SST), Windows WDM-KS (4 in, 0 out)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sounddevice as sd\n",
+    "audio_device_list = sd.query_devices()\n",
+    "# 11 CABLE Input (VB-Audio Virtual Cable), Windows DirectSound\n",
+    "print(audio_device_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'   0 Microsoft Sound Mapper - Input, MME (2 in, 0 out)\\n>  1 Microphone Array (Intel® Smart , MME (4 in, 0 out)\\n   2 CABLE Output (VB-Audio Virtual , MME (8 in, 0 out)\\n   3 Microsoft Sound Mapper - Output, MME (0 in, 2 out)\\n<  4 Speakers (Realtek(R) Audio), MME (0 in, 8 out)\\n   5 CABLE Input (VB-Audio Virtual C, MME (0 in, 8 out)\\n   6 Primary Sound Capture Driver, Windows DirectSound (2 in, 0 out)\\n   7 Microphone Array (Intel® Smart Sound Technology for Digital Microphones), Windows DirectSound (4 in, 0 out)\\n   8 CABLE Output (VB-Audio Virtual Cable), Windows DirectSound (8 in, 0 out)\\n   9 Primary Sound Driver, Windows DirectSound (0 in, 2 out)\\n  10 Speakers (Realtek(R) Audio), Windows DirectSound (0 in, 8 out)\\n  11 CABLE Input (VB-Audio Virtual Cable), Windows DirectSound (0 in, 8 out)\\n  12 CABLE Input (VB-Audio Virtual Cable), Windows WASAPI (0 in, 2 out)\\n  13 Speakers (Realtek(R) Audio), Windows WASAPI (0 in, 2 out)\\n  14 CABLE Output (VB-Audio Virtual Cable), Windows WASAPI (2 in, 0 out)\\n  15 Microphone Array (Intel® Smart Sound Technology for Digital Microphones), Windows WASAPI (2 in, 0 out)\\n  16 Microphone Array 1 (), Windows WDM-KS (2 in, 0 out)\\n  17 Microphone Array 2 (), Windows WDM-KS (2 in, 0 out)\\n  18 Microphone Array 3 (), Windows WDM-KS (4 in, 0 out)\\n  19 Microphone Array 4 (), Windows WDM-KS (4 in, 0 out)\\n  20 CABLE Output (VB-Audio Point), Windows WDM-KS (8 in, 0 out)\\n  21 Speakers (VB-Audio Point), Windows WDM-KS (0 in, 8 out)\\n  22 Stereo Mix (Realtek HD Audio Stereo input), Windows WDM-KS (2 in, 0 out)\\n  23 Headphones 1 (Realtek HD Audio 2nd output with SST), Windows WDM-KS (0 in, 2 out)\\n  24 Headphones 2 (Realtek HD Audio 2nd output with SST), Windows WDM-KS (0 in, 8 out)\\n  25 PC Speaker (Realtek HD Audio 2nd output with SST), Windows WDM-KS (2 in, 0 out)\\n  26 Speakers 1 (Realtek HD Audio output with SST), Windows WDM-KS (0 in, 2 out)\\n  27 Speakers 2 (Realtek HD Audio output with SST), Windows WDM-KS (0 in, 8 out)\\n  28 PC Speaker (Realtek HD Audio output with SST), Windows WDM-KS (2 in, 0 out)\\n  29 Microphone 1 (Realtek HD Audio Mic input with SST), Windows WDM-KS (2 in, 0 out)\\n  30 Microphone 2 (Realtek HD Audio Mic input with SST), Windows WDM-KS (4 in, 0 out)\\n  31 Microphone 3 (Realtek HD Audio Mic input with SST), Windows WDM-KS (4 in, 0 out)'"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "audio_device_list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "unsupported operand type(s) for +: 'aA' and 'int'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[18], line 8\u001b[0m\n\u001b[0;32m      5\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mint\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39ma)\n\u001b[0;32m      7\u001b[0m e \u001b[38;5;241m=\u001b[39m aA(\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m----> 8\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43me\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m)\n",
+      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'aA' and 'int'"
+     ]
+    }
+   ],
+   "source": [
+    "class aA:\n",
+    "    def __init__(self, a):\n",
+    "        self.a = a\n",
+    "    def __repr__(self):\n",
+    "        return int(self.a)\n",
+    "\n",
+    "e = aA(1)\n",
+    "print(e+1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'index': 1,\n",
+       " 'structVersion': 2,\n",
+       " 'name': 'Microphone Array (Intel® Smart ',\n",
+       " 'hostApi': 0,\n",
+       " 'maxInputChannels': 4,\n",
+       " 'maxOutputChannels': 0,\n",
+       " 'defaultLowInputLatency': 0.09,\n",
+       " 'defaultLowOutputLatency': 0.09,\n",
+       " 'defaultHighInputLatency': 0.18,\n",
+       " 'defaultHighOutputLatency': 0.18,\n",
+       " 'defaultSampleRate': 44100.0}"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "in_devices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'index': 4,\n",
+       " 'structVersion': 2,\n",
+       " 'name': 'Speakers (Realtek(R) Audio)',\n",
+       " 'hostApi': 0,\n",
+       " 'maxInputChannels': 0,\n",
+       " 'maxOutputChannels': 8,\n",
+       " 'defaultLowInputLatency': 0.09,\n",
+       " 'defaultLowOutputLatency': 0.09,\n",
+       " 'defaultHighInputLatency': 0.18,\n",
+       " 'defaultHighOutputLatency': 0.18,\n",
+       " 'defaultSampleRate': 44100.0}"
+      ]
+     },
+     "execution_count": 49,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "out_devices"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

test2.py

@@ -0,0 +1,7 @@
+import sounddevice as sd
+audio_device_list = sd.query_devices()
+audio_hostapis_list = sd.query_hostapis()
+idx_device = int(input(f"Please choose 1 Input Microphone (Just enter the device index): \n {audio_device_list}\nYour Index Choose is: "))
+# print(audio_device_list)
+device_name = audio_device_list[idx_device]['name'] + ", " + audio_hostapis_list[audio_device_list[idx_device]['hostapi']]['name']
+print(device_name)

utils/pass_to_virtual_micro.py

@@ -0,0 +1,64 @@
+import sounddevice as sd
+import numpy as np
+import wavio
+import datetime
+
+# Configuration for the recording
+SAMPLE_RATE = 44100
+CHANNELS = 2
+DTYPE = np.int16
+SECONDS_PER_CHUNK = 10  # You can modify this to record larger or smaller chunks at a time
+
+def select_device():
+    devices = sd.query_devices()
+    input_devices = [device for device in devices if device['max_input_channels'] > 0]
+    device_names = [device['name'] for device in input_devices]
+
+    # Check for "Sound Mixer"
+    for name in device_names:
+        if "Sound Mixer" in name:
+            return name
+
+    # Check for "CABLE Output"
+    for name in device_names:
+        if "CABLE Output" in name:
+            return name
+
+    # If neither "Sound Mixer" nor "CABLE Output" is found, prompt for VB-Cable installation
+    print("It seems you don't have a suitable input device installed.")
+    print("Please consider downloading and installing VB-Cable for this purpose.")
+    print("You can download it from here: https://vb-audio.com/Cable/")
+    exit(1)
+
+def get_filename_with_date_and_time():
+    current_time = datetime.datetime.now()
+    formatted_date_time = current_time.strftime('%m-%d-%Y_%H-%M-%S')
+    filename = f"./output/recording_{formatted_date_time}.wav"
+    return filename
+
+def record_until_closed(device_name):
+    with sd.InputStream(samplerate=SAMPLE_RATE, channels=CHANNELS, dtype=DTYPE, device=device_name) as stream:
+        print("Recording... Press Ctrl+C to stop and save.")
+        all_data = []
+
+        try:
+            while True:
+                audio_chunk, _ = stream.read(int(SECONDS_PER_CHUNK * SAMPLE_RATE))
+                all_data.append(audio_chunk)
+        except KeyboardInterrupt:
+            # If user presses Ctrl+C, stop recording and save to a WAV file
+            print("Recording stopped. Saving...")
+
+            # Concatenate all chunks to form the complete audio data
+            audio_data = np.concatenate(all_data, axis=0)
+
+            # Get filename with date and time
+            filename = get_filename_with_date_and_time()
+
+            # Save to a WAV file
+            wavio.write(filename, audio_data, SAMPLE_RATE, sampwidth=2)
+            print(f"Saved as '{filename}'")
+
+if __name__ == "__main__":
+    device_name = select_device()
+    record_until_closed(device_name)