📋 Genel Bakış

audio modülü, ses dosyalarını yükleme, oynatma, kaydetme ve işleme için kapsamlı araçlar sağlar. MP3, WAV, FLAC gibi formatları destekler, ses efektleri ve sentezleyici özellikleri sunar.

💡 Kullanım Örnekleri

kullan audio
kullan fs

sınıf MüzikÇalar {
    değer ses: Opsiyonel<audio.Ses> = boş
    değer oynatılıyor: Mantıksal = yanlış
    
    fonksiyon yükle(dosya_yolu: Dize) -> Sonuç<Boş, Hata> {
        bu.ses = audio.yükle(dosya_yolu)?
        yazdır(f"✓ Yüklendi: {dosya_yolu}")
        
        // Ses bilgilerini göster
        değer süre = bu.ses.aç().süre()
        değer örnek_hızı = bu.ses.aç().örnek_hızı()
        değer kanal = bu.ses.aç().kanal_sayısı()
        
        yazdır(f"  Süre: {süre:.2f} saniye")
        yazdır(f"  Örnek hızı: {örnek_hızı} Hz")
        yazdır(f"  Kanallar: {kanal}")
        
        dön Tamam(boş)
    }
    
    fonksiyon oynat() {
        eğer bu.ses.var_mı() {
            audio.oynat(bu.ses.aç())
            bu.oynatılıyor = doğru
            yazdır("▶️  Oynatılıyor...")
        } yoksa {
            yazdır("❌ Önce bir ses dosyası yükleyin!")
        }
    }
    
    fonksiyon duraklat() {
        eğer bu.ses.var_mı() ve bu.oynatılıyor {
            audio.duraklat(bu.ses.aç())
            bu.oynatılıyor = yanlış
            yazdır("⏸️  Duraklatıldı")
        }
    }
    
    fonksiyon devam_et() {
        eğer bu.ses.var_mı() ve !bu.oynatılıyor {
            audio.devam_et(bu.ses.aç())
            bu.oynatılıyor = doğru
            yazdır("▶️  Devam ediyor...")
        }
    }
    
    fonksiyon durdur() {
        eğer bu.ses.var_mı() {
            audio.durdur(bu.ses.aç())
            bu.oynatılıyor = yanlış
            yazdır("⏹️  Durduruldu")
        }
    }
    
    fonksiyon ses_seviyesi_ayarla(seviye: Gerçek) {
        eğer bu.ses.var_mı() {
            değer kısıtlı = seviye.kısıtla(0.0, 1.0)
            audio.ses_seviyesi(bu.ses.aç(), kısıtlı)
            yazdır(f"🔊 Ses seviyesi: {(kısıtlı * 100):.0f}%")
        }
    }
}

// Kullanım
değer çalar = MüzikÇalar {}

çalar.yükle("müzik.mp3").aç()
çalar.oynat()

// Ses kontrolü
çalar.ses_seviyesi_ayarla(0.7)

// Bekle
audio.bekle(5.0)

çalar.duraklat()
audio.bekle(2.0)
çalar.devam_et()

// Şarkı bitene kadar bekle
çalar.ses.aç().tamamlanana_kadar_bekle()
yazdır("✓ Oynatma tamamlandı")

kullan audio
kullan time

sınıf SesKaydedici {
    değer mikrofon: audio.Mikrofon
    değer kayıt: Opsiyonel<audio.KayıtArabelleği> = boş
    değer kayıt_aktif: Mantıksal = yanlış
    
    fonksiyon yeni() -> Sonuç<SesKaydedici, Hata> {
        değer mikrofon = audio.mikrofon_aç(
            örnek_hızı: 44100,
            kanallar: 2,
            tampon_boyutu: 4096
        )?
        
        yazdır("🎙️  Mikrofon hazır")
        yazdır(f"  Örnek hızı: {mikrofon.örnek_hızı()} Hz")
        yazdır(f"  Kanallar: {mikrofon.kanal_sayısı()}")
        
        dön Tamam(SesKaydedici {
            mikrofon: mikrofon,
            kayıt: boş,
            kayıt_aktif: yanlış
        })
    }
    
    fonksiyon kayıt_başlat() {
        bu.kayıt = audio.KayıtArabelleği.yeni()
        bu.kayıt_aktif = doğru
        
        audio.kayıt_başlat(bu.mikrofon, bu.kayıt.aç())
        yazdır("🔴 Kayıt başladı...")
    }
    
    fonksiyon kayıt_durdur() -> audio.KayıtArabelleği {
        audio.kayıt_durdur(bu.mikrofon)
        bu.kayıt_aktif = yanlış
        yazdır("⏹️  Kayıt durduruldu")
        
        dön bu.kayıt.al()
    }
    
    fonksiyon dosyaya_kaydet(dosya_adı: Dize) -> Sonuç<Boş, Hata> {
        eğer bu.kayıt.var_mı() {
            audio.wav_olarak_kaydet(bu.kayıt.aç(), dosya_adı)?
            yazdır(f"💾 Kaydedildi: {dosya_adı}")
            dön Tamam(boş)
        }
        dön Hata("Kayıt bulunamadı!")
    }
    
    fonksiyon seviye_göster() {
        döngü {
            eğer !bu.kayıt_aktif {
                kır
            }
            
            değer seviye = audio.giriş_seviyesi(bu.mikrofon)
            değer çubuk_sayısı = (seviye * 50).tam()
            değer çubuk = "█" * çubuk_sayısı + "░" * (50 - çubuk_sayısı)
            
            yazdır(f"\r🎤 {çubuk} {(seviye * 100):.0f}%", yeni_satır: yanlış)
            time.uyu(0.05)
        }
        yazdır()  // Yeni satır
    }
}

// Kullanım
değer kaydedici = SesKaydedici.yeni().aç()

yazdır("\n3 saniye içinde kayıt başlayacak...")
time.uyu(3.0)

kaydedici.kayıt_başlat()

// 10 saniye kaydet
değer başlangıç = time.şimdi()
döngü {
    değer geçen = (time.şimdi() - başlangıç).saniye()
    eğer geçen >= 10.0 {
        kır
    }
    time.uyu(0.1)
}

değer kayıt = kaydedici.kayıt_durdur()
kaydedici.dosyaya_kaydet("kayıt.wav").aç()

yazdır("\n✓ Ses başarıyla kaydedildi!")

kullan audio
kullan math

sınıf Sentezleyici {
    değer örnek_hızı: Tam = 44100
    
    fonksiyon nota_çal(nota: Dize, süre: Gerçek, dalga_tipi: Dize = "sinüs") -> audio.Ses {
        değer frekans = audio.nota_frekansı(nota)
        değer örnek_sayısı = (bu.örnek_hızı * süre).tam()
        değer örnekler = Liste.yeni<Gerçek>(örnek_sayısı)
        
        için i içinde 0..örnek_sayısı {
            değer t = i.gerçek() / bu.örnek_hızı.gerçek()
            değer faz = 2.0 * math.PI * frekans * t
            
            değer örnek = eşleştir dalga_tipi {
                "sinüs" => math.sin(faz),
                "kare" => eğer math.sin(faz) >= 0.0 { 1.0 } yoksa { -1.0 },
                "testere" => 2.0 * (faz / (2.0 * math.PI) - (faz / (2.0 * math.PI)).taban()),
                _ => math.sin(faz)
            }
            
            // ADSR zarfı uygula (basit)
            değer zarf = bu.adsr_zarfı(t, süre)
            örnekler.ekle(örnek * zarf)
        }
        
        dön audio.örneklerden_oluştur(örnekler, bu.örnek_hızı)
    }
    
    fonksiyon adsr_zarfı(t: Gerçek, toplam_süre: Gerçek) -> Gerçek {
        // Attack, Decay, Sustain, Release
        değer attack = 0.05
        değer decay = 0.1
        değer sustain = 0.7
        değer release = 0.2
        
        eğer t < attack {
            dön t / attack
        } yoksa eğer t < attack + decay {
            değer decay_t = (t - attack) / decay
            dön 1.0 - (1.0 - sustain) * decay_t
        } yoksa eğer t < toplam_süre - release {
            dön sustain
        } yoksa {
            değer release_t = (t - (toplam_süre - release)) / release
            dön sustain * (1.0 - release_t)
        }
        dön 0.0
    }
    
    fonksiyon melodi_çal(notalar: Liste<(Dize, Gerçek)>) {
        yazdır("🎹 Melodi çalınıyor...")
        
        için (nota, süre) içinde notalar {
            değer ses = bu.nota_çal(nota, süre)
            audio.oynat(ses)
            audio.bekle(süre)
        }
        
        yazdır("✓ Melodi tamamlandı")
    }
    
    fonksiyon akor_çal(notalar: Liste<Dize>, süre: Gerçek) {
        // Birden fazla notayı aynı anda çal
        değer sesler = notalar.eşle(|nota| bu.nota_çal(nota, süre))
        değer karışık = audio.sesleri_karıştır(sesler)
        
        audio.oynat(karışık)
        audio.bekle(süre)
    }
}

// Kullanım
değer synth = Sentezleyici {}

// Basit melodi (Twinkle Twinkle Little Star)
değer melodi = [
    ("C4", 0.5), ("C4", 0.5), ("G4", 0.5), ("G4", 0.5),
    ("A4", 0.5), ("A4", 0.5), ("G4", 1.0),
    ("F4", 0.5), ("F4", 0.5), ("E4", 0.5), ("E4", 0.5),
    ("D4", 0.5), ("D4", 0.5), ("C4", 1.0)
]

synth.melodi_çal(melodi)

// C majör akoru
yazdır("\n🎸 C majör akoru...")
synth.akor_çal(["C4", "E4", "G4"], 2.0)

yazdır("✓ Bitti!")

🎯 İyi Uygulamalar

• Ses dosyalarını asenkron yükleyin
• Büyük ses dosyaları için streaming kullanın
• Ses efektlerini önceden işleyin (pre-process)
• Mikrofon erişimi için kullanıcı izni alın
• Oynatma bitişlerini callback ile yakalayın
• Ses işleme için yeterli tampon boyutu kullanın
• Normalize ederek ses seviyesi tutarlılığı sağlayın

🔗 İlgili Modüller

• fs - Dosya sistemi işlemleri
• math - Matematiksel fonksiyonlar
• thread - Asenkron işlemler
• time - Zamanlama işlemleri