app

app.py

@@ -0,0 +1,254 @@
+import numpy as np
+import wave
+import gradio as gr
+import tempfile
+from typing import List, Optional
+import json
+
+# Notas musicales comunes con sus frecuencias
+NOTES = {
+    "C4": 261.63, "D4": 293.66, "E4": 329.63, "F4": 349.23,
+    "G4": 392.00, "A4": 440.00, "B4": 493.88, "C5": 523.25
+}
+
+def generate_tone(frequency: float, duration: float, sample_rate: int, 
+                 amplitude: int, wave_type: str, subdivisions: int = 1) -> np.ndarray:
+    """
+    Genera un tono con parámetros avanzados incluyendo submuestreo.
+    """
+    total_samples = int(sample_rate * duration)
+    samples_per_subdivision = total_samples // subdivisions
+    
+    t = np.linspace(0, duration, total_samples, endpoint=False)
+    
+    try:
+        if wave_type == "square":
+            tone = amplitude * np.sign(np.sin(2 * np.pi * frequency * t))
+        elif wave_type == "sine":
+            tone = amplitude * np.sin(2 * np.pi * frequency * t)
+        elif wave_type == "triangle":
+            tone = amplitude * (2 * np.abs(2 * (frequency * t % 1) - 1) - 1)
+        elif wave_type == "sawtooth":
+            tone = amplitude * (2 * (frequency * t % 1) - 1)
+        else:
+            raise ValueError(f"Tipo de onda no válido: {wave_type}")
+        
+        # Aplicar submuestreo
+        if subdivisions > 1:
+            subsampled_tone = np.zeros_like(tone)
+            for i in range(subdivisions):
+                start = i * samples_per_subdivision
+                end = (i + 1) * samples_per_subdivision
+                subsampled_tone[start:end] = tone[start:end] * (1 - abs(i - (subdivisions-1)/2) / ((subdivisions-1)/2))
+            tone = subsampled_tone
+        
+        return tone.astype(np.int16)
+    except Exception as e:
+        raise ValueError(f"Error generando el tono: {str(e)}")
+
+def apply_custom_rhythm(tone: np.ndarray, rhythm_pattern: List[int], 
+                        sample_rate: int, beat_duration: float) -> np.ndarray:
+    """
+    Aplica un patrón rítmico personalizado binario.
+    """
+    if not rhythm_pattern:
+        return tone
+    
+    total_samples = len(tone)
+    samples_per_beat = int(sample_rate * beat_duration)
+    
+    # Generar envolvente rítmica
+    rhythm_envelope = np.zeros(total_samples)
+    current_sample = 0
+    
+    for beat in rhythm_pattern:
+        if current_sample >= total_samples:
+            break
+        
+        beat_samples = samples_per_beat
+        if current_sample + beat_samples > total_samples:
+            beat_samples = total_samples - current_sample
+        
+        if beat == 1:
+            # Añadir fade in/out
+            fade_length = int(beat_samples * 0.1)
+            fade_in = np.linspace(0, 1, fade_length)
+            fade_out = np.linspace(1, 0, fade_length)
+            
+            beat_envelope = np.ones(beat_samples)
+            beat_envelope[:fade_length] *= fade_in
+            beat_envelope[-fade_length:] *= fade_out
+            
+            rhythm_envelope[current_sample:current_sample+beat_samples] = beat_envelope
+        
+        current_sample += samples_per_beat
+    
+    return (tone * rhythm_envelope).astype(np.int16)
+
+def generate_music(melody: str, counter_melody: str, wave_type: str, 
+                  tempo: int, melody_volume: int, counter_volume: int,
+                  rhythm_pattern: str, melody_subdivisions: int, 
+                  counter_subdivisions: int) -> str:
+    """
+    Genera una pieza musical con submuestreo y ritmo personalizado.
+    """
+    try:
+        sample_rate = 44100
+        beat_duration = 60 / tempo
+        
+        # Convertir patrón rítmico de texto a lista
+        try:
+            rhythm_list = [int(x) for x in rhythm_pattern.split(",") if x.strip() in ['0', '1']]
+        except:
+            rhythm_list = []
+        
+        # Convertir cadenas de notas
+        melody_notes = [note.strip() for note in melody.split(",") if note.strip()]
+        counter_notes = [note.strip() for note in counter_melody.split(",") if note.strip()]
+        
+        def validate_note(note: str) -> tuple:
+            try:
+                freq, beats = map(float, note.split(":"))
+                if freq <= 0 or beats <= 0:
+                    raise ValueError
+                return freq, beats
+            except:
+                raise ValueError(f"Formato inválido de nota: {note}")
+        
+        # Generar melodía principal
+        main_tone = []
+        for note in melody_notes:
+            freq, beats = validate_note(note)
+            tone = generate_tone(freq, beats * beat_duration, sample_rate, 
+                               melody_volume, wave_type, melody_subdivisions)
+            main_tone.append(tone)
+        main_tone = np.concatenate(main_tone)
+        
+        # Aplicar ritmo personalizado
+        if rhythm_list:
+            main_tone = apply_custom_rhythm(main_tone, rhythm_list, sample_rate, beat_duration)
+        
+        # Generar contramelodía
+        counter_tone = []
+        if counter_notes:
+            for note in counter_notes:
+                freq, beats = validate_note(note)
+                tone = generate_tone(freq, beats * beat_duration, sample_rate, 
+                                   counter_volume, wave_type, counter_subdivisions)
+                counter_tone.append(tone)
+            counter_tone = np.concatenate(counter_tone)
+            
+            # Aplicar ritmo personalizado
+            if rhythm_list:
+                counter_tone = apply_custom_rhythm(counter_tone, rhythm_list, sample_rate, beat_duration)
+        else:
+            counter_tone = np.zeros_like(main_tone)
+        
+        # Asegurar misma longitud
+        max_length = max(len(main_tone), len(counter_tone))
+        main_tone = np.pad(main_tone, (0, max_length - len(main_tone)))
+        counter_tone = np.pad(counter_tone, (0, max_length - len(counter_tone)))
+        
+        # Mezclar pistas
+        combined_audio = main_tone + counter_tone
+        combined_audio = np.clip(combined_audio, -32767, 32767).astype(np.int16)
+        
+        # Guardar audio
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmpfile:
+            with wave.open(tmpfile.name, 'w') as wf:
+                wf.setnchannels(1)
+                wf.setsampwidth(2)
+                wf.setframerate(sample_rate)
+                wf.writeframes(combined_audio.tobytes())
+            return tmpfile.name
+            
+    except Exception as e:
+        raise gr.Error(f"Error generando la música: {str(e)}")
+
+# Interfaz de Gradio
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="indigo", secondary_hue="blue")) as ui:
+    gr.Markdown("""
+    # 🎵 Generador de Música Avanzado
+    
+    Crea música con ritmos y submuestreo personalizados.
+    
+    ## Formato de Entrada
+    - Notas: `frecuencia:duración` (Ej: 440:1)
+    - Ritmo: Patrón binario de 0 y 1 (Ej: 1,0,1,0)
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            melody = gr.Textbox(
+                label="Melodía Principal",
+                placeholder="Ejemplo: 440:1, 494:0.5",
+                lines=3
+            )
+            counter_melody = gr.Textbox(
+                label="Contramelodía (opcional)",
+                placeholder="Ejemplo: 330:1, 349:0.5",
+                lines=3
+            )
+    
+    with gr.Row():
+        with gr.Column():
+            wave_type = gr.Radio(
+                ["sine", "square", "triangle", "sawtooth"],
+                label="Tipo de Onda",
+                value="square"
+            )
+            rhythm_pattern = gr.Textbox(
+                label="Patrón Rítmico (0 y 1)",
+                placeholder="Ejemplo: 1,0,1,0",
+                value=""
+            )
+        
+        with gr.Column():
+            melody_subdivisions = gr.Slider(
+                minimum=1, maximum=8, step=1,
+                label="Subdivisiones de Melodía",
+                value=1
+            )
+            counter_subdivisions = gr.Slider(
+                minimum=1, maximum=8, step=1,
+                label="Subdivisiones de Contramelodía",
+                value=1
+            )
+            
+            tempo = gr.Slider(
+                minimum=60, maximum=180, step=5,
+                label="Tempo (BPM)",
+                value=120
+            )
+            
+            volume_row = gr.Row()
+            with volume_row:
+                melody_volume = gr.Slider(
+                    minimum=0, maximum=30000, step=1000,
+                    label="Vol. Melodía", value=15000
+                )
+                counter_volume = gr.Slider(
+                    minimum=0, maximum=30000, step=1000,
+                    label="Vol. Contramelodía", value=10000
+                )
+    
+    output_audio = gr.Audio(label="Audio Generado")
+    
+    generate_btn = gr.Button("Generar Música", variant="primary")
+    generate_btn.click(
+        fn=generate_music,
+        inputs=[melody, counter_melody, wave_type, tempo, 
+                melody_volume, counter_volume, rhythm_pattern, 
+                melody_subdivisions, counter_subdivisions],
+        outputs=output_audio
+    )
+    
+    gr.Markdown("""
+    ### Características Avanzadas
+    - Ritmo personalizado con patrón binario
+    - Submuestreo para efectos de textura
+    - Control independiente de melodía y contramelodía
+    """)
+
+if __name__ == "__main__":
+    ui.launch()